Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
5527 anupam.sin 58 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
5527 anupam.sin 64 
     - pickUp
65 
     - orderType
94 ashish 66 
    """
67 
    pass
68 
 
1398 varun.gupt 69 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 70 
    """
71 
    Parameters:
72 
     - transactionId
73 
    """
74 
    pass
75 
 
4801 anupam.sin 76 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 77 
    """
78 
    Parameters:
4801 anupam.sin 79 
     - statuses
483 rajveer 80 
     - from_date
81 
     - to_date
82 
     - warehouse_id
94 ashish 83 
    """
84 
    pass
85 
 
4133 chandransh 86 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
87 
    """
88 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
89 
    Pass the status as null and the limit as 0 to ignore them.
90 
 
91 
    Parameters:
92 
     - statuses
93 
     - offset
94 
     - limit
95 
     - warehouse_id
96 
    """
97 
    pass
98 
 
99 
  def getOrderCount(self, statuses, warehouseId):
100 
    """
101 
    Returns the count of orders with the given statuses assigned to the given warehouse.
102 
 
103 
    Parameters:
104 
     - statuses
105 
     - warehouseId
106 
    """
107 
    pass
108 
 
999 varun.gupt 109 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
110 
    """
1132 chandransh 111 
    Returns orders within a range of their billing dates
3431 rajveer 112 
 
999 varun.gupt 113 
    Parameters:
114 
     - status
115 
     - start_billing_date
116 
     - end_billing_date
117 
     - warehouse_id
118 
    """
119 
    pass
120 
 
3451 chandransh 121 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 122 
    """
123 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 124 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
125 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 126 
 
3427 chandransh 127 
    Parameters:
128 
     - fromShippingDate
129 
     - toShippingDate
130 
     - providerId
131 
     - warehouseId
3451 chandransh 132 
     - cod
3427 chandransh 133 
    """
134 
    pass
135 
 
1382 varun.gupt 136 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
137 
    """
138 
    Returns order ids for orders which can be returned
3431 rajveer 139 
 
1382 varun.gupt 140 
    Parameters:
141 
     - customer_id
142 
     - limit
143 
    """
144 
    pass
145 
 
146 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
147 
    """
148 
    Returns order ids for orders which can be cancelled
3431 rajveer 149 
 
1382 varun.gupt 150 
    Parameters:
151 
     - customer_id
152 
     - limit
153 
    """
154 
    pass
155 
 
483 rajveer 156 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 157 
    """
158 
    Parameters:
483 rajveer 159 
     - orderId
160 
     - status
161 
     - description
94 ashish 162 
    """
163 
    pass
164 
 
1528 ankur.sing 165 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 166 
    """
1528 ankur.sing 167 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
168 
    only user who owns the transaction can view its order details.
3431 rajveer 169 
 
94 ashish 170 
    Parameters:
171 
     - transactionId
1528 ankur.sing 172 
     - customerId
94 ashish 173 
    """
174 
    pass
175 
 
3014 chandransh 176 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 177 
    """
3014 chandransh 178 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
179 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 180 
 
94 ashish 181 
    Parameters:
483 rajveer 182 
     - customerId
183 
     - from_date
184 
     - to_date
3014 chandransh 185 
     - statuses
94 ashish 186 
    """
187 
    pass
188 
 
483 rajveer 189 
  def createOrder(self, order):
94 ashish 190 
    """
191 
    Parameters:
483 rajveer 192 
     - order
94 ashish 193 
    """
194 
    pass
195 
 
483 rajveer 196 
  def getOrder(self, id):
94 ashish 197 
    """
198 
    Parameters:
483 rajveer 199 
     - id
94 ashish 200 
    """
201 
    pass
202 
 
483 rajveer 203 
  def getLineItemsForOrder(self, orderId):
94 ashish 204 
    """
205 
    Parameters:
483 rajveer 206 
     - orderId
94 ashish 207 
    """
208 
    pass
209 
 
4999 phani.kuma 210 
  def getOrderList(self, order_ids):
211 
    """
212 
    Parameters:
213 
     - order_ids
214 
    """
215 
    pass
216 
 
5386 phani.kuma 217 
  def getOrderListForVendor(self, order_ids, vendorId):
218 
    """
219 
    Parameters:
220 
     - order_ids
221 
     - vendorId
222 
    """
223 
    pass
224 
 
1528 ankur.sing 225 
  def getOrderForCustomer(self, orderId, customerId):
226 
    """
227 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
228 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 229 
 
1528 ankur.sing 230 
    Parameters:
231 
     - orderId
232 
     - customerId
233 
    """
234 
    pass
235 
 
4444 rajveer 236 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 237 
    """
238 
    Parameters:
4394 rajveer 239 
     - type
4444 rajveer 240 
     - warehouseId
4394 rajveer 241 
     - status
242 
     - timestamp
3064 chandransh 243 
    """
244 
    pass
245 
 
4444 rajveer 246 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 247 
    """
248 
    Parameters:
249 
     - type
4444 rajveer 250 
     - warehouseId
4394 rajveer 251 
     - description
3064 chandransh 252 
    """
253 
    pass
254 
 
4444 rajveer 255 
  def markAlertsAsSeen(self, warehouseId):
256 
    """
257 
    Parameters:
258 
     - warehouseId
259 
    """
260 
    pass
261 
 
3064 chandransh 262 
  def getValidOrderCount(self, ):
263 
    """
264 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
265 
    """
266 
    pass
267 
 
268 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
269 
    """
270 
    Returns the number of distinct customers who have done successful transactions
271 
    """
272 
    pass
273 
 
274 
  def getValidOrdersAmountRange(self, ):
275 
    """
276 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
277 
    List contains two values, first minimum amount and second maximum amount.
278 
    """
279 
    pass
280 
 
5874 rajveer 281 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 282 
    """
283 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
284 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 285 
 
3064 chandransh 286 
    Parameters:
287 
     - limit
5874 rajveer 288 
     - onlyStore
3064 chandransh 289 
    """
290 
    pass
291 
 
1220 chandransh 292 
  def batchOrders(self, warehouseId):
293 
    """
294 
    Create a batch of all the pending orders for the given warehouse.
295 
    The returned list is orderd by created_timestamp.
296 
    If there are no pending orders, an empty list is returned.
3431 rajveer 297 
 
1220 chandransh 298 
    Parameters:
299 
     - warehouseId
300 
    """
301 
    pass
302 
 
1208 chandransh 303 
  def markOrderAsOutOfStock(self, orderId):
304 
    """
305 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 306 
 
1208 chandransh 307 
    Parameters:
308 
     - orderId
309 
    """
310 
    pass
311 
 
3064 chandransh 312 
  def verifyOrder(self, orderId):
759 chandransh 313 
    """
3064 chandransh 314 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
315 
    timestamp. It is intended to be used for COD orders but can be harmlessly
316 
    used for all other orders as well.
317 
    Throws an exception if no such order exists.
3431 rajveer 318 
 
759 chandransh 319 
    Parameters:
3064 chandransh 320 
     - orderId
321 
    """
322 
    pass
323 
 
324 
  def acceptOrder(self, orderId):
325 
    """
326 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
327 
    given order is not a COD order, it also captures the payment if the same has
328 
    not been captured.
329 
    Throws an exception if no such order exists.
3431 rajveer 330 
 
3064 chandransh 331 
    Parameters:
332 
     - orderId
333 
    """
334 
    pass
335 
 
5110 mandeep.dh 336 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 337 
    """
338 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 339 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 340 
    the IMEI no. if a -1 is supplied.
341 
    Also, it generates an invoice number for the order, marks the order as
342 
    BILLED and sets the billing timestamp.
343 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 344 
 
3064 chandransh 345 
    Parameters:
346 
     - orderId
4283 anupam.sin 347 
     - invoice_number
4658 mandeep.dh 348 
     - serialNumber
3064 chandransh 349 
     - itemNumber
4283 anupam.sin 350 
     - billed_by
351 
     - jacketNumber
3064 chandransh 352 
     - billingType
5110 mandeep.dh 353 
     - fulfilmentWarehouseId
4763 rajveer 354 
     - authorize
3064 chandransh 355 
    """
356 
    pass
357 
 
4763 rajveer 358 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 359 
    """
360 
    Add the invoice number to the order.
361 
 
362 
    Parameters:
363 
     - orderId
364 
     - invoiceNumber
4763 rajveer 365 
     - color
4579 rajveer 366 
    """
367 
    pass
368 
 
4910 phani.kuma 369 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 370 
    """
371 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 372 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 373 
 
374 
    Parameters:
375 
     - warehouseId
376 
     - providerId
377 
     - cod
4910 phani.kuma 378 
     - orderIds
4410 rajveer 379 
    """
380 
    pass
381 
 
5713 rajveer 382 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 383 
    """
384 
    Parameters:
385 
     - providerId
386 
     - orderIds
5713 rajveer 387 
     - awbs
5676 rajveer 388 
    """
389 
    pass
390 
 
4910 phani.kuma 391 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 392 
    """
4910 phani.kuma 393 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
394 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 395 
 
3064 chandransh 396 
    Parameters:
759 chandransh 397 
     - providerId
4910 phani.kuma 398 
     - pickupDetails
759 chandransh 399 
    """
400 
    pass
401 
 
4910 phani.kuma 402 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 403 
    """
404 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 405 
 
1113 chandransh 406 
    Parameters:
407 
     - providerId
408 
    """
409 
    pass
410 
 
1132 chandransh 411 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
412 
    """
413 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
414 
    the name of the receiver.
415 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 416 
 
1132 chandransh 417 
    Parameters:
418 
     - providerId
419 
     - deliveredOrders
420 
    """
421 
    pass
422 
 
4910 phani.kuma 423 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 424 
    """
4910 phani.kuma 425 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 426 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 427 
 
1135 chandransh 428 
    Parameters:
429 
     - providerId
430 
     - returnedOrders
431 
    """
432 
    pass
433 
 
4910 phani.kuma 434 
  def getRTOrders(self, providerId):
435 
    """
436 
    Returns a list of orders that were returned by courier.
437 
 
438 
    Parameters:
439 
     - providerId
440 
    """
441 
    pass
442 
 
1246 chandransh 443 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
444 
    """
445 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 446 
 
1246 chandransh 447 
    Parameters:
448 
     - providerId
449 
     - undeliveredOrders
450 
    """
451 
    pass
452 
 
4910 phani.kuma 453 
  def getNonDeliveredOrdersbyCourier(self, providerId):
454 
    """
455 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
456 
 
457 
    Parameters:
458 
     - providerId
459 
    """
460 
    pass
461 
 
462 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
463 
    """
464 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
465 
 
466 
    Parameters:
467 
     - providerId
468 
     - local_connected_orders
469 
    """
470 
    pass
471 
 
472 
  def getOrdersNotLocalConnected(self, providerId):
473 
    """
474 
    Returns a list of orders that were picked up or shipped but pending local connection.
475 
 
476 
    Parameters:
477 
     - providerId
478 
    """
479 
    pass
480 
 
481 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
482 
    """
483 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
484 
 
485 
    Parameters:
486 
     - providerId
487 
     - destination_city_reached_orders
488 
    """
489 
    pass
490 
 
491 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
492 
    """
493 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
494 
 
495 
    Parameters:
496 
     - providerId
497 
     - first_atdl_orders
498 
    """
499 
    pass
500 
 
1408 ankur.sing 501 
  def getUndeliveredOrders(self, providerId, warehouseId):
502 
    """
503 
    Returns the list of orders whose delivery time has passed but have not been
504 
    delivered yet for the given provider and warehouse. To get a complete list of
505 
    undelivered orders, pass them as -1.
506 
    Returns an empty list if no such orders exist.
3431 rajveer 507 
 
1408 ankur.sing 508 
    Parameters:
509 
     - providerId
510 
     - warehouseId
511 
    """
512 
    pass
513 
 
4783 phani.kuma 514 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
515 
    """
516 
    Returns the list of orders whose expected delivery date has passed but have not been
517 
    delivered yet.
518 
    Returns an empty list if no such orders exist.
519 
    """
520 
    pass
521 
 
2536 chandransh 522 
  def toggleDOAFlag(self, orderId):
523 
    """
524 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
525 
    Returns the final flag status.
526 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 527 
 
2536 chandransh 528 
    Parameters:
529 
     - orderId
530 
    """
531 
    pass
1886 ankur.sing 532 
 
4712 rajveer 533 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
534 
    """
535 
    Parameters:
536 
     - orderId
537 
     - deliveryTimestamp
538 
     - receiver
539 
    """
540 
    pass
541 
 
5553 rajveer 542 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
543 
    """
544 
    Parameters:
545 
     - orderId
546 
     - deliveryTimestamp
547 
    """
548 
    pass
549 
 
4454 rajveer 550 
  def markOrderDoaRequestReceived(self, orderId):
551 
    """
552 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
553 
 
554 
    Parameters:
555 
     - orderId
556 
    """
557 
    pass
558 
 
559 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
560 
    """
561 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
562 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
563 
 
564 
    Parameters:
565 
     - orderId
566 
     - isAuthorized
567 
    """
568 
    pass
569 
 
4488 rajveer 570 
  def markOrderReturnRequestReceived(self, orderId):
571 
    """
572 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
573 
 
574 
    Parameters:
575 
     - orderId
576 
    """
577 
    pass
578 
 
579 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
580 
    """
581 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
582 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
583 
 
584 
    Parameters:
585 
     - orderId
586 
     - isAuthorized
587 
    """
588 
    pass
589 
 
4579 rajveer 590 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 591 
    """
592 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 593 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
594 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 595 
    For any other status, it returns false.
596 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 597 
 
2536 chandransh 598 
    Parameters:
599 
     - orderId
4579 rajveer 600 
     - providerId
2536 chandransh 601 
    """
602 
    pass
603 
 
4602 rajveer 604 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 605 
    """
4452 rajveer 606 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 607 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
608 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
609 
    	3. Returns true
2591 chandransh 610 
    If the order is in any other status, it returns false.
2536 chandransh 611 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 612 
 
2536 chandransh 613 
    Parameters:
614 
     - orderId
615 
     - pickupNumber
4602 rajveer 616 
     - providerId
2536 chandransh 617 
    """
618 
    pass
619 
 
2764 chandransh 620 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
621 
    """
622 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 623 
 
2764 chandransh 624 
    Parameters:
625 
     - providerId
626 
     - pickupDetails
627 
    """
628 
    pass
629 
 
4910 phani.kuma 630 
  def getDoasNotPickedUp(self, providerId):
631 
    """
632 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
633 
 
634 
    Parameters:
635 
     - providerId
636 
    """
637 
    pass
638 
 
4741 phani.kuma 639 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
640 
    """
641 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
642 
 
643 
    Parameters:
644 
     - providerId
645 
     - pickupDetails
646 
    """
647 
    pass
648 
 
4910 phani.kuma 649 
  def getReturnOrdersNotPickedUp(self, providerId):
650 
    """
651 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
652 
 
653 
    Parameters:
654 
     - providerId
655 
    """
656 
    pass
657 
 
4479 rajveer 658 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 659 
    """
4452 rajveer 660 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 661 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 662 
    If the order is in any other state, it returns false.
663 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 664 
 
2591 chandransh 665 
    Parameters:
666 
     - orderId
4479 rajveer 667 
     - receiveCondition
2591 chandransh 668 
    """
669 
    pass
2536 chandransh 670 
 
2591 chandransh 671 
  def validateDoa(self, orderId, isValid):
672 
    """
4452 rajveer 673 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 674 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 675 
    If the order is in any other state, it returns false.
676 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 677 
 
2591 chandransh 678 
    Parameters:
679 
     - orderId
680 
     - isValid
681 
    """
682 
    pass
683 
 
4495 rajveer 684 
  def validateReturnProduct(self, orderId, isUsable):
685 
    """
686 
    Parameters:
687 
     - orderId
688 
     - isUsable
689 
    """
690 
    pass
691 
 
2616 chandransh 692 
  def reshipOrder(self, orderId):
693 
    """
4484 rajveer 694 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 695 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 696 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 697 
 
698 
    If the order is in DOA_CERT_VALID state, it does the following:
699 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
700 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 701 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 702 
 
2616 chandransh 703 
    Returns the id of the newly created order.
3431 rajveer 704 
 
2616 chandransh 705 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 706 
 
2616 chandransh 707 
    Parameters:
708 
     - orderId
709 
    """
710 
    pass
2591 chandransh 711 
 
3226 chandransh 712 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 713 
    """
4484 rajveer 714 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 715 
    	1. Creates a refund request for batch processing.
716 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 717 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 718 
 
2616 chandransh 719 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
720 
    	1. Creates a refund request for batch processing.
3226 chandransh 721 
    	2. Cancels the reservation of the item in the warehouse.
722 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 723 
 
3226 chandransh 724 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
725 
    	1. Cancels the reservation of the item in the warehouse.
726 
    	2. Marks the current order as CANCELED.
727 
 
728 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
729 
 
2616 chandransh 730 
    Returns True if it is successful, False otherwise.
3431 rajveer 731 
 
2616 chandransh 732 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 733 
 
2616 chandransh 734 
    Parameters:
735 
     - orderId
3226 chandransh 736 
     - refundedBy
737 
     - reason
2616 chandransh 738 
    """
739 
    pass
740 
 
2690 chandransh 741 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
742 
    """
743 
    Get all return orders created between the from and to dates for the given warehouse.
744 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 745 
 
2690 chandransh 746 
    Parameters:
747 
     - warehouseId
748 
     - fromDate
749 
     - toDate
750 
    """
751 
    pass
2616 chandransh 752 
 
5481 phani.kuma 753 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
754 
    """
755 
    Get all return orders created between the from and to dates.
756 
 
757 
    Parameters:
758 
     - onlyNotProcessed
759 
     - fromDate
760 
     - toDate
761 
    """
762 
    pass
763 
 
2700 chandransh 764 
  def getReturnOrder(self, id):
765 
    """
766 
    Returns the ReturnOrder corresponding to the given id.
767 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 768 
 
2700 chandransh 769 
    Parameters:
770 
     - id
771 
    """
772 
    pass
773 
 
2690 chandransh 774 
  def processReturn(self, returnOrderId):
775 
    """
776 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 777 
 
2690 chandransh 778 
    Parameters:
779 
     - returnOrderId
780 
    """
781 
    pass
782 
 
3451 chandransh 783 
  def updateWeight(self, orderId, weight):
784 
    """
785 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 786 
 
3451 chandransh 787 
    Parameters:
788 
     - orderId
789 
     - weight
790 
    """
791 
    pass
792 
 
3469 chandransh 793 
  def changeItem(self, orderId, itemId):
794 
    """
795 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
796 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 797 
 
3469 chandransh 798 
    Parameters:
799 
     - orderId
800 
     - itemId
801 
    """
802 
    pass
803 
 
804 
  def shiftToWarehouse(self, orderId, warehouseId):
805 
    """
806 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
807 
 
808 
    Parameters:
809 
     - orderId
810 
     - warehouseId
811 
    """
812 
    pass
813 
 
4647 rajveer 814 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 815 
    """
816 
    Adds the given delay reason to the given order.
3986 chandransh 817 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 818 
    Raises an exception if no order with the given id can be found.
3469 chandransh 819 
 
3553 chandransh 820 
    Parameters:
821 
     - orderId
822 
     - delayReason
3986 chandransh 823 
     - furtherDelay
4647 rajveer 824 
     - delayReasonText
3553 chandransh 825 
    """
826 
    pass
827 
 
3956 chandransh 828 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
829 
    """
830 
    Marks the COD orders with given AWB nos. as having been processed.
831 
    Updates the captured amount for the corresponding payment.
3553 chandransh 832 
 
3956 chandransh 833 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
834 
    1. There is no order corresponding to an AWB number.
835 
    2. The captured amount for a payment exceeds the total payment.
836 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
837 
 
838 
    Parameters:
839 
     - collectedAmountMap
840 
     - xferBy
841 
     - xferTxnId
842 
     - xferDate
843 
    """
844 
    pass
845 
 
4008 mandeep.dh 846 
  def getTransactionsRequiringExtraProcessing(self, category):
847 
    """
4065 mandeep.dh 848 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 849 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 850 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 851 
 
4008 mandeep.dh 852 
    Parameters:
853 
     - category
854 
    """
855 
    pass
856 
 
857 
  def markTransactionAsProcessed(self, transactionId, category):
858 
    """
859 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 860 
    It essentially deletes the transaction id record for a particular
861 
    processing type category (if present) from DB.
862 
    This is currently used by CRM application.
4008 mandeep.dh 863 
 
864 
    Parameters:
865 
     - transactionId
866 
     - category
867 
    """
868 
    pass
869 
 
4018 chandransh 870 
  def getItemWiseRiskyOrdersCount(self, ):
871 
    """
872 
    Returns a map containing the number of risky orders keyed by item id. A risky order
873 
    is defined as one whose shipping date is about to expire.
874 
    """
875 
    pass
4008 mandeep.dh 876 
 
4295 varun.gupt 877 
  def getOrdersForItemIds(self, itemIds):
878 
    """
879 
    Returns a list of all orders which have items with given id
880 
 
881 
    Parameters:
882 
     - itemIds
883 
    """
884 
    pass
885 
 
4247 rajveer 886 
  def markOrderCancellationRequestReceived(self, orderId):
887 
    """
888 
    Mark order as cancellation request received. If customer sends request of cancellation of
889 
    a particular order, this method will be called. It will just change status of the order
890 
    depending on its current status. It also records the previous status, so that we can move
891 
    back to that status if cancellation request is denied.
4018 chandransh 892 
 
4247 rajveer 893 
    Parameters:
894 
     - orderId
895 
    """
896 
    pass
897 
 
898 
  def markOrderCancellationRequestConfirmed(self, orderId):
899 
    """
900 
    If we decide to to cancel order, CRM will call this method to move the status of order to
901 
    cancellation request confirmed. After this OM will be able to cancel the order.
902 
 
903 
    Parameters:
904 
     - orderId
905 
    """
906 
    pass
907 
 
908 
  def markOrderCancellationRequestDenied(self, orderId):
909 
    """
910 
    If we decide to not to cancel order, we will move the order ro previous status.
911 
 
912 
    Parameters:
913 
     - orderId
914 
    """
915 
    pass
916 
 
4258 rajveer 917 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 918 
    """
4258 rajveer 919 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
920 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 921 
 
922 
    Parameters:
4258 rajveer 923 
     - transactionId
4247 rajveer 924 
    """
925 
    pass
926 
 
4259 anupam.sin 927 
  def refundTransaction(self, transactionId, refundedBy, reason):
928 
    """
929 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
930 
    need to be cancelled
4247 rajveer 931 
 
4259 anupam.sin 932 
    Parameters:
933 
     - transactionId
934 
     - refundedBy
935 
     - reason
936 
    """
937 
    pass
938 
 
4324 mandeep.dh 939 
  def updateShipmentAddress(self, orderId, addressId):
940 
    """
941 
    Updates shipment address of an order. Delivery and shipping date estimates
942 
    etc. are also updated here.
943 
 
944 
    Throws TransactionServiceException in case address change is not
945 
    possible due to certain reasons such as new pincode in address is
946 
    not serviceable etc.
947 
 
948 
    Parameters:
949 
     - orderId
950 
     - addressId
951 
    """
952 
    pass
953 
 
4285 rajveer 954 
  def acceptOrdersForItemId(self, itemId, inventory):
955 
    """
956 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
957 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 958 
 
4285 rajveer 959 
    Parameters:
960 
     - itemId
961 
     - inventory
962 
    """
963 
    pass
964 
 
4369 rajveer 965 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 966 
    """
967 
    Parameters:
968 
     - vendorId
969 
     - itemId
970 
     - quantity
971 
     - estimate
4369 rajveer 972 
     - isReminder
4303 rajveer 973 
    """
974 
    pass
4285 rajveer 975 
 
4369 rajveer 976 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 977 
    """
978 
    Parameters:
979 
     - vendorId
980 
     - itemId
981 
     - quantity
982 
     - estimate
4369 rajveer 983 
     - isReminder
4303 rajveer 984 
    """
985 
    pass
986 
 
4369 rajveer 987 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 988 
    """
989 
    Parameters:
990 
     - vendorId
991 
     - itemId
992 
     - quantity
993 
     - estimate
4369 rajveer 994 
     - isReminder
4303 rajveer 995 
    """
996 
    pass
997 
 
4369 rajveer 998 
  def markOrdersAsTimeout(self, vendorId):
999 
    """
1000 
    Parameters:
1001 
     - vendorId
1002 
    """
1003 
    pass
4303 rajveer 1004 
 
4662 rajveer 1005 
  def markOrderAsLostInTransit(self, orderId):
1006 
    """
1007 
    Mark order as LOST_IN_TRANSIT
1008 
 
1009 
    Parameters:
1010 
     - orderId
1011 
    """
1012 
    pass
1013 
 
4386 anupam.sin 1014 
  def getOrderForAwb(self, awb):
1015 
    """
1016 
    Returns the order corresponding to an AWB number
4369 rajveer 1017 
 
4386 anupam.sin 1018 
    Parameters:
1019 
     - awb
1020 
    """
1021 
    pass
1022 
 
4910 phani.kuma 1023 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1024 
    """
4910 phani.kuma 1025 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1026 
 
4506 phani.kuma 1027 
    Parameters:
1028 
     - logistics_provider_id
4910 phani.kuma 1029 
     - order_status_list
4506 phani.kuma 1030 
    """
1031 
    pass
1032 
 
4600 varun.gupt 1033 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1034 
    """
1035 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1036 
 
4600 varun.gupt 1037 
    Parameters:
1038 
     - vendorId
1039 
     - billingDateFrom
1040 
     - billingDateTo
1041 
    """
1042 
    pass
1043 
 
4607 rajveer 1044 
  def getSlippedSippingDateOrders(self, ):
1045 
    pass
1046 
 
4709 rajveer 1047 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1048 
    """
1049 
    Parameters:
1050 
     - cancelDateFrom
1051 
     - cancelDateTo
1052 
    """
1053 
    pass
1054 
 
4600 varun.gupt 1055 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1056 
    """
1057 
    Parameters:
1058 
     - mapAWBAndAmount
1059 
    """
1060 
    pass
1061 
 
4905 varun.gupt 1062 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1063 
    """
1064 
    Parameters:
1065 
     - settlementDate
1066 
     - paymentGatewayId
4905 varun.gupt 1067 
     - referenceId
4600 varun.gupt 1068 
     - serviceTax
1069 
     - otherCharges
1070 
     - netCollection
1071 
    """
1072 
    pass
1073 
 
1074 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1075 
    """
1076 
    Parameters:
1077 
     - settlementId
1078 
     - settlementDate
1079 
     - transactionDateFrom
1080 
     - transactionDateTo
1081 
     - amount
1082 
    """
1083 
    pass
1084 
 
5386 phani.kuma 1085 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1086 
    """
1087 
    Parameters:
5189 varun.gupt 1088 
     - referenceId
1089 
     - isRefund
4600 varun.gupt 1090 
    """
1091 
    pass
1092 
 
5386 phani.kuma 1093 
  def getSettlementForCod(self, orderId, isRefund):
1094 
    """
1095 
    Parameters:
1096 
     - orderId
1097 
     - isRefund
1098 
    """
1099 
    pass
1100 
 
4600 varun.gupt 1101 
  def getEBSSettlementSummaries(self, ):
1102 
    pass
1103 
 
1104 
  def markEBSSettlementUploaded(self, settlementId):
1105 
    """
1106 
    Parameters:
1107 
     - settlementId
1108 
    """
1109 
    pass
1110 
 
1111 
  def getEBSSettlementDate(self, settlementId):
1112 
    """
1113 
    Parameters:
1114 
     - settlementId
1115 
    """
1116 
    pass
1117 
 
4715 varun.gupt 1118 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1119 
    """
1120 
    Parameters:
1121 
     - settlementDateFrom
1122 
     - settlementDateTo
1123 
     - isRefund
1124 
    """
1125 
    pass
4600 varun.gupt 1126 
 
4715 varun.gupt 1127 
  def getReshippedOrderIds(self, orderIds):
1128 
    """
1129 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1130 
 
1131 
    Parameters:
1132 
     - orderIds
1133 
    """
1134 
    pass
1135 
 
5481 phani.kuma 1136 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1137 
    """
1138 
    Parameters:
1139 
     - vendorId
5481 phani.kuma 1140 
     - onlyVendorNotPaid
1141 
     - billingDateFrom
1142 
     - billingDateTo
4875 varun.gupt 1143 
    """
1144 
    pass
4757 mandeep.dh 1145 
 
5031 varun.gupt 1146 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1147 
    """
1148 
    Parameters:
1149 
     - startDate
1150 
     - endDate
1151 
    """
1152 
    pass
4875 varun.gupt 1153 
 
5067 varun.gupt 1154 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1155 
    """
1156 
    Parameters:
1157 
     - status
1158 
     - startDatetime
1159 
     - endDatetime
1160 
    """
1161 
    pass
5031 varun.gupt 1162 
 
5348 anupam.sin 1163 
  def updateCODAgent(self, agent, orderId):
1164 
    """
1165 
    Updates the agent who handled the COD verification call
1166 
 
1167 
    Parameters:
1168 
     - agent
1169 
     - orderId
1170 
    """
1171 
    pass
1172 
 
5099 varun.gupt 1173 
  def updateOrderAsPaidToVendor(self, orderId):
1174 
    """
1175 
    Parameters:
1176 
     - orderId
1177 
    """
1178 
    pass
5067 varun.gupt 1179 
 
5386 phani.kuma 1180 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1181 
    """
1182 
    Parameters:
1183 
     - orderId
1184 
    """
1185 
    pass
1186 
 
5208 varun.gupt 1187 
  def getRefundedOrdersMarkedPaid(self, ):
1188 
    pass
5099 varun.gupt 1189 
 
5447 anupam.sin 1190 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1191 
    """
1192 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1193 
 
5447 anupam.sin 1194 
 
1195 
    Parameters:
1196 
     - minOrderId
1197 
     - maxOrderId
1198 
    """
1199 
    pass
1200 
 
5527 anupam.sin 1201 
  def getAllAttributesForOrderId(self, orderId):
1202 
    """
1203 
    gets all attributes for a given orderId
5447 anupam.sin 1204 
 
5527 anupam.sin 1205 
    Parameters:
1206 
     - orderId
1207 
    """
1208 
    pass
1209 
 
5676 rajveer 1210 
  def setOrderAttributes(self, orderId, attributes):
1211 
    """
1212 
    sets attributes for an order
1213 
 
1214 
    Parameters:
1215 
     - orderId
1216 
     - attributes
1217 
    """
1218 
    pass
1219 
 
5527 anupam.sin 1220 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1221 
    """
1222 
    sets attributes for all orders in a transaction
1223 
 
1224 
    Parameters:
1225 
     - transactionId
1226 
     - attribute
1227 
    """
1228 
    pass
1229 
 
5553 rajveer 1230 
  def getReceivePendingOrders(self, storeId):
1231 
    """
1232 
    Parameters:
1233 
     - storeId
1234 
    """
1235 
    pass
5527 anupam.sin 1236 
 
5553 rajveer 1237 
  def getReceivedAtStoreOrders(self, storeId):
1238 
    """
1239 
    Parameters:
1240 
     - storeId
1241 
    """
1242 
    pass
1243 
 
5713 rajveer 1244 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
1245 
    """
1246 
    Parameters:
1247 
     - storeId
1248 
     - fromDate
1249 
     - toDate
1250 
     - onlyCod
1251 
    """
1252 
    pass
1253 
 
5833 rajveer 1254 
  def getOrderAttributeValue(self, orderId, attributeName):
1255 
    """
1256 
    Parameters:
1257 
     - orderId
1258 
     - attributeName
1259 
    """
1260 
    pass
1261 
 
6019 rajveer 1262 
  def changeJacketNumber(self, orderId, jacketNumber):
1263 
    """
1264 
    Parameters:
1265 
     - orderId
1266 
     - jacketNumber
1267 
    """
1268 
    pass
1269 
 
1270 
  def markOrderAsRtoInTransit(self, orderId):
1271 
    """
1272 
    Parameters:
1273 
     - orderId
1274 
    """
1275 
    pass
1276 
 
5593 mandeep.dh 1277 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1278 
    """
1279 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1280 
    invoked while scanning IN of items.
5553 rajveer 1281 
 
5593 mandeep.dh 1282 
    Parameters:
1283 
     - itemId
1284 
     - quantity
1285 
     - fulfilmentWarehouseId
1286 
     - billingWarehouseId
1287 
    """
1288 
    pass
1289 
 
6000 mandeep.dh 1290 
  def createRechargeOrder(self, rechargeOrder):
1291 
    """
1292 
    Parameters:
1293 
     - rechargeOrder
1294 
    """
1295 
    pass
5593 mandeep.dh 1296 
 
6031 rajveer 1297 
  def getRechargeOrder(self, rechargeRrderId):
1298 
    """
1299 
    Parameters:
1300 
     - rechargeRrderId
1301 
    """
1302 
    pass
1303 
 
1304 
  def getRechargeOrders(self, userId):
1305 
    """
1306 
    Parameters:
1307 
     - userId
1308 
    """
1309 
    pass
1310 
 
6000 mandeep.dh 1311 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
1312 
    """
1313 
    Parameters:
1314 
     - rechargeOrderId
1315 
     - rechargeOrderStatus
1316 
    """
1317 
    pass
1318 
 
6031 rajveer 1319 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 1320 
    """
1321 
    Parameters:
6031 rajveer 1322 
     - rechargeOrderId
6000 mandeep.dh 1323 
    """
1324 
    pass
1325 
 
6031 rajveer 1326 
  def getUserWallet(self, userId):
6000 mandeep.dh 1327 
    """
1328 
    Parameters:
6031 rajveer 1329 
     - userId
6000 mandeep.dh 1330 
    """
1331 
    pass
1332 
 
6031 rajveer 1333 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 1334 
    """
1335 
    Parameters:
6031 rajveer 1336 
     - userId
6000 mandeep.dh 1337 
    """
1338 
    pass
1339 
 
6050 anupam.sin 1340 
  def getRechargeOrdersForTransaction(self, txnId):
1341 
    """
1342 
    Returns a recharge order for a given transactionId
1343 
 
1344 
    Parameters:
1345 
     - txnId
1346 
    """
1347 
    pass
1348 
 
6206 rajveer 1349 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 1350 
    """
1351 
    Parameters:
1352 
     - rechargeType
6206 rajveer 1353 
     - onlyActive
6048 rajveer 1354 
    """
1355 
    pass
6000 mandeep.dh 1356 
 
6049 rajveer 1357 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 1358 
    """
1359 
    Parameters:
6049 rajveer 1360 
     - rechargeType
6048 rajveer 1361 
     - deviceNumber
1362 
    """
1363 
    pass
1364 
 
6336 anupam.sin 1365 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId):
6269 rajveer 1366 
    """
1367 
    Parameters:
1368 
     - rechargeType
1369 
     - deviceNumber
6307 anupam.sin 1370 
     - userSelectedProviderId
6269 rajveer 1371 
    """
1372 
    pass
1373 
 
6094 rajveer 1374 
  def getRechargeOrdersForDevice(self, deviceNumber):
1375 
    """
1376 
    Parameters:
1377 
     - deviceNumber
1378 
    """
1379 
    pass
6048 rajveer 1380 
 
6094 rajveer 1381 
  def addAmountToWallet(self, userId, orderId, amount):
1382 
    """
1383 
    Parameters:
1384 
     - userId
1385 
     - orderId
1386 
     - amount
1387 
    """
1388 
    pass
1389 
 
6188 rajveer 1390 
  def getRechargeStatistics(self, ):
1391 
    pass
1392 
 
6154 rajveer 1393 
  def getRechargeOrdersForStatus(self, status):
1394 
    """
1395 
    Parameters:
1396 
     - status
1397 
    """
1398 
    pass
6094 rajveer 1399 
 
6159 rajveer 1400 
  def getPlansForOperator(self, operatorId):
1401 
    """
1402 
    Parameters:
1403 
     - operatorId
1404 
    """
1405 
    pass
6154 rajveer 1406 
 
6307 anupam.sin 1407 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 1408 
    """
1409 
    Returns denominations for a given operator and circle
6159 rajveer 1410 
 
6289 anupam.sin 1411 
    Parameters:
1412 
     - operatorId
6307 anupam.sin 1413 
     - circleCode
6289 anupam.sin 1414 
     - denominationType
1415 
    """
1416 
    pass
1417 
 
1418 
 
3376 rajveer 1419 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1420 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1421 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1422 
 
1423 
  def createTransaction(self, transaction):
1424 
    """
1425 
    Parameters:
1426 
     - transaction
1427 
    """
1428 
    self.send_createTransaction(transaction)
132 ashish 1429 
    return self.recv_createTransaction()
94 ashish 1430 
 
1431 
  def send_createTransaction(self, transaction):
1432 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1433 
    args = createTransaction_args()
1434 
    args.transaction = transaction
1435 
    args.write(self._oprot)
1436 
    self._oprot.writeMessageEnd()
1437 
    self._oprot.trans.flush()
1438 
 
1439 
  def recv_createTransaction(self, ):
1440 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1441 
    if mtype == TMessageType.EXCEPTION:
1442 
      x = TApplicationException()
1443 
      x.read(self._iprot)
1444 
      self._iprot.readMessageEnd()
1445 
      raise x
1446 
    result = createTransaction_result()
1447 
    result.read(self._iprot)
1448 
    self._iprot.readMessageEnd()
3431 rajveer 1449 
    if result.success is not None:
132 ashish 1450 
      return result.success
3431 rajveer 1451 
    if result.ex is not None:
94 ashish 1452 
      raise result.ex
132 ashish 1453 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1454 
 
1455 
  def getTransaction(self, id):
1456 
    """
1457 
    Parameters:
1458 
     - id
1459 
    """
1460 
    self.send_getTransaction(id)
1461 
    return self.recv_getTransaction()
1462 
 
1463 
  def send_getTransaction(self, id):
1464 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1465 
    args = getTransaction_args()
1466 
    args.id = id
1467 
    args.write(self._oprot)
1468 
    self._oprot.writeMessageEnd()
1469 
    self._oprot.trans.flush()
1470 
 
1471 
  def recv_getTransaction(self, ):
1472 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1473 
    if mtype == TMessageType.EXCEPTION:
1474 
      x = TApplicationException()
1475 
      x.read(self._iprot)
1476 
      self._iprot.readMessageEnd()
1477 
      raise x
1478 
    result = getTransaction_result()
1479 
    result.read(self._iprot)
1480 
    self._iprot.readMessageEnd()
3431 rajveer 1481 
    if result.success is not None:
94 ashish 1482 
      return result.success
3431 rajveer 1483 
    if result.ex is not None:
94 ashish 1484 
      raise result.ex
1485 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1486 
 
1487 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1488 
    """
1489 
    Parameters:
1490 
     - customerId
1491 
     - from_date
1492 
     - to_date
1493 
     - status
1494 
    """
1495 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1496 
    return self.recv_getTransactionsForCustomer()
1497 
 
1498 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1499 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1500 
    args = getTransactionsForCustomer_args()
1501 
    args.customerId = customerId
1502 
    args.from_date = from_date
1503 
    args.to_date = to_date
1504 
    args.status = status
1505 
    args.write(self._oprot)
1506 
    self._oprot.writeMessageEnd()
1507 
    self._oprot.trans.flush()
1508 
 
1509 
  def recv_getTransactionsForCustomer(self, ):
1510 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1511 
    if mtype == TMessageType.EXCEPTION:
1512 
      x = TApplicationException()
1513 
      x.read(self._iprot)
1514 
      self._iprot.readMessageEnd()
1515 
      raise x
1516 
    result = getTransactionsForCustomer_result()
1517 
    result.read(self._iprot)
1518 
    self._iprot.readMessageEnd()
3431 rajveer 1519 
    if result.success is not None:
94 ashish 1520 
      return result.success
3431 rajveer 1521 
    if result.ex is not None:
94 ashish 1522 
      raise result.ex
1523 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1524 
 
132 ashish 1525 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1526 
    """
1527 
    Parameters:
1528 
     - shoppingCartId
1529 
    """
1530 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1531 
    return self.recv_getTransactionsForShoppingCartId()
1532 
 
1533 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1534 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1535 
    args = getTransactionsForShoppingCartId_args()
1536 
    args.shoppingCartId = shoppingCartId
1537 
    args.write(self._oprot)
1538 
    self._oprot.writeMessageEnd()
1539 
    self._oprot.trans.flush()
1540 
 
1541 
  def recv_getTransactionsForShoppingCartId(self, ):
1542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1543 
    if mtype == TMessageType.EXCEPTION:
1544 
      x = TApplicationException()
1545 
      x.read(self._iprot)
1546 
      self._iprot.readMessageEnd()
1547 
      raise x
1548 
    result = getTransactionsForShoppingCartId_result()
1549 
    result.read(self._iprot)
1550 
    self._iprot.readMessageEnd()
3431 rajveer 1551 
    if result.success is not None:
132 ashish 1552 
      return result.success
3431 rajveer 1553 
    if result.ex is not None:
132 ashish 1554 
      raise result.ex
1555 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1556 
 
94 ashish 1557 
  def getTransactionStatus(self, transactionId):
1558 
    """
1559 
    Parameters:
1560 
     - transactionId
1561 
    """
1562 
    self.send_getTransactionStatus(transactionId)
1563 
    return self.recv_getTransactionStatus()
1564 
 
1565 
  def send_getTransactionStatus(self, transactionId):
1566 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1567 
    args = getTransactionStatus_args()
1568 
    args.transactionId = transactionId
1569 
    args.write(self._oprot)
1570 
    self._oprot.writeMessageEnd()
1571 
    self._oprot.trans.flush()
1572 
 
1573 
  def recv_getTransactionStatus(self, ):
1574 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1575 
    if mtype == TMessageType.EXCEPTION:
1576 
      x = TApplicationException()
1577 
      x.read(self._iprot)
1578 
      self._iprot.readMessageEnd()
1579 
      raise x
1580 
    result = getTransactionStatus_result()
1581 
    result.read(self._iprot)
1582 
    self._iprot.readMessageEnd()
3431 rajveer 1583 
    if result.success is not None:
94 ashish 1584 
      return result.success
3431 rajveer 1585 
    if result.ex is not None:
94 ashish 1586 
      raise result.ex
1587 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1588 
 
5527 anupam.sin 1589 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1590 
    """
1591 
    Parameters:
1592 
     - transactionId
1593 
     - status
1594 
     - description
5527 anupam.sin 1595 
     - pickUp
1596 
     - orderType
94 ashish 1597 
    """
5527 anupam.sin 1598 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1599 
    return self.recv_changeTransactionStatus()
1600 
 
5527 anupam.sin 1601 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1602 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1603 
    args = changeTransactionStatus_args()
1604 
    args.transactionId = transactionId
1605 
    args.status = status
1606 
    args.description = description
5527 anupam.sin 1607 
    args.pickUp = pickUp
1608 
    args.orderType = orderType
94 ashish 1609 
    args.write(self._oprot)
1610 
    self._oprot.writeMessageEnd()
1611 
    self._oprot.trans.flush()
1612 
 
1613 
  def recv_changeTransactionStatus(self, ):
1614 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1615 
    if mtype == TMessageType.EXCEPTION:
1616 
      x = TApplicationException()
1617 
      x.read(self._iprot)
1618 
      self._iprot.readMessageEnd()
1619 
      raise x
1620 
    result = changeTransactionStatus_result()
1621 
    result.read(self._iprot)
1622 
    self._iprot.readMessageEnd()
3431 rajveer 1623 
    if result.success is not None:
94 ashish 1624 
      return result.success
3431 rajveer 1625 
    if result.ex is not None:
94 ashish 1626 
      raise result.ex
1627 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1628 
 
1398 varun.gupt 1629 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1630 
    """
1631 
    Parameters:
1632 
     - transactionId
1633 
    """
1398 varun.gupt 1634 
    self.send_enqueueTransactionInfoEmail(transactionId)
1635 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1636 
 
1398 varun.gupt 1637 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1638 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1639 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1640 
    args.transactionId = transactionId
1641 
    args.write(self._oprot)
1642 
    self._oprot.writeMessageEnd()
1643 
    self._oprot.trans.flush()
1644 
 
1398 varun.gupt 1645 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1646 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1647 
    if mtype == TMessageType.EXCEPTION:
1648 
      x = TApplicationException()
1649 
      x.read(self._iprot)
1650 
      self._iprot.readMessageEnd()
1651 
      raise x
1398 varun.gupt 1652 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1653 
    result.read(self._iprot)
1654 
    self._iprot.readMessageEnd()
3431 rajveer 1655 
    if result.success is not None:
1382 varun.gupt 1656 
      return result.success
3431 rajveer 1657 
    if result.ex is not None:
1382 varun.gupt 1658 
      raise result.ex
1398 varun.gupt 1659 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1660 
 
4801 anupam.sin 1661 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1662 
    """
1663 
    Parameters:
4801 anupam.sin 1664 
     - statuses
483 rajveer 1665 
     - from_date
1666 
     - to_date
1667 
     - warehouse_id
94 ashish 1668 
    """
4801 anupam.sin 1669 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1670 
    return self.recv_getAllOrders()
94 ashish 1671 
 
4801 anupam.sin 1672 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1673 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1674 
    args = getAllOrders_args()
4801 anupam.sin 1675 
    args.statuses = statuses
483 rajveer 1676 
    args.from_date = from_date
1677 
    args.to_date = to_date
1678 
    args.warehouse_id = warehouse_id
94 ashish 1679 
    args.write(self._oprot)
1680 
    self._oprot.writeMessageEnd()
1681 
    self._oprot.trans.flush()
1682 
 
483 rajveer 1683 
  def recv_getAllOrders(self, ):
94 ashish 1684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1685 
    if mtype == TMessageType.EXCEPTION:
1686 
      x = TApplicationException()
1687 
      x.read(self._iprot)
1688 
      self._iprot.readMessageEnd()
1689 
      raise x
483 rajveer 1690 
    result = getAllOrders_result()
94 ashish 1691 
    result.read(self._iprot)
1692 
    self._iprot.readMessageEnd()
3431 rajveer 1693 
    if result.success is not None:
94 ashish 1694 
      return result.success
3431 rajveer 1695 
    if result.ex is not None:
94 ashish 1696 
      raise result.ex
483 rajveer 1697 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1698 
 
4133 chandransh 1699 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1700 
    """
1701 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1702 
    Pass the status as null and the limit as 0 to ignore them.
1703 
 
1704 
    Parameters:
1705 
     - statuses
1706 
     - offset
1707 
     - limit
1708 
     - warehouse_id
1709 
    """
1710 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1711 
    return self.recv_getOrdersInBatch()
1712 
 
1713 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1714 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1715 
    args = getOrdersInBatch_args()
1716 
    args.statuses = statuses
1717 
    args.offset = offset
1718 
    args.limit = limit
1719 
    args.warehouse_id = warehouse_id
1720 
    args.write(self._oprot)
1721 
    self._oprot.writeMessageEnd()
1722 
    self._oprot.trans.flush()
1723 
 
1724 
  def recv_getOrdersInBatch(self, ):
1725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1726 
    if mtype == TMessageType.EXCEPTION:
1727 
      x = TApplicationException()
1728 
      x.read(self._iprot)
1729 
      self._iprot.readMessageEnd()
1730 
      raise x
1731 
    result = getOrdersInBatch_result()
1732 
    result.read(self._iprot)
1733 
    self._iprot.readMessageEnd()
1734 
    if result.success is not None:
1735 
      return result.success
1736 
    if result.ex is not None:
1737 
      raise result.ex
1738 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1739 
 
1740 
  def getOrderCount(self, statuses, warehouseId):
1741 
    """
1742 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1743 
 
1744 
    Parameters:
1745 
     - statuses
1746 
     - warehouseId
1747 
    """
1748 
    self.send_getOrderCount(statuses, warehouseId)
1749 
    return self.recv_getOrderCount()
1750 
 
1751 
  def send_getOrderCount(self, statuses, warehouseId):
1752 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1753 
    args = getOrderCount_args()
1754 
    args.statuses = statuses
1755 
    args.warehouseId = warehouseId
1756 
    args.write(self._oprot)
1757 
    self._oprot.writeMessageEnd()
1758 
    self._oprot.trans.flush()
1759 
 
1760 
  def recv_getOrderCount(self, ):
1761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1762 
    if mtype == TMessageType.EXCEPTION:
1763 
      x = TApplicationException()
1764 
      x.read(self._iprot)
1765 
      self._iprot.readMessageEnd()
1766 
      raise x
1767 
    result = getOrderCount_result()
1768 
    result.read(self._iprot)
1769 
    self._iprot.readMessageEnd()
1770 
    if result.success is not None:
1771 
      return result.success
1772 
    if result.ex is not None:
1773 
      raise result.ex
1774 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1775 
 
999 varun.gupt 1776 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1777 
    """
1132 chandransh 1778 
    Returns orders within a range of their billing dates
3431 rajveer 1779 
 
999 varun.gupt 1780 
    Parameters:
1781 
     - status
1782 
     - start_billing_date
1783 
     - end_billing_date
1784 
     - warehouse_id
1785 
    """
1786 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1787 
    return self.recv_getOrdersByBillingDate()
1788 
 
1789 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1790 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1791 
    args = getOrdersByBillingDate_args()
1792 
    args.status = status
1793 
    args.start_billing_date = start_billing_date
1794 
    args.end_billing_date = end_billing_date
1795 
    args.warehouse_id = warehouse_id
1796 
    args.write(self._oprot)
1797 
    self._oprot.writeMessageEnd()
1798 
    self._oprot.trans.flush()
1799 
 
1800 
  def recv_getOrdersByBillingDate(self, ):
1801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1802 
    if mtype == TMessageType.EXCEPTION:
1803 
      x = TApplicationException()
1804 
      x.read(self._iprot)
1805 
      self._iprot.readMessageEnd()
1806 
      raise x
1807 
    result = getOrdersByBillingDate_result()
1808 
    result.read(self._iprot)
1809 
    self._iprot.readMessageEnd()
3431 rajveer 1810 
    if result.success is not None:
999 varun.gupt 1811 
      return result.success
3431 rajveer 1812 
    if result.ex is not None:
999 varun.gupt 1813 
      raise result.ex
1814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1815 
 
3451 chandransh 1816 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1817 
    """
1818 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1819 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1820 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1821 
 
3427 chandransh 1822 
    Parameters:
1823 
     - fromShippingDate
1824 
     - toShippingDate
1825 
     - providerId
1826 
     - warehouseId
3451 chandransh 1827 
     - cod
3427 chandransh 1828 
    """
3451 chandransh 1829 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1830 
    return self.recv_getOrdersByShippingDate()
1831 
 
3451 chandransh 1832 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1833 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1834 
    args = getOrdersByShippingDate_args()
1835 
    args.fromShippingDate = fromShippingDate
1836 
    args.toShippingDate = toShippingDate
1837 
    args.providerId = providerId
1838 
    args.warehouseId = warehouseId
3451 chandransh 1839 
    args.cod = cod
3427 chandransh 1840 
    args.write(self._oprot)
1841 
    self._oprot.writeMessageEnd()
1842 
    self._oprot.trans.flush()
1843 
 
1844 
  def recv_getOrdersByShippingDate(self, ):
1845 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1846 
    if mtype == TMessageType.EXCEPTION:
1847 
      x = TApplicationException()
1848 
      x.read(self._iprot)
1849 
      self._iprot.readMessageEnd()
1850 
      raise x
1851 
    result = getOrdersByShippingDate_result()
1852 
    result.read(self._iprot)
1853 
    self._iprot.readMessageEnd()
3431 rajveer 1854 
    if result.success is not None:
3427 chandransh 1855 
      return result.success
3431 rajveer 1856 
    if result.ex is not None:
3427 chandransh 1857 
      raise result.ex
1858 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1859 
 
1382 varun.gupt 1860 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1861 
    """
1862 
    Returns order ids for orders which can be returned
3431 rajveer 1863 
 
1382 varun.gupt 1864 
    Parameters:
1865 
     - customer_id
1866 
     - limit
1867 
    """
1868 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1869 
    return self.recv_getReturnableOrdersForCustomer()
1870 
 
1871 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1872 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1873 
    args = getReturnableOrdersForCustomer_args()
1874 
    args.customer_id = customer_id
1875 
    args.limit = limit
1876 
    args.write(self._oprot)
1877 
    self._oprot.writeMessageEnd()
1878 
    self._oprot.trans.flush()
1879 
 
1880 
  def recv_getReturnableOrdersForCustomer(self, ):
1881 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1882 
    if mtype == TMessageType.EXCEPTION:
1883 
      x = TApplicationException()
1884 
      x.read(self._iprot)
1885 
      self._iprot.readMessageEnd()
1886 
      raise x
1887 
    result = getReturnableOrdersForCustomer_result()
1888 
    result.read(self._iprot)
1889 
    self._iprot.readMessageEnd()
3431 rajveer 1890 
    if result.success is not None:
1382 varun.gupt 1891 
      return result.success
3431 rajveer 1892 
    if result.ex is not None:
1382 varun.gupt 1893 
      raise result.ex
1894 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1895 
 
1896 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1897 
    """
1898 
    Returns order ids for orders which can be cancelled
3431 rajveer 1899 
 
1382 varun.gupt 1900 
    Parameters:
1901 
     - customer_id
1902 
     - limit
1903 
    """
1904 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1905 
    return self.recv_getCancellableOrdersForCustomer()
1906 
 
1907 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1908 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1909 
    args = getCancellableOrdersForCustomer_args()
1910 
    args.customer_id = customer_id
1911 
    args.limit = limit
1912 
    args.write(self._oprot)
1913 
    self._oprot.writeMessageEnd()
1914 
    self._oprot.trans.flush()
1915 
 
1916 
  def recv_getCancellableOrdersForCustomer(self, ):
1917 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1918 
    if mtype == TMessageType.EXCEPTION:
1919 
      x = TApplicationException()
1920 
      x.read(self._iprot)
1921 
      self._iprot.readMessageEnd()
1922 
      raise x
1923 
    result = getCancellableOrdersForCustomer_result()
1924 
    result.read(self._iprot)
1925 
    self._iprot.readMessageEnd()
3431 rajveer 1926 
    if result.success is not None:
1382 varun.gupt 1927 
      return result.success
3431 rajveer 1928 
    if result.ex is not None:
1382 varun.gupt 1929 
      raise result.ex
1930 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1931 
 
483 rajveer 1932 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1933 
    """
1934 
    Parameters:
483 rajveer 1935 
     - orderId
1936 
     - status
1937 
     - description
94 ashish 1938 
    """
483 rajveer 1939 
    self.send_changeOrderStatus(orderId, status, description)
1940 
    return self.recv_changeOrderStatus()
94 ashish 1941 
 
483 rajveer 1942 
  def send_changeOrderStatus(self, orderId, status, description):
1943 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1944 
    args = changeOrderStatus_args()
1945 
    args.orderId = orderId
1946 
    args.status = status
1947 
    args.description = description
94 ashish 1948 
    args.write(self._oprot)
1949 
    self._oprot.writeMessageEnd()
1950 
    self._oprot.trans.flush()
1951 
 
483 rajveer 1952 
  def recv_changeOrderStatus(self, ):
94 ashish 1953 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1954 
    if mtype == TMessageType.EXCEPTION:
1955 
      x = TApplicationException()
1956 
      x.read(self._iprot)
1957 
      self._iprot.readMessageEnd()
1958 
      raise x
483 rajveer 1959 
    result = changeOrderStatus_result()
94 ashish 1960 
    result.read(self._iprot)
1961 
    self._iprot.readMessageEnd()
3431 rajveer 1962 
    if result.success is not None:
94 ashish 1963 
      return result.success
3431 rajveer 1964 
    if result.ex is not None:
94 ashish 1965 
      raise result.ex
483 rajveer 1966 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1967 
 
1528 ankur.sing 1968 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1969 
    """
1528 ankur.sing 1970 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
1971 
    only user who owns the transaction can view its order details.
3431 rajveer 1972 
 
94 ashish 1973 
    Parameters:
1974 
     - transactionId
1528 ankur.sing 1975 
     - customerId
94 ashish 1976 
    """
1528 ankur.sing 1977 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 1978 
    return self.recv_getOrdersForTransaction()
94 ashish 1979 
 
1528 ankur.sing 1980 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 1981 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
1982 
    args = getOrdersForTransaction_args()
94 ashish 1983 
    args.transactionId = transactionId
1528 ankur.sing 1984 
    args.customerId = customerId
94 ashish 1985 
    args.write(self._oprot)
1986 
    self._oprot.writeMessageEnd()
1987 
    self._oprot.trans.flush()
1988 
 
483 rajveer 1989 
  def recv_getOrdersForTransaction(self, ):
94 ashish 1990 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1991 
    if mtype == TMessageType.EXCEPTION:
1992 
      x = TApplicationException()
1993 
      x.read(self._iprot)
1994 
      self._iprot.readMessageEnd()
1995 
      raise x
483 rajveer 1996 
    result = getOrdersForTransaction_result()
94 ashish 1997 
    result.read(self._iprot)
1998 
    self._iprot.readMessageEnd()
3431 rajveer 1999 
    if result.success is not None:
94 ashish 2000 
      return result.success
3431 rajveer 2001 
    if result.ex is not None:
94 ashish 2002 
      raise result.ex
483 rajveer 2003 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2004 
 
3014 chandransh 2005 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2006 
    """
3014 chandransh 2007 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2008 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2009 
 
94 ashish 2010 
    Parameters:
483 rajveer 2011 
     - customerId
2012 
     - from_date
2013 
     - to_date
3014 chandransh 2014 
     - statuses
94 ashish 2015 
    """
3014 chandransh 2016 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2017 
    return self.recv_getOrdersForCustomer()
94 ashish 2018 
 
3014 chandransh 2019 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2020 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2021 
    args = getOrdersForCustomer_args()
2022 
    args.customerId = customerId
2023 
    args.from_date = from_date
2024 
    args.to_date = to_date
3014 chandransh 2025 
    args.statuses = statuses
94 ashish 2026 
    args.write(self._oprot)
2027 
    self._oprot.writeMessageEnd()
2028 
    self._oprot.trans.flush()
2029 
 
483 rajveer 2030 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2031 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2032 
    if mtype == TMessageType.EXCEPTION:
2033 
      x = TApplicationException()
2034 
      x.read(self._iprot)
2035 
      self._iprot.readMessageEnd()
2036 
      raise x
483 rajveer 2037 
    result = getOrdersForCustomer_result()
94 ashish 2038 
    result.read(self._iprot)
2039 
    self._iprot.readMessageEnd()
3431 rajveer 2040 
    if result.success is not None:
94 ashish 2041 
      return result.success
3431 rajveer 2042 
    if result.ex is not None:
94 ashish 2043 
      raise result.ex
483 rajveer 2044 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2045 
 
483 rajveer 2046 
  def createOrder(self, order):
94 ashish 2047 
    """
2048 
    Parameters:
483 rajveer 2049 
     - order
94 ashish 2050 
    """
483 rajveer 2051 
    self.send_createOrder(order)
2052 
    return self.recv_createOrder()
94 ashish 2053 
 
483 rajveer 2054 
  def send_createOrder(self, order):
2055 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2056 
    args = createOrder_args()
2057 
    args.order = order
94 ashish 2058 
    args.write(self._oprot)
2059 
    self._oprot.writeMessageEnd()
2060 
    self._oprot.trans.flush()
2061 
 
483 rajveer 2062 
  def recv_createOrder(self, ):
94 ashish 2063 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2064 
    if mtype == TMessageType.EXCEPTION:
2065 
      x = TApplicationException()
2066 
      x.read(self._iprot)
2067 
      self._iprot.readMessageEnd()
2068 
      raise x
483 rajveer 2069 
    result = createOrder_result()
94 ashish 2070 
    result.read(self._iprot)
2071 
    self._iprot.readMessageEnd()
3431 rajveer 2072 
    if result.success is not None:
94 ashish 2073 
      return result.success
3431 rajveer 2074 
    if result.ex is not None:
94 ashish 2075 
      raise result.ex
483 rajveer 2076 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2077 
 
483 rajveer 2078 
  def getOrder(self, id):
94 ashish 2079 
    """
2080 
    Parameters:
483 rajveer 2081 
     - id
94 ashish 2082 
    """
483 rajveer 2083 
    self.send_getOrder(id)
2084 
    return self.recv_getOrder()
94 ashish 2085 
 
483 rajveer 2086 
  def send_getOrder(self, id):
2087 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2088 
    args = getOrder_args()
2089 
    args.id = id
94 ashish 2090 
    args.write(self._oprot)
2091 
    self._oprot.writeMessageEnd()
2092 
    self._oprot.trans.flush()
2093 
 
483 rajveer 2094 
  def recv_getOrder(self, ):
94 ashish 2095 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2096 
    if mtype == TMessageType.EXCEPTION:
2097 
      x = TApplicationException()
2098 
      x.read(self._iprot)
2099 
      self._iprot.readMessageEnd()
2100 
      raise x
483 rajveer 2101 
    result = getOrder_result()
94 ashish 2102 
    result.read(self._iprot)
2103 
    self._iprot.readMessageEnd()
3431 rajveer 2104 
    if result.success is not None:
94 ashish 2105 
      return result.success
3431 rajveer 2106 
    if result.ex is not None:
94 ashish 2107 
      raise result.ex
483 rajveer 2108 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2109 
 
483 rajveer 2110 
  def getLineItemsForOrder(self, orderId):
94 ashish 2111 
    """
2112 
    Parameters:
483 rajveer 2113 
     - orderId
94 ashish 2114 
    """
483 rajveer 2115 
    self.send_getLineItemsForOrder(orderId)
2116 
    return self.recv_getLineItemsForOrder()
94 ashish 2117 
 
483 rajveer 2118 
  def send_getLineItemsForOrder(self, orderId):
2119 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2120 
    args = getLineItemsForOrder_args()
2121 
    args.orderId = orderId
94 ashish 2122 
    args.write(self._oprot)
2123 
    self._oprot.writeMessageEnd()
2124 
    self._oprot.trans.flush()
2125 
 
483 rajveer 2126 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2127 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2128 
    if mtype == TMessageType.EXCEPTION:
2129 
      x = TApplicationException()
2130 
      x.read(self._iprot)
2131 
      self._iprot.readMessageEnd()
2132 
      raise x
483 rajveer 2133 
    result = getLineItemsForOrder_result()
94 ashish 2134 
    result.read(self._iprot)
2135 
    self._iprot.readMessageEnd()
3431 rajveer 2136 
    if result.success is not None:
94 ashish 2137 
      return result.success
3431 rajveer 2138 
    if result.ex is not None:
94 ashish 2139 
      raise result.ex
483 rajveer 2140 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2141 
 
4999 phani.kuma 2142 
  def getOrderList(self, order_ids):
2143 
    """
2144 
    Parameters:
2145 
     - order_ids
2146 
    """
2147 
    self.send_getOrderList(order_ids)
2148 
    return self.recv_getOrderList()
2149 
 
2150 
  def send_getOrderList(self, order_ids):
2151 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2152 
    args = getOrderList_args()
2153 
    args.order_ids = order_ids
2154 
    args.write(self._oprot)
2155 
    self._oprot.writeMessageEnd()
2156 
    self._oprot.trans.flush()
2157 
 
2158 
  def recv_getOrderList(self, ):
2159 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2160 
    if mtype == TMessageType.EXCEPTION:
2161 
      x = TApplicationException()
2162 
      x.read(self._iprot)
2163 
      self._iprot.readMessageEnd()
2164 
      raise x
2165 
    result = getOrderList_result()
2166 
    result.read(self._iprot)
2167 
    self._iprot.readMessageEnd()
2168 
    if result.success is not None:
2169 
      return result.success
2170 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2171 
 
5386 phani.kuma 2172 
  def getOrderListForVendor(self, order_ids, vendorId):
2173 
    """
2174 
    Parameters:
2175 
     - order_ids
2176 
     - vendorId
2177 
    """
2178 
    self.send_getOrderListForVendor(order_ids, vendorId)
2179 
    return self.recv_getOrderListForVendor()
2180 
 
2181 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2182 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2183 
    args = getOrderListForVendor_args()
2184 
    args.order_ids = order_ids
2185 
    args.vendorId = vendorId
2186 
    args.write(self._oprot)
2187 
    self._oprot.writeMessageEnd()
2188 
    self._oprot.trans.flush()
2189 
 
2190 
  def recv_getOrderListForVendor(self, ):
2191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2192 
    if mtype == TMessageType.EXCEPTION:
2193 
      x = TApplicationException()
2194 
      x.read(self._iprot)
2195 
      self._iprot.readMessageEnd()
2196 
      raise x
2197 
    result = getOrderListForVendor_result()
2198 
    result.read(self._iprot)
2199 
    self._iprot.readMessageEnd()
2200 
    if result.success is not None:
2201 
      return result.success
2202 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2203 
 
1528 ankur.sing 2204 
  def getOrderForCustomer(self, orderId, customerId):
2205 
    """
2206 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2207 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2208 
 
1528 ankur.sing 2209 
    Parameters:
2210 
     - orderId
2211 
     - customerId
2212 
    """
2213 
    self.send_getOrderForCustomer(orderId, customerId)
2214 
    return self.recv_getOrderForCustomer()
2215 
 
2216 
  def send_getOrderForCustomer(self, orderId, customerId):
2217 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2218 
    args = getOrderForCustomer_args()
2219 
    args.orderId = orderId
2220 
    args.customerId = customerId
2221 
    args.write(self._oprot)
2222 
    self._oprot.writeMessageEnd()
2223 
    self._oprot.trans.flush()
2224 
 
2225 
  def recv_getOrderForCustomer(self, ):
2226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2227 
    if mtype == TMessageType.EXCEPTION:
2228 
      x = TApplicationException()
2229 
      x.read(self._iprot)
2230 
      self._iprot.readMessageEnd()
2231 
      raise x
2232 
    result = getOrderForCustomer_result()
2233 
    result.read(self._iprot)
2234 
    self._iprot.readMessageEnd()
3431 rajveer 2235 
    if result.success is not None:
1528 ankur.sing 2236 
      return result.success
3431 rajveer 2237 
    if result.ex is not None:
1528 ankur.sing 2238 
      raise result.ex
2239 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2240 
 
4444 rajveer 2241 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2242 
    """
2243 
    Parameters:
4394 rajveer 2244 
     - type
4444 rajveer 2245 
     - warehouseId
4394 rajveer 2246 
     - status
2247 
     - timestamp
3064 chandransh 2248 
    """
4444 rajveer 2249 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2250 
    return self.recv_getAlerts()
2251 
 
4444 rajveer 2252 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2253 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2254 
    args = getAlerts_args()
4394 rajveer 2255 
    args.type = type
4444 rajveer 2256 
    args.warehouseId = warehouseId
4394 rajveer 2257 
    args.status = status
2258 
    args.timestamp = timestamp
3064 chandransh 2259 
    args.write(self._oprot)
2260 
    self._oprot.writeMessageEnd()
2261 
    self._oprot.trans.flush()
2262 
 
2263 
  def recv_getAlerts(self, ):
2264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2265 
    if mtype == TMessageType.EXCEPTION:
2266 
      x = TApplicationException()
2267 
      x.read(self._iprot)
2268 
      self._iprot.readMessageEnd()
2269 
      raise x
2270 
    result = getAlerts_result()
2271 
    result.read(self._iprot)
2272 
    self._iprot.readMessageEnd()
3431 rajveer 2273 
    if result.success is not None:
3064 chandransh 2274 
      return result.success
2275 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2276 
 
4444 rajveer 2277 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2278 
    """
2279 
    Parameters:
2280 
     - type
4444 rajveer 2281 
     - warehouseId
4394 rajveer 2282 
     - description
3064 chandransh 2283 
    """
4444 rajveer 2284 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2285 
    self.recv_addAlert()
3064 chandransh 2286 
 
4444 rajveer 2287 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2288 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2289 
    args = addAlert_args()
3064 chandransh 2290 
    args.type = type
4444 rajveer 2291 
    args.warehouseId = warehouseId
4394 rajveer 2292 
    args.description = description
3064 chandransh 2293 
    args.write(self._oprot)
2294 
    self._oprot.writeMessageEnd()
2295 
    self._oprot.trans.flush()
2296 
 
4394 rajveer 2297 
  def recv_addAlert(self, ):
3064 chandransh 2298 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2299 
    if mtype == TMessageType.EXCEPTION:
2300 
      x = TApplicationException()
2301 
      x.read(self._iprot)
2302 
      self._iprot.readMessageEnd()
2303 
      raise x
4394 rajveer 2304 
    result = addAlert_result()
3064 chandransh 2305 
    result.read(self._iprot)
2306 
    self._iprot.readMessageEnd()
2307 
    return
2308 
 
4444 rajveer 2309 
  def markAlertsAsSeen(self, warehouseId):
2310 
    """
2311 
    Parameters:
2312 
     - warehouseId
2313 
    """
2314 
    self.send_markAlertsAsSeen(warehouseId)
2315 
    self.recv_markAlertsAsSeen()
2316 
 
2317 
  def send_markAlertsAsSeen(self, warehouseId):
2318 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2319 
    args = markAlertsAsSeen_args()
2320 
    args.warehouseId = warehouseId
2321 
    args.write(self._oprot)
2322 
    self._oprot.writeMessageEnd()
2323 
    self._oprot.trans.flush()
2324 
 
2325 
  def recv_markAlertsAsSeen(self, ):
2326 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2327 
    if mtype == TMessageType.EXCEPTION:
2328 
      x = TApplicationException()
2329 
      x.read(self._iprot)
2330 
      self._iprot.readMessageEnd()
2331 
      raise x
2332 
    result = markAlertsAsSeen_result()
2333 
    result.read(self._iprot)
2334 
    self._iprot.readMessageEnd()
2335 
    return
2336 
 
3064 chandransh 2337 
  def getValidOrderCount(self, ):
2338 
    """
2339 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2340 
    """
2341 
    self.send_getValidOrderCount()
2342 
    return self.recv_getValidOrderCount()
2343 
 
2344 
  def send_getValidOrderCount(self, ):
2345 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2346 
    args = getValidOrderCount_args()
2347 
    args.write(self._oprot)
2348 
    self._oprot.writeMessageEnd()
2349 
    self._oprot.trans.flush()
2350 
 
2351 
  def recv_getValidOrderCount(self, ):
2352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2353 
    if mtype == TMessageType.EXCEPTION:
2354 
      x = TApplicationException()
2355 
      x.read(self._iprot)
2356 
      self._iprot.readMessageEnd()
2357 
      raise x
2358 
    result = getValidOrderCount_result()
2359 
    result.read(self._iprot)
2360 
    self._iprot.readMessageEnd()
3431 rajveer 2361 
    if result.success is not None:
3064 chandransh 2362 
      return result.success
2363 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2364 
 
2365 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2366 
    """
2367 
    Returns the number of distinct customers who have done successful transactions
2368 
    """
2369 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2370 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2371 
 
2372 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2373 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2374 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2375 
    args.write(self._oprot)
2376 
    self._oprot.writeMessageEnd()
2377 
    self._oprot.trans.flush()
2378 
 
2379 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2380 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2381 
    if mtype == TMessageType.EXCEPTION:
2382 
      x = TApplicationException()
2383 
      x.read(self._iprot)
2384 
      self._iprot.readMessageEnd()
2385 
      raise x
2386 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2387 
    result.read(self._iprot)
2388 
    self._iprot.readMessageEnd()
3431 rajveer 2389 
    if result.success is not None:
3064 chandransh 2390 
      return result.success
2391 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2392 
 
2393 
  def getValidOrdersAmountRange(self, ):
2394 
    """
2395 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2396 
    List contains two values, first minimum amount and second maximum amount.
2397 
    """
2398 
    self.send_getValidOrdersAmountRange()
2399 
    return self.recv_getValidOrdersAmountRange()
2400 
 
2401 
  def send_getValidOrdersAmountRange(self, ):
2402 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2403 
    args = getValidOrdersAmountRange_args()
2404 
    args.write(self._oprot)
2405 
    self._oprot.writeMessageEnd()
2406 
    self._oprot.trans.flush()
2407 
 
2408 
  def recv_getValidOrdersAmountRange(self, ):
2409 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2410 
    if mtype == TMessageType.EXCEPTION:
2411 
      x = TApplicationException()
2412 
      x.read(self._iprot)
2413 
      self._iprot.readMessageEnd()
2414 
      raise x
2415 
    result = getValidOrdersAmountRange_result()
2416 
    result.read(self._iprot)
2417 
    self._iprot.readMessageEnd()
3431 rajveer 2418 
    if result.success is not None:
3064 chandransh 2419 
      return result.success
2420 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2421 
 
5874 rajveer 2422 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2423 
    """
2424 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2425 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2426 
 
3064 chandransh 2427 
    Parameters:
2428 
     - limit
5874 rajveer 2429 
     - onlyStore
3064 chandransh 2430 
    """
5874 rajveer 2431 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2432 
    return self.recv_getValidOrders()
2433 
 
5874 rajveer 2434 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2435 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2436 
    args = getValidOrders_args()
2437 
    args.limit = limit
5874 rajveer 2438 
    args.onlyStore = onlyStore
3064 chandransh 2439 
    args.write(self._oprot)
2440 
    self._oprot.writeMessageEnd()
2441 
    self._oprot.trans.flush()
2442 
 
2443 
  def recv_getValidOrders(self, ):
2444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2445 
    if mtype == TMessageType.EXCEPTION:
2446 
      x = TApplicationException()
2447 
      x.read(self._iprot)
2448 
      self._iprot.readMessageEnd()
2449 
      raise x
2450 
    result = getValidOrders_result()
2451 
    result.read(self._iprot)
2452 
    self._iprot.readMessageEnd()
3431 rajveer 2453 
    if result.success is not None:
3064 chandransh 2454 
      return result.success
2455 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2456 
 
1220 chandransh 2457 
  def batchOrders(self, warehouseId):
2458 
    """
2459 
    Create a batch of all the pending orders for the given warehouse.
2460 
    The returned list is orderd by created_timestamp.
2461 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2462 
 
1220 chandransh 2463 
    Parameters:
2464 
     - warehouseId
2465 
    """
2466 
    self.send_batchOrders(warehouseId)
2467 
    return self.recv_batchOrders()
2468 
 
2469 
  def send_batchOrders(self, warehouseId):
2470 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2471 
    args = batchOrders_args()
2472 
    args.warehouseId = warehouseId
2473 
    args.write(self._oprot)
2474 
    self._oprot.writeMessageEnd()
2475 
    self._oprot.trans.flush()
2476 
 
2477 
  def recv_batchOrders(self, ):
2478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2479 
    if mtype == TMessageType.EXCEPTION:
2480 
      x = TApplicationException()
2481 
      x.read(self._iprot)
2482 
      self._iprot.readMessageEnd()
2483 
      raise x
2484 
    result = batchOrders_result()
2485 
    result.read(self._iprot)
2486 
    self._iprot.readMessageEnd()
3431 rajveer 2487 
    if result.success is not None:
1220 chandransh 2488 
      return result.success
3431 rajveer 2489 
    if result.ex is not None:
1220 chandransh 2490 
      raise result.ex
2491 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2492 
 
1208 chandransh 2493 
  def markOrderAsOutOfStock(self, orderId):
2494 
    """
2495 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2496 
 
1208 chandransh 2497 
    Parameters:
2498 
     - orderId
2499 
    """
2500 
    self.send_markOrderAsOutOfStock(orderId)
2501 
    return self.recv_markOrderAsOutOfStock()
2502 
 
2503 
  def send_markOrderAsOutOfStock(self, orderId):
2504 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2505 
    args = markOrderAsOutOfStock_args()
2506 
    args.orderId = orderId
2507 
    args.write(self._oprot)
2508 
    self._oprot.writeMessageEnd()
2509 
    self._oprot.trans.flush()
2510 
 
2511 
  def recv_markOrderAsOutOfStock(self, ):
2512 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2513 
    if mtype == TMessageType.EXCEPTION:
2514 
      x = TApplicationException()
2515 
      x.read(self._iprot)
2516 
      self._iprot.readMessageEnd()
2517 
      raise x
2518 
    result = markOrderAsOutOfStock_result()
2519 
    result.read(self._iprot)
2520 
    self._iprot.readMessageEnd()
3431 rajveer 2521 
    if result.success is not None:
1208 chandransh 2522 
      return result.success
3431 rajveer 2523 
    if result.ex is not None:
1208 chandransh 2524 
      raise result.ex
2525 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2526 
 
3064 chandransh 2527 
  def verifyOrder(self, orderId):
759 chandransh 2528 
    """
3064 chandransh 2529 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2530 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2531 
    used for all other orders as well.
2532 
    Throws an exception if no such order exists.
3431 rajveer 2533 
 
759 chandransh 2534 
    Parameters:
3064 chandransh 2535 
     - orderId
759 chandransh 2536 
    """
3064 chandransh 2537 
    self.send_verifyOrder(orderId)
2538 
    return self.recv_verifyOrder()
759 chandransh 2539 
 
3064 chandransh 2540 
  def send_verifyOrder(self, orderId):
2541 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2542 
    args = verifyOrder_args()
2543 
    args.orderId = orderId
759 chandransh 2544 
    args.write(self._oprot)
2545 
    self._oprot.writeMessageEnd()
2546 
    self._oprot.trans.flush()
2547 
 
3064 chandransh 2548 
  def recv_verifyOrder(self, ):
759 chandransh 2549 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2550 
    if mtype == TMessageType.EXCEPTION:
2551 
      x = TApplicationException()
2552 
      x.read(self._iprot)
2553 
      self._iprot.readMessageEnd()
2554 
      raise x
3064 chandransh 2555 
    result = verifyOrder_result()
759 chandransh 2556 
    result.read(self._iprot)
2557 
    self._iprot.readMessageEnd()
3431 rajveer 2558 
    if result.success is not None:
759 chandransh 2559 
      return result.success
3431 rajveer 2560 
    if result.ex is not None:
759 chandransh 2561 
      raise result.ex
3064 chandransh 2562 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2563 
 
3064 chandransh 2564 
  def acceptOrder(self, orderId):
1113 chandransh 2565 
    """
3064 chandransh 2566 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2567 
    given order is not a COD order, it also captures the payment if the same has
2568 
    not been captured.
2569 
    Throws an exception if no such order exists.
3431 rajveer 2570 
 
1113 chandransh 2571 
    Parameters:
3064 chandransh 2572 
     - orderId
1113 chandransh 2573 
    """
3064 chandransh 2574 
    self.send_acceptOrder(orderId)
2575 
    return self.recv_acceptOrder()
1113 chandransh 2576 
 
3064 chandransh 2577 
  def send_acceptOrder(self, orderId):
2578 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2579 
    args = acceptOrder_args()
2580 
    args.orderId = orderId
1113 chandransh 2581 
    args.write(self._oprot)
2582 
    self._oprot.writeMessageEnd()
2583 
    self._oprot.trans.flush()
2584 
 
3064 chandransh 2585 
  def recv_acceptOrder(self, ):
1113 chandransh 2586 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2587 
    if mtype == TMessageType.EXCEPTION:
2588 
      x = TApplicationException()
2589 
      x.read(self._iprot)
2590 
      self._iprot.readMessageEnd()
2591 
      raise x
3064 chandransh 2592 
    result = acceptOrder_result()
1113 chandransh 2593 
    result.read(self._iprot)
2594 
    self._iprot.readMessageEnd()
3431 rajveer 2595 
    if result.success is not None:
1113 chandransh 2596 
      return result.success
3431 rajveer 2597 
    if result.ex is not None:
1113 chandransh 2598 
      raise result.ex
3064 chandransh 2599 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2600 
 
5110 mandeep.dh 2601 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2602 
    """
3064 chandransh 2603 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2604 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2605 
    the IMEI no. if a -1 is supplied.
2606 
    Also, it generates an invoice number for the order, marks the order as
2607 
    BILLED and sets the billing timestamp.
2608 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2609 
 
1135 chandransh 2610 
    Parameters:
3064 chandransh 2611 
     - orderId
2612 
     - invoice_number
4658 mandeep.dh 2613 
     - serialNumber
4283 anupam.sin 2614 
     - itemNumber
3064 chandransh 2615 
     - billed_by
4264 rajveer 2616 
     - jacketNumber
4283 anupam.sin 2617 
     - billingType
5110 mandeep.dh 2618 
     - fulfilmentWarehouseId
4763 rajveer 2619 
     - authorize
1135 chandransh 2620 
    """
5110 mandeep.dh 2621 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2622 
    return self.recv_addBillingDetails()
1135 chandransh 2623 
 
5110 mandeep.dh 2624 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2625 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2626 
    args = addBillingDetails_args()
2627 
    args.orderId = orderId
2628 
    args.invoice_number = invoice_number
4658 mandeep.dh 2629 
    args.serialNumber = serialNumber
4283 anupam.sin 2630 
    args.itemNumber = itemNumber
3064 chandransh 2631 
    args.billed_by = billed_by
4264 rajveer 2632 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2633 
    args.billingType = billingType
5110 mandeep.dh 2634 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2635 
    args.authorize = authorize
1135 chandransh 2636 
    args.write(self._oprot)
2637 
    self._oprot.writeMessageEnd()
2638 
    self._oprot.trans.flush()
2639 
 
3064 chandransh 2640 
  def recv_addBillingDetails(self, ):
1135 chandransh 2641 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2642 
    if mtype == TMessageType.EXCEPTION:
2643 
      x = TApplicationException()
2644 
      x.read(self._iprot)
2645 
      self._iprot.readMessageEnd()
2646 
      raise x
3064 chandransh 2647 
    result = addBillingDetails_result()
1135 chandransh 2648 
    result.read(self._iprot)
2649 
    self._iprot.readMessageEnd()
3431 rajveer 2650 
    if result.success is not None:
3064 chandransh 2651 
      return result.success
3431 rajveer 2652 
    if result.ex is not None:
1135 chandransh 2653 
      raise result.ex
3064 chandransh 2654 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2655 
 
4763 rajveer 2656 
  def addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2657 
    """
2658 
    Add the invoice number to the order.
2659 
 
2660 
    Parameters:
2661 
     - orderId
2662 
     - invoiceNumber
4763 rajveer 2663 
     - color
4579 rajveer 2664 
    """
4763 rajveer 2665 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color)
4579 rajveer 2666 
    self.recv_addInvoiceNumber()
2667 
 
4763 rajveer 2668 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color):
4579 rajveer 2669 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2670 
    args = addInvoiceNumber_args()
2671 
    args.orderId = orderId
2672 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2673 
    args.color = color
4579 rajveer 2674 
    args.write(self._oprot)
2675 
    self._oprot.writeMessageEnd()
2676 
    self._oprot.trans.flush()
2677 
 
2678 
  def recv_addInvoiceNumber(self, ):
2679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2680 
    if mtype == TMessageType.EXCEPTION:
2681 
      x = TApplicationException()
2682 
      x.read(self._iprot)
2683 
      self._iprot.readMessageEnd()
2684 
      raise x
2685 
    result = addInvoiceNumber_result()
2686 
    result.read(self._iprot)
2687 
    self._iprot.readMessageEnd()
2688 
    if result.ex is not None:
2689 
      raise result.ex
2690 
    return
2691 
 
4910 phani.kuma 2692 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2693 
    """
3064 chandransh 2694 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2695 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2696 
 
1408 ankur.sing 2697 
    Parameters:
3064 chandransh 2698 
     - warehouseId
1408 ankur.sing 2699 
     - providerId
3064 chandransh 2700 
     - cod
4910 phani.kuma 2701 
     - orderIds
1408 ankur.sing 2702 
    """
4910 phani.kuma 2703 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2704 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2705 
 
4910 phani.kuma 2706 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2707 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2708 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2709 
    args.warehouseId = warehouseId
1408 ankur.sing 2710 
    args.providerId = providerId
3064 chandransh 2711 
    args.cod = cod
4910 phani.kuma 2712 
    args.orderIds = orderIds
1408 ankur.sing 2713 
    args.write(self._oprot)
2714 
    self._oprot.writeMessageEnd()
2715 
    self._oprot.trans.flush()
2716 
 
4910 phani.kuma 2717 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2718 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2719 
    if mtype == TMessageType.EXCEPTION:
2720 
      x = TApplicationException()
2721 
      x.read(self._iprot)
2722 
      self._iprot.readMessageEnd()
2723 
      raise x
4910 phani.kuma 2724 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2725 
    result.read(self._iprot)
2726 
    self._iprot.readMessageEnd()
3431 rajveer 2727 
    if result.success is not None:
1408 ankur.sing 2728 
      return result.success
3431 rajveer 2729 
    if result.ex is not None:
3064 chandransh 2730 
      raise result.ex
4910 phani.kuma 2731 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2732 
 
5713 rajveer 2733 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2734 
    """
2735 
    Parameters:
2736 
     - providerId
2737 
     - orderIds
5713 rajveer 2738 
     - awbs
5676 rajveer 2739 
    """
5713 rajveer 2740 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2741 
    return self.recv_markOrdersAsReturnedFromStore()
2742 
 
5713 rajveer 2743 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2744 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2745 
    args = markOrdersAsReturnedFromStore_args()
2746 
    args.providerId = providerId
2747 
    args.orderIds = orderIds
5713 rajveer 2748 
    args.awbs = awbs
5676 rajveer 2749 
    args.write(self._oprot)
2750 
    self._oprot.writeMessageEnd()
2751 
    self._oprot.trans.flush()
2752 
 
2753 
  def recv_markOrdersAsReturnedFromStore(self, ):
2754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2755 
    if mtype == TMessageType.EXCEPTION:
2756 
      x = TApplicationException()
2757 
      x.read(self._iprot)
2758 
      self._iprot.readMessageEnd()
2759 
      raise x
2760 
    result = markOrdersAsReturnedFromStore_result()
2761 
    result.read(self._iprot)
2762 
    self._iprot.readMessageEnd()
2763 
    if result.success is not None:
2764 
      return result.success
2765 
    if result.ex is not None:
2766 
      raise result.ex
2767 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2768 
 
4910 phani.kuma 2769 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2770 
    """
4910 phani.kuma 2771 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2772 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2773 
 
2774 
    Parameters:
2775 
     - providerId
4910 phani.kuma 2776 
     - pickupDetails
4410 rajveer 2777 
    """
4910 phani.kuma 2778 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2779 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2780 
 
4910 phani.kuma 2781 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2782 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2783 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2784 
    args.providerId = providerId
4910 phani.kuma 2785 
    args.pickupDetails = pickupDetails
4410 rajveer 2786 
    args.write(self._oprot)
2787 
    self._oprot.writeMessageEnd()
2788 
    self._oprot.trans.flush()
2789 
 
4910 phani.kuma 2790 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2792 
    if mtype == TMessageType.EXCEPTION:
2793 
      x = TApplicationException()
2794 
      x.read(self._iprot)
2795 
      self._iprot.readMessageEnd()
2796 
      raise x
4910 phani.kuma 2797 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2798 
    result.read(self._iprot)
2799 
    self._iprot.readMessageEnd()
2800 
    if result.ex is not None:
2801 
      raise result.ex
4910 phani.kuma 2802 
    return
4410 rajveer 2803 
 
4910 phani.kuma 2804 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2805 
    """
3064 chandransh 2806 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2807 
 
94 ashish 2808 
    Parameters:
3064 chandransh 2809 
     - providerId
304 ashish 2810 
    """
4910 phani.kuma 2811 
    self.send_getOrdersNotPickedUp(providerId)
2812 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2813 
 
4910 phani.kuma 2814 
  def send_getOrdersNotPickedUp(self, providerId):
2815 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2816 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2817 
    args.providerId = providerId
304 ashish 2818 
    args.write(self._oprot)
2819 
    self._oprot.writeMessageEnd()
2820 
    self._oprot.trans.flush()
2821 
 
4910 phani.kuma 2822 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2824 
    if mtype == TMessageType.EXCEPTION:
2825 
      x = TApplicationException()
2826 
      x.read(self._iprot)
2827 
      self._iprot.readMessageEnd()
2828 
      raise x
4910 phani.kuma 2829 
    result = getOrdersNotPickedUp_result()
304 ashish 2830 
    result.read(self._iprot)
2831 
    self._iprot.readMessageEnd()
3431 rajveer 2832 
    if result.success is not None:
304 ashish 2833 
      return result.success
4910 phani.kuma 2834 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2835 
 
3064 chandransh 2836 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2837 
    """
3064 chandransh 2838 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2839 
    the name of the receiver.
2840 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2841 
 
304 ashish 2842 
    Parameters:
3064 chandransh 2843 
     - providerId
2844 
     - deliveredOrders
304 ashish 2845 
    """
3064 chandransh 2846 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2847 
    self.recv_markOrdersAsDelivered()
304 ashish 2848 
 
3064 chandransh 2849 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2850 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2851 
    args = markOrdersAsDelivered_args()
2852 
    args.providerId = providerId
2853 
    args.deliveredOrders = deliveredOrders
304 ashish 2854 
    args.write(self._oprot)
2855 
    self._oprot.writeMessageEnd()
2856 
    self._oprot.trans.flush()
2857 
 
3064 chandransh 2858 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2859 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2860 
    if mtype == TMessageType.EXCEPTION:
2861 
      x = TApplicationException()
2862 
      x.read(self._iprot)
2863 
      self._iprot.readMessageEnd()
2864 
      raise x
3064 chandransh 2865 
    result = markOrdersAsDelivered_result()
304 ashish 2866 
    result.read(self._iprot)
2867 
    self._iprot.readMessageEnd()
3431 rajveer 2868 
    if result.ex is not None:
3064 chandransh 2869 
      raise result.ex
304 ashish 2870 
    return
2871 
 
4910 phani.kuma 2872 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2873 
    """
4910 phani.kuma 2874 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2875 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2876 
 
3064 chandransh 2877 
    Parameters:
2878 
     - providerId
2879 
     - returnedOrders
1596 ankur.sing 2880 
    """
4910 phani.kuma 2881 
    self.send_markAsRTOrders(providerId, returnedOrders)
2882 
    self.recv_markAsRTOrders()
304 ashish 2883 
 
4910 phani.kuma 2884 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2885 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2886 
    args = markAsRTOrders_args()
3064 chandransh 2887 
    args.providerId = providerId
2888 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2889 
    args.write(self._oprot)
2890 
    self._oprot.writeMessageEnd()
2891 
    self._oprot.trans.flush()
2892 
 
4910 phani.kuma 2893 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2894 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2895 
    if mtype == TMessageType.EXCEPTION:
2896 
      x = TApplicationException()
2897 
      x.read(self._iprot)
2898 
      self._iprot.readMessageEnd()
2899 
      raise x
4910 phani.kuma 2900 
    result = markAsRTOrders_result()
1596 ankur.sing 2901 
    result.read(self._iprot)
2902 
    self._iprot.readMessageEnd()
3431 rajveer 2903 
    if result.ex is not None:
3064 chandransh 2904 
      raise result.ex
2905 
    return
1596 ankur.sing 2906 
 
4910 phani.kuma 2907 
  def getRTOrders(self, providerId):
2908 
    """
2909 
    Returns a list of orders that were returned by courier.
2910 
 
2911 
    Parameters:
2912 
     - providerId
2913 
    """
2914 
    self.send_getRTOrders(providerId)
2915 
    return self.recv_getRTOrders()
2916 
 
2917 
  def send_getRTOrders(self, providerId):
2918 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2919 
    args = getRTOrders_args()
2920 
    args.providerId = providerId
2921 
    args.write(self._oprot)
2922 
    self._oprot.writeMessageEnd()
2923 
    self._oprot.trans.flush()
2924 
 
2925 
  def recv_getRTOrders(self, ):
2926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2927 
    if mtype == TMessageType.EXCEPTION:
2928 
      x = TApplicationException()
2929 
      x.read(self._iprot)
2930 
      self._iprot.readMessageEnd()
2931 
      raise x
2932 
    result = getRTOrders_result()
2933 
    result.read(self._iprot)
2934 
    self._iprot.readMessageEnd()
2935 
    if result.success is not None:
2936 
      return result.success
2937 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2938 
 
3064 chandransh 2939 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2940 
    """
3064 chandransh 2941 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2942 
 
3064 chandransh 2943 
    Parameters:
2944 
     - providerId
2945 
     - undeliveredOrders
1627 ankur.sing 2946 
    """
3064 chandransh 2947 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2948 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2949 
 
3064 chandransh 2950 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2951 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2952 
    args = updateNonDeliveryReason_args()
2953 
    args.providerId = providerId
2954 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2955 
    args.write(self._oprot)
2956 
    self._oprot.writeMessageEnd()
2957 
    self._oprot.trans.flush()
2958 
 
3064 chandransh 2959 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2960 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2961 
    if mtype == TMessageType.EXCEPTION:
2962 
      x = TApplicationException()
2963 
      x.read(self._iprot)
2964 
      self._iprot.readMessageEnd()
2965 
      raise x
3064 chandransh 2966 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 2967 
    result.read(self._iprot)
2968 
    self._iprot.readMessageEnd()
4910 phani.kuma 2969 
    if result.ex is not None:
2970 
      raise result.ex
2971 
    return
2972 
 
2973 
  def getNonDeliveredOrdersbyCourier(self, providerId):
2974 
    """
2975 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
2976 
 
2977 
    Parameters:
2978 
     - providerId
2979 
    """
2980 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
2981 
    return self.recv_getNonDeliveredOrdersbyCourier()
2982 
 
2983 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
2984 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
2985 
    args = getNonDeliveredOrdersbyCourier_args()
2986 
    args.providerId = providerId
2987 
    args.write(self._oprot)
2988 
    self._oprot.writeMessageEnd()
2989 
    self._oprot.trans.flush()
2990 
 
2991 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
2992 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2993 
    if mtype == TMessageType.EXCEPTION:
2994 
      x = TApplicationException()
2995 
      x.read(self._iprot)
2996 
      self._iprot.readMessageEnd()
2997 
      raise x
2998 
    result = getNonDeliveredOrdersbyCourier_result()
2999 
    result.read(self._iprot)
3000 
    self._iprot.readMessageEnd()
4581 phani.kuma 3001 
    if result.success is not None:
3002 
      return result.success
4910 phani.kuma 3003 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3004 
 
3005 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3006 
    """
3007 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3008 
 
3009 
    Parameters:
3010 
     - providerId
3011 
     - local_connected_orders
3012 
    """
3013 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3014 
    self.recv_markOrdersAsLocalConnected()
3015 
 
3016 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3017 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3018 
    args = markOrdersAsLocalConnected_args()
3019 
    args.providerId = providerId
3020 
    args.local_connected_orders = local_connected_orders
3021 
    args.write(self._oprot)
3022 
    self._oprot.writeMessageEnd()
3023 
    self._oprot.trans.flush()
3024 
 
3025 
  def recv_markOrdersAsLocalConnected(self, ):
3026 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3027 
    if mtype == TMessageType.EXCEPTION:
3028 
      x = TApplicationException()
3029 
      x.read(self._iprot)
3030 
      self._iprot.readMessageEnd()
3031 
      raise x
3032 
    result = markOrdersAsLocalConnected_result()
3033 
    result.read(self._iprot)
3034 
    self._iprot.readMessageEnd()
3431 rajveer 3035 
    if result.ex is not None:
3064 chandransh 3036 
      raise result.ex
4910 phani.kuma 3037 
    return
1627 ankur.sing 3038 
 
4910 phani.kuma 3039 
  def getOrdersNotLocalConnected(self, providerId):
3040 
    """
3041 
    Returns a list of orders that were picked up or shipped but pending local connection.
3042 
 
3043 
    Parameters:
3044 
     - providerId
3045 
    """
3046 
    self.send_getOrdersNotLocalConnected(providerId)
3047 
    return self.recv_getOrdersNotLocalConnected()
3048 
 
3049 
  def send_getOrdersNotLocalConnected(self, providerId):
3050 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3051 
    args = getOrdersNotLocalConnected_args()
3052 
    args.providerId = providerId
3053 
    args.write(self._oprot)
3054 
    self._oprot.writeMessageEnd()
3055 
    self._oprot.trans.flush()
3056 
 
3057 
  def recv_getOrdersNotLocalConnected(self, ):
3058 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3059 
    if mtype == TMessageType.EXCEPTION:
3060 
      x = TApplicationException()
3061 
      x.read(self._iprot)
3062 
      self._iprot.readMessageEnd()
3063 
      raise x
3064 
    result = getOrdersNotLocalConnected_result()
3065 
    result.read(self._iprot)
3066 
    self._iprot.readMessageEnd()
3067 
    if result.success is not None:
3068 
      return result.success
3069 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3070 
 
3071 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3072 
    """
3073 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3074 
 
3075 
    Parameters:
3076 
     - providerId
3077 
     - destination_city_reached_orders
3078 
    """
3079 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3080 
    self.recv_markOrdersAsDestinationCityReached()
3081 
 
3082 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3083 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3084 
    args = markOrdersAsDestinationCityReached_args()
3085 
    args.providerId = providerId
3086 
    args.destination_city_reached_orders = destination_city_reached_orders
3087 
    args.write(self._oprot)
3088 
    self._oprot.writeMessageEnd()
3089 
    self._oprot.trans.flush()
3090 
 
3091 
  def recv_markOrdersAsDestinationCityReached(self, ):
3092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3093 
    if mtype == TMessageType.EXCEPTION:
3094 
      x = TApplicationException()
3095 
      x.read(self._iprot)
3096 
      self._iprot.readMessageEnd()
3097 
      raise x
3098 
    result = markOrdersAsDestinationCityReached_result()
3099 
    result.read(self._iprot)
3100 
    self._iprot.readMessageEnd()
3101 
    if result.ex is not None:
3102 
      raise result.ex
3103 
    return
3104 
 
3105 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3106 
    """
3107 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3108 
 
3109 
    Parameters:
3110 
     - providerId
3111 
     - first_atdl_orders
3112 
    """
3113 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3114 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3115 
 
3116 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3117 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3118 
    args = markOrdersAsFirstDeliveryAttempted_args()
3119 
    args.providerId = providerId
3120 
    args.first_atdl_orders = first_atdl_orders
3121 
    args.write(self._oprot)
3122 
    self._oprot.writeMessageEnd()
3123 
    self._oprot.trans.flush()
3124 
 
3125 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3127 
    if mtype == TMessageType.EXCEPTION:
3128 
      x = TApplicationException()
3129 
      x.read(self._iprot)
3130 
      self._iprot.readMessageEnd()
3131 
      raise x
3132 
    result = markOrdersAsFirstDeliveryAttempted_result()
3133 
    result.read(self._iprot)
3134 
    self._iprot.readMessageEnd()
3135 
    if result.ex is not None:
3136 
      raise result.ex
3137 
    return
3138 
 
3064 chandransh 3139 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3140 
    """
3064 chandransh 3141 
    Returns the list of orders whose delivery time has passed but have not been
3142 
    delivered yet for the given provider and warehouse. To get a complete list of
3143 
    undelivered orders, pass them as -1.
3144 
    Returns an empty list if no such orders exist.
3431 rajveer 3145 
 
1886 ankur.sing 3146 
    Parameters:
3064 chandransh 3147 
     - providerId
3148 
     - warehouseId
1886 ankur.sing 3149 
    """
3064 chandransh 3150 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3151 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3152 
 
3064 chandransh 3153 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3154 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3155 
    args = getUndeliveredOrders_args()
3156 
    args.providerId = providerId
3157 
    args.warehouseId = warehouseId
1886 ankur.sing 3158 
    args.write(self._oprot)
3159 
    self._oprot.writeMessageEnd()
3160 
    self._oprot.trans.flush()
3161 
 
3064 chandransh 3162 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3164 
    if mtype == TMessageType.EXCEPTION:
3165 
      x = TApplicationException()
3166 
      x.read(self._iprot)
3167 
      self._iprot.readMessageEnd()
3168 
      raise x
3064 chandransh 3169 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3170 
    result.read(self._iprot)
3171 
    self._iprot.readMessageEnd()
3431 rajveer 3172 
    if result.success is not None:
1886 ankur.sing 3173 
      return result.success
3064 chandransh 3174 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3175 
 
4783 phani.kuma 3176 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3177 
    """
3178 
    Returns the list of orders whose expected delivery date has passed but have not been
3179 
    delivered yet.
3180 
    Returns an empty list if no such orders exist.
3181 
    """
3182 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3183 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3184 
 
3185 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3186 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3187 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3188 
    args.write(self._oprot)
3189 
    self._oprot.writeMessageEnd()
3190 
    self._oprot.trans.flush()
3191 
 
3192 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3193 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3194 
    if mtype == TMessageType.EXCEPTION:
3195 
      x = TApplicationException()
3196 
      x.read(self._iprot)
3197 
      self._iprot.readMessageEnd()
3198 
      raise x
3199 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3200 
    result.read(self._iprot)
3201 
    self._iprot.readMessageEnd()
3202 
    if result.success is not None:
3203 
      return result.success
3204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3205 
 
2536 chandransh 3206 
  def toggleDOAFlag(self, orderId):
3207 
    """
3208 
    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.
3209 
    Returns the final flag status.
3210 
    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 3211 
 
2536 chandransh 3212 
    Parameters:
3213 
     - orderId
3214 
    """
3215 
    self.send_toggleDOAFlag(orderId)
3216 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3217 
 
2536 chandransh 3218 
  def send_toggleDOAFlag(self, orderId):
3219 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3220 
    args = toggleDOAFlag_args()
3221 
    args.orderId = orderId
3222 
    args.write(self._oprot)
3223 
    self._oprot.writeMessageEnd()
3224 
    self._oprot.trans.flush()
3225 
 
3226 
  def recv_toggleDOAFlag(self, ):
3227 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3228 
    if mtype == TMessageType.EXCEPTION:
3229 
      x = TApplicationException()
3230 
      x.read(self._iprot)
3231 
      self._iprot.readMessageEnd()
3232 
      raise x
3233 
    result = toggleDOAFlag_result()
3234 
    result.read(self._iprot)
3235 
    self._iprot.readMessageEnd()
3431 rajveer 3236 
    if result.success is not None:
2536 chandransh 3237 
      return result.success
3431 rajveer 3238 
    if result.ex is not None:
2536 chandransh 3239 
      raise result.ex
3240 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3241 
 
4712 rajveer 3242 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3243 
    """
3244 
    Parameters:
3245 
     - orderId
3246 
     - deliveryTimestamp
3247 
     - receiver
3248 
    """
3249 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3250 
    self.recv_markOrderAsDelivered()
3251 
 
3252 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3253 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3254 
    args = markOrderAsDelivered_args()
3255 
    args.orderId = orderId
3256 
    args.deliveryTimestamp = deliveryTimestamp
3257 
    args.receiver = receiver
3258 
    args.write(self._oprot)
3259 
    self._oprot.writeMessageEnd()
3260 
    self._oprot.trans.flush()
3261 
 
3262 
  def recv_markOrderAsDelivered(self, ):
3263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3264 
    if mtype == TMessageType.EXCEPTION:
3265 
      x = TApplicationException()
3266 
      x.read(self._iprot)
3267 
      self._iprot.readMessageEnd()
3268 
      raise x
3269 
    result = markOrderAsDelivered_result()
3270 
    result.read(self._iprot)
3271 
    self._iprot.readMessageEnd()
3272 
    if result.ex is not None:
3273 
      raise result.ex
3274 
    return
3275 
 
5553 rajveer 3276 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3277 
    """
3278 
    Parameters:
3279 
     - orderId
3280 
     - deliveryTimestamp
3281 
    """
3282 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3283 
    self.recv_markOrderAsReceivedAtStore()
3284 
 
3285 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3286 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3287 
    args = markOrderAsReceivedAtStore_args()
3288 
    args.orderId = orderId
3289 
    args.deliveryTimestamp = deliveryTimestamp
3290 
    args.write(self._oprot)
3291 
    self._oprot.writeMessageEnd()
3292 
    self._oprot.trans.flush()
3293 
 
3294 
  def recv_markOrderAsReceivedAtStore(self, ):
3295 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3296 
    if mtype == TMessageType.EXCEPTION:
3297 
      x = TApplicationException()
3298 
      x.read(self._iprot)
3299 
      self._iprot.readMessageEnd()
3300 
      raise x
3301 
    result = markOrderAsReceivedAtStore_result()
3302 
    result.read(self._iprot)
3303 
    self._iprot.readMessageEnd()
3304 
    if result.ex is not None:
3305 
      raise result.ex
3306 
    return
3307 
 
4454 rajveer 3308 
  def markOrderDoaRequestReceived(self, orderId):
3309 
    """
3310 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3311 
 
3312 
    Parameters:
3313 
     - orderId
3314 
    """
3315 
    self.send_markOrderDoaRequestReceived(orderId)
3316 
    return self.recv_markOrderDoaRequestReceived()
3317 
 
3318 
  def send_markOrderDoaRequestReceived(self, orderId):
3319 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3320 
    args = markOrderDoaRequestReceived_args()
3321 
    args.orderId = orderId
3322 
    args.write(self._oprot)
3323 
    self._oprot.writeMessageEnd()
3324 
    self._oprot.trans.flush()
3325 
 
3326 
  def recv_markOrderDoaRequestReceived(self, ):
3327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3328 
    if mtype == TMessageType.EXCEPTION:
3329 
      x = TApplicationException()
3330 
      x.read(self._iprot)
3331 
      self._iprot.readMessageEnd()
3332 
      raise x
3333 
    result = markOrderDoaRequestReceived_result()
3334 
    result.read(self._iprot)
3335 
    self._iprot.readMessageEnd()
3336 
    if result.success is not None:
3337 
      return result.success
3338 
    if result.ex is not None:
3339 
      raise result.ex
3340 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3341 
 
3342 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3343 
    """
3344 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3345 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3346 
 
3347 
    Parameters:
3348 
     - orderId
3349 
     - isAuthorized
3350 
    """
3351 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3352 
    return self.recv_markOrderDoaRequestAuthorized()
3353 
 
3354 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3355 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3356 
    args = markOrderDoaRequestAuthorized_args()
3357 
    args.orderId = orderId
3358 
    args.isAuthorized = isAuthorized
3359 
    args.write(self._oprot)
3360 
    self._oprot.writeMessageEnd()
3361 
    self._oprot.trans.flush()
3362 
 
3363 
  def recv_markOrderDoaRequestAuthorized(self, ):
3364 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3365 
    if mtype == TMessageType.EXCEPTION:
3366 
      x = TApplicationException()
3367 
      x.read(self._iprot)
3368 
      self._iprot.readMessageEnd()
3369 
      raise x
3370 
    result = markOrderDoaRequestAuthorized_result()
3371 
    result.read(self._iprot)
3372 
    self._iprot.readMessageEnd()
3373 
    if result.success is not None:
3374 
      return result.success
3375 
    if result.ex is not None:
3376 
      raise result.ex
3377 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3378 
 
4488 rajveer 3379 
  def markOrderReturnRequestReceived(self, orderId):
3380 
    """
3381 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3382 
 
3383 
    Parameters:
3384 
     - orderId
3385 
    """
3386 
    self.send_markOrderReturnRequestReceived(orderId)
3387 
    return self.recv_markOrderReturnRequestReceived()
3388 
 
3389 
  def send_markOrderReturnRequestReceived(self, orderId):
3390 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3391 
    args = markOrderReturnRequestReceived_args()
3392 
    args.orderId = orderId
3393 
    args.write(self._oprot)
3394 
    self._oprot.writeMessageEnd()
3395 
    self._oprot.trans.flush()
3396 
 
3397 
  def recv_markOrderReturnRequestReceived(self, ):
3398 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3399 
    if mtype == TMessageType.EXCEPTION:
3400 
      x = TApplicationException()
3401 
      x.read(self._iprot)
3402 
      self._iprot.readMessageEnd()
3403 
      raise x
3404 
    result = markOrderReturnRequestReceived_result()
3405 
    result.read(self._iprot)
3406 
    self._iprot.readMessageEnd()
3407 
    if result.success is not None:
3408 
      return result.success
3409 
    if result.ex is not None:
3410 
      raise result.ex
3411 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3412 
 
3413 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3414 
    """
3415 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3416 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3417 
 
3418 
    Parameters:
3419 
     - orderId
3420 
     - isAuthorized
3421 
    """
3422 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3423 
    return self.recv_markOrderReturnRequestAuthorized()
3424 
 
3425 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3426 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3427 
    args = markOrderReturnRequestAuthorized_args()
3428 
    args.orderId = orderId
3429 
    args.isAuthorized = isAuthorized
3430 
    args.write(self._oprot)
3431 
    self._oprot.writeMessageEnd()
3432 
    self._oprot.trans.flush()
3433 
 
3434 
  def recv_markOrderReturnRequestAuthorized(self, ):
3435 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3436 
    if mtype == TMessageType.EXCEPTION:
3437 
      x = TApplicationException()
3438 
      x.read(self._iprot)
3439 
      self._iprot.readMessageEnd()
3440 
      raise x
3441 
    result = markOrderReturnRequestAuthorized_result()
3442 
    result.read(self._iprot)
3443 
    self._iprot.readMessageEnd()
3444 
    if result.success is not None:
3445 
      return result.success
3446 
    if result.ex is not None:
3447 
      raise result.ex
3448 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3449 
 
4579 rajveer 3450 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3451 
    """
3452 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3453 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3454 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3455 
    For any other status, it returns false.
3456 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3457 
 
2536 chandransh 3458 
    Parameters:
3459 
     - orderId
4579 rajveer 3460 
     - providerId
2536 chandransh 3461 
    """
4579 rajveer 3462 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3463 
    return self.recv_requestPickupNumber()
3464 
 
4579 rajveer 3465 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3466 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3467 
    args = requestPickupNumber_args()
3468 
    args.orderId = orderId
4579 rajveer 3469 
    args.providerId = providerId
2536 chandransh 3470 
    args.write(self._oprot)
3471 
    self._oprot.writeMessageEnd()
3472 
    self._oprot.trans.flush()
3473 
 
3474 
  def recv_requestPickupNumber(self, ):
3475 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3476 
    if mtype == TMessageType.EXCEPTION:
3477 
      x = TApplicationException()
3478 
      x.read(self._iprot)
3479 
      self._iprot.readMessageEnd()
3480 
      raise x
3481 
    result = requestPickupNumber_result()
3482 
    result.read(self._iprot)
3483 
    self._iprot.readMessageEnd()
3431 rajveer 3484 
    if result.success is not None:
2536 chandransh 3485 
      return result.success
3431 rajveer 3486 
    if result.ex is not None:
2536 chandransh 3487 
      raise result.ex
3488 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3489 
 
4602 rajveer 3490 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3491 
    """
4452 rajveer 3492 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3493 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3494 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3495 
    	3. Returns true
2591 chandransh 3496 
    If the order is in any other status, it returns false.
2536 chandransh 3497 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3498 
 
2536 chandransh 3499 
    Parameters:
3500 
     - orderId
3501 
     - pickupNumber
4602 rajveer 3502 
     - providerId
2536 chandransh 3503 
    """
4602 rajveer 3504 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3505 
    return self.recv_authorizePickup()
3506 
 
4602 rajveer 3507 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3508 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3509 
    args = authorizePickup_args()
3510 
    args.orderId = orderId
3511 
    args.pickupNumber = pickupNumber
4602 rajveer 3512 
    args.providerId = providerId
2536 chandransh 3513 
    args.write(self._oprot)
3514 
    self._oprot.writeMessageEnd()
3515 
    self._oprot.trans.flush()
3516 
 
3517 
  def recv_authorizePickup(self, ):
3518 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3519 
    if mtype == TMessageType.EXCEPTION:
3520 
      x = TApplicationException()
3521 
      x.read(self._iprot)
3522 
      self._iprot.readMessageEnd()
3523 
      raise x
3524 
    result = authorizePickup_result()
3525 
    result.read(self._iprot)
3526 
    self._iprot.readMessageEnd()
3431 rajveer 3527 
    if result.success is not None:
2536 chandransh 3528 
      return result.success
3431 rajveer 3529 
    if result.ex is not None:
2536 chandransh 3530 
      raise result.ex
3531 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3532 
 
2764 chandransh 3533 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3534 
    """
3535 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3536 
 
2764 chandransh 3537 
    Parameters:
3538 
     - providerId
3539 
     - pickupDetails
3540 
    """
3541 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3542 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3543 
 
3544 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3545 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3546 
    args = markDoasAsPickedUp_args()
3547 
    args.providerId = providerId
3548 
    args.pickupDetails = pickupDetails
3549 
    args.write(self._oprot)
3550 
    self._oprot.writeMessageEnd()
3551 
    self._oprot.trans.flush()
3552 
 
3553 
  def recv_markDoasAsPickedUp(self, ):
3554 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3555 
    if mtype == TMessageType.EXCEPTION:
3556 
      x = TApplicationException()
3557 
      x.read(self._iprot)
3558 
      self._iprot.readMessageEnd()
3559 
      raise x
3560 
    result = markDoasAsPickedUp_result()
3561 
    result.read(self._iprot)
3562 
    self._iprot.readMessageEnd()
4910 phani.kuma 3563 
    return
3564 
 
3565 
  def getDoasNotPickedUp(self, providerId):
3566 
    """
3567 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3568 
 
3569 
    Parameters:
3570 
     - providerId
3571 
    """
3572 
    self.send_getDoasNotPickedUp(providerId)
3573 
    return self.recv_getDoasNotPickedUp()
3574 
 
3575 
  def send_getDoasNotPickedUp(self, providerId):
3576 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3577 
    args = getDoasNotPickedUp_args()
3578 
    args.providerId = providerId
3579 
    args.write(self._oprot)
3580 
    self._oprot.writeMessageEnd()
3581 
    self._oprot.trans.flush()
3582 
 
3583 
  def recv_getDoasNotPickedUp(self, ):
3584 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3585 
    if mtype == TMessageType.EXCEPTION:
3586 
      x = TApplicationException()
3587 
      x.read(self._iprot)
3588 
      self._iprot.readMessageEnd()
3589 
      raise x
3590 
    result = getDoasNotPickedUp_result()
3591 
    result.read(self._iprot)
3592 
    self._iprot.readMessageEnd()
3431 rajveer 3593 
    if result.success is not None:
2764 chandransh 3594 
      return result.success
4910 phani.kuma 3595 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3596 
 
4741 phani.kuma 3597 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3598 
    """
3599 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3600 
 
3601 
    Parameters:
3602 
     - providerId
3603 
     - pickupDetails
3604 
    """
3605 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3606 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3607 
 
3608 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3609 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3610 
    args = markReturnOrdersAsPickedUp_args()
3611 
    args.providerId = providerId
3612 
    args.pickupDetails = pickupDetails
3613 
    args.write(self._oprot)
3614 
    self._oprot.writeMessageEnd()
3615 
    self._oprot.trans.flush()
3616 
 
3617 
  def recv_markReturnOrdersAsPickedUp(self, ):
3618 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3619 
    if mtype == TMessageType.EXCEPTION:
3620 
      x = TApplicationException()
3621 
      x.read(self._iprot)
3622 
      self._iprot.readMessageEnd()
3623 
      raise x
3624 
    result = markReturnOrdersAsPickedUp_result()
3625 
    result.read(self._iprot)
3626 
    self._iprot.readMessageEnd()
4910 phani.kuma 3627 
    return
3628 
 
3629 
  def getReturnOrdersNotPickedUp(self, providerId):
3630 
    """
3631 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3632 
 
3633 
    Parameters:
3634 
     - providerId
3635 
    """
3636 
    self.send_getReturnOrdersNotPickedUp(providerId)
3637 
    return self.recv_getReturnOrdersNotPickedUp()
3638 
 
3639 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3640 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3641 
    args = getReturnOrdersNotPickedUp_args()
3642 
    args.providerId = providerId
3643 
    args.write(self._oprot)
3644 
    self._oprot.writeMessageEnd()
3645 
    self._oprot.trans.flush()
3646 
 
3647 
  def recv_getReturnOrdersNotPickedUp(self, ):
3648 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3649 
    if mtype == TMessageType.EXCEPTION:
3650 
      x = TApplicationException()
3651 
      x.read(self._iprot)
3652 
      self._iprot.readMessageEnd()
3653 
      raise x
3654 
    result = getReturnOrdersNotPickedUp_result()
3655 
    result.read(self._iprot)
3656 
    self._iprot.readMessageEnd()
4741 phani.kuma 3657 
    if result.success is not None:
3658 
      return result.success
4910 phani.kuma 3659 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3660 
 
4479 rajveer 3661 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3662 
    """
4452 rajveer 3663 
    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 3664 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3665 
    If the order is in any other state, it returns false.
3666 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3667 
 
2591 chandransh 3668 
    Parameters:
3669 
     - orderId
4479 rajveer 3670 
     - receiveCondition
2591 chandransh 3671 
    """
4479 rajveer 3672 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3673 
    return self.recv_receiveReturn()
2536 chandransh 3674 
 
4479 rajveer 3675 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3676 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3677 
    args = receiveReturn_args()
2591 chandransh 3678 
    args.orderId = orderId
4479 rajveer 3679 
    args.receiveCondition = receiveCondition
2591 chandransh 3680 
    args.write(self._oprot)
3681 
    self._oprot.writeMessageEnd()
3682 
    self._oprot.trans.flush()
3683 
 
2616 chandransh 3684 
  def recv_receiveReturn(self, ):
2591 chandransh 3685 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3686 
    if mtype == TMessageType.EXCEPTION:
3687 
      x = TApplicationException()
3688 
      x.read(self._iprot)
3689 
      self._iprot.readMessageEnd()
3690 
      raise x
2616 chandransh 3691 
    result = receiveReturn_result()
2591 chandransh 3692 
    result.read(self._iprot)
3693 
    self._iprot.readMessageEnd()
3431 rajveer 3694 
    if result.success is not None:
2591 chandransh 3695 
      return result.success
3431 rajveer 3696 
    if result.ex is not None:
2591 chandransh 3697 
      raise result.ex
2616 chandransh 3698 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3699 
 
3700 
  def validateDoa(self, orderId, isValid):
3701 
    """
4452 rajveer 3702 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3703 
    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 3704 
    If the order is in any other state, it returns false.
3705 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3706 
 
2591 chandransh 3707 
    Parameters:
3708 
     - orderId
3709 
     - isValid
3710 
    """
3711 
    self.send_validateDoa(orderId, isValid)
3712 
    return self.recv_validateDoa()
3713 
 
3714 
  def send_validateDoa(self, orderId, isValid):
3715 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3716 
    args = validateDoa_args()
3717 
    args.orderId = orderId
3718 
    args.isValid = isValid
3719 
    args.write(self._oprot)
3720 
    self._oprot.writeMessageEnd()
3721 
    self._oprot.trans.flush()
3722 
 
3723 
  def recv_validateDoa(self, ):
3724 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3725 
    if mtype == TMessageType.EXCEPTION:
3726 
      x = TApplicationException()
3727 
      x.read(self._iprot)
3728 
      self._iprot.readMessageEnd()
3729 
      raise x
3730 
    result = validateDoa_result()
3731 
    result.read(self._iprot)
3732 
    self._iprot.readMessageEnd()
3431 rajveer 3733 
    if result.success is not None:
2591 chandransh 3734 
      return result.success
3431 rajveer 3735 
    if result.ex is not None:
2591 chandransh 3736 
      raise result.ex
3737 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3738 
 
4495 rajveer 3739 
  def validateReturnProduct(self, orderId, isUsable):
3740 
    """
3741 
    Parameters:
3742 
     - orderId
3743 
     - isUsable
3744 
    """
3745 
    self.send_validateReturnProduct(orderId, isUsable)
3746 
    return self.recv_validateReturnProduct()
3747 
 
3748 
  def send_validateReturnProduct(self, orderId, isUsable):
3749 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3750 
    args = validateReturnProduct_args()
3751 
    args.orderId = orderId
3752 
    args.isUsable = isUsable
3753 
    args.write(self._oprot)
3754 
    self._oprot.writeMessageEnd()
3755 
    self._oprot.trans.flush()
3756 
 
3757 
  def recv_validateReturnProduct(self, ):
3758 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3759 
    if mtype == TMessageType.EXCEPTION:
3760 
      x = TApplicationException()
3761 
      x.read(self._iprot)
3762 
      self._iprot.readMessageEnd()
3763 
      raise x
3764 
    result = validateReturnProduct_result()
3765 
    result.read(self._iprot)
3766 
    self._iprot.readMessageEnd()
3767 
    if result.success is not None:
3768 
      return result.success
3769 
    if result.ex is not None:
3770 
      raise result.ex
3771 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3772 
 
2616 chandransh 3773 
  def reshipOrder(self, orderId):
3774 
    """
4484 rajveer 3775 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3776 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3777 
    	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 3778 
 
3779 
    If the order is in DOA_CERT_VALID state, it does the following:
3780 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3781 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3782 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3783 
 
2616 chandransh 3784 
    Returns the id of the newly created order.
3431 rajveer 3785 
 
2616 chandransh 3786 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3787 
 
2616 chandransh 3788 
    Parameters:
3789 
     - orderId
3790 
    """
3791 
    self.send_reshipOrder(orderId)
3792 
    return self.recv_reshipOrder()
2591 chandransh 3793 
 
2616 chandransh 3794 
  def send_reshipOrder(self, orderId):
3795 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3796 
    args = reshipOrder_args()
3797 
    args.orderId = orderId
3798 
    args.write(self._oprot)
3799 
    self._oprot.writeMessageEnd()
3800 
    self._oprot.trans.flush()
3801 
 
3802 
  def recv_reshipOrder(self, ):
3803 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3804 
    if mtype == TMessageType.EXCEPTION:
3805 
      x = TApplicationException()
3806 
      x.read(self._iprot)
3807 
      self._iprot.readMessageEnd()
3808 
      raise x
3809 
    result = reshipOrder_result()
3810 
    result.read(self._iprot)
3811 
    self._iprot.readMessageEnd()
3431 rajveer 3812 
    if result.success is not None:
2616 chandransh 3813 
      return result.success
3431 rajveer 3814 
    if result.ex is not None:
2616 chandransh 3815 
      raise result.ex
3816 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3817 
 
3226 chandransh 3818 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3819 
    """
4484 rajveer 3820 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3821 
    	1. Creates a refund request for batch processing.
3822 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3823 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3824 
 
2616 chandransh 3825 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3826 
    	1. Creates a refund request for batch processing.
3226 chandransh 3827 
    	2. Cancels the reservation of the item in the warehouse.
3828 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3829 
 
3226 chandransh 3830 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3831 
    	1. Cancels the reservation of the item in the warehouse.
3832 
    	2. Marks the current order as CANCELED.
3833 
 
3834 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3835 
 
2616 chandransh 3836 
    Returns True if it is successful, False otherwise.
3431 rajveer 3837 
 
2616 chandransh 3838 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3839 
 
2616 chandransh 3840 
    Parameters:
3841 
     - orderId
3226 chandransh 3842 
     - refundedBy
3843 
     - reason
2616 chandransh 3844 
    """
3226 chandransh 3845 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3846 
    return self.recv_refundOrder()
3847 
 
3226 chandransh 3848 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3849 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3850 
    args = refundOrder_args()
3851 
    args.orderId = orderId
3226 chandransh 3852 
    args.refundedBy = refundedBy
3853 
    args.reason = reason
2616 chandransh 3854 
    args.write(self._oprot)
3855 
    self._oprot.writeMessageEnd()
3856 
    self._oprot.trans.flush()
3857 
 
3858 
  def recv_refundOrder(self, ):
3859 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3860 
    if mtype == TMessageType.EXCEPTION:
3861 
      x = TApplicationException()
3862 
      x.read(self._iprot)
3863 
      self._iprot.readMessageEnd()
3864 
      raise x
3865 
    result = refundOrder_result()
3866 
    result.read(self._iprot)
3867 
    self._iprot.readMessageEnd()
3431 rajveer 3868 
    if result.success is not None:
2616 chandransh 3869 
      return result.success
3431 rajveer 3870 
    if result.ex is not None:
2616 chandransh 3871 
      raise result.ex
3872 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3873 
 
2690 chandransh 3874 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3875 
    """
3876 
    Get all return orders created between the from and to dates for the given warehouse.
3877 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3878 
 
2690 chandransh 3879 
    Parameters:
3880 
     - warehouseId
3881 
     - fromDate
3882 
     - toDate
3883 
    """
3884 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3885 
    return self.recv_getReturnOrders()
2616 chandransh 3886 
 
2690 chandransh 3887 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3888 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3889 
    args = getReturnOrders_args()
3890 
    args.warehouseId = warehouseId
3891 
    args.fromDate = fromDate
3892 
    args.toDate = toDate
3893 
    args.write(self._oprot)
3894 
    self._oprot.writeMessageEnd()
3895 
    self._oprot.trans.flush()
3896 
 
3897 
  def recv_getReturnOrders(self, ):
3898 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3899 
    if mtype == TMessageType.EXCEPTION:
3900 
      x = TApplicationException()
3901 
      x.read(self._iprot)
3902 
      self._iprot.readMessageEnd()
3903 
      raise x
3904 
    result = getReturnOrders_result()
3905 
    result.read(self._iprot)
3906 
    self._iprot.readMessageEnd()
3431 rajveer 3907 
    if result.success is not None:
2690 chandransh 3908 
      return result.success
3909 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3910 
 
5481 phani.kuma 3911 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3912 
    """
3913 
    Get all return orders created between the from and to dates.
3914 
 
3915 
    Parameters:
3916 
     - onlyNotProcessed
3917 
     - fromDate
3918 
     - toDate
3919 
    """
3920 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3921 
    return self.recv_getAllReturnOrders()
3922 
 
3923 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3924 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3925 
    args = getAllReturnOrders_args()
3926 
    args.onlyNotProcessed = onlyNotProcessed
3927 
    args.fromDate = fromDate
3928 
    args.toDate = toDate
3929 
    args.write(self._oprot)
3930 
    self._oprot.writeMessageEnd()
3931 
    self._oprot.trans.flush()
3932 
 
3933 
  def recv_getAllReturnOrders(self, ):
3934 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3935 
    if mtype == TMessageType.EXCEPTION:
3936 
      x = TApplicationException()
3937 
      x.read(self._iprot)
3938 
      self._iprot.readMessageEnd()
3939 
      raise x
3940 
    result = getAllReturnOrders_result()
3941 
    result.read(self._iprot)
3942 
    self._iprot.readMessageEnd()
3943 
    if result.success is not None:
3944 
      return result.success
3945 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3946 
 
2700 chandransh 3947 
  def getReturnOrder(self, id):
3948 
    """
3949 
    Returns the ReturnOrder corresponding to the given id.
3950 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3951 
 
2700 chandransh 3952 
    Parameters:
3953 
     - id
3954 
    """
3955 
    self.send_getReturnOrder(id)
3956 
    return self.recv_getReturnOrder()
3957 
 
3958 
  def send_getReturnOrder(self, id):
3959 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3960 
    args = getReturnOrder_args()
3961 
    args.id = id
3962 
    args.write(self._oprot)
3963 
    self._oprot.writeMessageEnd()
3964 
    self._oprot.trans.flush()
3965 
 
3966 
  def recv_getReturnOrder(self, ):
3967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3968 
    if mtype == TMessageType.EXCEPTION:
3969 
      x = TApplicationException()
3970 
      x.read(self._iprot)
3971 
      self._iprot.readMessageEnd()
3972 
      raise x
3973 
    result = getReturnOrder_result()
3974 
    result.read(self._iprot)
3975 
    self._iprot.readMessageEnd()
3431 rajveer 3976 
    if result.success is not None:
2700 chandransh 3977 
      return result.success
3431 rajveer 3978 
    if result.ex is not None:
2700 chandransh 3979 
      raise result.ex
3980 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
3981 
 
2690 chandransh 3982 
  def processReturn(self, returnOrderId):
3983 
    """
3984 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 3985 
 
2690 chandransh 3986 
    Parameters:
3987 
     - returnOrderId
3988 
    """
3989 
    self.send_processReturn(returnOrderId)
3990 
    self.recv_processReturn()
3991 
 
3992 
  def send_processReturn(self, returnOrderId):
3993 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
3994 
    args = processReturn_args()
3995 
    args.returnOrderId = returnOrderId
3996 
    args.write(self._oprot)
3997 
    self._oprot.writeMessageEnd()
3998 
    self._oprot.trans.flush()
3999 
 
4000 
  def recv_processReturn(self, ):
4001 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4002 
    if mtype == TMessageType.EXCEPTION:
4003 
      x = TApplicationException()
4004 
      x.read(self._iprot)
4005 
      self._iprot.readMessageEnd()
4006 
      raise x
4007 
    result = processReturn_result()
4008 
    result.read(self._iprot)
4009 
    self._iprot.readMessageEnd()
3431 rajveer 4010 
    if result.ex is not None:
2690 chandransh 4011 
      raise result.ex
4012 
    return
4013 
 
3451 chandransh 4014 
  def updateWeight(self, orderId, weight):
4015 
    """
4016 
    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 4017 
 
3451 chandransh 4018 
    Parameters:
4019 
     - orderId
4020 
     - weight
4021 
    """
4022 
    self.send_updateWeight(orderId, weight)
4023 
    return self.recv_updateWeight()
4024 
 
4025 
  def send_updateWeight(self, orderId, weight):
4026 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4027 
    args = updateWeight_args()
4028 
    args.orderId = orderId
4029 
    args.weight = weight
4030 
    args.write(self._oprot)
4031 
    self._oprot.writeMessageEnd()
4032 
    self._oprot.trans.flush()
4033 
 
4034 
  def recv_updateWeight(self, ):
4035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4036 
    if mtype == TMessageType.EXCEPTION:
4037 
      x = TApplicationException()
4038 
      x.read(self._iprot)
4039 
      self._iprot.readMessageEnd()
4040 
      raise x
4041 
    result = updateWeight_result()
4042 
    result.read(self._iprot)
4043 
    self._iprot.readMessageEnd()
4044 
    if result.success is not None:
4045 
      return result.success
4046 
    if result.ex is not None:
4047 
      raise result.ex
4048 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4049 
 
3469 chandransh 4050 
  def changeItem(self, orderId, itemId):
4051 
    """
4052 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4053 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4054 
 
3469 chandransh 4055 
    Parameters:
4056 
     - orderId
4057 
     - itemId
4058 
    """
4059 
    self.send_changeItem(orderId, itemId)
4060 
    return self.recv_changeItem()
4061 
 
4062 
  def send_changeItem(self, orderId, itemId):
4063 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4064 
    args = changeItem_args()
4065 
    args.orderId = orderId
4066 
    args.itemId = itemId
4067 
    args.write(self._oprot)
4068 
    self._oprot.writeMessageEnd()
4069 
    self._oprot.trans.flush()
4070 
 
4071 
  def recv_changeItem(self, ):
4072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4073 
    if mtype == TMessageType.EXCEPTION:
4074 
      x = TApplicationException()
4075 
      x.read(self._iprot)
4076 
      self._iprot.readMessageEnd()
4077 
      raise x
4078 
    result = changeItem_result()
4079 
    result.read(self._iprot)
4080 
    self._iprot.readMessageEnd()
4081 
    if result.success is not None:
4082 
      return result.success
4083 
    if result.ex is not None:
4084 
      raise result.ex
4085 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4086 
 
4087 
  def shiftToWarehouse(self, orderId, warehouseId):
4088 
    """
4089 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4090 
 
4091 
    Parameters:
4092 
     - orderId
4093 
     - warehouseId
4094 
    """
4095 
    self.send_shiftToWarehouse(orderId, warehouseId)
4096 
    return self.recv_shiftToWarehouse()
4097 
 
4098 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4099 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4100 
    args = shiftToWarehouse_args()
4101 
    args.orderId = orderId
4102 
    args.warehouseId = warehouseId
4103 
    args.write(self._oprot)
4104 
    self._oprot.writeMessageEnd()
4105 
    self._oprot.trans.flush()
4106 
 
4107 
  def recv_shiftToWarehouse(self, ):
4108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4109 
    if mtype == TMessageType.EXCEPTION:
4110 
      x = TApplicationException()
4111 
      x.read(self._iprot)
4112 
      self._iprot.readMessageEnd()
4113 
      raise x
4114 
    result = shiftToWarehouse_result()
4115 
    result.read(self._iprot)
4116 
    self._iprot.readMessageEnd()
4117 
    if result.success is not None:
4118 
      return result.success
4119 
    if result.ex is not None:
4120 
      raise result.ex
4121 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4122 
 
4647 rajveer 4123 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4124 
    """
4125 
    Adds the given delay reason to the given order.
3986 chandransh 4126 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4127 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4128 
 
3553 chandransh 4129 
    Parameters:
4130 
     - orderId
4131 
     - delayReason
3986 chandransh 4132 
     - furtherDelay
4647 rajveer 4133 
     - delayReasonText
3553 chandransh 4134 
    """
4647 rajveer 4135 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4136 
    return self.recv_addDelayReason()
4137 
 
4647 rajveer 4138 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4139 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4140 
    args = addDelayReason_args()
4141 
    args.orderId = orderId
4142 
    args.delayReason = delayReason
3986 chandransh 4143 
    args.furtherDelay = furtherDelay
4647 rajveer 4144 
    args.delayReasonText = delayReasonText
3553 chandransh 4145 
    args.write(self._oprot)
4146 
    self._oprot.writeMessageEnd()
4147 
    self._oprot.trans.flush()
4148 
 
4149 
  def recv_addDelayReason(self, ):
4150 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4151 
    if mtype == TMessageType.EXCEPTION:
4152 
      x = TApplicationException()
4153 
      x.read(self._iprot)
4154 
      self._iprot.readMessageEnd()
4155 
      raise x
4156 
    result = addDelayReason_result()
4157 
    result.read(self._iprot)
4158 
    self._iprot.readMessageEnd()
4159 
    if result.success is not None:
4160 
      return result.success
4161 
    if result.ex is not None:
4162 
      raise result.ex
4163 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4164 
 
3956 chandransh 4165 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4166 
    """
4167 
    Marks the COD orders with given AWB nos. as having been processed.
4168 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4169 
 
3956 chandransh 4170 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4171 
    1. There is no order corresponding to an AWB number.
4172 
    2. The captured amount for a payment exceeds the total payment.
4173 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4174 
 
4175 
    Parameters:
4176 
     - collectedAmountMap
4177 
     - xferBy
4178 
     - xferTxnId
4179 
     - xferDate
4180 
    """
4181 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4182 
    return self.recv_reconcileCodCollection()
4183 
 
4184 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4185 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4186 
    args = reconcileCodCollection_args()
4187 
    args.collectedAmountMap = collectedAmountMap
4188 
    args.xferBy = xferBy
4189 
    args.xferTxnId = xferTxnId
4190 
    args.xferDate = xferDate
4191 
    args.write(self._oprot)
4192 
    self._oprot.writeMessageEnd()
4193 
    self._oprot.trans.flush()
4194 
 
4195 
  def recv_reconcileCodCollection(self, ):
4196 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4197 
    if mtype == TMessageType.EXCEPTION:
4198 
      x = TApplicationException()
4199 
      x.read(self._iprot)
4200 
      self._iprot.readMessageEnd()
4201 
      raise x
4202 
    result = reconcileCodCollection_result()
4203 
    result.read(self._iprot)
4204 
    self._iprot.readMessageEnd()
4205 
    if result.success is not None:
4206 
      return result.success
4207 
    if result.ex is not None:
4208 
      raise result.ex
4209 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4210 
 
4008 mandeep.dh 4211 
  def getTransactionsRequiringExtraProcessing(self, category):
4212 
    """
4065 mandeep.dh 4213 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4214 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4215 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4216 
 
4008 mandeep.dh 4217 
    Parameters:
4218 
     - category
4219 
    """
4220 
    self.send_getTransactionsRequiringExtraProcessing(category)
4221 
    return self.recv_getTransactionsRequiringExtraProcessing()
4222 
 
4223 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4224 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4225 
    args = getTransactionsRequiringExtraProcessing_args()
4226 
    args.category = category
4227 
    args.write(self._oprot)
4228 
    self._oprot.writeMessageEnd()
4229 
    self._oprot.trans.flush()
4230 
 
4231 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4232 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4233 
    if mtype == TMessageType.EXCEPTION:
4234 
      x = TApplicationException()
4235 
      x.read(self._iprot)
4236 
      self._iprot.readMessageEnd()
4237 
      raise x
4238 
    result = getTransactionsRequiringExtraProcessing_result()
4239 
    result.read(self._iprot)
4240 
    self._iprot.readMessageEnd()
4241 
    if result.success is not None:
4242 
      return result.success
4243 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4244 
 
4245 
  def markTransactionAsProcessed(self, transactionId, category):
4246 
    """
4247 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4248 
    It essentially deletes the transaction id record for a particular
4249 
    processing type category (if present) from DB.
4250 
    This is currently used by CRM application.
4008 mandeep.dh 4251 
 
4252 
    Parameters:
4253 
     - transactionId
4254 
     - category
4255 
    """
4256 
    self.send_markTransactionAsProcessed(transactionId, category)
4257 
    self.recv_markTransactionAsProcessed()
4258 
 
4259 
  def send_markTransactionAsProcessed(self, transactionId, category):
4260 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4261 
    args = markTransactionAsProcessed_args()
4262 
    args.transactionId = transactionId
4263 
    args.category = category
4264 
    args.write(self._oprot)
4265 
    self._oprot.writeMessageEnd()
4266 
    self._oprot.trans.flush()
4267 
 
4268 
  def recv_markTransactionAsProcessed(self, ):
4269 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4270 
    if mtype == TMessageType.EXCEPTION:
4271 
      x = TApplicationException()
4272 
      x.read(self._iprot)
4273 
      self._iprot.readMessageEnd()
4274 
      raise x
4275 
    result = markTransactionAsProcessed_result()
4276 
    result.read(self._iprot)
4277 
    self._iprot.readMessageEnd()
4278 
    return
4279 
 
4018 chandransh 4280 
  def getItemWiseRiskyOrdersCount(self, ):
4281 
    """
4282 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4283 
    is defined as one whose shipping date is about to expire.
4284 
    """
4285 
    self.send_getItemWiseRiskyOrdersCount()
4286 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4287 
 
4018 chandransh 4288 
  def send_getItemWiseRiskyOrdersCount(self, ):
4289 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4290 
    args = getItemWiseRiskyOrdersCount_args()
4291 
    args.write(self._oprot)
4292 
    self._oprot.writeMessageEnd()
4293 
    self._oprot.trans.flush()
4294 
 
4295 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4296 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4297 
    if mtype == TMessageType.EXCEPTION:
4298 
      x = TApplicationException()
4299 
      x.read(self._iprot)
4300 
      self._iprot.readMessageEnd()
4301 
      raise x
4302 
    result = getItemWiseRiskyOrdersCount_result()
4303 
    result.read(self._iprot)
4304 
    self._iprot.readMessageEnd()
4305 
    if result.success is not None:
4306 
      return result.success
4307 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4308 
 
4295 varun.gupt 4309 
  def getOrdersForItemIds(self, itemIds):
4310 
    """
4311 
    Returns a list of all orders which have items with given id
4312 
 
4313 
    Parameters:
4314 
     - itemIds
4315 
    """
4316 
    self.send_getOrdersForItemIds(itemIds)
4317 
    return self.recv_getOrdersForItemIds()
4318 
 
4319 
  def send_getOrdersForItemIds(self, itemIds):
4320 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4321 
    args = getOrdersForItemIds_args()
4322 
    args.itemIds = itemIds
4323 
    args.write(self._oprot)
4324 
    self._oprot.writeMessageEnd()
4325 
    self._oprot.trans.flush()
4326 
 
4327 
  def recv_getOrdersForItemIds(self, ):
4328 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4329 
    if mtype == TMessageType.EXCEPTION:
4330 
      x = TApplicationException()
4331 
      x.read(self._iprot)
4332 
      self._iprot.readMessageEnd()
4333 
      raise x
4334 
    result = getOrdersForItemIds_result()
4335 
    result.read(self._iprot)
4336 
    self._iprot.readMessageEnd()
4337 
    if result.success is not None:
4338 
      return result.success
4339 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4340 
 
4247 rajveer 4341 
  def markOrderCancellationRequestReceived(self, orderId):
4342 
    """
4343 
    Mark order as cancellation request received. If customer sends request of cancellation of
4344 
    a particular order, this method will be called. It will just change status of the order
4345 
    depending on its current status. It also records the previous status, so that we can move
4346 
    back to that status if cancellation request is denied.
4018 chandransh 4347 
 
4247 rajveer 4348 
    Parameters:
4349 
     - orderId
4350 
    """
4351 
    self.send_markOrderCancellationRequestReceived(orderId)
4352 
    self.recv_markOrderCancellationRequestReceived()
4353 
 
4354 
  def send_markOrderCancellationRequestReceived(self, orderId):
4355 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4356 
    args = markOrderCancellationRequestReceived_args()
4357 
    args.orderId = orderId
4358 
    args.write(self._oprot)
4359 
    self._oprot.writeMessageEnd()
4360 
    self._oprot.trans.flush()
4361 
 
4362 
  def recv_markOrderCancellationRequestReceived(self, ):
4363 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4364 
    if mtype == TMessageType.EXCEPTION:
4365 
      x = TApplicationException()
4366 
      x.read(self._iprot)
4367 
      self._iprot.readMessageEnd()
4368 
      raise x
4369 
    result = markOrderCancellationRequestReceived_result()
4370 
    result.read(self._iprot)
4371 
    self._iprot.readMessageEnd()
4372 
    if result.ex is not None:
4373 
      raise result.ex
4374 
    return
4375 
 
4376 
  def markOrderCancellationRequestConfirmed(self, orderId):
4377 
    """
4378 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4379 
    cancellation request confirmed. After this OM will be able to cancel the order.
4380 
 
4381 
    Parameters:
4382 
     - orderId
4383 
    """
4384 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4385 
    self.recv_markOrderCancellationRequestConfirmed()
4386 
 
4387 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4388 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4389 
    args = markOrderCancellationRequestConfirmed_args()
4390 
    args.orderId = orderId
4391 
    args.write(self._oprot)
4392 
    self._oprot.writeMessageEnd()
4393 
    self._oprot.trans.flush()
4394 
 
4395 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4396 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4397 
    if mtype == TMessageType.EXCEPTION:
4398 
      x = TApplicationException()
4399 
      x.read(self._iprot)
4400 
      self._iprot.readMessageEnd()
4401 
      raise x
4402 
    result = markOrderCancellationRequestConfirmed_result()
4403 
    result.read(self._iprot)
4404 
    self._iprot.readMessageEnd()
4405 
    if result.ex is not None:
4406 
      raise result.ex
4407 
    return
4408 
 
4409 
  def markOrderCancellationRequestDenied(self, orderId):
4410 
    """
4411 
    If we decide to not to cancel order, we will move the order ro previous status.
4412 
 
4413 
    Parameters:
4414 
     - orderId
4415 
    """
4416 
    self.send_markOrderCancellationRequestDenied(orderId)
4417 
    self.recv_markOrderCancellationRequestDenied()
4418 
 
4419 
  def send_markOrderCancellationRequestDenied(self, orderId):
4420 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4421 
    args = markOrderCancellationRequestDenied_args()
4422 
    args.orderId = orderId
4423 
    args.write(self._oprot)
4424 
    self._oprot.writeMessageEnd()
4425 
    self._oprot.trans.flush()
4426 
 
4427 
  def recv_markOrderCancellationRequestDenied(self, ):
4428 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4429 
    if mtype == TMessageType.EXCEPTION:
4430 
      x = TApplicationException()
4431 
      x.read(self._iprot)
4432 
      self._iprot.readMessageEnd()
4433 
      raise x
4434 
    result = markOrderCancellationRequestDenied_result()
4435 
    result.read(self._iprot)
4436 
    self._iprot.readMessageEnd()
4437 
    if result.ex is not None:
4438 
      raise result.ex
4439 
    return
4440 
 
4258 rajveer 4441 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4442 
    """
4258 rajveer 4443 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4444 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4445 
 
4446 
    Parameters:
4258 rajveer 4447 
     - transactionId
4247 rajveer 4448 
    """
4258 rajveer 4449 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4450 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4451 
 
4258 rajveer 4452 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4453 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4454 
    args = markTransactionAsPaymentFlagRemoved_args()
4455 
    args.transactionId = transactionId
4247 rajveer 4456 
    args.write(self._oprot)
4457 
    self._oprot.writeMessageEnd()
4458 
    self._oprot.trans.flush()
4459 
 
4258 rajveer 4460 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4462 
    if mtype == TMessageType.EXCEPTION:
4463 
      x = TApplicationException()
4464 
      x.read(self._iprot)
4465 
      self._iprot.readMessageEnd()
4466 
      raise x
4258 rajveer 4467 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4468 
    result.read(self._iprot)
4469 
    self._iprot.readMessageEnd()
4470 
    if result.ex is not None:
4471 
      raise result.ex
4472 
    return
4473 
 
4259 anupam.sin 4474 
  def refundTransaction(self, transactionId, refundedBy, reason):
4475 
    """
4476 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4477 
    need to be cancelled
4247 rajveer 4478 
 
4259 anupam.sin 4479 
    Parameters:
4480 
     - transactionId
4481 
     - refundedBy
4482 
     - reason
4483 
    """
4484 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4485 
    self.recv_refundTransaction()
4486 
 
4487 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4488 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4489 
    args = refundTransaction_args()
4490 
    args.transactionId = transactionId
4491 
    args.refundedBy = refundedBy
4492 
    args.reason = reason
4493 
    args.write(self._oprot)
4494 
    self._oprot.writeMessageEnd()
4495 
    self._oprot.trans.flush()
4496 
 
4497 
  def recv_refundTransaction(self, ):
4498 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4499 
    if mtype == TMessageType.EXCEPTION:
4500 
      x = TApplicationException()
4501 
      x.read(self._iprot)
4502 
      self._iprot.readMessageEnd()
4503 
      raise x
4504 
    result = refundTransaction_result()
4505 
    result.read(self._iprot)
4506 
    self._iprot.readMessageEnd()
4507 
    if result.ex is not None:
4508 
      raise result.ex
4509 
    return
4510 
 
4324 mandeep.dh 4511 
  def updateShipmentAddress(self, orderId, addressId):
4512 
    """
4513 
    Updates shipment address of an order. Delivery and shipping date estimates
4514 
    etc. are also updated here.
4515 
 
4516 
    Throws TransactionServiceException in case address change is not
4517 
    possible due to certain reasons such as new pincode in address is
4518 
    not serviceable etc.
4519 
 
4520 
    Parameters:
4521 
     - orderId
4522 
     - addressId
4523 
    """
4524 
    self.send_updateShipmentAddress(orderId, addressId)
4525 
    self.recv_updateShipmentAddress()
4526 
 
4527 
  def send_updateShipmentAddress(self, orderId, addressId):
4528 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4529 
    args = updateShipmentAddress_args()
4530 
    args.orderId = orderId
4531 
    args.addressId = addressId
4532 
    args.write(self._oprot)
4533 
    self._oprot.writeMessageEnd()
4534 
    self._oprot.trans.flush()
4535 
 
4536 
  def recv_updateShipmentAddress(self, ):
4537 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4538 
    if mtype == TMessageType.EXCEPTION:
4539 
      x = TApplicationException()
4540 
      x.read(self._iprot)
4541 
      self._iprot.readMessageEnd()
4542 
      raise x
4543 
    result = updateShipmentAddress_result()
4544 
    result.read(self._iprot)
4545 
    self._iprot.readMessageEnd()
4546 
    if result.ex is not None:
4547 
      raise result.ex
4548 
    return
4549 
 
4285 rajveer 4550 
  def acceptOrdersForItemId(self, itemId, inventory):
4551 
    """
4552 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4553 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4554 
 
4285 rajveer 4555 
    Parameters:
4556 
     - itemId
4557 
     - inventory
4558 
    """
4559 
    self.send_acceptOrdersForItemId(itemId, inventory)
4560 
    return self.recv_acceptOrdersForItemId()
4561 
 
4562 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4563 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4564 
    args = acceptOrdersForItemId_args()
4565 
    args.itemId = itemId
4566 
    args.inventory = inventory
4567 
    args.write(self._oprot)
4568 
    self._oprot.writeMessageEnd()
4569 
    self._oprot.trans.flush()
4570 
 
4571 
  def recv_acceptOrdersForItemId(self, ):
4572 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4573 
    if mtype == TMessageType.EXCEPTION:
4574 
      x = TApplicationException()
4575 
      x.read(self._iprot)
4576 
      self._iprot.readMessageEnd()
4577 
      raise x
4578 
    result = acceptOrdersForItemId_result()
4579 
    result.read(self._iprot)
4580 
    self._iprot.readMessageEnd()
4581 
    if result.success is not None:
4582 
      return result.success
4583 
    if result.ex is not None:
4584 
      raise result.ex
4585 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4586 
 
4369 rajveer 4587 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4588 
    """
4589 
    Parameters:
4590 
     - vendorId
4591 
     - itemId
4592 
     - quantity
4593 
     - estimate
4369 rajveer 4594 
     - isReminder
4303 rajveer 4595 
    """
4369 rajveer 4596 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4597 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4598 
 
4369 rajveer 4599 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4600 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4601 
    args = markOrdersAsPORaised_args()
4602 
    args.vendorId = vendorId
4603 
    args.itemId = itemId
4604 
    args.quantity = quantity
4605 
    args.estimate = estimate
4369 rajveer 4606 
    args.isReminder = isReminder
4303 rajveer 4607 
    args.write(self._oprot)
4608 
    self._oprot.writeMessageEnd()
4609 
    self._oprot.trans.flush()
4610 
 
4611 
  def recv_markOrdersAsPORaised(self, ):
4612 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4613 
    if mtype == TMessageType.EXCEPTION:
4614 
      x = TApplicationException()
4615 
      x.read(self._iprot)
4616 
      self._iprot.readMessageEnd()
4617 
      raise x
4618 
    result = markOrdersAsPORaised_result()
4619 
    result.read(self._iprot)
4620 
    self._iprot.readMessageEnd()
4621 
    if result.ex is not None:
4622 
      raise result.ex
4623 
    return
4624 
 
4369 rajveer 4625 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4626 
    """
4627 
    Parameters:
4628 
     - vendorId
4629 
     - itemId
4630 
     - quantity
4631 
     - estimate
4369 rajveer 4632 
     - isReminder
4303 rajveer 4633 
    """
4369 rajveer 4634 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4635 
    self.recv_markOrdersAsReversalInitiated()
4636 
 
4369 rajveer 4637 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4638 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4639 
    args = markOrdersAsReversalInitiated_args()
4640 
    args.vendorId = vendorId
4641 
    args.itemId = itemId
4642 
    args.quantity = quantity
4643 
    args.estimate = estimate
4369 rajveer 4644 
    args.isReminder = isReminder
4303 rajveer 4645 
    args.write(self._oprot)
4646 
    self._oprot.writeMessageEnd()
4647 
    self._oprot.trans.flush()
4648 
 
4649 
  def recv_markOrdersAsReversalInitiated(self, ):
4650 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4651 
    if mtype == TMessageType.EXCEPTION:
4652 
      x = TApplicationException()
4653 
      x.read(self._iprot)
4654 
      self._iprot.readMessageEnd()
4655 
      raise x
4656 
    result = markOrdersAsReversalInitiated_result()
4657 
    result.read(self._iprot)
4658 
    self._iprot.readMessageEnd()
4659 
    if result.ex is not None:
4660 
      raise result.ex
4661 
    return
4662 
 
4369 rajveer 4663 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4664 
    """
4665 
    Parameters:
4666 
     - vendorId
4667 
     - itemId
4668 
     - quantity
4669 
     - estimate
4369 rajveer 4670 
     - isReminder
4303 rajveer 4671 
    """
4369 rajveer 4672 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4673 
    self.recv_markOrdersAsNotAvailabke()
4674 
 
4369 rajveer 4675 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4676 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4677 
    args = markOrdersAsNotAvailabke_args()
4678 
    args.vendorId = vendorId
4679 
    args.itemId = itemId
4680 
    args.quantity = quantity
4681 
    args.estimate = estimate
4369 rajveer 4682 
    args.isReminder = isReminder
4303 rajveer 4683 
    args.write(self._oprot)
4684 
    self._oprot.writeMessageEnd()
4685 
    self._oprot.trans.flush()
4686 
 
4687 
  def recv_markOrdersAsNotAvailabke(self, ):
4688 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4689 
    if mtype == TMessageType.EXCEPTION:
4690 
      x = TApplicationException()
4691 
      x.read(self._iprot)
4692 
      self._iprot.readMessageEnd()
4693 
      raise x
4694 
    result = markOrdersAsNotAvailabke_result()
4695 
    result.read(self._iprot)
4696 
    self._iprot.readMessageEnd()
4697 
    if result.ex is not None:
4698 
      raise result.ex
4699 
    return
4700 
 
4369 rajveer 4701 
  def markOrdersAsTimeout(self, vendorId):
4702 
    """
4703 
    Parameters:
4704 
     - vendorId
4705 
    """
4706 
    self.send_markOrdersAsTimeout(vendorId)
4707 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4708 
 
4369 rajveer 4709 
  def send_markOrdersAsTimeout(self, vendorId):
4710 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4711 
    args = markOrdersAsTimeout_args()
4712 
    args.vendorId = vendorId
4713 
    args.write(self._oprot)
4714 
    self._oprot.writeMessageEnd()
4715 
    self._oprot.trans.flush()
4716 
 
4717 
  def recv_markOrdersAsTimeout(self, ):
4718 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4719 
    if mtype == TMessageType.EXCEPTION:
4720 
      x = TApplicationException()
4721 
      x.read(self._iprot)
4722 
      self._iprot.readMessageEnd()
4723 
      raise x
4724 
    result = markOrdersAsTimeout_result()
4725 
    result.read(self._iprot)
4726 
    self._iprot.readMessageEnd()
4727 
    if result.success is not None:
4728 
      return result.success
4729 
    if result.ex is not None:
4730 
      raise result.ex
4731 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4732 
 
4662 rajveer 4733 
  def markOrderAsLostInTransit(self, orderId):
4734 
    """
4735 
    Mark order as LOST_IN_TRANSIT
4736 
 
4737 
    Parameters:
4738 
     - orderId
4739 
    """
4740 
    self.send_markOrderAsLostInTransit(orderId)
4741 
    return self.recv_markOrderAsLostInTransit()
4742 
 
4743 
  def send_markOrderAsLostInTransit(self, orderId):
4744 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4745 
    args = markOrderAsLostInTransit_args()
4746 
    args.orderId = orderId
4747 
    args.write(self._oprot)
4748 
    self._oprot.writeMessageEnd()
4749 
    self._oprot.trans.flush()
4750 
 
4751 
  def recv_markOrderAsLostInTransit(self, ):
4752 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4753 
    if mtype == TMessageType.EXCEPTION:
4754 
      x = TApplicationException()
4755 
      x.read(self._iprot)
4756 
      self._iprot.readMessageEnd()
4757 
      raise x
4758 
    result = markOrderAsLostInTransit_result()
4759 
    result.read(self._iprot)
4760 
    self._iprot.readMessageEnd()
4761 
    if result.success is not None:
4762 
      return result.success
4763 
    if result.ex is not None:
4764 
      raise result.ex
4765 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4766 
 
4386 anupam.sin 4767 
  def getOrderForAwb(self, awb):
4768 
    """
4769 
    Returns the order corresponding to an AWB number
4369 rajveer 4770 
 
4386 anupam.sin 4771 
    Parameters:
4772 
     - awb
4773 
    """
4774 
    self.send_getOrderForAwb(awb)
4775 
    return self.recv_getOrderForAwb()
4776 
 
4777 
  def send_getOrderForAwb(self, awb):
4778 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4779 
    args = getOrderForAwb_args()
4780 
    args.awb = awb
4781 
    args.write(self._oprot)
4782 
    self._oprot.writeMessageEnd()
4783 
    self._oprot.trans.flush()
4784 
 
4785 
  def recv_getOrderForAwb(self, ):
4786 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4787 
    if mtype == TMessageType.EXCEPTION:
4788 
      x = TApplicationException()
4789 
      x.read(self._iprot)
4790 
      self._iprot.readMessageEnd()
4791 
      raise x
4792 
    result = getOrderForAwb_result()
4793 
    result.read(self._iprot)
4794 
    self._iprot.readMessageEnd()
4795 
    if result.success is not None:
4796 
      return result.success
4797 
    if result.ex is not None:
4798 
      raise result.ex
4799 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4800 
 
4910 phani.kuma 4801 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4802 
    """
4910 phani.kuma 4803 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4804 
 
4506 phani.kuma 4805 
    Parameters:
4806 
     - logistics_provider_id
4910 phani.kuma 4807 
     - order_status_list
4506 phani.kuma 4808 
    """
4910 phani.kuma 4809 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4810 
    return self.recv_getOrdersForProviderForStatus()
4811 
 
4910 phani.kuma 4812 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4813 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4814 
    args = getOrdersForProviderForStatus_args()
4815 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4816 
    args.order_status_list = order_status_list
4506 phani.kuma 4817 
    args.write(self._oprot)
4818 
    self._oprot.writeMessageEnd()
4819 
    self._oprot.trans.flush()
4820 
 
4821 
  def recv_getOrdersForProviderForStatus(self, ):
4822 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4823 
    if mtype == TMessageType.EXCEPTION:
4824 
      x = TApplicationException()
4825 
      x.read(self._iprot)
4826 
      self._iprot.readMessageEnd()
4827 
      raise x
4828 
    result = getOrdersForProviderForStatus_result()
4829 
    result.read(self._iprot)
4830 
    self._iprot.readMessageEnd()
4831 
    if result.success is not None:
4832 
      return result.success
4833 
    if result.ex is not None:
4834 
      raise result.ex
4835 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4836 
 
4600 varun.gupt 4837 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4838 
    """
4839 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4840 
 
4600 varun.gupt 4841 
    Parameters:
4842 
     - vendorId
4843 
     - billingDateFrom
4844 
     - billingDateTo
4845 
    """
4846 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4847 
    return self.recv_getBilledOrdersForVendor()
4848 
 
4849 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4850 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4851 
    args = getBilledOrdersForVendor_args()
4852 
    args.vendorId = vendorId
4853 
    args.billingDateFrom = billingDateFrom
4854 
    args.billingDateTo = billingDateTo
4855 
    args.write(self._oprot)
4856 
    self._oprot.writeMessageEnd()
4857 
    self._oprot.trans.flush()
4858 
 
4859 
  def recv_getBilledOrdersForVendor(self, ):
4860 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4861 
    if mtype == TMessageType.EXCEPTION:
4862 
      x = TApplicationException()
4863 
      x.read(self._iprot)
4864 
      self._iprot.readMessageEnd()
4865 
      raise x
4866 
    result = getBilledOrdersForVendor_result()
4867 
    result.read(self._iprot)
4868 
    self._iprot.readMessageEnd()
4869 
    if result.success is not None:
4870 
      return result.success
4871 
    if result.ex is not None:
4872 
      raise result.ex
4873 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4874 
 
4607 rajveer 4875 
  def getSlippedSippingDateOrders(self, ):
4876 
    self.send_getSlippedSippingDateOrders()
4877 
    return self.recv_getSlippedSippingDateOrders()
4878 
 
4879 
  def send_getSlippedSippingDateOrders(self, ):
4880 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4881 
    args = getSlippedSippingDateOrders_args()
4882 
    args.write(self._oprot)
4883 
    self._oprot.writeMessageEnd()
4884 
    self._oprot.trans.flush()
4885 
 
4886 
  def recv_getSlippedSippingDateOrders(self, ):
4887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4888 
    if mtype == TMessageType.EXCEPTION:
4889 
      x = TApplicationException()
4890 
      x.read(self._iprot)
4891 
      self._iprot.readMessageEnd()
4892 
      raise x
4893 
    result = getSlippedSippingDateOrders_result()
4894 
    result.read(self._iprot)
4895 
    self._iprot.readMessageEnd()
4896 
    if result.success is not None:
4897 
      return result.success
4898 
    if result.ex is not None:
4899 
      raise result.ex
4900 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4901 
 
4709 rajveer 4902 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4903 
    """
4904 
    Parameters:
4905 
     - cancelDateFrom
4906 
     - cancelDateTo
4907 
    """
4908 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4909 
    return self.recv_getCancelledOrders()
4910 
 
4911 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4912 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4913 
    args = getCancelledOrders_args()
4914 
    args.cancelDateFrom = cancelDateFrom
4915 
    args.cancelDateTo = cancelDateTo
4916 
    args.write(self._oprot)
4917 
    self._oprot.writeMessageEnd()
4918 
    self._oprot.trans.flush()
4919 
 
4920 
  def recv_getCancelledOrders(self, ):
4921 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4922 
    if mtype == TMessageType.EXCEPTION:
4923 
      x = TApplicationException()
4924 
      x.read(self._iprot)
4925 
      self._iprot.readMessageEnd()
4926 
      raise x
4927 
    result = getCancelledOrders_result()
4928 
    result.read(self._iprot)
4929 
    self._iprot.readMessageEnd()
4930 
    if result.success is not None:
4931 
      return result.success
4932 
    if result.ex is not None:
4933 
      raise result.ex
4934 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4935 
 
4600 varun.gupt 4936 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4937 
    """
4938 
    Parameters:
4939 
     - mapAWBAndAmount
4940 
    """
4941 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4942 
    self.recv_saveBluedartSettlements()
4943 
 
4944 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4945 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4946 
    args = saveBluedartSettlements_args()
4947 
    args.mapAWBAndAmount = mapAWBAndAmount
4948 
    args.write(self._oprot)
4949 
    self._oprot.writeMessageEnd()
4950 
    self._oprot.trans.flush()
4951 
 
4952 
  def recv_saveBluedartSettlements(self, ):
4953 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4954 
    if mtype == TMessageType.EXCEPTION:
4955 
      x = TApplicationException()
4956 
      x.read(self._iprot)
4957 
      self._iprot.readMessageEnd()
4958 
      raise x
4959 
    result = saveBluedartSettlements_result()
4960 
    result.read(self._iprot)
4961 
    self._iprot.readMessageEnd()
4962 
    if result.ex is not None:
4963 
      raise result.ex
4964 
    return
4965 
 
4905 varun.gupt 4966 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4967 
    """
4968 
    Parameters:
4969 
     - settlementDate
4970 
     - paymentGatewayId
4905 varun.gupt 4971 
     - referenceId
4600 varun.gupt 4972 
     - serviceTax
4973 
     - otherCharges
4974 
     - netCollection
4975 
    """
4905 varun.gupt 4976 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 4977 
    self.recv_savePaymentSettlements()
4978 
 
4905 varun.gupt 4979 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 4980 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
4981 
    args = savePaymentSettlements_args()
4982 
    args.settlementDate = settlementDate
4983 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 4984 
    args.referenceId = referenceId
4600 varun.gupt 4985 
    args.serviceTax = serviceTax
4986 
    args.otherCharges = otherCharges
4987 
    args.netCollection = netCollection
4988 
    args.write(self._oprot)
4989 
    self._oprot.writeMessageEnd()
4990 
    self._oprot.trans.flush()
4991 
 
4992 
  def recv_savePaymentSettlements(self, ):
4993 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4994 
    if mtype == TMessageType.EXCEPTION:
4995 
      x = TApplicationException()
4996 
      x.read(self._iprot)
4997 
      self._iprot.readMessageEnd()
4998 
      raise x
4999 
    result = savePaymentSettlements_result()
5000 
    result.read(self._iprot)
5001 
    self._iprot.readMessageEnd()
5002 
    if result.ex is not None:
5003 
      raise result.ex
5004 
    return
5005 
 
5006 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5007 
    """
5008 
    Parameters:
5009 
     - settlementId
5010 
     - settlementDate
5011 
     - transactionDateFrom
5012 
     - transactionDateTo
5013 
     - amount
5014 
    """
5015 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5016 
    self.recv_saveEBSSettlementSummary()
5017 
 
5018 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5019 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5020 
    args = saveEBSSettlementSummary_args()
5021 
    args.settlementId = settlementId
5022 
    args.settlementDate = settlementDate
5023 
    args.transactionDateFrom = transactionDateFrom
5024 
    args.transactionDateTo = transactionDateTo
5025 
    args.amount = amount
5026 
    args.write(self._oprot)
5027 
    self._oprot.writeMessageEnd()
5028 
    self._oprot.trans.flush()
5029 
 
5030 
  def recv_saveEBSSettlementSummary(self, ):
5031 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5032 
    if mtype == TMessageType.EXCEPTION:
5033 
      x = TApplicationException()
5034 
      x.read(self._iprot)
5035 
      self._iprot.readMessageEnd()
5036 
      raise x
5037 
    result = saveEBSSettlementSummary_result()
5038 
    result.read(self._iprot)
5039 
    self._iprot.readMessageEnd()
5040 
    if result.ex is not None:
5041 
      raise result.ex
5042 
    return
5043 
 
5386 phani.kuma 5044 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5045 
    """
5046 
    Parameters:
5189 varun.gupt 5047 
     - referenceId
5048 
     - isRefund
4600 varun.gupt 5049 
    """
5386 phani.kuma 5050 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5051 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5052 
 
5386 phani.kuma 5053 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5054 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5055 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5056 
    args.referenceId = referenceId
5057 
    args.isRefund = isRefund
4600 varun.gupt 5058 
    args.write(self._oprot)
5059 
    self._oprot.writeMessageEnd()
5060 
    self._oprot.trans.flush()
5061 
 
5386 phani.kuma 5062 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5063 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5064 
    if mtype == TMessageType.EXCEPTION:
5065 
      x = TApplicationException()
5066 
      x.read(self._iprot)
5067 
      self._iprot.readMessageEnd()
5068 
      raise x
5386 phani.kuma 5069 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5070 
    result.read(self._iprot)
5071 
    self._iprot.readMessageEnd()
5072 
    if result.success is not None:
5073 
      return result.success
5074 
    if result.ex is not None:
5075 
      raise result.ex
5386 phani.kuma 5076 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5077 
 
5386 phani.kuma 5078 
  def getSettlementForCod(self, orderId, isRefund):
5079 
    """
5080 
    Parameters:
5081 
     - orderId
5082 
     - isRefund
5083 
    """
5084 
    self.send_getSettlementForCod(orderId, isRefund)
5085 
    return self.recv_getSettlementForCod()
5086 
 
5087 
  def send_getSettlementForCod(self, orderId, isRefund):
5088 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5089 
    args = getSettlementForCod_args()
5090 
    args.orderId = orderId
5091 
    args.isRefund = isRefund
5092 
    args.write(self._oprot)
5093 
    self._oprot.writeMessageEnd()
5094 
    self._oprot.trans.flush()
5095 
 
5096 
  def recv_getSettlementForCod(self, ):
5097 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5098 
    if mtype == TMessageType.EXCEPTION:
5099 
      x = TApplicationException()
5100 
      x.read(self._iprot)
5101 
      self._iprot.readMessageEnd()
5102 
      raise x
5103 
    result = getSettlementForCod_result()
5104 
    result.read(self._iprot)
5105 
    self._iprot.readMessageEnd()
5106 
    if result.success is not None:
5107 
      return result.success
5108 
    if result.ex is not None:
5109 
      raise result.ex
5110 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5111 
 
4600 varun.gupt 5112 
  def getEBSSettlementSummaries(self, ):
5113 
    self.send_getEBSSettlementSummaries()
5114 
    return self.recv_getEBSSettlementSummaries()
5115 
 
5116 
  def send_getEBSSettlementSummaries(self, ):
5117 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5118 
    args = getEBSSettlementSummaries_args()
5119 
    args.write(self._oprot)
5120 
    self._oprot.writeMessageEnd()
5121 
    self._oprot.trans.flush()
5122 
 
5123 
  def recv_getEBSSettlementSummaries(self, ):
5124 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5125 
    if mtype == TMessageType.EXCEPTION:
5126 
      x = TApplicationException()
5127 
      x.read(self._iprot)
5128 
      self._iprot.readMessageEnd()
5129 
      raise x
5130 
    result = getEBSSettlementSummaries_result()
5131 
    result.read(self._iprot)
5132 
    self._iprot.readMessageEnd()
5133 
    if result.success is not None:
5134 
      return result.success
5135 
    if result.ex is not None:
5136 
      raise result.ex
5137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5138 
 
5139 
  def markEBSSettlementUploaded(self, settlementId):
5140 
    """
5141 
    Parameters:
5142 
     - settlementId
5143 
    """
5144 
    self.send_markEBSSettlementUploaded(settlementId)
5145 
    self.recv_markEBSSettlementUploaded()
5146 
 
5147 
  def send_markEBSSettlementUploaded(self, settlementId):
5148 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5149 
    args = markEBSSettlementUploaded_args()
5150 
    args.settlementId = settlementId
5151 
    args.write(self._oprot)
5152 
    self._oprot.writeMessageEnd()
5153 
    self._oprot.trans.flush()
5154 
 
5155 
  def recv_markEBSSettlementUploaded(self, ):
5156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5157 
    if mtype == TMessageType.EXCEPTION:
5158 
      x = TApplicationException()
5159 
      x.read(self._iprot)
5160 
      self._iprot.readMessageEnd()
5161 
      raise x
5162 
    result = markEBSSettlementUploaded_result()
5163 
    result.read(self._iprot)
5164 
    self._iprot.readMessageEnd()
5165 
    if result.ex is not None:
5166 
      raise result.ex
5167 
    return
5168 
 
5169 
  def getEBSSettlementDate(self, settlementId):
5170 
    """
5171 
    Parameters:
5172 
     - settlementId
5173 
    """
5174 
    self.send_getEBSSettlementDate(settlementId)
5175 
    return self.recv_getEBSSettlementDate()
5176 
 
5177 
  def send_getEBSSettlementDate(self, settlementId):
5178 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5179 
    args = getEBSSettlementDate_args()
5180 
    args.settlementId = settlementId
5181 
    args.write(self._oprot)
5182 
    self._oprot.writeMessageEnd()
5183 
    self._oprot.trans.flush()
5184 
 
5185 
  def recv_getEBSSettlementDate(self, ):
5186 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5187 
    if mtype == TMessageType.EXCEPTION:
5188 
      x = TApplicationException()
5189 
      x.read(self._iprot)
5190 
      self._iprot.readMessageEnd()
5191 
      raise x
5192 
    result = getEBSSettlementDate_result()
5193 
    result.read(self._iprot)
5194 
    self._iprot.readMessageEnd()
5195 
    if result.success is not None:
5196 
      return result.success
5197 
    if result.ex is not None:
5198 
      raise result.ex
5199 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5200 
 
4715 varun.gupt 5201 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5202 
    """
5203 
    Parameters:
5204 
     - settlementDateFrom
5205 
     - settlementDateTo
5206 
     - isRefund
5207 
    """
5208 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5209 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5210 
 
4715 varun.gupt 5211 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5212 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5213 
    args = getSettlementsByDate_args()
5214 
    args.settlementDateFrom = settlementDateFrom
5215 
    args.settlementDateTo = settlementDateTo
5216 
    args.isRefund = isRefund
5217 
    args.write(self._oprot)
5218 
    self._oprot.writeMessageEnd()
5219 
    self._oprot.trans.flush()
5220 
 
5221 
  def recv_getSettlementsByDate(self, ):
5222 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5223 
    if mtype == TMessageType.EXCEPTION:
5224 
      x = TApplicationException()
5225 
      x.read(self._iprot)
5226 
      self._iprot.readMessageEnd()
5227 
      raise x
5228 
    result = getSettlementsByDate_result()
5229 
    result.read(self._iprot)
5230 
    self._iprot.readMessageEnd()
5231 
    if result.success is not None:
5232 
      return result.success
5233 
    if result.ex is not None:
5234 
      raise result.ex
5235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5236 
 
5237 
  def getReshippedOrderIds(self, orderIds):
5238 
    """
5239 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5240 
 
5241 
    Parameters:
5242 
     - orderIds
5243 
    """
5244 
    self.send_getReshippedOrderIds(orderIds)
5245 
    return self.recv_getReshippedOrderIds()
5246 
 
5247 
  def send_getReshippedOrderIds(self, orderIds):
5248 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5249 
    args = getReshippedOrderIds_args()
5250 
    args.orderIds = orderIds
5251 
    args.write(self._oprot)
5252 
    self._oprot.writeMessageEnd()
5253 
    self._oprot.trans.flush()
5254 
 
5255 
  def recv_getReshippedOrderIds(self, ):
5256 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5257 
    if mtype == TMessageType.EXCEPTION:
5258 
      x = TApplicationException()
5259 
      x.read(self._iprot)
5260 
      self._iprot.readMessageEnd()
5261 
      raise x
5262 
    result = getReshippedOrderIds_result()
5263 
    result.read(self._iprot)
5264 
    self._iprot.readMessageEnd()
5265 
    if result.success is not None:
5266 
      return result.success
5267 
    if result.ex is not None:
5268 
      raise result.ex
5269 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5270 
 
5481 phani.kuma 5271 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5272 
    """
5273 
    Parameters:
5274 
     - vendorId
5481 phani.kuma 5275 
     - onlyVendorNotPaid
5276 
     - billingDateFrom
5277 
     - billingDateTo
4875 varun.gupt 5278 
    """
5481 phani.kuma 5279 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5280 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5281 
 
5481 phani.kuma 5282 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5283 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5284 
    args = getBilledOrders_args()
4875 varun.gupt 5285 
    args.vendorId = vendorId
5481 phani.kuma 5286 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5287 
    args.billingDateFrom = billingDateFrom
5288 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5289 
    args.write(self._oprot)
5290 
    self._oprot.writeMessageEnd()
5291 
    self._oprot.trans.flush()
5292 
 
5481 phani.kuma 5293 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5295 
    if mtype == TMessageType.EXCEPTION:
5296 
      x = TApplicationException()
5297 
      x.read(self._iprot)
5298 
      self._iprot.readMessageEnd()
5299 
      raise x
5481 phani.kuma 5300 
    result = getBilledOrders_result()
4875 varun.gupt 5301 
    result.read(self._iprot)
5302 
    self._iprot.readMessageEnd()
5303 
    if result.success is not None:
5304 
      return result.success
5305 
    if result.ex is not None:
5306 
      raise result.ex
5481 phani.kuma 5307 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5308 
 
5031 varun.gupt 5309 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5310 
    """
5311 
    Parameters:
5312 
     - startDate
5313 
     - endDate
5314 
    """
5315 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5316 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5317 
 
5031 varun.gupt 5318 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5319 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5320 
    args = getStatusDistributionOfOrders_args()
5321 
    args.startDate = startDate
5322 
    args.endDate = endDate
5323 
    args.write(self._oprot)
5324 
    self._oprot.writeMessageEnd()
5325 
    self._oprot.trans.flush()
5326 
 
5327 
  def recv_getStatusDistributionOfOrders(self, ):
5328 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5329 
    if mtype == TMessageType.EXCEPTION:
5330 
      x = TApplicationException()
5331 
      x.read(self._iprot)
5332 
      self._iprot.readMessageEnd()
5333 
      raise x
5334 
    result = getStatusDistributionOfOrders_result()
5335 
    result.read(self._iprot)
5336 
    self._iprot.readMessageEnd()
5337 
    if result.success is not None:
5338 
      return result.success
5339 
    if result.ex is not None:
5340 
      raise result.ex
5341 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5342 
 
5067 varun.gupt 5343 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5344 
    """
5345 
    Parameters:
5346 
     - status
5347 
     - startDatetime
5348 
     - endDatetime
5349 
    """
5350 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5351 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5352 
 
5067 varun.gupt 5353 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5354 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5355 
    args = getOrderIdsForStatus_args()
5356 
    args.status = status
5357 
    args.startDatetime = startDatetime
5358 
    args.endDatetime = endDatetime
5359 
    args.write(self._oprot)
5360 
    self._oprot.writeMessageEnd()
5361 
    self._oprot.trans.flush()
5362 
 
5363 
  def recv_getOrderIdsForStatus(self, ):
5364 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5365 
    if mtype == TMessageType.EXCEPTION:
5366 
      x = TApplicationException()
5367 
      x.read(self._iprot)
5368 
      self._iprot.readMessageEnd()
5369 
      raise x
5370 
    result = getOrderIdsForStatus_result()
5371 
    result.read(self._iprot)
5372 
    self._iprot.readMessageEnd()
5373 
    if result.success is not None:
5374 
      return result.success
5375 
    if result.ex is not None:
5376 
      raise result.ex
5377 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5378 
 
5348 anupam.sin 5379 
  def updateCODAgent(self, agent, orderId):
5380 
    """
5381 
    Updates the agent who handled the COD verification call
5382 
 
5383 
    Parameters:
5384 
     - agent
5385 
     - orderId
5386 
    """
5387 
    self.send_updateCODAgent(agent, orderId)
5388 
    self.recv_updateCODAgent()
5389 
 
5390 
  def send_updateCODAgent(self, agent, orderId):
5391 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5392 
    args = updateCODAgent_args()
5393 
    args.agent = agent
5394 
    args.orderId = orderId
5395 
    args.write(self._oprot)
5396 
    self._oprot.writeMessageEnd()
5397 
    self._oprot.trans.flush()
5398 
 
5399 
  def recv_updateCODAgent(self, ):
5400 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5401 
    if mtype == TMessageType.EXCEPTION:
5402 
      x = TApplicationException()
5403 
      x.read(self._iprot)
5404 
      self._iprot.readMessageEnd()
5405 
      raise x
5406 
    result = updateCODAgent_result()
5407 
    result.read(self._iprot)
5408 
    self._iprot.readMessageEnd()
5409 
    if result.ex is not None:
5410 
      raise result.ex
5411 
    return
5412 
 
5099 varun.gupt 5413 
  def updateOrderAsPaidToVendor(self, orderId):
5414 
    """
5415 
    Parameters:
5416 
     - orderId
5417 
    """
5418 
    self.send_updateOrderAsPaidToVendor(orderId)
5419 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5420 
 
5099 varun.gupt 5421 
  def send_updateOrderAsPaidToVendor(self, orderId):
5422 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5423 
    args = updateOrderAsPaidToVendor_args()
5424 
    args.orderId = orderId
5425 
    args.write(self._oprot)
5426 
    self._oprot.writeMessageEnd()
5427 
    self._oprot.trans.flush()
5428 
 
5429 
  def recv_updateOrderAsPaidToVendor(self, ):
5430 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5431 
    if mtype == TMessageType.EXCEPTION:
5432 
      x = TApplicationException()
5433 
      x.read(self._iprot)
5434 
      self._iprot.readMessageEnd()
5435 
      raise x
5436 
    result = updateOrderAsPaidToVendor_result()
5437 
    result.read(self._iprot)
5438 
    self._iprot.readMessageEnd()
5439 
    if result.ex is not None:
5440 
      raise result.ex
5441 
    return
5442 
 
5386 phani.kuma 5443 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5444 
    """
5445 
    Parameters:
5446 
     - orderId
5447 
    """
5448 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5449 
    self.recv_updateOrderOnlyAsPaidToVendor()
5450 
 
5451 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5452 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5453 
    args = updateOrderOnlyAsPaidToVendor_args()
5454 
    args.orderId = orderId
5455 
    args.write(self._oprot)
5456 
    self._oprot.writeMessageEnd()
5457 
    self._oprot.trans.flush()
5458 
 
5459 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5460 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5461 
    if mtype == TMessageType.EXCEPTION:
5462 
      x = TApplicationException()
5463 
      x.read(self._iprot)
5464 
      self._iprot.readMessageEnd()
5465 
      raise x
5466 
    result = updateOrderOnlyAsPaidToVendor_result()
5467 
    result.read(self._iprot)
5468 
    self._iprot.readMessageEnd()
5469 
    if result.ex is not None:
5470 
      raise result.ex
5471 
    return
5472 
 
5208 varun.gupt 5473 
  def getRefundedOrdersMarkedPaid(self, ):
5474 
    self.send_getRefundedOrdersMarkedPaid()
5475 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5476 
 
5208 varun.gupt 5477 
  def send_getRefundedOrdersMarkedPaid(self, ):
5478 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5479 
    args = getRefundedOrdersMarkedPaid_args()
5480 
    args.write(self._oprot)
5481 
    self._oprot.writeMessageEnd()
5482 
    self._oprot.trans.flush()
5483 
 
5484 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5485 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5486 
    if mtype == TMessageType.EXCEPTION:
5487 
      x = TApplicationException()
5488 
      x.read(self._iprot)
5489 
      self._iprot.readMessageEnd()
5490 
      raise x
5491 
    result = getRefundedOrdersMarkedPaid_result()
5492 
    result.read(self._iprot)
5493 
    self._iprot.readMessageEnd()
5494 
    if result.success is not None:
5495 
      return result.success
5496 
    if result.ex is not None:
5497 
      raise result.ex
5498 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5499 
 
5447 anupam.sin 5500 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5501 
    """
5502 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5503 
 
5447 anupam.sin 5504 
 
5505 
    Parameters:
5506 
     - minOrderId
5507 
     - maxOrderId
5508 
    """
5509 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5510 
    return self.recv_getAllVerificationAgents()
5511 
 
5512 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5513 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5514 
    args = getAllVerificationAgents_args()
5515 
    args.minOrderId = minOrderId
5516 
    args.maxOrderId = maxOrderId
5517 
    args.write(self._oprot)
5518 
    self._oprot.writeMessageEnd()
5519 
    self._oprot.trans.flush()
5520 
 
5521 
  def recv_getAllVerificationAgents(self, ):
5522 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5523 
    if mtype == TMessageType.EXCEPTION:
5524 
      x = TApplicationException()
5525 
      x.read(self._iprot)
5526 
      self._iprot.readMessageEnd()
5527 
      raise x
5528 
    result = getAllVerificationAgents_result()
5529 
    result.read(self._iprot)
5530 
    self._iprot.readMessageEnd()
5531 
    if result.success is not None:
5532 
      return result.success
5533 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5534 
 
5527 anupam.sin 5535 
  def getAllAttributesForOrderId(self, orderId):
5536 
    """
5537 
    gets all attributes for a given orderId
5447 anupam.sin 5538 
 
5527 anupam.sin 5539 
    Parameters:
5540 
     - orderId
5541 
    """
5542 
    self.send_getAllAttributesForOrderId(orderId)
5543 
    return self.recv_getAllAttributesForOrderId()
5544 
 
5545 
  def send_getAllAttributesForOrderId(self, orderId):
5546 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5547 
    args = getAllAttributesForOrderId_args()
5548 
    args.orderId = orderId
5549 
    args.write(self._oprot)
5550 
    self._oprot.writeMessageEnd()
5551 
    self._oprot.trans.flush()
5552 
 
5553 
  def recv_getAllAttributesForOrderId(self, ):
5554 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5555 
    if mtype == TMessageType.EXCEPTION:
5556 
      x = TApplicationException()
5557 
      x.read(self._iprot)
5558 
      self._iprot.readMessageEnd()
5559 
      raise x
5560 
    result = getAllAttributesForOrderId_result()
5561 
    result.read(self._iprot)
5562 
    self._iprot.readMessageEnd()
5563 
    if result.success is not None:
5564 
      return result.success
5565 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5566 
 
5676 rajveer 5567 
  def setOrderAttributes(self, orderId, attributes):
5568 
    """
5569 
    sets attributes for an order
5570 
 
5571 
    Parameters:
5572 
     - orderId
5573 
     - attributes
5574 
    """
5575 
    self.send_setOrderAttributes(orderId, attributes)
5576 
    self.recv_setOrderAttributes()
5577 
 
5578 
  def send_setOrderAttributes(self, orderId, attributes):
5579 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5580 
    args = setOrderAttributes_args()
5581 
    args.orderId = orderId
5582 
    args.attributes = attributes
5583 
    args.write(self._oprot)
5584 
    self._oprot.writeMessageEnd()
5585 
    self._oprot.trans.flush()
5586 
 
5587 
  def recv_setOrderAttributes(self, ):
5588 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5589 
    if mtype == TMessageType.EXCEPTION:
5590 
      x = TApplicationException()
5591 
      x.read(self._iprot)
5592 
      self._iprot.readMessageEnd()
5593 
      raise x
5594 
    result = setOrderAttributes_result()
5595 
    result.read(self._iprot)
5596 
    self._iprot.readMessageEnd()
5597 
    return
5598 
 
5527 anupam.sin 5599 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5600 
    """
5601 
    sets attributes for all orders in a transaction
5602 
 
5603 
    Parameters:
5604 
     - transactionId
5605 
     - attribute
5606 
    """
5607 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5608 
    self.recv_setOrderAttributeForTransaction()
5609 
 
5610 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5611 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5612 
    args = setOrderAttributeForTransaction_args()
5613 
    args.transactionId = transactionId
5614 
    args.attribute = attribute
5615 
    args.write(self._oprot)
5616 
    self._oprot.writeMessageEnd()
5617 
    self._oprot.trans.flush()
5618 
 
5619 
  def recv_setOrderAttributeForTransaction(self, ):
5620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5621 
    if mtype == TMessageType.EXCEPTION:
5622 
      x = TApplicationException()
5623 
      x.read(self._iprot)
5624 
      self._iprot.readMessageEnd()
5625 
      raise x
5626 
    result = setOrderAttributeForTransaction_result()
5627 
    result.read(self._iprot)
5628 
    self._iprot.readMessageEnd()
5629 
    return
5630 
 
5553 rajveer 5631 
  def getReceivePendingOrders(self, storeId):
5632 
    """
5633 
    Parameters:
5634 
     - storeId
5635 
    """
5636 
    self.send_getReceivePendingOrders(storeId)
5637 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5638 
 
5553 rajveer 5639 
  def send_getReceivePendingOrders(self, storeId):
5640 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5641 
    args = getReceivePendingOrders_args()
5642 
    args.storeId = storeId
5643 
    args.write(self._oprot)
5644 
    self._oprot.writeMessageEnd()
5645 
    self._oprot.trans.flush()
5646 
 
5647 
  def recv_getReceivePendingOrders(self, ):
5648 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5649 
    if mtype == TMessageType.EXCEPTION:
5650 
      x = TApplicationException()
5651 
      x.read(self._iprot)
5652 
      self._iprot.readMessageEnd()
5653 
      raise x
5654 
    result = getReceivePendingOrders_result()
5655 
    result.read(self._iprot)
5656 
    self._iprot.readMessageEnd()
5657 
    if result.success is not None:
5658 
      return result.success
5659 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5660 
 
5661 
  def getReceivedAtStoreOrders(self, storeId):
5662 
    """
5663 
    Parameters:
5664 
     - storeId
5665 
    """
5666 
    self.send_getReceivedAtStoreOrders(storeId)
5667 
    return self.recv_getReceivedAtStoreOrders()
5668 
 
5669 
  def send_getReceivedAtStoreOrders(self, storeId):
5670 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5671 
    args = getReceivedAtStoreOrders_args()
5672 
    args.storeId = storeId
5673 
    args.write(self._oprot)
5674 
    self._oprot.writeMessageEnd()
5675 
    self._oprot.trans.flush()
5676 
 
5677 
  def recv_getReceivedAtStoreOrders(self, ):
5678 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5679 
    if mtype == TMessageType.EXCEPTION:
5680 
      x = TApplicationException()
5681 
      x.read(self._iprot)
5682 
      self._iprot.readMessageEnd()
5683 
      raise x
5684 
    result = getReceivedAtStoreOrders_result()
5685 
    result.read(self._iprot)
5686 
    self._iprot.readMessageEnd()
5687 
    if result.success is not None:
5688 
      return result.success
5689 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5690 
 
5713 rajveer 5691 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5692 
    """
5693 
    Parameters:
5694 
     - storeId
5695 
     - fromDate
5696 
     - toDate
5697 
     - onlyCod
5698 
    """
5699 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5700 
    return self.recv_getOrdersCollectionAtStore()
5701 
 
5702 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5703 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5704 
    args = getOrdersCollectionAtStore_args()
5705 
    args.storeId = storeId
5706 
    args.fromDate = fromDate
5707 
    args.toDate = toDate
5708 
    args.onlyCod = onlyCod
5709 
    args.write(self._oprot)
5710 
    self._oprot.writeMessageEnd()
5711 
    self._oprot.trans.flush()
5712 
 
5713 
  def recv_getOrdersCollectionAtStore(self, ):
5714 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5715 
    if mtype == TMessageType.EXCEPTION:
5716 
      x = TApplicationException()
5717 
      x.read(self._iprot)
5718 
      self._iprot.readMessageEnd()
5719 
      raise x
5720 
    result = getOrdersCollectionAtStore_result()
5721 
    result.read(self._iprot)
5722 
    self._iprot.readMessageEnd()
5723 
    if result.success is not None:
5724 
      return result.success
5725 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5726 
 
5833 rajveer 5727 
  def getOrderAttributeValue(self, orderId, attributeName):
5728 
    """
5729 
    Parameters:
5730 
     - orderId
5731 
     - attributeName
5732 
    """
5733 
    self.send_getOrderAttributeValue(orderId, attributeName)
5734 
    return self.recv_getOrderAttributeValue()
5735 
 
5736 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5737 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5738 
    args = getOrderAttributeValue_args()
5739 
    args.orderId = orderId
5740 
    args.attributeName = attributeName
5741 
    args.write(self._oprot)
5742 
    self._oprot.writeMessageEnd()
5743 
    self._oprot.trans.flush()
5744 
 
5745 
  def recv_getOrderAttributeValue(self, ):
5746 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5747 
    if mtype == TMessageType.EXCEPTION:
5748 
      x = TApplicationException()
5749 
      x.read(self._iprot)
5750 
      self._iprot.readMessageEnd()
5751 
      raise x
5752 
    result = getOrderAttributeValue_result()
5753 
    result.read(self._iprot)
5754 
    self._iprot.readMessageEnd()
5755 
    if result.success is not None:
5756 
      return result.success
5757 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5758 
 
6019 rajveer 5759 
  def changeJacketNumber(self, orderId, jacketNumber):
5760 
    """
5761 
    Parameters:
5762 
     - orderId
5763 
     - jacketNumber
5764 
    """
5765 
    self.send_changeJacketNumber(orderId, jacketNumber)
5766 
    return self.recv_changeJacketNumber()
5767 
 
5768 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5769 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5770 
    args = changeJacketNumber_args()
5771 
    args.orderId = orderId
5772 
    args.jacketNumber = jacketNumber
5773 
    args.write(self._oprot)
5774 
    self._oprot.writeMessageEnd()
5775 
    self._oprot.trans.flush()
5776 
 
5777 
  def recv_changeJacketNumber(self, ):
5778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5779 
    if mtype == TMessageType.EXCEPTION:
5780 
      x = TApplicationException()
5781 
      x.read(self._iprot)
5782 
      self._iprot.readMessageEnd()
5783 
      raise x
5784 
    result = changeJacketNumber_result()
5785 
    result.read(self._iprot)
5786 
    self._iprot.readMessageEnd()
5787 
    if result.success is not None:
5788 
      return result.success
5789 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5790 
 
5791 
  def markOrderAsRtoInTransit(self, orderId):
5792 
    """
5793 
    Parameters:
5794 
     - orderId
5795 
    """
5796 
    self.send_markOrderAsRtoInTransit(orderId)
5797 
    return self.recv_markOrderAsRtoInTransit()
5798 
 
5799 
  def send_markOrderAsRtoInTransit(self, orderId):
5800 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5801 
    args = markOrderAsRtoInTransit_args()
5802 
    args.orderId = orderId
5803 
    args.write(self._oprot)
5804 
    self._oprot.writeMessageEnd()
5805 
    self._oprot.trans.flush()
5806 
 
5807 
  def recv_markOrderAsRtoInTransit(self, ):
5808 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5809 
    if mtype == TMessageType.EXCEPTION:
5810 
      x = TApplicationException()
5811 
      x.read(self._iprot)
5812 
      self._iprot.readMessageEnd()
5813 
      raise x
5814 
    result = markOrderAsRtoInTransit_result()
5815 
    result.read(self._iprot)
5816 
    self._iprot.readMessageEnd()
5817 
    if result.success is not None:
5818 
      return result.success
5819 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5820 
 
5593 mandeep.dh 5821 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5822 
    """
5823 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5824 
    invoked while scanning IN of items.
5553 rajveer 5825 
 
5593 mandeep.dh 5826 
    Parameters:
5827 
     - itemId
5828 
     - quantity
5829 
     - fulfilmentWarehouseId
5830 
     - billingWarehouseId
5831 
    """
5832 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5833 
    self.recv_acceptOrderForItem()
5834 
 
5835 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5836 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5837 
    args = acceptOrderForItem_args()
5838 
    args.itemId = itemId
5839 
    args.quantity = quantity
5840 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5841 
    args.billingWarehouseId = billingWarehouseId
5842 
    args.write(self._oprot)
5843 
    self._oprot.writeMessageEnd()
5844 
    self._oprot.trans.flush()
5845 
 
5846 
  def recv_acceptOrderForItem(self, ):
5847 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5848 
    if mtype == TMessageType.EXCEPTION:
5849 
      x = TApplicationException()
5850 
      x.read(self._iprot)
5851 
      self._iprot.readMessageEnd()
5852 
      raise x
5853 
    result = acceptOrderForItem_result()
5854 
    result.read(self._iprot)
5855 
    self._iprot.readMessageEnd()
5856 
    return
5857 
 
6000 mandeep.dh 5858 
  def createRechargeOrder(self, rechargeOrder):
5859 
    """
5860 
    Parameters:
5861 
     - rechargeOrder
5862 
    """
5863 
    self.send_createRechargeOrder(rechargeOrder)
5864 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5865 
 
6000 mandeep.dh 5866 
  def send_createRechargeOrder(self, rechargeOrder):
5867 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5868 
    args = createRechargeOrder_args()
5869 
    args.rechargeOrder = rechargeOrder
5870 
    args.write(self._oprot)
5871 
    self._oprot.writeMessageEnd()
5872 
    self._oprot.trans.flush()
5873 
 
5874 
  def recv_createRechargeOrder(self, ):
5875 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5876 
    if mtype == TMessageType.EXCEPTION:
5877 
      x = TApplicationException()
5878 
      x.read(self._iprot)
5879 
      self._iprot.readMessageEnd()
5880 
      raise x
5881 
    result = createRechargeOrder_result()
5882 
    result.read(self._iprot)
5883 
    self._iprot.readMessageEnd()
5884 
    if result.success is not None:
5885 
      return result.success
5886 
    if result.ex is not None:
5887 
      raise result.ex
5888 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5889 
 
6031 rajveer 5890 
  def getRechargeOrder(self, rechargeRrderId):
5891 
    """
5892 
    Parameters:
5893 
     - rechargeRrderId
5894 
    """
5895 
    self.send_getRechargeOrder(rechargeRrderId)
5896 
    return self.recv_getRechargeOrder()
5897 
 
5898 
  def send_getRechargeOrder(self, rechargeRrderId):
5899 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5900 
    args = getRechargeOrder_args()
5901 
    args.rechargeRrderId = rechargeRrderId
5902 
    args.write(self._oprot)
5903 
    self._oprot.writeMessageEnd()
5904 
    self._oprot.trans.flush()
5905 
 
5906 
  def recv_getRechargeOrder(self, ):
5907 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5908 
    if mtype == TMessageType.EXCEPTION:
5909 
      x = TApplicationException()
5910 
      x.read(self._iprot)
5911 
      self._iprot.readMessageEnd()
5912 
      raise x
5913 
    result = getRechargeOrder_result()
5914 
    result.read(self._iprot)
5915 
    self._iprot.readMessageEnd()
5916 
    if result.success is not None:
5917 
      return result.success
5918 
    if result.ex is not None:
5919 
      raise result.ex
5920 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
5921 
 
5922 
  def getRechargeOrders(self, userId):
5923 
    """
5924 
    Parameters:
5925 
     - userId
5926 
    """
5927 
    self.send_getRechargeOrders(userId)
5928 
    return self.recv_getRechargeOrders()
5929 
 
5930 
  def send_getRechargeOrders(self, userId):
5931 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
5932 
    args = getRechargeOrders_args()
5933 
    args.userId = userId
5934 
    args.write(self._oprot)
5935 
    self._oprot.writeMessageEnd()
5936 
    self._oprot.trans.flush()
5937 
 
5938 
  def recv_getRechargeOrders(self, ):
5939 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5940 
    if mtype == TMessageType.EXCEPTION:
5941 
      x = TApplicationException()
5942 
      x.read(self._iprot)
5943 
      self._iprot.readMessageEnd()
5944 
      raise x
5945 
    result = getRechargeOrders_result()
5946 
    result.read(self._iprot)
5947 
    self._iprot.readMessageEnd()
5948 
    if result.success is not None:
5949 
      return result.success
5950 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
5951 
 
6000 mandeep.dh 5952 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5953 
    """
5954 
    Parameters:
5955 
     - rechargeOrderId
5956 
     - rechargeOrderStatus
5957 
    """
5958 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 5959 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 5960 
 
5961 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5962 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
5963 
    args = updateRechargeOrderStatus_args()
5964 
    args.rechargeOrderId = rechargeOrderId
5965 
    args.rechargeOrderStatus = rechargeOrderStatus
5966 
    args.write(self._oprot)
5967 
    self._oprot.writeMessageEnd()
5968 
    self._oprot.trans.flush()
5969 
 
5970 
  def recv_updateRechargeOrderStatus(self, ):
5971 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5972 
    if mtype == TMessageType.EXCEPTION:
5973 
      x = TApplicationException()
5974 
      x.read(self._iprot)
5975 
      self._iprot.readMessageEnd()
5976 
      raise x
5977 
    result = updateRechargeOrderStatus_result()
5978 
    result.read(self._iprot)
5979 
    self._iprot.readMessageEnd()
6031 rajveer 5980 
    if result.success is not None:
5981 
      return result.success
6000 mandeep.dh 5982 
    if result.ex is not None:
5983 
      raise result.ex
6031 rajveer 5984 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 5985 
 
6031 rajveer 5986 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5987 
    """
5988 
    Parameters:
6031 rajveer 5989 
     - rechargeOrderId
6000 mandeep.dh 5990 
    """
6031 rajveer 5991 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 5992 
    return self.recv_activateRechargeTxn()
5993 
 
6031 rajveer 5994 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 5995 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
5996 
    args = activateRechargeTxn_args()
6031 rajveer 5997 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 5998 
    args.write(self._oprot)
5999 
    self._oprot.writeMessageEnd()
6000 
    self._oprot.trans.flush()
6001 
 
6002 
  def recv_activateRechargeTxn(self, ):
6003 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6004 
    if mtype == TMessageType.EXCEPTION:
6005 
      x = TApplicationException()
6006 
      x.read(self._iprot)
6007 
      self._iprot.readMessageEnd()
6008 
      raise x
6009 
    result = activateRechargeTxn_result()
6010 
    result.read(self._iprot)
6011 
    self._iprot.readMessageEnd()
6012 
    if result.success is not None:
6013 
      return result.success
6014 
    if result.ex is not None:
6015 
      raise result.ex
6016 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6017 
 
6031 rajveer 6018 
  def getUserWallet(self, userId):
6000 mandeep.dh 6019 
    """
6020 
    Parameters:
6031 rajveer 6021 
     - userId
6000 mandeep.dh 6022 
    """
6031 rajveer 6023 
    self.send_getUserWallet(userId)
6024 
    return self.recv_getUserWallet()
6000 mandeep.dh 6025 
 
6031 rajveer 6026 
  def send_getUserWallet(self, userId):
6027 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6028 
    args = getUserWallet_args()
6029 
    args.userId = userId
6000 mandeep.dh 6030 
    args.write(self._oprot)
6031 
    self._oprot.writeMessageEnd()
6032 
    self._oprot.trans.flush()
6033 
 
6031 rajveer 6034 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6036 
    if mtype == TMessageType.EXCEPTION:
6037 
      x = TApplicationException()
6038 
      x.read(self._iprot)
6039 
      self._iprot.readMessageEnd()
6040 
      raise x
6031 rajveer 6041 
    result = getUserWallet_result()
6000 mandeep.dh 6042 
    result.read(self._iprot)
6043 
    self._iprot.readMessageEnd()
6044 
    if result.success is not None:
6045 
      return result.success
6031 rajveer 6046 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6047 
 
6031 rajveer 6048 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6049 
    """
6050 
    Parameters:
6031 rajveer 6051 
     - userId
6000 mandeep.dh 6052 
    """
6031 rajveer 6053 
    self.send_getUserWalletHistory(userId)
6054 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6055 
 
6031 rajveer 6056 
  def send_getUserWalletHistory(self, userId):
6057 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6058 
    args = getUserWalletHistory_args()
6059 
    args.userId = userId
6000 mandeep.dh 6060 
    args.write(self._oprot)
6061 
    self._oprot.writeMessageEnd()
6062 
    self._oprot.trans.flush()
6063 
 
6031 rajveer 6064 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6065 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6066 
    if mtype == TMessageType.EXCEPTION:
6067 
      x = TApplicationException()
6068 
      x.read(self._iprot)
6069 
      self._iprot.readMessageEnd()
6070 
      raise x
6031 rajveer 6071 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6072 
    result.read(self._iprot)
6073 
    self._iprot.readMessageEnd()
6074 
    if result.success is not None:
6075 
      return result.success
6031 rajveer 6076 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6077 
 
6050 anupam.sin 6078 
  def getRechargeOrdersForTransaction(self, txnId):
6079 
    """
6080 
    Returns a recharge order for a given transactionId
6081 
 
6082 
    Parameters:
6083 
     - txnId
6084 
    """
6085 
    self.send_getRechargeOrdersForTransaction(txnId)
6086 
    return self.recv_getRechargeOrdersForTransaction()
6087 
 
6088 
  def send_getRechargeOrdersForTransaction(self, txnId):
6089 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6090 
    args = getRechargeOrdersForTransaction_args()
6091 
    args.txnId = txnId
6092 
    args.write(self._oprot)
6093 
    self._oprot.writeMessageEnd()
6094 
    self._oprot.trans.flush()
6095 
 
6096 
  def recv_getRechargeOrdersForTransaction(self, ):
6097 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6098 
    if mtype == TMessageType.EXCEPTION:
6099 
      x = TApplicationException()
6100 
      x.read(self._iprot)
6101 
      self._iprot.readMessageEnd()
6102 
      raise x
6103 
    result = getRechargeOrdersForTransaction_result()
6104 
    result.read(self._iprot)
6105 
    self._iprot.readMessageEnd()
6106 
    if result.success is not None:
6107 
      return result.success
6108 
    if result.ex is not None:
6109 
      raise result.ex
6110 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6111 
 
6206 rajveer 6112 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6113 
    """
6114 
    Parameters:
6115 
     - rechargeType
6206 rajveer 6116 
     - onlyActive
6048 rajveer 6117 
    """
6206 rajveer 6118 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6119 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6120 
 
6206 rajveer 6121 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6122 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6123 
    args = getServiceProviders_args()
6124 
    args.rechargeType = rechargeType
6206 rajveer 6125 
    args.onlyActive = onlyActive
6048 rajveer 6126 
    args.write(self._oprot)
6127 
    self._oprot.writeMessageEnd()
6128 
    self._oprot.trans.flush()
6129 
 
6130 
  def recv_getServiceProviders(self, ):
6131 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6132 
    if mtype == TMessageType.EXCEPTION:
6133 
      x = TApplicationException()
6134 
      x.read(self._iprot)
6135 
      self._iprot.readMessageEnd()
6136 
      raise x
6137 
    result = getServiceProviders_result()
6138 
    result.read(self._iprot)
6139 
    self._iprot.readMessageEnd()
6140 
    if result.success is not None:
6141 
      return result.success
6142 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6143 
 
6049 rajveer 6144 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6145 
    """
6146 
    Parameters:
6049 rajveer 6147 
     - rechargeType
6048 rajveer 6148 
     - deviceNumber
6149 
    """
6049 rajveer 6150 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6151 
    return self.recv_getServiceProviderForDevice()
6152 
 
6049 rajveer 6153 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6154 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6155 
    args = getServiceProviderForDevice_args()
6049 rajveer 6156 
    args.rechargeType = rechargeType
6048 rajveer 6157 
    args.deviceNumber = deviceNumber
6158 
    args.write(self._oprot)
6159 
    self._oprot.writeMessageEnd()
6160 
    self._oprot.trans.flush()
6161 
 
6162 
  def recv_getServiceProviderForDevice(self, ):
6163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6164 
    if mtype == TMessageType.EXCEPTION:
6165 
      x = TApplicationException()
6166 
      x.read(self._iprot)
6167 
      self._iprot.readMessageEnd()
6168 
      raise x
6169 
    result = getServiceProviderForDevice_result()
6170 
    result.read(self._iprot)
6171 
    self._iprot.readMessageEnd()
6172 
    if result.success is not None:
6173 
      return result.success
6174 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6175 
 
6336 anupam.sin 6176 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId):
6269 rajveer 6177 
    """
6178 
    Parameters:
6179 
     - rechargeType
6180 
     - deviceNumber
6307 anupam.sin 6181 
     - userSelectedProviderId
6269 rajveer 6182 
    """
6336 anupam.sin 6183 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId)
6269 rajveer 6184 
    return self.recv_validateRecharge()
6185 
 
6336 anupam.sin 6186 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId):
6269 rajveer 6187 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6188 
    args = validateRecharge_args()
6189 
    args.rechargeType = rechargeType
6190 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6191 
    args.userSelectedProviderId = userSelectedProviderId
6269 rajveer 6192 
    args.write(self._oprot)
6193 
    self._oprot.writeMessageEnd()
6194 
    self._oprot.trans.flush()
6195 
 
6196 
  def recv_validateRecharge(self, ):
6197 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6198 
    if mtype == TMessageType.EXCEPTION:
6199 
      x = TApplicationException()
6200 
      x.read(self._iprot)
6201 
      self._iprot.readMessageEnd()
6202 
      raise x
6203 
    result = validateRecharge_result()
6204 
    result.read(self._iprot)
6205 
    self._iprot.readMessageEnd()
6206 
    if result.success is not None:
6207 
      return result.success
6208 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6209 
 
6094 rajveer 6210 
  def getRechargeOrdersForDevice(self, deviceNumber):
6211 
    """
6212 
    Parameters:
6213 
     - deviceNumber
6214 
    """
6215 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6216 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6217 
 
6094 rajveer 6218 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6219 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6220 
    args = getRechargeOrdersForDevice_args()
6221 
    args.deviceNumber = deviceNumber
6222 
    args.write(self._oprot)
6223 
    self._oprot.writeMessageEnd()
6224 
    self._oprot.trans.flush()
6225 
 
6226 
  def recv_getRechargeOrdersForDevice(self, ):
6227 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6228 
    if mtype == TMessageType.EXCEPTION:
6229 
      x = TApplicationException()
6230 
      x.read(self._iprot)
6231 
      self._iprot.readMessageEnd()
6232 
      raise x
6233 
    result = getRechargeOrdersForDevice_result()
6234 
    result.read(self._iprot)
6235 
    self._iprot.readMessageEnd()
6236 
    if result.success is not None:
6237 
      return result.success
6238 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6239 
 
6240 
  def addAmountToWallet(self, userId, orderId, amount):
6241 
    """
6242 
    Parameters:
6243 
     - userId
6244 
     - orderId
6245 
     - amount
6246 
    """
6247 
    self.send_addAmountToWallet(userId, orderId, amount)
6248 
    self.recv_addAmountToWallet()
6249 
 
6250 
  def send_addAmountToWallet(self, userId, orderId, amount):
6251 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6252 
    args = addAmountToWallet_args()
6253 
    args.userId = userId
6254 
    args.orderId = orderId
6255 
    args.amount = amount
6256 
    args.write(self._oprot)
6257 
    self._oprot.writeMessageEnd()
6258 
    self._oprot.trans.flush()
6259 
 
6260 
  def recv_addAmountToWallet(self, ):
6261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6262 
    if mtype == TMessageType.EXCEPTION:
6263 
      x = TApplicationException()
6264 
      x.read(self._iprot)
6265 
      self._iprot.readMessageEnd()
6266 
      raise x
6267 
    result = addAmountToWallet_result()
6268 
    result.read(self._iprot)
6269 
    self._iprot.readMessageEnd()
6270 
    return
6271 
 
6188 rajveer 6272 
  def getRechargeStatistics(self, ):
6273 
    self.send_getRechargeStatistics()
6274 
    return self.recv_getRechargeStatistics()
6275 
 
6276 
  def send_getRechargeStatistics(self, ):
6277 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6278 
    args = getRechargeStatistics_args()
6279 
    args.write(self._oprot)
6280 
    self._oprot.writeMessageEnd()
6281 
    self._oprot.trans.flush()
6282 
 
6283 
  def recv_getRechargeStatistics(self, ):
6284 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6285 
    if mtype == TMessageType.EXCEPTION:
6286 
      x = TApplicationException()
6287 
      x.read(self._iprot)
6288 
      self._iprot.readMessageEnd()
6289 
      raise x
6290 
    result = getRechargeStatistics_result()
6291 
    result.read(self._iprot)
6292 
    self._iprot.readMessageEnd()
6293 
    if result.success is not None:
6294 
      return result.success
6295 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6296 
 
6154 rajveer 6297 
  def getRechargeOrdersForStatus(self, status):
6298 
    """
6299 
    Parameters:
6300 
     - status
6301 
    """
6302 
    self.send_getRechargeOrdersForStatus(status)
6303 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6304 
 
6154 rajveer 6305 
  def send_getRechargeOrdersForStatus(self, status):
6306 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6307 
    args = getRechargeOrdersForStatus_args()
6308 
    args.status = status
6309 
    args.write(self._oprot)
6310 
    self._oprot.writeMessageEnd()
6311 
    self._oprot.trans.flush()
6312 
 
6313 
  def recv_getRechargeOrdersForStatus(self, ):
6314 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6315 
    if mtype == TMessageType.EXCEPTION:
6316 
      x = TApplicationException()
6317 
      x.read(self._iprot)
6318 
      self._iprot.readMessageEnd()
6319 
      raise x
6320 
    result = getRechargeOrdersForStatus_result()
6321 
    result.read(self._iprot)
6322 
    self._iprot.readMessageEnd()
6323 
    if result.success is not None:
6324 
      return result.success
6325 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6326 
 
6159 rajveer 6327 
  def getPlansForOperator(self, operatorId):
6328 
    """
6329 
    Parameters:
6330 
     - operatorId
6331 
    """
6332 
    self.send_getPlansForOperator(operatorId)
6333 
    return self.recv_getPlansForOperator()
6154 rajveer 6334 
 
6159 rajveer 6335 
  def send_getPlansForOperator(self, operatorId):
6336 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6337 
    args = getPlansForOperator_args()
6338 
    args.operatorId = operatorId
6339 
    args.write(self._oprot)
6340 
    self._oprot.writeMessageEnd()
6341 
    self._oprot.trans.flush()
6342 
 
6343 
  def recv_getPlansForOperator(self, ):
6344 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6345 
    if mtype == TMessageType.EXCEPTION:
6346 
      x = TApplicationException()
6347 
      x.read(self._iprot)
6348 
      self._iprot.readMessageEnd()
6349 
      raise x
6350 
    result = getPlansForOperator_result()
6351 
    result.read(self._iprot)
6352 
    self._iprot.readMessageEnd()
6353 
    if result.success is not None:
6354 
      return result.success
6355 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6356 
 
6307 anupam.sin 6357 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6358 
    """
6359 
    Returns denominations for a given operator and circle
6159 rajveer 6360 
 
6289 anupam.sin 6361 
    Parameters:
6362 
     - operatorId
6307 anupam.sin 6363 
     - circleCode
6289 anupam.sin 6364 
     - denominationType
6365 
    """
6307 anupam.sin 6366 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6367 
    return self.recv_getRechargeDenominations()
6368 
 
6307 anupam.sin 6369 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6370 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6371 
    args = getRechargeDenominations_args()
6372 
    args.operatorId = operatorId
6307 anupam.sin 6373 
    args.circleCode = circleCode
6289 anupam.sin 6374 
    args.denominationType = denominationType
6375 
    args.write(self._oprot)
6376 
    self._oprot.writeMessageEnd()
6377 
    self._oprot.trans.flush()
6378 
 
6379 
  def recv_getRechargeDenominations(self, ):
6380 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6381 
    if mtype == TMessageType.EXCEPTION:
6382 
      x = TApplicationException()
6383 
      x.read(self._iprot)
6384 
      self._iprot.readMessageEnd()
6385 
      raise x
6386 
    result = getRechargeDenominations_result()
6387 
    result.read(self._iprot)
6388 
    self._iprot.readMessageEnd()
6389 
    if result.success is not None:
6390 
      return result.success
6391 
    if result.ex is not None:
6392 
      raise result.ex
6393 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6394 
 
6395 
 
3376 rajveer 6396 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6397 
  def __init__(self, handler):
3376 rajveer 6398 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6399 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6400 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6401 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6402 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6403 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6404 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6405 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6406 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6407 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6408 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6409 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6410 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6411 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6412 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6413 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6414 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6415 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6416 
    self._processMap["createOrder"] = Processor.process_createOrder
6417 
    self._processMap["getOrder"] = Processor.process_getOrder
6418 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6419 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6420 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6421 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6422 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6423 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6424 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6425 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6426 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6427 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6428 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6429 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6430 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6431 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6432 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6433 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6434 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6435 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6436 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6437 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6438 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6439 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6440 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6441 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6442 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6443 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6444 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6445 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6446 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6447 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6448 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6449 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6450 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6451 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6452 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6453 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6454 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6455 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6456 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6457 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6458 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6459 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6460 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6461 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6462 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6463 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6464 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6465 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6466 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6467 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6468 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6469 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6470 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6471 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6472 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6473 
    self._processMap["changeItem"] = Processor.process_changeItem
6474 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6475 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6476 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6477 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6478 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6479 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6480 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6481 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6482 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6483 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6484 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6485 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6486 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6487 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6488 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6489 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6490 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6491 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6492 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6493 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6494 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6495 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6496 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6497 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6498 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6499 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6500 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6501 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6502 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6503 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6504 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6505 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6506 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6507 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6508 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6509 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6510 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6511 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6512 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6513 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6514 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6515 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6516 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6517 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6518 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6519 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6520 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6521 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6522 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6523 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6524 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6525 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6526 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6527 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6528 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6529 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6530 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6531 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6532 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 6533 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 6534 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6535 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 6536 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 6537 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
6538 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 6539 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 6540 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 6541 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 6542 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
94 ashish 6543 
 
6544 
  def process(self, iprot, oprot):
6545 
    (name, type, seqid) = iprot.readMessageBegin()
6546 
    if name not in self._processMap:
6547 
      iprot.skip(TType.STRUCT)
6548 
      iprot.readMessageEnd()
6549 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6550 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6551 
      x.write(oprot)
6552 
      oprot.writeMessageEnd()
6553 
      oprot.trans.flush()
6554 
      return
6555 
    else:
6556 
      self._processMap[name](self, seqid, iprot, oprot)
6557 
    return True
6558 
 
6559 
  def process_createTransaction(self, seqid, iprot, oprot):
6560 
    args = createTransaction_args()
6561 
    args.read(iprot)
6562 
    iprot.readMessageEnd()
6563 
    result = createTransaction_result()
6564 
    try:
132 ashish 6565 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6566 
    except TransactionServiceException, ex:
6567 
      result.ex = ex
6568 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6569 
    result.write(oprot)
6570 
    oprot.writeMessageEnd()
6571 
    oprot.trans.flush()
6572 
 
6573 
  def process_getTransaction(self, seqid, iprot, oprot):
6574 
    args = getTransaction_args()
6575 
    args.read(iprot)
6576 
    iprot.readMessageEnd()
6577 
    result = getTransaction_result()
6578 
    try:
6579 
      result.success = self._handler.getTransaction(args.id)
6580 
    except TransactionServiceException, ex:
6581 
      result.ex = ex
6582 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6583 
    result.write(oprot)
6584 
    oprot.writeMessageEnd()
6585 
    oprot.trans.flush()
6586 
 
6587 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6588 
    args = getTransactionsForCustomer_args()
6589 
    args.read(iprot)
6590 
    iprot.readMessageEnd()
6591 
    result = getTransactionsForCustomer_result()
6592 
    try:
6593 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6594 
    except TransactionServiceException, ex:
6595 
      result.ex = ex
6596 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6597 
    result.write(oprot)
6598 
    oprot.writeMessageEnd()
6599 
    oprot.trans.flush()
6600 
 
132 ashish 6601 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6602 
    args = getTransactionsForShoppingCartId_args()
6603 
    args.read(iprot)
6604 
    iprot.readMessageEnd()
6605 
    result = getTransactionsForShoppingCartId_result()
6606 
    try:
6607 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6608 
    except TransactionServiceException, ex:
6609 
      result.ex = ex
6610 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6611 
    result.write(oprot)
6612 
    oprot.writeMessageEnd()
6613 
    oprot.trans.flush()
6614 
 
94 ashish 6615 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6616 
    args = getTransactionStatus_args()
6617 
    args.read(iprot)
6618 
    iprot.readMessageEnd()
6619 
    result = getTransactionStatus_result()
6620 
    try:
6621 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6622 
    except TransactionServiceException, ex:
6623 
      result.ex = ex
6624 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6625 
    result.write(oprot)
6626 
    oprot.writeMessageEnd()
6627 
    oprot.trans.flush()
6628 
 
6629 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6630 
    args = changeTransactionStatus_args()
6631 
    args.read(iprot)
6632 
    iprot.readMessageEnd()
6633 
    result = changeTransactionStatus_result()
6634 
    try:
5527 anupam.sin 6635 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6636 
    except TransactionServiceException, ex:
6637 
      result.ex = ex
6638 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6639 
    result.write(oprot)
6640 
    oprot.writeMessageEnd()
6641 
    oprot.trans.flush()
6642 
 
1398 varun.gupt 6643 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6644 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6645 
    args.read(iprot)
6646 
    iprot.readMessageEnd()
1398 varun.gupt 6647 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6648 
    try:
1398 varun.gupt 6649 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6650 
    except TransactionServiceException, ex:
6651 
      result.ex = ex
1398 varun.gupt 6652 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6653 
    result.write(oprot)
6654 
    oprot.writeMessageEnd()
6655 
    oprot.trans.flush()
6656 
 
483 rajveer 6657 
  def process_getAllOrders(self, seqid, iprot, oprot):
6658 
    args = getAllOrders_args()
94 ashish 6659 
    args.read(iprot)
6660 
    iprot.readMessageEnd()
483 rajveer 6661 
    result = getAllOrders_result()
94 ashish 6662 
    try:
4801 anupam.sin 6663 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6664 
    except TransactionServiceException, ex:
6665 
      result.ex = ex
483 rajveer 6666 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6667 
    result.write(oprot)
6668 
    oprot.writeMessageEnd()
6669 
    oprot.trans.flush()
6670 
 
4133 chandransh 6671 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
6672 
    args = getOrdersInBatch_args()
6673 
    args.read(iprot)
6674 
    iprot.readMessageEnd()
6675 
    result = getOrdersInBatch_result()
6676 
    try:
6677 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
6678 
    except TransactionServiceException, ex:
6679 
      result.ex = ex
6680 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
6681 
    result.write(oprot)
6682 
    oprot.writeMessageEnd()
6683 
    oprot.trans.flush()
6684 
 
6685 
  def process_getOrderCount(self, seqid, iprot, oprot):
6686 
    args = getOrderCount_args()
6687 
    args.read(iprot)
6688 
    iprot.readMessageEnd()
6689 
    result = getOrderCount_result()
6690 
    try:
6691 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
6692 
    except TransactionServiceException, ex:
6693 
      result.ex = ex
6694 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
6695 
    result.write(oprot)
6696 
    oprot.writeMessageEnd()
6697 
    oprot.trans.flush()
6698 
 
999 varun.gupt 6699 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
6700 
    args = getOrdersByBillingDate_args()
6701 
    args.read(iprot)
6702 
    iprot.readMessageEnd()
6703 
    result = getOrdersByBillingDate_result()
6704 
    try:
6705 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
6706 
    except TransactionServiceException, ex:
6707 
      result.ex = ex
6708 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
6709 
    result.write(oprot)
6710 
    oprot.writeMessageEnd()
6711 
    oprot.trans.flush()
6712 
 
3427 chandransh 6713 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
6714 
    args = getOrdersByShippingDate_args()
6715 
    args.read(iprot)
6716 
    iprot.readMessageEnd()
6717 
    result = getOrdersByShippingDate_result()
6718 
    try:
3451 chandransh 6719 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 6720 
    except TransactionServiceException, ex:
6721 
      result.ex = ex
6722 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
6723 
    result.write(oprot)
6724 
    oprot.writeMessageEnd()
6725 
    oprot.trans.flush()
6726 
 
1382 varun.gupt 6727 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
6728 
    args = getReturnableOrdersForCustomer_args()
6729 
    args.read(iprot)
6730 
    iprot.readMessageEnd()
6731 
    result = getReturnableOrdersForCustomer_result()
6732 
    try:
6733 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
6734 
    except TransactionServiceException, ex:
6735 
      result.ex = ex
6736 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
6737 
    result.write(oprot)
6738 
    oprot.writeMessageEnd()
6739 
    oprot.trans.flush()
6740 
 
6741 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
6742 
    args = getCancellableOrdersForCustomer_args()
6743 
    args.read(iprot)
6744 
    iprot.readMessageEnd()
6745 
    result = getCancellableOrdersForCustomer_result()
6746 
    try:
6747 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
6748 
    except TransactionServiceException, ex:
6749 
      result.ex = ex
6750 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
6751 
    result.write(oprot)
6752 
    oprot.writeMessageEnd()
6753 
    oprot.trans.flush()
6754 
 
483 rajveer 6755 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
6756 
    args = changeOrderStatus_args()
94 ashish 6757 
    args.read(iprot)
6758 
    iprot.readMessageEnd()
483 rajveer 6759 
    result = changeOrderStatus_result()
94 ashish 6760 
    try:
483 rajveer 6761 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 6762 
    except TransactionServiceException, ex:
6763 
      result.ex = ex
483 rajveer 6764 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 6765 
    result.write(oprot)
6766 
    oprot.writeMessageEnd()
6767 
    oprot.trans.flush()
6768 
 
483 rajveer 6769 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
6770 
    args = getOrdersForTransaction_args()
94 ashish 6771 
    args.read(iprot)
6772 
    iprot.readMessageEnd()
483 rajveer 6773 
    result = getOrdersForTransaction_result()
94 ashish 6774 
    try:
1528 ankur.sing 6775 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 6776 
    except TransactionServiceException, ex:
6777 
      result.ex = ex
483 rajveer 6778 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 6779 
    result.write(oprot)
6780 
    oprot.writeMessageEnd()
6781 
    oprot.trans.flush()
6782 
 
483 rajveer 6783 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
6784 
    args = getOrdersForCustomer_args()
94 ashish 6785 
    args.read(iprot)
6786 
    iprot.readMessageEnd()
483 rajveer 6787 
    result = getOrdersForCustomer_result()
94 ashish 6788 
    try:
3014 chandransh 6789 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 6790 
    except TransactionServiceException, ex:
6791 
      result.ex = ex
483 rajveer 6792 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 6793 
    result.write(oprot)
6794 
    oprot.writeMessageEnd()
6795 
    oprot.trans.flush()
6796 
 
483 rajveer 6797 
  def process_createOrder(self, seqid, iprot, oprot):
6798 
    args = createOrder_args()
94 ashish 6799 
    args.read(iprot)
6800 
    iprot.readMessageEnd()
483 rajveer 6801 
    result = createOrder_result()
94 ashish 6802 
    try:
483 rajveer 6803 
      result.success = self._handler.createOrder(args.order)
94 ashish 6804 
    except TransactionServiceException, ex:
6805 
      result.ex = ex
483 rajveer 6806 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 6807 
    result.write(oprot)
6808 
    oprot.writeMessageEnd()
6809 
    oprot.trans.flush()
6810 
 
483 rajveer 6811 
  def process_getOrder(self, seqid, iprot, oprot):
6812 
    args = getOrder_args()
94 ashish 6813 
    args.read(iprot)
6814 
    iprot.readMessageEnd()
483 rajveer 6815 
    result = getOrder_result()
94 ashish 6816 
    try:
483 rajveer 6817 
      result.success = self._handler.getOrder(args.id)
94 ashish 6818 
    except TransactionServiceException, ex:
6819 
      result.ex = ex
483 rajveer 6820 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 6821 
    result.write(oprot)
6822 
    oprot.writeMessageEnd()
6823 
    oprot.trans.flush()
6824 
 
483 rajveer 6825 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
6826 
    args = getLineItemsForOrder_args()
94 ashish 6827 
    args.read(iprot)
6828 
    iprot.readMessageEnd()
483 rajveer 6829 
    result = getLineItemsForOrder_result()
94 ashish 6830 
    try:
483 rajveer 6831 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 6832 
    except TransactionServiceException, ex:
6833 
      result.ex = ex
483 rajveer 6834 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 6835 
    result.write(oprot)
6836 
    oprot.writeMessageEnd()
6837 
    oprot.trans.flush()
6838 
 
4999 phani.kuma 6839 
  def process_getOrderList(self, seqid, iprot, oprot):
6840 
    args = getOrderList_args()
6841 
    args.read(iprot)
6842 
    iprot.readMessageEnd()
6843 
    result = getOrderList_result()
6844 
    result.success = self._handler.getOrderList(args.order_ids)
6845 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
6846 
    result.write(oprot)
6847 
    oprot.writeMessageEnd()
6848 
    oprot.trans.flush()
6849 
 
5386 phani.kuma 6850 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
6851 
    args = getOrderListForVendor_args()
6852 
    args.read(iprot)
6853 
    iprot.readMessageEnd()
6854 
    result = getOrderListForVendor_result()
6855 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
6856 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
6857 
    result.write(oprot)
6858 
    oprot.writeMessageEnd()
6859 
    oprot.trans.flush()
6860 
 
1528 ankur.sing 6861 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
6862 
    args = getOrderForCustomer_args()
6863 
    args.read(iprot)
6864 
    iprot.readMessageEnd()
6865 
    result = getOrderForCustomer_result()
6866 
    try:
6867 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
6868 
    except TransactionServiceException, ex:
6869 
      result.ex = ex
6870 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
6871 
    result.write(oprot)
6872 
    oprot.writeMessageEnd()
6873 
    oprot.trans.flush()
6874 
 
3064 chandransh 6875 
  def process_getAlerts(self, seqid, iprot, oprot):
6876 
    args = getAlerts_args()
6877 
    args.read(iprot)
6878 
    iprot.readMessageEnd()
6879 
    result = getAlerts_result()
4444 rajveer 6880 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 6881 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
6882 
    result.write(oprot)
6883 
    oprot.writeMessageEnd()
6884 
    oprot.trans.flush()
6885 
 
4394 rajveer 6886 
  def process_addAlert(self, seqid, iprot, oprot):
6887 
    args = addAlert_args()
3064 chandransh 6888 
    args.read(iprot)
6889 
    iprot.readMessageEnd()
4394 rajveer 6890 
    result = addAlert_result()
4444 rajveer 6891 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 6892 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 6893 
    result.write(oprot)
6894 
    oprot.writeMessageEnd()
6895 
    oprot.trans.flush()
6896 
 
4444 rajveer 6897 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
6898 
    args = markAlertsAsSeen_args()
6899 
    args.read(iprot)
6900 
    iprot.readMessageEnd()
6901 
    result = markAlertsAsSeen_result()
6902 
    self._handler.markAlertsAsSeen(args.warehouseId)
6903 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
6904 
    result.write(oprot)
6905 
    oprot.writeMessageEnd()
6906 
    oprot.trans.flush()
6907 
 
3064 chandransh 6908 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
6909 
    args = getValidOrderCount_args()
6910 
    args.read(iprot)
6911 
    iprot.readMessageEnd()
6912 
    result = getValidOrderCount_result()
6913 
    result.success = self._handler.getValidOrderCount()
6914 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
6915 
    result.write(oprot)
6916 
    oprot.writeMessageEnd()
6917 
    oprot.trans.flush()
6918 
 
6919 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
6920 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
6921 
    args.read(iprot)
6922 
    iprot.readMessageEnd()
6923 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
6924 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
6925 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
6926 
    result.write(oprot)
6927 
    oprot.writeMessageEnd()
6928 
    oprot.trans.flush()
6929 
 
6930 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
6931 
    args = getValidOrdersAmountRange_args()
6932 
    args.read(iprot)
6933 
    iprot.readMessageEnd()
6934 
    result = getValidOrdersAmountRange_result()
6935 
    result.success = self._handler.getValidOrdersAmountRange()
6936 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
6937 
    result.write(oprot)
6938 
    oprot.writeMessageEnd()
6939 
    oprot.trans.flush()
6940 
 
6941 
  def process_getValidOrders(self, seqid, iprot, oprot):
6942 
    args = getValidOrders_args()
6943 
    args.read(iprot)
6944 
    iprot.readMessageEnd()
6945 
    result = getValidOrders_result()
5874 rajveer 6946 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 6947 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
6948 
    result.write(oprot)
6949 
    oprot.writeMessageEnd()
6950 
    oprot.trans.flush()
6951 
 
1220 chandransh 6952 
  def process_batchOrders(self, seqid, iprot, oprot):
6953 
    args = batchOrders_args()
6954 
    args.read(iprot)
6955 
    iprot.readMessageEnd()
6956 
    result = batchOrders_result()
6957 
    try:
6958 
      result.success = self._handler.batchOrders(args.warehouseId)
6959 
    except TransactionServiceException, ex:
6960 
      result.ex = ex
6961 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
6962 
    result.write(oprot)
6963 
    oprot.writeMessageEnd()
6964 
    oprot.trans.flush()
6965 
 
1208 chandransh 6966 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
6967 
    args = markOrderAsOutOfStock_args()
6968 
    args.read(iprot)
6969 
    iprot.readMessageEnd()
6970 
    result = markOrderAsOutOfStock_result()
6971 
    try:
6972 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
6973 
    except TransactionServiceException, ex:
6974 
      result.ex = ex
6975 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
6976 
    result.write(oprot)
6977 
    oprot.writeMessageEnd()
6978 
    oprot.trans.flush()
6979 
 
3064 chandransh 6980 
  def process_verifyOrder(self, seqid, iprot, oprot):
6981 
    args = verifyOrder_args()
759 chandransh 6982 
    args.read(iprot)
6983 
    iprot.readMessageEnd()
3064 chandransh 6984 
    result = verifyOrder_result()
759 chandransh 6985 
    try:
3064 chandransh 6986 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 6987 
    except TransactionServiceException, ex:
6988 
      result.ex = ex
3064 chandransh 6989 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 6990 
    result.write(oprot)
6991 
    oprot.writeMessageEnd()
6992 
    oprot.trans.flush()
6993 
 
3064 chandransh 6994 
  def process_acceptOrder(self, seqid, iprot, oprot):
6995 
    args = acceptOrder_args()
1113 chandransh 6996 
    args.read(iprot)
6997 
    iprot.readMessageEnd()
3064 chandransh 6998 
    result = acceptOrder_result()
1113 chandransh 6999 
    try:
3064 chandransh 7000 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7001 
    except TransactionServiceException, ex:
7002 
      result.ex = ex
3064 chandransh 7003 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7004 
    result.write(oprot)
7005 
    oprot.writeMessageEnd()
7006 
    oprot.trans.flush()
7007 
 
3064 chandransh 7008 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7009 
    args = addBillingDetails_args()
1135 chandransh 7010 
    args.read(iprot)
7011 
    iprot.readMessageEnd()
3064 chandransh 7012 
    result = addBillingDetails_result()
1135 chandransh 7013 
    try:
5110 mandeep.dh 7014 
      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 7015 
    except TransactionServiceException, ex:
7016 
      result.ex = ex
3064 chandransh 7017 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7018 
    result.write(oprot)
7019 
    oprot.writeMessageEnd()
7020 
    oprot.trans.flush()
7021 
 
4579 rajveer 7022 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7023 
    args = addInvoiceNumber_args()
7024 
    args.read(iprot)
7025 
    iprot.readMessageEnd()
7026 
    result = addInvoiceNumber_result()
7027 
    try:
4763 rajveer 7028 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color)
4579 rajveer 7029 
    except TransactionServiceException, ex:
7030 
      result.ex = ex
7031 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7032 
    result.write(oprot)
7033 
    oprot.writeMessageEnd()
7034 
    oprot.trans.flush()
7035 
 
4410 rajveer 7036 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7037 
    args = markOrdersAsShippedFromWarehouse_args()
7038 
    args.read(iprot)
7039 
    iprot.readMessageEnd()
7040 
    result = markOrdersAsShippedFromWarehouse_result()
7041 
    try:
4789 rajveer 7042 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7043 
    except TransactionServiceException, ex:
7044 
      result.ex = ex
7045 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7046 
    result.write(oprot)
7047 
    oprot.writeMessageEnd()
7048 
    oprot.trans.flush()
7049 
 
5676 rajveer 7050 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7051 
    args = markOrdersAsReturnedFromStore_args()
7052 
    args.read(iprot)
7053 
    iprot.readMessageEnd()
7054 
    result = markOrdersAsReturnedFromStore_result()
7055 
    try:
5713 rajveer 7056 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7057 
    except TransactionServiceException, ex:
7058 
      result.ex = ex
7059 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7060 
    result.write(oprot)
7061 
    oprot.writeMessageEnd()
7062 
    oprot.trans.flush()
7063 
 
3064 chandransh 7064 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7065 
    args = markOrdersAsPickedUp_args()
304 ashish 7066 
    args.read(iprot)
7067 
    iprot.readMessageEnd()
3064 chandransh 7068 
    result = markOrdersAsPickedUp_result()
7069 
    try:
4910 phani.kuma 7070 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7071 
    except TransactionServiceException, ex:
7072 
      result.ex = ex
7073 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7074 
    result.write(oprot)
7075 
    oprot.writeMessageEnd()
7076 
    oprot.trans.flush()
94 ashish 7077 
 
4910 phani.kuma 7078 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7079 
    args = getOrdersNotPickedUp_args()
7080 
    args.read(iprot)
7081 
    iprot.readMessageEnd()
7082 
    result = getOrdersNotPickedUp_result()
7083 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7084 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7085 
    result.write(oprot)
7086 
    oprot.writeMessageEnd()
7087 
    oprot.trans.flush()
7088 
 
3064 chandransh 7089 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7090 
    args = markOrdersAsDelivered_args()
304 ashish 7091 
    args.read(iprot)
7092 
    iprot.readMessageEnd()
3064 chandransh 7093 
    result = markOrdersAsDelivered_result()
7094 
    try:
7095 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7096 
    except TransactionServiceException, ex:
7097 
      result.ex = ex
7098 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7099 
    result.write(oprot)
7100 
    oprot.writeMessageEnd()
7101 
    oprot.trans.flush()
7102 
 
4910 phani.kuma 7103 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7104 
    args = markAsRTOrders_args()
1596 ankur.sing 7105 
    args.read(iprot)
7106 
    iprot.readMessageEnd()
4910 phani.kuma 7107 
    result = markAsRTOrders_result()
3064 chandransh 7108 
    try:
4910 phani.kuma 7109 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7110 
    except TransactionServiceException, ex:
7111 
      result.ex = ex
4910 phani.kuma 7112 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7113 
    result.write(oprot)
7114 
    oprot.writeMessageEnd()
7115 
    oprot.trans.flush()
304 ashish 7116 
 
4910 phani.kuma 7117 
  def process_getRTOrders(self, seqid, iprot, oprot):
7118 
    args = getRTOrders_args()
7119 
    args.read(iprot)
7120 
    iprot.readMessageEnd()
7121 
    result = getRTOrders_result()
7122 
    result.success = self._handler.getRTOrders(args.providerId)
7123 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7124 
    result.write(oprot)
7125 
    oprot.writeMessageEnd()
7126 
    oprot.trans.flush()
7127 
 
3064 chandransh 7128 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7129 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7130 
    args.read(iprot)
7131 
    iprot.readMessageEnd()
3064 chandransh 7132 
    result = updateNonDeliveryReason_result()
7133 
    try:
4910 phani.kuma 7134 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7135 
    except TransactionServiceException, ex:
7136 
      result.ex = ex
7137 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7138 
    result.write(oprot)
7139 
    oprot.writeMessageEnd()
7140 
    oprot.trans.flush()
1596 ankur.sing 7141 
 
4910 phani.kuma 7142 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7143 
    args = getNonDeliveredOrdersbyCourier_args()
7144 
    args.read(iprot)
7145 
    iprot.readMessageEnd()
7146 
    result = getNonDeliveredOrdersbyCourier_result()
7147 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7148 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7149 
    result.write(oprot)
7150 
    oprot.writeMessageEnd()
7151 
    oprot.trans.flush()
7152 
 
7153 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7154 
    args = markOrdersAsLocalConnected_args()
7155 
    args.read(iprot)
7156 
    iprot.readMessageEnd()
7157 
    result = markOrdersAsLocalConnected_result()
7158 
    try:
7159 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7160 
    except TransactionServiceException, ex:
7161 
      result.ex = ex
7162 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7163 
    result.write(oprot)
7164 
    oprot.writeMessageEnd()
7165 
    oprot.trans.flush()
7166 
 
7167 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7168 
    args = getOrdersNotLocalConnected_args()
7169 
    args.read(iprot)
7170 
    iprot.readMessageEnd()
7171 
    result = getOrdersNotLocalConnected_result()
7172 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7173 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7174 
    result.write(oprot)
7175 
    oprot.writeMessageEnd()
7176 
    oprot.trans.flush()
7177 
 
7178 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7179 
    args = markOrdersAsDestinationCityReached_args()
7180 
    args.read(iprot)
7181 
    iprot.readMessageEnd()
7182 
    result = markOrdersAsDestinationCityReached_result()
7183 
    try:
7184 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7185 
    except TransactionServiceException, ex:
7186 
      result.ex = ex
7187 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7188 
    result.write(oprot)
7189 
    oprot.writeMessageEnd()
7190 
    oprot.trans.flush()
7191 
 
7192 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7193 
    args = markOrdersAsFirstDeliveryAttempted_args()
7194 
    args.read(iprot)
7195 
    iprot.readMessageEnd()
7196 
    result = markOrdersAsFirstDeliveryAttempted_result()
7197 
    try:
7198 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7199 
    except TransactionServiceException, ex:
7200 
      result.ex = ex
7201 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7202 
    result.write(oprot)
7203 
    oprot.writeMessageEnd()
7204 
    oprot.trans.flush()
7205 
 
3064 chandransh 7206 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7207 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7208 
    args.read(iprot)
7209 
    iprot.readMessageEnd()
3064 chandransh 7210 
    result = getUndeliveredOrders_result()
7211 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7212 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7213 
    result.write(oprot)
7214 
    oprot.writeMessageEnd()
7215 
    oprot.trans.flush()
7216 
 
4783 phani.kuma 7217 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7218 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7219 
    args.read(iprot)
7220 
    iprot.readMessageEnd()
7221 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7222 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7223 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7224 
    result.write(oprot)
7225 
    oprot.writeMessageEnd()
7226 
    oprot.trans.flush()
7227 
 
2536 chandransh 7228 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7229 
    args = toggleDOAFlag_args()
7230 
    args.read(iprot)
7231 
    iprot.readMessageEnd()
7232 
    result = toggleDOAFlag_result()
7233 
    try:
7234 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7235 
    except TransactionServiceException, ex:
7236 
      result.ex = ex
7237 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7238 
    result.write(oprot)
7239 
    oprot.writeMessageEnd()
7240 
    oprot.trans.flush()
1886 ankur.sing 7241 
 
4712 rajveer 7242 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7243 
    args = markOrderAsDelivered_args()
7244 
    args.read(iprot)
7245 
    iprot.readMessageEnd()
7246 
    result = markOrderAsDelivered_result()
7247 
    try:
7248 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7249 
    except TransactionServiceException, ex:
7250 
      result.ex = ex
7251 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7252 
    result.write(oprot)
7253 
    oprot.writeMessageEnd()
7254 
    oprot.trans.flush()
7255 
 
5553 rajveer 7256 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7257 
    args = markOrderAsReceivedAtStore_args()
7258 
    args.read(iprot)
7259 
    iprot.readMessageEnd()
7260 
    result = markOrderAsReceivedAtStore_result()
7261 
    try:
7262 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7263 
    except TransactionServiceException, ex:
7264 
      result.ex = ex
7265 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7266 
    result.write(oprot)
7267 
    oprot.writeMessageEnd()
7268 
    oprot.trans.flush()
7269 
 
4454 rajveer 7270 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7271 
    args = markOrderDoaRequestReceived_args()
7272 
    args.read(iprot)
7273 
    iprot.readMessageEnd()
7274 
    result = markOrderDoaRequestReceived_result()
7275 
    try:
7276 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7277 
    except TransactionServiceException, ex:
7278 
      result.ex = ex
7279 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7280 
    result.write(oprot)
7281 
    oprot.writeMessageEnd()
7282 
    oprot.trans.flush()
7283 
 
7284 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7285 
    args = markOrderDoaRequestAuthorized_args()
7286 
    args.read(iprot)
7287 
    iprot.readMessageEnd()
7288 
    result = markOrderDoaRequestAuthorized_result()
7289 
    try:
7290 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7291 
    except TransactionServiceException, ex:
7292 
      result.ex = ex
7293 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7294 
    result.write(oprot)
7295 
    oprot.writeMessageEnd()
7296 
    oprot.trans.flush()
7297 
 
4488 rajveer 7298 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7299 
    args = markOrderReturnRequestReceived_args()
7300 
    args.read(iprot)
7301 
    iprot.readMessageEnd()
7302 
    result = markOrderReturnRequestReceived_result()
7303 
    try:
7304 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7305 
    except TransactionServiceException, ex:
7306 
      result.ex = ex
7307 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7308 
    result.write(oprot)
7309 
    oprot.writeMessageEnd()
7310 
    oprot.trans.flush()
7311 
 
7312 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7313 
    args = markOrderReturnRequestAuthorized_args()
7314 
    args.read(iprot)
7315 
    iprot.readMessageEnd()
7316 
    result = markOrderReturnRequestAuthorized_result()
7317 
    try:
7318 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7319 
    except TransactionServiceException, ex:
7320 
      result.ex = ex
7321 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7322 
    result.write(oprot)
7323 
    oprot.writeMessageEnd()
7324 
    oprot.trans.flush()
7325 
 
2536 chandransh 7326 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7327 
    args = requestPickupNumber_args()
7328 
    args.read(iprot)
7329 
    iprot.readMessageEnd()
7330 
    result = requestPickupNumber_result()
7331 
    try:
4579 rajveer 7332 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7333 
    except TransactionServiceException, ex:
7334 
      result.ex = ex
7335 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7336 
    result.write(oprot)
7337 
    oprot.writeMessageEnd()
7338 
    oprot.trans.flush()
7339 
 
7340 
  def process_authorizePickup(self, seqid, iprot, oprot):
7341 
    args = authorizePickup_args()
7342 
    args.read(iprot)
7343 
    iprot.readMessageEnd()
7344 
    result = authorizePickup_result()
7345 
    try:
4602 rajveer 7346 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7347 
    except TransactionServiceException, ex:
7348 
      result.ex = ex
7349 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7350 
    result.write(oprot)
7351 
    oprot.writeMessageEnd()
7352 
    oprot.trans.flush()
7353 
 
2764 chandransh 7354 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7355 
    args = markDoasAsPickedUp_args()
7356 
    args.read(iprot)
7357 
    iprot.readMessageEnd()
7358 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7359 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7360 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7361 
    result.write(oprot)
7362 
    oprot.writeMessageEnd()
7363 
    oprot.trans.flush()
7364 
 
4910 phani.kuma 7365 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7366 
    args = getDoasNotPickedUp_args()
7367 
    args.read(iprot)
7368 
    iprot.readMessageEnd()
7369 
    result = getDoasNotPickedUp_result()
7370 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7371 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7372 
    result.write(oprot)
7373 
    oprot.writeMessageEnd()
7374 
    oprot.trans.flush()
7375 
 
4741 phani.kuma 7376 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7377 
    args = markReturnOrdersAsPickedUp_args()
7378 
    args.read(iprot)
7379 
    iprot.readMessageEnd()
7380 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7381 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7382 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7383 
    result.write(oprot)
7384 
    oprot.writeMessageEnd()
7385 
    oprot.trans.flush()
7386 
 
4910 phani.kuma 7387 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7388 
    args = getReturnOrdersNotPickedUp_args()
7389 
    args.read(iprot)
7390 
    iprot.readMessageEnd()
7391 
    result = getReturnOrdersNotPickedUp_result()
7392 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7393 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7394 
    result.write(oprot)
7395 
    oprot.writeMessageEnd()
7396 
    oprot.trans.flush()
7397 
 
2616 chandransh 7398 
  def process_receiveReturn(self, seqid, iprot, oprot):
7399 
    args = receiveReturn_args()
2591 chandransh 7400 
    args.read(iprot)
7401 
    iprot.readMessageEnd()
2616 chandransh 7402 
    result = receiveReturn_result()
2591 chandransh 7403 
    try:
4479 rajveer 7404 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7405 
    except TransactionServiceException, ex:
7406 
      result.ex = ex
2616 chandransh 7407 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7408 
    result.write(oprot)
7409 
    oprot.writeMessageEnd()
7410 
    oprot.trans.flush()
2536 chandransh 7411 
 
2591 chandransh 7412 
  def process_validateDoa(self, seqid, iprot, oprot):
7413 
    args = validateDoa_args()
7414 
    args.read(iprot)
7415 
    iprot.readMessageEnd()
7416 
    result = validateDoa_result()
7417 
    try:
7418 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7419 
    except TransactionServiceException, ex:
7420 
      result.ex = ex
7421 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7422 
    result.write(oprot)
7423 
    oprot.writeMessageEnd()
7424 
    oprot.trans.flush()
7425 
 
4495 rajveer 7426 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7427 
    args = validateReturnProduct_args()
7428 
    args.read(iprot)
7429 
    iprot.readMessageEnd()
7430 
    result = validateReturnProduct_result()
7431 
    try:
7432 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7433 
    except TransactionServiceException, ex:
7434 
      result.ex = ex
7435 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7436 
    result.write(oprot)
7437 
    oprot.writeMessageEnd()
7438 
    oprot.trans.flush()
7439 
 
2616 chandransh 7440 
  def process_reshipOrder(self, seqid, iprot, oprot):
7441 
    args = reshipOrder_args()
7442 
    args.read(iprot)
7443 
    iprot.readMessageEnd()
7444 
    result = reshipOrder_result()
7445 
    try:
7446 
      result.success = self._handler.reshipOrder(args.orderId)
7447 
    except TransactionServiceException, ex:
7448 
      result.ex = ex
7449 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7450 
    result.write(oprot)
7451 
    oprot.writeMessageEnd()
7452 
    oprot.trans.flush()
2591 chandransh 7453 
 
2616 chandransh 7454 
  def process_refundOrder(self, seqid, iprot, oprot):
7455 
    args = refundOrder_args()
7456 
    args.read(iprot)
7457 
    iprot.readMessageEnd()
7458 
    result = refundOrder_result()
7459 
    try:
3226 chandransh 7460 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7461 
    except TransactionServiceException, ex:
7462 
      result.ex = ex
7463 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7464 
    result.write(oprot)
7465 
    oprot.writeMessageEnd()
7466 
    oprot.trans.flush()
7467 
 
2690 chandransh 7468 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7469 
    args = getReturnOrders_args()
7470 
    args.read(iprot)
7471 
    iprot.readMessageEnd()
7472 
    result = getReturnOrders_result()
7473 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7474 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7475 
    result.write(oprot)
7476 
    oprot.writeMessageEnd()
7477 
    oprot.trans.flush()
2616 chandransh 7478 
 
5481 phani.kuma 7479 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7480 
    args = getAllReturnOrders_args()
7481 
    args.read(iprot)
7482 
    iprot.readMessageEnd()
7483 
    result = getAllReturnOrders_result()
7484 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7485 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7486 
    result.write(oprot)
7487 
    oprot.writeMessageEnd()
7488 
    oprot.trans.flush()
7489 
 
2700 chandransh 7490 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7491 
    args = getReturnOrder_args()
7492 
    args.read(iprot)
7493 
    iprot.readMessageEnd()
7494 
    result = getReturnOrder_result()
7495 
    try:
7496 
      result.success = self._handler.getReturnOrder(args.id)
7497 
    except TransactionServiceException, ex:
7498 
      result.ex = ex
7499 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7500 
    result.write(oprot)
7501 
    oprot.writeMessageEnd()
7502 
    oprot.trans.flush()
7503 
 
2690 chandransh 7504 
  def process_processReturn(self, seqid, iprot, oprot):
7505 
    args = processReturn_args()
7506 
    args.read(iprot)
7507 
    iprot.readMessageEnd()
7508 
    result = processReturn_result()
7509 
    try:
7510 
      self._handler.processReturn(args.returnOrderId)
7511 
    except TransactionServiceException, ex:
7512 
      result.ex = ex
7513 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7514 
    result.write(oprot)
7515 
    oprot.writeMessageEnd()
7516 
    oprot.trans.flush()
7517 
 
3451 chandransh 7518 
  def process_updateWeight(self, seqid, iprot, oprot):
7519 
    args = updateWeight_args()
7520 
    args.read(iprot)
7521 
    iprot.readMessageEnd()
7522 
    result = updateWeight_result()
7523 
    try:
7524 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7525 
    except TransactionServiceException, ex:
7526 
      result.ex = ex
7527 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7528 
    result.write(oprot)
7529 
    oprot.writeMessageEnd()
7530 
    oprot.trans.flush()
2819 chandransh 7531 
 
3469 chandransh 7532 
  def process_changeItem(self, seqid, iprot, oprot):
7533 
    args = changeItem_args()
7534 
    args.read(iprot)
7535 
    iprot.readMessageEnd()
7536 
    result = changeItem_result()
7537 
    try:
7538 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7539 
    except TransactionServiceException, ex:
7540 
      result.ex = ex
7541 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7542 
    result.write(oprot)
7543 
    oprot.writeMessageEnd()
7544 
    oprot.trans.flush()
3451 chandransh 7545 
 
3469 chandransh 7546 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7547 
    args = shiftToWarehouse_args()
7548 
    args.read(iprot)
7549 
    iprot.readMessageEnd()
7550 
    result = shiftToWarehouse_result()
7551 
    try:
7552 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7553 
    except TransactionServiceException, ex:
7554 
      result.ex = ex
7555 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7556 
    result.write(oprot)
7557 
    oprot.writeMessageEnd()
7558 
    oprot.trans.flush()
7559 
 
3553 chandransh 7560 
  def process_addDelayReason(self, seqid, iprot, oprot):
7561 
    args = addDelayReason_args()
7562 
    args.read(iprot)
7563 
    iprot.readMessageEnd()
7564 
    result = addDelayReason_result()
7565 
    try:
4647 rajveer 7566 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7567 
    except TransactionServiceException, ex:
7568 
      result.ex = ex
7569 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7570 
    result.write(oprot)
7571 
    oprot.writeMessageEnd()
7572 
    oprot.trans.flush()
3469 chandransh 7573 
 
3956 chandransh 7574 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7575 
    args = reconcileCodCollection_args()
7576 
    args.read(iprot)
7577 
    iprot.readMessageEnd()
7578 
    result = reconcileCodCollection_result()
7579 
    try:
7580 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7581 
    except TransactionServiceException, ex:
7582 
      result.ex = ex
7583 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7584 
    result.write(oprot)
7585 
    oprot.writeMessageEnd()
7586 
    oprot.trans.flush()
3553 chandransh 7587 
 
4008 mandeep.dh 7588 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7589 
    args = getTransactionsRequiringExtraProcessing_args()
7590 
    args.read(iprot)
7591 
    iprot.readMessageEnd()
7592 
    result = getTransactionsRequiringExtraProcessing_result()
7593 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7594 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7595 
    result.write(oprot)
7596 
    oprot.writeMessageEnd()
7597 
    oprot.trans.flush()
3956 chandransh 7598 
 
4008 mandeep.dh 7599 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7600 
    args = markTransactionAsProcessed_args()
7601 
    args.read(iprot)
7602 
    iprot.readMessageEnd()
7603 
    result = markTransactionAsProcessed_result()
7604 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7605 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7606 
    result.write(oprot)
7607 
    oprot.writeMessageEnd()
7608 
    oprot.trans.flush()
7609 
 
4018 chandransh 7610 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7611 
    args = getItemWiseRiskyOrdersCount_args()
7612 
    args.read(iprot)
7613 
    iprot.readMessageEnd()
7614 
    result = getItemWiseRiskyOrdersCount_result()
7615 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7616 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7617 
    result.write(oprot)
7618 
    oprot.writeMessageEnd()
7619 
    oprot.trans.flush()
4008 mandeep.dh 7620 
 
4295 varun.gupt 7621 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7622 
    args = getOrdersForItemIds_args()
7623 
    args.read(iprot)
7624 
    iprot.readMessageEnd()
7625 
    result = getOrdersForItemIds_result()
7626 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7627 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7628 
    result.write(oprot)
7629 
    oprot.writeMessageEnd()
7630 
    oprot.trans.flush()
7631 
 
4247 rajveer 7632 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7633 
    args = markOrderCancellationRequestReceived_args()
7634 
    args.read(iprot)
7635 
    iprot.readMessageEnd()
7636 
    result = markOrderCancellationRequestReceived_result()
7637 
    try:
7638 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7639 
    except TransactionServiceException, ex:
7640 
      result.ex = ex
7641 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7642 
    result.write(oprot)
7643 
    oprot.writeMessageEnd()
7644 
    oprot.trans.flush()
4018 chandransh 7645 
 
4247 rajveer 7646 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7647 
    args = markOrderCancellationRequestConfirmed_args()
7648 
    args.read(iprot)
7649 
    iprot.readMessageEnd()
7650 
    result = markOrderCancellationRequestConfirmed_result()
7651 
    try:
7652 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7653 
    except TransactionServiceException, ex:
7654 
      result.ex = ex
7655 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7656 
    result.write(oprot)
7657 
    oprot.writeMessageEnd()
7658 
    oprot.trans.flush()
7659 
 
7660 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7661 
    args = markOrderCancellationRequestDenied_args()
7662 
    args.read(iprot)
7663 
    iprot.readMessageEnd()
7664 
    result = markOrderCancellationRequestDenied_result()
7665 
    try:
7666 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7667 
    except TransactionServiceException, ex:
7668 
      result.ex = ex
7669 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
7670 
    result.write(oprot)
7671 
    oprot.writeMessageEnd()
7672 
    oprot.trans.flush()
7673 
 
4258 rajveer 7674 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
7675 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 7676 
    args.read(iprot)
7677 
    iprot.readMessageEnd()
4258 rajveer 7678 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 7679 
    try:
4258 rajveer 7680 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 7681 
    except TransactionServiceException, ex:
7682 
      result.ex = ex
4258 rajveer 7683 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 7684 
    result.write(oprot)
7685 
    oprot.writeMessageEnd()
7686 
    oprot.trans.flush()
7687 
 
4259 anupam.sin 7688 
  def process_refundTransaction(self, seqid, iprot, oprot):
7689 
    args = refundTransaction_args()
7690 
    args.read(iprot)
7691 
    iprot.readMessageEnd()
7692 
    result = refundTransaction_result()
7693 
    try:
7694 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
7695 
    except TransactionServiceException, ex:
7696 
      result.ex = ex
7697 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
7698 
    result.write(oprot)
7699 
    oprot.writeMessageEnd()
7700 
    oprot.trans.flush()
4247 rajveer 7701 
 
4324 mandeep.dh 7702 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
7703 
    args = updateShipmentAddress_args()
7704 
    args.read(iprot)
7705 
    iprot.readMessageEnd()
7706 
    result = updateShipmentAddress_result()
7707 
    try:
7708 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
7709 
    except TransactionServiceException, ex:
7710 
      result.ex = ex
7711 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
7712 
    result.write(oprot)
7713 
    oprot.writeMessageEnd()
7714 
    oprot.trans.flush()
7715 
 
4285 rajveer 7716 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
7717 
    args = acceptOrdersForItemId_args()
7718 
    args.read(iprot)
7719 
    iprot.readMessageEnd()
7720 
    result = acceptOrdersForItemId_result()
7721 
    try:
7722 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
7723 
    except TransactionServiceException, ex:
7724 
      result.ex = ex
7725 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
7726 
    result.write(oprot)
7727 
    oprot.writeMessageEnd()
7728 
    oprot.trans.flush()
4259 anupam.sin 7729 
 
4303 rajveer 7730 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
7731 
    args = markOrdersAsPORaised_args()
7732 
    args.read(iprot)
7733 
    iprot.readMessageEnd()
7734 
    result = markOrdersAsPORaised_result()
7735 
    try:
4369 rajveer 7736 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7737 
    except TransactionServiceException, ex:
7738 
      result.ex = ex
7739 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
7740 
    result.write(oprot)
7741 
    oprot.writeMessageEnd()
7742 
    oprot.trans.flush()
4285 rajveer 7743 
 
4303 rajveer 7744 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
7745 
    args = markOrdersAsReversalInitiated_args()
7746 
    args.read(iprot)
7747 
    iprot.readMessageEnd()
7748 
    result = markOrdersAsReversalInitiated_result()
7749 
    try:
4369 rajveer 7750 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7751 
    except TransactionServiceException, ex:
7752 
      result.ex = ex
7753 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
7754 
    result.write(oprot)
7755 
    oprot.writeMessageEnd()
7756 
    oprot.trans.flush()
7757 
 
7758 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
7759 
    args = markOrdersAsNotAvailabke_args()
7760 
    args.read(iprot)
7761 
    iprot.readMessageEnd()
7762 
    result = markOrdersAsNotAvailabke_result()
7763 
    try:
4369 rajveer 7764 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7765 
    except TransactionServiceException, ex:
7766 
      result.ex = ex
7767 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
7768 
    result.write(oprot)
7769 
    oprot.writeMessageEnd()
7770 
    oprot.trans.flush()
7771 
 
4369 rajveer 7772 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
7773 
    args = markOrdersAsTimeout_args()
7774 
    args.read(iprot)
7775 
    iprot.readMessageEnd()
7776 
    result = markOrdersAsTimeout_result()
7777 
    try:
7778 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
7779 
    except TransactionServiceException, ex:
7780 
      result.ex = ex
7781 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
7782 
    result.write(oprot)
7783 
    oprot.writeMessageEnd()
7784 
    oprot.trans.flush()
4303 rajveer 7785 
 
4662 rajveer 7786 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
7787 
    args = markOrderAsLostInTransit_args()
7788 
    args.read(iprot)
7789 
    iprot.readMessageEnd()
7790 
    result = markOrderAsLostInTransit_result()
7791 
    try:
7792 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
7793 
    except TransactionServiceException, ex:
7794 
      result.ex = ex
7795 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
7796 
    result.write(oprot)
7797 
    oprot.writeMessageEnd()
7798 
    oprot.trans.flush()
7799 
 
4386 anupam.sin 7800 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
7801 
    args = getOrderForAwb_args()
7802 
    args.read(iprot)
7803 
    iprot.readMessageEnd()
7804 
    result = getOrderForAwb_result()
7805 
    try:
7806 
      result.success = self._handler.getOrderForAwb(args.awb)
7807 
    except TransactionServiceException, ex:
7808 
      result.ex = ex
7809 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
7810 
    result.write(oprot)
7811 
    oprot.writeMessageEnd()
7812 
    oprot.trans.flush()
4369 rajveer 7813 
 
4506 phani.kuma 7814 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
7815 
    args = getOrdersForProviderForStatus_args()
7816 
    args.read(iprot)
7817 
    iprot.readMessageEnd()
7818 
    result = getOrdersForProviderForStatus_result()
7819 
    try:
4910 phani.kuma 7820 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 7821 
    except TransactionServiceException, ex:
7822 
      result.ex = ex
7823 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
7824 
    result.write(oprot)
7825 
    oprot.writeMessageEnd()
7826 
    oprot.trans.flush()
4386 anupam.sin 7827 
 
4600 varun.gupt 7828 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
7829 
    args = getBilledOrdersForVendor_args()
7830 
    args.read(iprot)
7831 
    iprot.readMessageEnd()
7832 
    result = getBilledOrdersForVendor_result()
7833 
    try:
7834 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
7835 
    except TransactionServiceException, ex:
7836 
      result.ex = ex
7837 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
7838 
    result.write(oprot)
7839 
    oprot.writeMessageEnd()
7840 
    oprot.trans.flush()
4506 phani.kuma 7841 
 
4607 rajveer 7842 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
7843 
    args = getSlippedSippingDateOrders_args()
7844 
    args.read(iprot)
7845 
    iprot.readMessageEnd()
7846 
    result = getSlippedSippingDateOrders_result()
7847 
    try:
7848 
      result.success = self._handler.getSlippedSippingDateOrders()
7849 
    except TransactionServiceException, ex:
7850 
      result.ex = ex
7851 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
7852 
    result.write(oprot)
7853 
    oprot.writeMessageEnd()
7854 
    oprot.trans.flush()
7855 
 
4709 rajveer 7856 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
7857 
    args = getCancelledOrders_args()
7858 
    args.read(iprot)
7859 
    iprot.readMessageEnd()
7860 
    result = getCancelledOrders_result()
7861 
    try:
7862 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
7863 
    except TransactionServiceException, ex:
7864 
      result.ex = ex
7865 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
7866 
    result.write(oprot)
7867 
    oprot.writeMessageEnd()
7868 
    oprot.trans.flush()
7869 
 
4600 varun.gupt 7870 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
7871 
    args = saveBluedartSettlements_args()
7872 
    args.read(iprot)
7873 
    iprot.readMessageEnd()
7874 
    result = saveBluedartSettlements_result()
7875 
    try:
7876 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
7877 
    except TransactionServiceException, ex:
7878 
      result.ex = ex
7879 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
7880 
    result.write(oprot)
7881 
    oprot.writeMessageEnd()
7882 
    oprot.trans.flush()
7883 
 
7884 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
7885 
    args = savePaymentSettlements_args()
7886 
    args.read(iprot)
7887 
    iprot.readMessageEnd()
7888 
    result = savePaymentSettlements_result()
7889 
    try:
4905 varun.gupt 7890 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 7891 
    except TransactionServiceException, ex:
7892 
      result.ex = ex
7893 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
7894 
    result.write(oprot)
7895 
    oprot.writeMessageEnd()
7896 
    oprot.trans.flush()
7897 
 
7898 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
7899 
    args = saveEBSSettlementSummary_args()
7900 
    args.read(iprot)
7901 
    iprot.readMessageEnd()
7902 
    result = saveEBSSettlementSummary_result()
7903 
    try:
7904 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
7905 
    except TransactionServiceException, ex:
7906 
      result.ex = ex
7907 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
7908 
    result.write(oprot)
7909 
    oprot.writeMessageEnd()
7910 
    oprot.trans.flush()
7911 
 
5386 phani.kuma 7912 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
7913 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 7914 
    args.read(iprot)
7915 
    iprot.readMessageEnd()
5386 phani.kuma 7916 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 7917 
    try:
5386 phani.kuma 7918 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 7919 
    except TransactionServiceException, ex:
7920 
      result.ex = ex
5386 phani.kuma 7921 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 7922 
    result.write(oprot)
7923 
    oprot.writeMessageEnd()
7924 
    oprot.trans.flush()
7925 
 
5386 phani.kuma 7926 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
7927 
    args = getSettlementForCod_args()
7928 
    args.read(iprot)
7929 
    iprot.readMessageEnd()
7930 
    result = getSettlementForCod_result()
7931 
    try:
7932 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
7933 
    except TransactionServiceException, ex:
7934 
      result.ex = ex
7935 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
7936 
    result.write(oprot)
7937 
    oprot.writeMessageEnd()
7938 
    oprot.trans.flush()
7939 
 
4600 varun.gupt 7940 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
7941 
    args = getEBSSettlementSummaries_args()
7942 
    args.read(iprot)
7943 
    iprot.readMessageEnd()
7944 
    result = getEBSSettlementSummaries_result()
7945 
    try:
7946 
      result.success = self._handler.getEBSSettlementSummaries()
7947 
    except TransactionServiceException, ex:
7948 
      result.ex = ex
7949 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
7950 
    result.write(oprot)
7951 
    oprot.writeMessageEnd()
7952 
    oprot.trans.flush()
7953 
 
7954 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
7955 
    args = markEBSSettlementUploaded_args()
7956 
    args.read(iprot)
7957 
    iprot.readMessageEnd()
7958 
    result = markEBSSettlementUploaded_result()
7959 
    try:
7960 
      self._handler.markEBSSettlementUploaded(args.settlementId)
7961 
    except TransactionServiceException, ex:
7962 
      result.ex = ex
7963 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
7964 
    result.write(oprot)
7965 
    oprot.writeMessageEnd()
7966 
    oprot.trans.flush()
7967 
 
7968 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
7969 
    args = getEBSSettlementDate_args()
7970 
    args.read(iprot)
7971 
    iprot.readMessageEnd()
7972 
    result = getEBSSettlementDate_result()
7973 
    try:
7974 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
7975 
    except TransactionServiceException, ex:
7976 
      result.ex = ex
7977 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
7978 
    result.write(oprot)
7979 
    oprot.writeMessageEnd()
7980 
    oprot.trans.flush()
7981 
 
4715 varun.gupt 7982 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
7983 
    args = getSettlementsByDate_args()
7984 
    args.read(iprot)
7985 
    iprot.readMessageEnd()
7986 
    result = getSettlementsByDate_result()
7987 
    try:
7988 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
7989 
    except TransactionServiceException, ex:
7990 
      result.ex = ex
7991 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
7992 
    result.write(oprot)
7993 
    oprot.writeMessageEnd()
7994 
    oprot.trans.flush()
4600 varun.gupt 7995 
 
4715 varun.gupt 7996 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
7997 
    args = getReshippedOrderIds_args()
7998 
    args.read(iprot)
7999 
    iprot.readMessageEnd()
8000 
    result = getReshippedOrderIds_result()
8001 
    try:
8002 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8003 
    except TransactionServiceException, ex:
8004 
      result.ex = ex
8005 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8006 
    result.write(oprot)
8007 
    oprot.writeMessageEnd()
8008 
    oprot.trans.flush()
8009 
 
5481 phani.kuma 8010 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8011 
    args = getBilledOrders_args()
4875 varun.gupt 8012 
    args.read(iprot)
8013 
    iprot.readMessageEnd()
5481 phani.kuma 8014 
    result = getBilledOrders_result()
4875 varun.gupt 8015 
    try:
5481 phani.kuma 8016 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8017 
    except TransactionServiceException, ex:
8018 
      result.ex = ex
5481 phani.kuma 8019 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8020 
    result.write(oprot)
8021 
    oprot.writeMessageEnd()
8022 
    oprot.trans.flush()
4757 mandeep.dh 8023 
 
5031 varun.gupt 8024 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8025 
    args = getStatusDistributionOfOrders_args()
8026 
    args.read(iprot)
8027 
    iprot.readMessageEnd()
8028 
    result = getStatusDistributionOfOrders_result()
8029 
    try:
8030 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8031 
    except TransactionServiceException, ex:
8032 
      result.ex = ex
8033 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8034 
    result.write(oprot)
8035 
    oprot.writeMessageEnd()
8036 
    oprot.trans.flush()
4875 varun.gupt 8037 
 
5067 varun.gupt 8038 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8039 
    args = getOrderIdsForStatus_args()
8040 
    args.read(iprot)
8041 
    iprot.readMessageEnd()
8042 
    result = getOrderIdsForStatus_result()
8043 
    try:
8044 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8045 
    except TransactionServiceException, ex:
8046 
      result.ex = ex
8047 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8048 
    result.write(oprot)
8049 
    oprot.writeMessageEnd()
8050 
    oprot.trans.flush()
5031 varun.gupt 8051 
 
5348 anupam.sin 8052 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8053 
    args = updateCODAgent_args()
8054 
    args.read(iprot)
8055 
    iprot.readMessageEnd()
8056 
    result = updateCODAgent_result()
8057 
    try:
8058 
      self._handler.updateCODAgent(args.agent, args.orderId)
8059 
    except TransactionServiceException, ex:
8060 
      result.ex = ex
8061 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8062 
    result.write(oprot)
8063 
    oprot.writeMessageEnd()
8064 
    oprot.trans.flush()
8065 
 
5099 varun.gupt 8066 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8067 
    args = updateOrderAsPaidToVendor_args()
8068 
    args.read(iprot)
8069 
    iprot.readMessageEnd()
8070 
    result = updateOrderAsPaidToVendor_result()
8071 
    try:
8072 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8073 
    except TransactionServiceException, ex:
8074 
      result.ex = ex
8075 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8076 
    result.write(oprot)
8077 
    oprot.writeMessageEnd()
8078 
    oprot.trans.flush()
5067 varun.gupt 8079 
 
5386 phani.kuma 8080 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8081 
    args = updateOrderOnlyAsPaidToVendor_args()
8082 
    args.read(iprot)
8083 
    iprot.readMessageEnd()
8084 
    result = updateOrderOnlyAsPaidToVendor_result()
8085 
    try:
8086 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8087 
    except TransactionServiceException, ex:
8088 
      result.ex = ex
8089 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8090 
    result.write(oprot)
8091 
    oprot.writeMessageEnd()
8092 
    oprot.trans.flush()
8093 
 
5208 varun.gupt 8094 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8095 
    args = getRefundedOrdersMarkedPaid_args()
8096 
    args.read(iprot)
8097 
    iprot.readMessageEnd()
8098 
    result = getRefundedOrdersMarkedPaid_result()
8099 
    try:
8100 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8101 
    except TransactionServiceException, ex:
8102 
      result.ex = ex
8103 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8104 
    result.write(oprot)
8105 
    oprot.writeMessageEnd()
8106 
    oprot.trans.flush()
5099 varun.gupt 8107 
 
5447 anupam.sin 8108 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8109 
    args = getAllVerificationAgents_args()
8110 
    args.read(iprot)
8111 
    iprot.readMessageEnd()
8112 
    result = getAllVerificationAgents_result()
8113 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8114 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8115 
    result.write(oprot)
8116 
    oprot.writeMessageEnd()
8117 
    oprot.trans.flush()
5208 varun.gupt 8118 
 
5527 anupam.sin 8119 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8120 
    args = getAllAttributesForOrderId_args()
8121 
    args.read(iprot)
8122 
    iprot.readMessageEnd()
8123 
    result = getAllAttributesForOrderId_result()
8124 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8125 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8126 
    result.write(oprot)
8127 
    oprot.writeMessageEnd()
8128 
    oprot.trans.flush()
5447 anupam.sin 8129 
 
5676 rajveer 8130 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8131 
    args = setOrderAttributes_args()
8132 
    args.read(iprot)
8133 
    iprot.readMessageEnd()
8134 
    result = setOrderAttributes_result()
8135 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8136 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8137 
    result.write(oprot)
8138 
    oprot.writeMessageEnd()
8139 
    oprot.trans.flush()
8140 
 
5527 anupam.sin 8141 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8142 
    args = setOrderAttributeForTransaction_args()
8143 
    args.read(iprot)
8144 
    iprot.readMessageEnd()
8145 
    result = setOrderAttributeForTransaction_result()
8146 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8147 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8148 
    result.write(oprot)
8149 
    oprot.writeMessageEnd()
8150 
    oprot.trans.flush()
8151 
 
5553 rajveer 8152 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8153 
    args = getReceivePendingOrders_args()
8154 
    args.read(iprot)
8155 
    iprot.readMessageEnd()
8156 
    result = getReceivePendingOrders_result()
8157 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8158 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8159 
    result.write(oprot)
8160 
    oprot.writeMessageEnd()
8161 
    oprot.trans.flush()
5527 anupam.sin 8162 
 
5553 rajveer 8163 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8164 
    args = getReceivedAtStoreOrders_args()
8165 
    args.read(iprot)
8166 
    iprot.readMessageEnd()
8167 
    result = getReceivedAtStoreOrders_result()
8168 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8169 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8170 
    result.write(oprot)
8171 
    oprot.writeMessageEnd()
8172 
    oprot.trans.flush()
8173 
 
5713 rajveer 8174 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8175 
    args = getOrdersCollectionAtStore_args()
8176 
    args.read(iprot)
8177 
    iprot.readMessageEnd()
8178 
    result = getOrdersCollectionAtStore_result()
8179 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8180 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8181 
    result.write(oprot)
8182 
    oprot.writeMessageEnd()
8183 
    oprot.trans.flush()
8184 
 
5833 rajveer 8185 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8186 
    args = getOrderAttributeValue_args()
8187 
    args.read(iprot)
8188 
    iprot.readMessageEnd()
8189 
    result = getOrderAttributeValue_result()
8190 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8191 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8192 
    result.write(oprot)
8193 
    oprot.writeMessageEnd()
8194 
    oprot.trans.flush()
8195 
 
6019 rajveer 8196 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8197 
    args = changeJacketNumber_args()
8198 
    args.read(iprot)
8199 
    iprot.readMessageEnd()
8200 
    result = changeJacketNumber_result()
8201 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8202 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8203 
    result.write(oprot)
8204 
    oprot.writeMessageEnd()
8205 
    oprot.trans.flush()
8206 
 
8207 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8208 
    args = markOrderAsRtoInTransit_args()
8209 
    args.read(iprot)
8210 
    iprot.readMessageEnd()
8211 
    result = markOrderAsRtoInTransit_result()
8212 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8213 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8214 
    result.write(oprot)
8215 
    oprot.writeMessageEnd()
8216 
    oprot.trans.flush()
8217 
 
5593 mandeep.dh 8218 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8219 
    args = acceptOrderForItem_args()
8220 
    args.read(iprot)
8221 
    iprot.readMessageEnd()
8222 
    result = acceptOrderForItem_result()
8223 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8224 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8225 
    result.write(oprot)
8226 
    oprot.writeMessageEnd()
8227 
    oprot.trans.flush()
5553 rajveer 8228 
 
6000 mandeep.dh 8229 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8230 
    args = createRechargeOrder_args()
8231 
    args.read(iprot)
8232 
    iprot.readMessageEnd()
8233 
    result = createRechargeOrder_result()
8234 
    try:
8235 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8236 
    except TransactionServiceException, ex:
8237 
      result.ex = ex
8238 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8239 
    result.write(oprot)
8240 
    oprot.writeMessageEnd()
8241 
    oprot.trans.flush()
5593 mandeep.dh 8242 
 
6031 rajveer 8243 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8244 
    args = getRechargeOrder_args()
8245 
    args.read(iprot)
8246 
    iprot.readMessageEnd()
8247 
    result = getRechargeOrder_result()
8248 
    try:
8249 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8250 
    except TransactionServiceException, ex:
8251 
      result.ex = ex
8252 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8253 
    result.write(oprot)
8254 
    oprot.writeMessageEnd()
8255 
    oprot.trans.flush()
8256 
 
8257 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8258 
    args = getRechargeOrders_args()
8259 
    args.read(iprot)
8260 
    iprot.readMessageEnd()
8261 
    result = getRechargeOrders_result()
8262 
    result.success = self._handler.getRechargeOrders(args.userId)
8263 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8264 
    result.write(oprot)
8265 
    oprot.writeMessageEnd()
8266 
    oprot.trans.flush()
8267 
 
6000 mandeep.dh 8268 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8269 
    args = updateRechargeOrderStatus_args()
8270 
    args.read(iprot)
8271 
    iprot.readMessageEnd()
8272 
    result = updateRechargeOrderStatus_result()
8273 
    try:
6031 rajveer 8274 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8275 
    except TransactionServiceException, ex:
8276 
      result.ex = ex
8277 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8278 
    result.write(oprot)
8279 
    oprot.writeMessageEnd()
8280 
    oprot.trans.flush()
8281 
 
8282 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8283 
    args = activateRechargeTxn_args()
8284 
    args.read(iprot)
8285 
    iprot.readMessageEnd()
8286 
    result = activateRechargeTxn_result()
8287 
    try:
6031 rajveer 8288 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8289 
    except TransactionServiceException, ex:
8290 
      result.ex = ex
8291 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8292 
    result.write(oprot)
8293 
    oprot.writeMessageEnd()
8294 
    oprot.trans.flush()
8295 
 
6031 rajveer 8296 
  def process_getUserWallet(self, seqid, iprot, oprot):
8297 
    args = getUserWallet_args()
6000 mandeep.dh 8298 
    args.read(iprot)
8299 
    iprot.readMessageEnd()
6031 rajveer 8300 
    result = getUserWallet_result()
8301 
    result.success = self._handler.getUserWallet(args.userId)
8302 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8303 
    result.write(oprot)
8304 
    oprot.writeMessageEnd()
8305 
    oprot.trans.flush()
8306 
 
6031 rajveer 8307 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8308 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8309 
    args.read(iprot)
8310 
    iprot.readMessageEnd()
6031 rajveer 8311 
    result = getUserWalletHistory_result()
8312 
    result.success = self._handler.getUserWalletHistory(args.userId)
8313 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8314 
    result.write(oprot)
8315 
    oprot.writeMessageEnd()
8316 
    oprot.trans.flush()
8317 
 
6050 anupam.sin 8318 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8319 
    args = getRechargeOrdersForTransaction_args()
8320 
    args.read(iprot)
8321 
    iprot.readMessageEnd()
8322 
    result = getRechargeOrdersForTransaction_result()
8323 
    try:
8324 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8325 
    except TransactionServiceException, ex:
8326 
      result.ex = ex
8327 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8328 
    result.write(oprot)
8329 
    oprot.writeMessageEnd()
8330 
    oprot.trans.flush()
8331 
 
6048 rajveer 8332 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8333 
    args = getServiceProviders_args()
8334 
    args.read(iprot)
8335 
    iprot.readMessageEnd()
8336 
    result = getServiceProviders_result()
6206 rajveer 8337 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 8338 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8339 
    result.write(oprot)
8340 
    oprot.writeMessageEnd()
8341 
    oprot.trans.flush()
6000 mandeep.dh 8342 
 
6048 rajveer 8343 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8344 
    args = getServiceProviderForDevice_args()
8345 
    args.read(iprot)
8346 
    iprot.readMessageEnd()
8347 
    result = getServiceProviderForDevice_result()
6049 rajveer 8348 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8349 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8350 
    result.write(oprot)
8351 
    oprot.writeMessageEnd()
8352 
    oprot.trans.flush()
8353 
 
6269 rajveer 8354 
  def process_validateRecharge(self, seqid, iprot, oprot):
8355 
    args = validateRecharge_args()
8356 
    args.read(iprot)
8357 
    iprot.readMessageEnd()
8358 
    result = validateRecharge_result()
6336 anupam.sin 8359 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId)
6269 rajveer 8360 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
8361 
    result.write(oprot)
8362 
    oprot.writeMessageEnd()
8363 
    oprot.trans.flush()
8364 
 
6094 rajveer 8365 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8366 
    args = getRechargeOrdersForDevice_args()
8367 
    args.read(iprot)
8368 
    iprot.readMessageEnd()
8369 
    result = getRechargeOrdersForDevice_result()
8370 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8371 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8372 
    result.write(oprot)
8373 
    oprot.writeMessageEnd()
8374 
    oprot.trans.flush()
6048 rajveer 8375 
 
6094 rajveer 8376 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8377 
    args = addAmountToWallet_args()
8378 
    args.read(iprot)
8379 
    iprot.readMessageEnd()
8380 
    result = addAmountToWallet_result()
8381 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8382 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8383 
    result.write(oprot)
8384 
    oprot.writeMessageEnd()
8385 
    oprot.trans.flush()
8386 
 
6188 rajveer 8387 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
8388 
    args = getRechargeStatistics_args()
8389 
    args.read(iprot)
8390 
    iprot.readMessageEnd()
8391 
    result = getRechargeStatistics_result()
8392 
    result.success = self._handler.getRechargeStatistics()
8393 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
8394 
    result.write(oprot)
8395 
    oprot.writeMessageEnd()
8396 
    oprot.trans.flush()
8397 
 
6154 rajveer 8398 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
8399 
    args = getRechargeOrdersForStatus_args()
8400 
    args.read(iprot)
8401 
    iprot.readMessageEnd()
8402 
    result = getRechargeOrdersForStatus_result()
8403 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
8404 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
8405 
    result.write(oprot)
8406 
    oprot.writeMessageEnd()
8407 
    oprot.trans.flush()
6094 rajveer 8408 
 
6159 rajveer 8409 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
8410 
    args = getPlansForOperator_args()
8411 
    args.read(iprot)
8412 
    iprot.readMessageEnd()
8413 
    result = getPlansForOperator_result()
8414 
    result.success = self._handler.getPlansForOperator(args.operatorId)
8415 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
8416 
    result.write(oprot)
8417 
    oprot.writeMessageEnd()
8418 
    oprot.trans.flush()
6154 rajveer 8419 
 
6289 anupam.sin 8420 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
8421 
    args = getRechargeDenominations_args()
8422 
    args.read(iprot)
8423 
    iprot.readMessageEnd()
8424 
    result = getRechargeDenominations_result()
8425 
    try:
6307 anupam.sin 8426 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 8427 
    except TransactionServiceException, ex:
8428 
      result.ex = ex
8429 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
8430 
    result.write(oprot)
8431 
    oprot.writeMessageEnd()
8432 
    oprot.trans.flush()
6159 rajveer 8433 
 
6289 anupam.sin 8434 
 
94 ashish 8435 
# HELPER FUNCTIONS AND STRUCTURES
8436 
 
8437 
class createTransaction_args:
8438 
  """
8439 
  Attributes:
8440 
   - transaction
8441 
  """
8442 
 
8443 
  thrift_spec = (
8444 
    None, # 0
8445 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8446 
  )
8447 
 
8448 
  def __init__(self, transaction=None,):
8449 
    self.transaction = transaction
8450 
 
8451 
  def read(self, iprot):
8452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8454 
      return
8455 
    iprot.readStructBegin()
8456 
    while True:
8457 
      (fname, ftype, fid) = iprot.readFieldBegin()
8458 
      if ftype == TType.STOP:
8459 
        break
8460 
      if fid == 1:
8461 
        if ftype == TType.STRUCT:
8462 
          self.transaction = Transaction()
8463 
          self.transaction.read(iprot)
8464 
        else:
8465 
          iprot.skip(ftype)
8466 
      else:
8467 
        iprot.skip(ftype)
8468 
      iprot.readFieldEnd()
8469 
    iprot.readStructEnd()
8470 
 
8471 
  def write(self, oprot):
8472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8474 
      return
8475 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8476 
    if self.transaction is not None:
94 ashish 8477 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
8478 
      self.transaction.write(oprot)
8479 
      oprot.writeFieldEnd()
8480 
    oprot.writeFieldStop()
8481 
    oprot.writeStructEnd()
8482 
 
3431 rajveer 8483 
  def validate(self):
8484 
    return
8485 
 
8486 
 
94 ashish 8487 
  def __repr__(self):
8488 
    L = ['%s=%r' % (key, value)
8489 
      for key, value in self.__dict__.iteritems()]
8490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8491 
 
8492 
  def __eq__(self, other):
8493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8494 
 
8495 
  def __ne__(self, other):
8496 
    return not (self == other)
8497 
 
8498 
class createTransaction_result:
8499 
  """
8500 
  Attributes:
132 ashish 8501 
   - success
94 ashish 8502 
   - ex
8503 
  """
8504 
 
8505 
  thrift_spec = (
132 ashish 8506 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8507 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8508 
  )
8509 
 
132 ashish 8510 
  def __init__(self, success=None, ex=None,):
8511 
    self.success = success
94 ashish 8512 
    self.ex = ex
8513 
 
8514 
  def read(self, iprot):
8515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8517 
      return
8518 
    iprot.readStructBegin()
8519 
    while True:
8520 
      (fname, ftype, fid) = iprot.readFieldBegin()
8521 
      if ftype == TType.STOP:
8522 
        break
132 ashish 8523 
      if fid == 0:
8524 
        if ftype == TType.I64:
8525 
          self.success = iprot.readI64();
8526 
        else:
8527 
          iprot.skip(ftype)
8528 
      elif fid == 1:
94 ashish 8529 
        if ftype == TType.STRUCT:
8530 
          self.ex = TransactionServiceException()
8531 
          self.ex.read(iprot)
8532 
        else:
8533 
          iprot.skip(ftype)
8534 
      else:
8535 
        iprot.skip(ftype)
8536 
      iprot.readFieldEnd()
8537 
    iprot.readStructEnd()
8538 
 
8539 
  def write(self, oprot):
8540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8542 
      return
8543 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 8544 
    if self.success is not None:
132 ashish 8545 
      oprot.writeFieldBegin('success', TType.I64, 0)
8546 
      oprot.writeI64(self.success)
8547 
      oprot.writeFieldEnd()
3431 rajveer 8548 
    if self.ex is not None:
94 ashish 8549 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8550 
      self.ex.write(oprot)
8551 
      oprot.writeFieldEnd()
8552 
    oprot.writeFieldStop()
8553 
    oprot.writeStructEnd()
8554 
 
3431 rajveer 8555 
  def validate(self):
8556 
    return
8557 
 
8558 
 
94 ashish 8559 
  def __repr__(self):
8560 
    L = ['%s=%r' % (key, value)
8561 
      for key, value in self.__dict__.iteritems()]
8562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8563 
 
8564 
  def __eq__(self, other):
8565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8566 
 
8567 
  def __ne__(self, other):
8568 
    return not (self == other)
8569 
 
8570 
class getTransaction_args:
8571 
  """
8572 
  Attributes:
8573 
   - id
8574 
  """
8575 
 
8576 
  thrift_spec = (
8577 
    None, # 0
8578 
    (1, TType.I64, 'id', None, None, ), # 1
8579 
  )
8580 
 
8581 
  def __init__(self, id=None,):
8582 
    self.id = id
8583 
 
8584 
  def read(self, iprot):
8585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8587 
      return
8588 
    iprot.readStructBegin()
8589 
    while True:
8590 
      (fname, ftype, fid) = iprot.readFieldBegin()
8591 
      if ftype == TType.STOP:
8592 
        break
8593 
      if fid == 1:
8594 
        if ftype == TType.I64:
8595 
          self.id = iprot.readI64();
8596 
        else:
8597 
          iprot.skip(ftype)
8598 
      else:
8599 
        iprot.skip(ftype)
8600 
      iprot.readFieldEnd()
8601 
    iprot.readStructEnd()
8602 
 
8603 
  def write(self, oprot):
8604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8606 
      return
8607 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 8608 
    if self.id is not None:
94 ashish 8609 
      oprot.writeFieldBegin('id', TType.I64, 1)
8610 
      oprot.writeI64(self.id)
8611 
      oprot.writeFieldEnd()
8612 
    oprot.writeFieldStop()
8613 
    oprot.writeStructEnd()
8614 
 
3431 rajveer 8615 
  def validate(self):
8616 
    return
8617 
 
8618 
 
94 ashish 8619 
  def __repr__(self):
8620 
    L = ['%s=%r' % (key, value)
8621 
      for key, value in self.__dict__.iteritems()]
8622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8623 
 
8624 
  def __eq__(self, other):
8625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8626 
 
8627 
  def __ne__(self, other):
8628 
    return not (self == other)
8629 
 
8630 
class getTransaction_result:
8631 
  """
8632 
  Attributes:
8633 
   - success
8634 
   - ex
8635 
  """
8636 
 
8637 
  thrift_spec = (
8638 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
8639 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8640 
  )
8641 
 
8642 
  def __init__(self, success=None, ex=None,):
8643 
    self.success = success
8644 
    self.ex = ex
8645 
 
8646 
  def read(self, iprot):
8647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8649 
      return
8650 
    iprot.readStructBegin()
8651 
    while True:
8652 
      (fname, ftype, fid) = iprot.readFieldBegin()
8653 
      if ftype == TType.STOP:
8654 
        break
8655 
      if fid == 0:
8656 
        if ftype == TType.STRUCT:
8657 
          self.success = Transaction()
8658 
          self.success.read(iprot)
8659 
        else:
8660 
          iprot.skip(ftype)
8661 
      elif fid == 1:
8662 
        if ftype == TType.STRUCT:
8663 
          self.ex = TransactionServiceException()
8664 
          self.ex.read(iprot)
8665 
        else:
8666 
          iprot.skip(ftype)
8667 
      else:
8668 
        iprot.skip(ftype)
8669 
      iprot.readFieldEnd()
8670 
    iprot.readStructEnd()
8671 
 
8672 
  def write(self, oprot):
8673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8675 
      return
8676 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 8677 
    if self.success is not None:
94 ashish 8678 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8679 
      self.success.write(oprot)
8680 
      oprot.writeFieldEnd()
3431 rajveer 8681 
    if self.ex is not None:
94 ashish 8682 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8683 
      self.ex.write(oprot)
8684 
      oprot.writeFieldEnd()
8685 
    oprot.writeFieldStop()
8686 
    oprot.writeStructEnd()
8687 
 
3431 rajveer 8688 
  def validate(self):
8689 
    return
8690 
 
8691 
 
94 ashish 8692 
  def __repr__(self):
8693 
    L = ['%s=%r' % (key, value)
8694 
      for key, value in self.__dict__.iteritems()]
8695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8696 
 
8697 
  def __eq__(self, other):
8698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8699 
 
8700 
  def __ne__(self, other):
8701 
    return not (self == other)
8702 
 
8703 
class getTransactionsForCustomer_args:
8704 
  """
8705 
  Attributes:
8706 
   - customerId
8707 
   - from_date
8708 
   - to_date
8709 
   - status
8710 
  """
8711 
 
8712 
  thrift_spec = (
8713 
    None, # 0
8714 
    (1, TType.I64, 'customerId', None, None, ), # 1
8715 
    (2, TType.I64, 'from_date', None, None, ), # 2
8716 
    (3, TType.I64, 'to_date', None, None, ), # 3
8717 
    (4, TType.I32, 'status', None, None, ), # 4
8718 
  )
8719 
 
8720 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
8721 
    self.customerId = customerId
8722 
    self.from_date = from_date
8723 
    self.to_date = to_date
8724 
    self.status = status
8725 
 
8726 
  def read(self, iprot):
8727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8729 
      return
8730 
    iprot.readStructBegin()
8731 
    while True:
8732 
      (fname, ftype, fid) = iprot.readFieldBegin()
8733 
      if ftype == TType.STOP:
8734 
        break
8735 
      if fid == 1:
8736 
        if ftype == TType.I64:
8737 
          self.customerId = iprot.readI64();
8738 
        else:
8739 
          iprot.skip(ftype)
8740 
      elif fid == 2:
8741 
        if ftype == TType.I64:
8742 
          self.from_date = iprot.readI64();
8743 
        else:
8744 
          iprot.skip(ftype)
8745 
      elif fid == 3:
8746 
        if ftype == TType.I64:
8747 
          self.to_date = iprot.readI64();
8748 
        else:
8749 
          iprot.skip(ftype)
8750 
      elif fid == 4:
8751 
        if ftype == TType.I32:
8752 
          self.status = iprot.readI32();
8753 
        else:
8754 
          iprot.skip(ftype)
8755 
      else:
8756 
        iprot.skip(ftype)
8757 
      iprot.readFieldEnd()
8758 
    iprot.readStructEnd()
8759 
 
8760 
  def write(self, oprot):
8761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8763 
      return
8764 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 8765 
    if self.customerId is not None:
94 ashish 8766 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8767 
      oprot.writeI64(self.customerId)
8768 
      oprot.writeFieldEnd()
3431 rajveer 8769 
    if self.from_date is not None:
94 ashish 8770 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8771 
      oprot.writeI64(self.from_date)
8772 
      oprot.writeFieldEnd()
3431 rajveer 8773 
    if self.to_date is not None:
94 ashish 8774 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8775 
      oprot.writeI64(self.to_date)
8776 
      oprot.writeFieldEnd()
3431 rajveer 8777 
    if self.status is not None:
94 ashish 8778 
      oprot.writeFieldBegin('status', TType.I32, 4)
8779 
      oprot.writeI32(self.status)
8780 
      oprot.writeFieldEnd()
8781 
    oprot.writeFieldStop()
8782 
    oprot.writeStructEnd()
8783 
 
3431 rajveer 8784 
  def validate(self):
8785 
    return
8786 
 
8787 
 
94 ashish 8788 
  def __repr__(self):
8789 
    L = ['%s=%r' % (key, value)
8790 
      for key, value in self.__dict__.iteritems()]
8791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8792 
 
8793 
  def __eq__(self, other):
8794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8795 
 
8796 
  def __ne__(self, other):
8797 
    return not (self == other)
8798 
 
8799 
class getTransactionsForCustomer_result:
8800 
  """
8801 
  Attributes:
8802 
   - success
8803 
   - ex
8804 
  """
8805 
 
8806 
  thrift_spec = (
8807 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8808 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8809 
  )
8810 
 
8811 
  def __init__(self, success=None, ex=None,):
8812 
    self.success = success
8813 
    self.ex = ex
8814 
 
8815 
  def read(self, iprot):
8816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8818 
      return
8819 
    iprot.readStructBegin()
8820 
    while True:
8821 
      (fname, ftype, fid) = iprot.readFieldBegin()
8822 
      if ftype == TType.STOP:
8823 
        break
8824 
      if fid == 0:
8825 
        if ftype == TType.LIST:
8826 
          self.success = []
6188 rajveer 8827 
          (_etype109, _size106) = iprot.readListBegin()
8828 
          for _i110 in xrange(_size106):
8829 
            _elem111 = Transaction()
8830 
            _elem111.read(iprot)
8831 
            self.success.append(_elem111)
94 ashish 8832 
          iprot.readListEnd()
8833 
        else:
8834 
          iprot.skip(ftype)
8835 
      elif fid == 1:
8836 
        if ftype == TType.STRUCT:
8837 
          self.ex = TransactionServiceException()
8838 
          self.ex.read(iprot)
8839 
        else:
8840 
          iprot.skip(ftype)
8841 
      else:
8842 
        iprot.skip(ftype)
8843 
      iprot.readFieldEnd()
8844 
    iprot.readStructEnd()
8845 
 
8846 
  def write(self, oprot):
8847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8849 
      return
8850 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 8851 
    if self.success is not None:
94 ashish 8852 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8853 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 8854 
      for iter112 in self.success:
8855 
        iter112.write(oprot)
94 ashish 8856 
      oprot.writeListEnd()
8857 
      oprot.writeFieldEnd()
3431 rajveer 8858 
    if self.ex is not None:
94 ashish 8859 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8860 
      self.ex.write(oprot)
8861 
      oprot.writeFieldEnd()
8862 
    oprot.writeFieldStop()
8863 
    oprot.writeStructEnd()
8864 
 
3431 rajveer 8865 
  def validate(self):
8866 
    return
8867 
 
8868 
 
94 ashish 8869 
  def __repr__(self):
8870 
    L = ['%s=%r' % (key, value)
8871 
      for key, value in self.__dict__.iteritems()]
8872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8873 
 
8874 
  def __eq__(self, other):
8875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8876 
 
8877 
  def __ne__(self, other):
8878 
    return not (self == other)
8879 
 
132 ashish 8880 
class getTransactionsForShoppingCartId_args:
8881 
  """
8882 
  Attributes:
8883 
   - shoppingCartId
8884 
  """
8885 
 
8886 
  thrift_spec = (
8887 
    None, # 0
8888 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
8889 
  )
8890 
 
8891 
  def __init__(self, shoppingCartId=None,):
8892 
    self.shoppingCartId = shoppingCartId
8893 
 
8894 
  def read(self, iprot):
8895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8897 
      return
8898 
    iprot.readStructBegin()
8899 
    while True:
8900 
      (fname, ftype, fid) = iprot.readFieldBegin()
8901 
      if ftype == TType.STOP:
8902 
        break
8903 
      if fid == 1:
8904 
        if ftype == TType.I64:
8905 
          self.shoppingCartId = iprot.readI64();
8906 
        else:
8907 
          iprot.skip(ftype)
8908 
      else:
8909 
        iprot.skip(ftype)
8910 
      iprot.readFieldEnd()
8911 
    iprot.readStructEnd()
8912 
 
8913 
  def write(self, oprot):
8914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8916 
      return
8917 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 8918 
    if self.shoppingCartId is not None:
132 ashish 8919 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
8920 
      oprot.writeI64(self.shoppingCartId)
8921 
      oprot.writeFieldEnd()
8922 
    oprot.writeFieldStop()
8923 
    oprot.writeStructEnd()
8924 
 
3431 rajveer 8925 
  def validate(self):
8926 
    return
8927 
 
8928 
 
132 ashish 8929 
  def __repr__(self):
8930 
    L = ['%s=%r' % (key, value)
8931 
      for key, value in self.__dict__.iteritems()]
8932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8933 
 
8934 
  def __eq__(self, other):
8935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8936 
 
8937 
  def __ne__(self, other):
8938 
    return not (self == other)
8939 
 
8940 
class getTransactionsForShoppingCartId_result:
8941 
  """
8942 
  Attributes:
8943 
   - success
8944 
   - ex
8945 
  """
8946 
 
8947 
  thrift_spec = (
8948 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
8949 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8950 
  )
8951 
 
8952 
  def __init__(self, success=None, ex=None,):
8953 
    self.success = success
8954 
    self.ex = ex
8955 
 
8956 
  def read(self, iprot):
8957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8959 
      return
8960 
    iprot.readStructBegin()
8961 
    while True:
8962 
      (fname, ftype, fid) = iprot.readFieldBegin()
8963 
      if ftype == TType.STOP:
8964 
        break
8965 
      if fid == 0:
8966 
        if ftype == TType.LIST:
8967 
          self.success = []
6188 rajveer 8968 
          (_etype116, _size113) = iprot.readListBegin()
8969 
          for _i117 in xrange(_size113):
8970 
            _elem118 = Transaction()
8971 
            _elem118.read(iprot)
8972 
            self.success.append(_elem118)
132 ashish 8973 
          iprot.readListEnd()
8974 
        else:
8975 
          iprot.skip(ftype)
8976 
      elif fid == 1:
8977 
        if ftype == TType.STRUCT:
8978 
          self.ex = TransactionServiceException()
8979 
          self.ex.read(iprot)
8980 
        else:
8981 
          iprot.skip(ftype)
8982 
      else:
8983 
        iprot.skip(ftype)
8984 
      iprot.readFieldEnd()
8985 
    iprot.readStructEnd()
8986 
 
8987 
  def write(self, oprot):
8988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8990 
      return
8991 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 8992 
    if self.success is not None:
132 ashish 8993 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8994 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 8995 
      for iter119 in self.success:
8996 
        iter119.write(oprot)
132 ashish 8997 
      oprot.writeListEnd()
8998 
      oprot.writeFieldEnd()
3431 rajveer 8999 
    if self.ex is not None:
132 ashish 9000 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9001 
      self.ex.write(oprot)
9002 
      oprot.writeFieldEnd()
9003 
    oprot.writeFieldStop()
9004 
    oprot.writeStructEnd()
9005 
 
3431 rajveer 9006 
  def validate(self):
9007 
    return
9008 
 
9009 
 
132 ashish 9010 
  def __repr__(self):
9011 
    L = ['%s=%r' % (key, value)
9012 
      for key, value in self.__dict__.iteritems()]
9013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9014 
 
9015 
  def __eq__(self, other):
9016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9017 
 
9018 
  def __ne__(self, other):
9019 
    return not (self == other)
9020 
 
94 ashish 9021 
class getTransactionStatus_args:
9022 
  """
9023 
  Attributes:
9024 
   - transactionId
9025 
  """
9026 
 
9027 
  thrift_spec = (
9028 
    None, # 0
9029 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9030 
  )
9031 
 
9032 
  def __init__(self, transactionId=None,):
9033 
    self.transactionId = transactionId
9034 
 
9035 
  def read(self, iprot):
9036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9038 
      return
9039 
    iprot.readStructBegin()
9040 
    while True:
9041 
      (fname, ftype, fid) = iprot.readFieldBegin()
9042 
      if ftype == TType.STOP:
9043 
        break
9044 
      if fid == 1:
9045 
        if ftype == TType.I64:
9046 
          self.transactionId = iprot.readI64();
9047 
        else:
9048 
          iprot.skip(ftype)
9049 
      else:
9050 
        iprot.skip(ftype)
9051 
      iprot.readFieldEnd()
9052 
    iprot.readStructEnd()
9053 
 
9054 
  def write(self, oprot):
9055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9057 
      return
9058 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 9059 
    if self.transactionId is not None:
94 ashish 9060 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9061 
      oprot.writeI64(self.transactionId)
9062 
      oprot.writeFieldEnd()
9063 
    oprot.writeFieldStop()
9064 
    oprot.writeStructEnd()
9065 
 
3431 rajveer 9066 
  def validate(self):
9067 
    return
9068 
 
9069 
 
94 ashish 9070 
  def __repr__(self):
9071 
    L = ['%s=%r' % (key, value)
9072 
      for key, value in self.__dict__.iteritems()]
9073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9074 
 
9075 
  def __eq__(self, other):
9076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9077 
 
9078 
  def __ne__(self, other):
9079 
    return not (self == other)
9080 
 
9081 
class getTransactionStatus_result:
9082 
  """
9083 
  Attributes:
9084 
   - success
9085 
   - ex
9086 
  """
9087 
 
9088 
  thrift_spec = (
9089 
    (0, TType.I32, 'success', None, None, ), # 0
9090 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9091 
  )
9092 
 
9093 
  def __init__(self, success=None, ex=None,):
9094 
    self.success = success
9095 
    self.ex = ex
9096 
 
9097 
  def read(self, iprot):
9098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9100 
      return
9101 
    iprot.readStructBegin()
9102 
    while True:
9103 
      (fname, ftype, fid) = iprot.readFieldBegin()
9104 
      if ftype == TType.STOP:
9105 
        break
9106 
      if fid == 0:
9107 
        if ftype == TType.I32:
9108 
          self.success = iprot.readI32();
9109 
        else:
9110 
          iprot.skip(ftype)
9111 
      elif fid == 1:
9112 
        if ftype == TType.STRUCT:
9113 
          self.ex = TransactionServiceException()
9114 
          self.ex.read(iprot)
9115 
        else:
9116 
          iprot.skip(ftype)
9117 
      else:
9118 
        iprot.skip(ftype)
9119 
      iprot.readFieldEnd()
9120 
    iprot.readStructEnd()
9121 
 
9122 
  def write(self, oprot):
9123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9125 
      return
9126 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 9127 
    if self.success is not None:
94 ashish 9128 
      oprot.writeFieldBegin('success', TType.I32, 0)
9129 
      oprot.writeI32(self.success)
9130 
      oprot.writeFieldEnd()
3431 rajveer 9131 
    if self.ex is not None:
94 ashish 9132 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9133 
      self.ex.write(oprot)
9134 
      oprot.writeFieldEnd()
9135 
    oprot.writeFieldStop()
9136 
    oprot.writeStructEnd()
9137 
 
3431 rajveer 9138 
  def validate(self):
9139 
    return
9140 
 
9141 
 
94 ashish 9142 
  def __repr__(self):
9143 
    L = ['%s=%r' % (key, value)
9144 
      for key, value in self.__dict__.iteritems()]
9145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9146 
 
9147 
  def __eq__(self, other):
9148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9149 
 
9150 
  def __ne__(self, other):
9151 
    return not (self == other)
9152 
 
9153 
class changeTransactionStatus_args:
9154 
  """
9155 
  Attributes:
9156 
   - transactionId
9157 
   - status
9158 
   - description
5527 anupam.sin 9159 
   - pickUp
9160 
   - orderType
94 ashish 9161 
  """
9162 
 
9163 
  thrift_spec = (
9164 
    None, # 0
9165 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9166 
    (2, TType.I32, 'status', None, None, ), # 2
9167 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 9168 
    (4, TType.I64, 'pickUp', None, None, ), # 4
9169 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 9170 
  )
9171 
 
5527 anupam.sin 9172 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 9173 
    self.transactionId = transactionId
9174 
    self.status = status
9175 
    self.description = description
5527 anupam.sin 9176 
    self.pickUp = pickUp
9177 
    self.orderType = orderType
94 ashish 9178 
 
9179 
  def read(self, iprot):
9180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9182 
      return
9183 
    iprot.readStructBegin()
9184 
    while True:
9185 
      (fname, ftype, fid) = iprot.readFieldBegin()
9186 
      if ftype == TType.STOP:
9187 
        break
9188 
      if fid == 1:
9189 
        if ftype == TType.I64:
9190 
          self.transactionId = iprot.readI64();
9191 
        else:
9192 
          iprot.skip(ftype)
9193 
      elif fid == 2:
9194 
        if ftype == TType.I32:
9195 
          self.status = iprot.readI32();
9196 
        else:
9197 
          iprot.skip(ftype)
9198 
      elif fid == 3:
9199 
        if ftype == TType.STRING:
9200 
          self.description = iprot.readString();
9201 
        else:
9202 
          iprot.skip(ftype)
5387 rajveer 9203 
      elif fid == 4:
5527 anupam.sin 9204 
        if ftype == TType.I64:
9205 
          self.pickUp = iprot.readI64();
5387 rajveer 9206 
        else:
9207 
          iprot.skip(ftype)
5527 anupam.sin 9208 
      elif fid == 5:
9209 
        if ftype == TType.I32:
9210 
          self.orderType = iprot.readI32();
9211 
        else:
9212 
          iprot.skip(ftype)
94 ashish 9213 
      else:
9214 
        iprot.skip(ftype)
9215 
      iprot.readFieldEnd()
9216 
    iprot.readStructEnd()
9217 
 
9218 
  def write(self, oprot):
9219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9221 
      return
9222 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 9223 
    if self.transactionId is not None:
94 ashish 9224 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9225 
      oprot.writeI64(self.transactionId)
9226 
      oprot.writeFieldEnd()
3431 rajveer 9227 
    if self.status is not None:
94 ashish 9228 
      oprot.writeFieldBegin('status', TType.I32, 2)
9229 
      oprot.writeI32(self.status)
9230 
      oprot.writeFieldEnd()
3431 rajveer 9231 
    if self.description is not None:
94 ashish 9232 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9233 
      oprot.writeString(self.description)
9234 
      oprot.writeFieldEnd()
5527 anupam.sin 9235 
    if self.pickUp is not None:
9236 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
9237 
      oprot.writeI64(self.pickUp)
5387 rajveer 9238 
      oprot.writeFieldEnd()
5527 anupam.sin 9239 
    if self.orderType is not None:
9240 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
9241 
      oprot.writeI32(self.orderType)
9242 
      oprot.writeFieldEnd()
94 ashish 9243 
    oprot.writeFieldStop()
9244 
    oprot.writeStructEnd()
9245 
 
3431 rajveer 9246 
  def validate(self):
9247 
    return
9248 
 
9249 
 
94 ashish 9250 
  def __repr__(self):
9251 
    L = ['%s=%r' % (key, value)
9252 
      for key, value in self.__dict__.iteritems()]
9253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9254 
 
9255 
  def __eq__(self, other):
9256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9257 
 
9258 
  def __ne__(self, other):
9259 
    return not (self == other)
9260 
 
9261 
class changeTransactionStatus_result:
9262 
  """
9263 
  Attributes:
9264 
   - success
9265 
   - ex
9266 
  """
9267 
 
9268 
  thrift_spec = (
9269 
    (0, TType.BOOL, 'success', None, None, ), # 0
9270 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9271 
  )
9272 
 
9273 
  def __init__(self, success=None, ex=None,):
9274 
    self.success = success
9275 
    self.ex = ex
9276 
 
9277 
  def read(self, iprot):
9278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9280 
      return
9281 
    iprot.readStructBegin()
9282 
    while True:
9283 
      (fname, ftype, fid) = iprot.readFieldBegin()
9284 
      if ftype == TType.STOP:
9285 
        break
9286 
      if fid == 0:
9287 
        if ftype == TType.BOOL:
9288 
          self.success = iprot.readBool();
9289 
        else:
9290 
          iprot.skip(ftype)
9291 
      elif fid == 1:
9292 
        if ftype == TType.STRUCT:
9293 
          self.ex = TransactionServiceException()
9294 
          self.ex.read(iprot)
9295 
        else:
9296 
          iprot.skip(ftype)
9297 
      else:
9298 
        iprot.skip(ftype)
9299 
      iprot.readFieldEnd()
9300 
    iprot.readStructEnd()
9301 
 
9302 
  def write(self, oprot):
9303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9305 
      return
9306 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9307 
    if self.success is not None:
94 ashish 9308 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9309 
      oprot.writeBool(self.success)
9310 
      oprot.writeFieldEnd()
3431 rajveer 9311 
    if self.ex is not None:
94 ashish 9312 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9313 
      self.ex.write(oprot)
9314 
      oprot.writeFieldEnd()
9315 
    oprot.writeFieldStop()
9316 
    oprot.writeStructEnd()
9317 
 
3431 rajveer 9318 
  def validate(self):
9319 
    return
9320 
 
9321 
 
94 ashish 9322 
  def __repr__(self):
9323 
    L = ['%s=%r' % (key, value)
9324 
      for key, value in self.__dict__.iteritems()]
9325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9326 
 
9327 
  def __eq__(self, other):
9328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9329 
 
9330 
  def __ne__(self, other):
9331 
    return not (self == other)
9332 
 
1398 varun.gupt 9333 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 9334 
  """
9335 
  Attributes:
9336 
   - transactionId
9337 
  """
9338 
 
9339 
  thrift_spec = (
9340 
    None, # 0
9341 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9342 
  )
9343 
 
9344 
  def __init__(self, transactionId=None,):
9345 
    self.transactionId = transactionId
9346 
 
9347 
  def read(self, iprot):
9348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9350 
      return
9351 
    iprot.readStructBegin()
9352 
    while True:
9353 
      (fname, ftype, fid) = iprot.readFieldBegin()
9354 
      if ftype == TType.STOP:
9355 
        break
9356 
      if fid == 1:
9357 
        if ftype == TType.I64:
9358 
          self.transactionId = iprot.readI64();
9359 
        else:
9360 
          iprot.skip(ftype)
9361 
      else:
9362 
        iprot.skip(ftype)
9363 
      iprot.readFieldEnd()
9364 
    iprot.readStructEnd()
9365 
 
9366 
  def write(self, oprot):
9367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9369 
      return
1398 varun.gupt 9370 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 9371 
    if self.transactionId is not None:
1382 varun.gupt 9372 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9373 
      oprot.writeI64(self.transactionId)
9374 
      oprot.writeFieldEnd()
9375 
    oprot.writeFieldStop()
9376 
    oprot.writeStructEnd()
9377 
 
3431 rajveer 9378 
  def validate(self):
9379 
    return
9380 
 
9381 
 
1382 varun.gupt 9382 
  def __repr__(self):
9383 
    L = ['%s=%r' % (key, value)
9384 
      for key, value in self.__dict__.iteritems()]
9385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9386 
 
9387 
  def __eq__(self, other):
9388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9389 
 
9390 
  def __ne__(self, other):
9391 
    return not (self == other)
9392 
 
1398 varun.gupt 9393 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 9394 
  """
9395 
  Attributes:
9396 
   - success
9397 
   - ex
9398 
  """
9399 
 
9400 
  thrift_spec = (
9401 
    (0, TType.BOOL, 'success', None, None, ), # 0
9402 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9403 
  )
9404 
 
9405 
  def __init__(self, success=None, ex=None,):
9406 
    self.success = success
9407 
    self.ex = ex
9408 
 
9409 
  def read(self, iprot):
9410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9412 
      return
9413 
    iprot.readStructBegin()
9414 
    while True:
9415 
      (fname, ftype, fid) = iprot.readFieldBegin()
9416 
      if ftype == TType.STOP:
9417 
        break
9418 
      if fid == 0:
9419 
        if ftype == TType.BOOL:
9420 
          self.success = iprot.readBool();
9421 
        else:
9422 
          iprot.skip(ftype)
9423 
      elif fid == 1:
9424 
        if ftype == TType.STRUCT:
9425 
          self.ex = TransactionServiceException()
9426 
          self.ex.read(iprot)
9427 
        else:
9428 
          iprot.skip(ftype)
9429 
      else:
9430 
        iprot.skip(ftype)
9431 
      iprot.readFieldEnd()
9432 
    iprot.readStructEnd()
9433 
 
9434 
  def write(self, oprot):
9435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9437 
      return
1398 varun.gupt 9438 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9439 
    if self.success is not None:
1382 varun.gupt 9440 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9441 
      oprot.writeBool(self.success)
9442 
      oprot.writeFieldEnd()
3431 rajveer 9443 
    if self.ex is not None:
1382 varun.gupt 9444 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9445 
      self.ex.write(oprot)
9446 
      oprot.writeFieldEnd()
9447 
    oprot.writeFieldStop()
9448 
    oprot.writeStructEnd()
9449 
 
3431 rajveer 9450 
  def validate(self):
9451 
    return
9452 
 
9453 
 
1382 varun.gupt 9454 
  def __repr__(self):
9455 
    L = ['%s=%r' % (key, value)
9456 
      for key, value in self.__dict__.iteritems()]
9457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9458 
 
9459 
  def __eq__(self, other):
9460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9461 
 
9462 
  def __ne__(self, other):
9463 
    return not (self == other)
9464 
 
483 rajveer 9465 
class getAllOrders_args:
94 ashish 9466 
  """
9467 
  Attributes:
4801 anupam.sin 9468 
   - statuses
483 rajveer 9469 
   - from_date
9470 
   - to_date
9471 
   - warehouse_id
94 ashish 9472 
  """
9473 
 
9474 
  thrift_spec = (
9475 
    None, # 0
4801 anupam.sin 9476 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 9477 
    (2, TType.I64, 'from_date', None, None, ), # 2
9478 
    (3, TType.I64, 'to_date', None, None, ), # 3
9479 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 9480 
  )
9481 
 
4801 anupam.sin 9482 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
9483 
    self.statuses = statuses
483 rajveer 9484 
    self.from_date = from_date
9485 
    self.to_date = to_date
9486 
    self.warehouse_id = warehouse_id
94 ashish 9487 
 
9488 
  def read(self, iprot):
9489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9491 
      return
9492 
    iprot.readStructBegin()
9493 
    while True:
9494 
      (fname, ftype, fid) = iprot.readFieldBegin()
9495 
      if ftype == TType.STOP:
9496 
        break
9497 
      if fid == 1:
4801 anupam.sin 9498 
        if ftype == TType.LIST:
9499 
          self.statuses = []
6188 rajveer 9500 
          (_etype123, _size120) = iprot.readListBegin()
9501 
          for _i124 in xrange(_size120):
9502 
            _elem125 = iprot.readI32();
9503 
            self.statuses.append(_elem125)
4801 anupam.sin 9504 
          iprot.readListEnd()
94 ashish 9505 
        else:
9506 
          iprot.skip(ftype)
483 rajveer 9507 
      elif fid == 2:
9508 
        if ftype == TType.I64:
9509 
          self.from_date = iprot.readI64();
94 ashish 9510 
        else:
9511 
          iprot.skip(ftype)
483 rajveer 9512 
      elif fid == 3:
9513 
        if ftype == TType.I64:
9514 
          self.to_date = iprot.readI64();
94 ashish 9515 
        else:
9516 
          iprot.skip(ftype)
483 rajveer 9517 
      elif fid == 4:
94 ashish 9518 
        if ftype == TType.I64:
483 rajveer 9519 
          self.warehouse_id = iprot.readI64();
94 ashish 9520 
        else:
9521 
          iprot.skip(ftype)
9522 
      else:
9523 
        iprot.skip(ftype)
9524 
      iprot.readFieldEnd()
9525 
    iprot.readStructEnd()
9526 
 
9527 
  def write(self, oprot):
9528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9530 
      return
483 rajveer 9531 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 9532 
    if self.statuses is not None:
9533 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9534 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9535 
      for iter126 in self.statuses:
9536 
        oprot.writeI32(iter126)
4801 anupam.sin 9537 
      oprot.writeListEnd()
94 ashish 9538 
      oprot.writeFieldEnd()
3431 rajveer 9539 
    if self.from_date is not None:
483 rajveer 9540 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9541 
      oprot.writeI64(self.from_date)
94 ashish 9542 
      oprot.writeFieldEnd()
3431 rajveer 9543 
    if self.to_date is not None:
483 rajveer 9544 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9545 
      oprot.writeI64(self.to_date)
94 ashish 9546 
      oprot.writeFieldEnd()
3431 rajveer 9547 
    if self.warehouse_id is not None:
483 rajveer 9548 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9549 
      oprot.writeI64(self.warehouse_id)
94 ashish 9550 
      oprot.writeFieldEnd()
9551 
    oprot.writeFieldStop()
9552 
    oprot.writeStructEnd()
9553 
 
3431 rajveer 9554 
  def validate(self):
9555 
    return
9556 
 
9557 
 
94 ashish 9558 
  def __repr__(self):
9559 
    L = ['%s=%r' % (key, value)
9560 
      for key, value in self.__dict__.iteritems()]
9561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9562 
 
9563 
  def __eq__(self, other):
9564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9565 
 
9566 
  def __ne__(self, other):
9567 
    return not (self == other)
9568 
 
483 rajveer 9569 
class getAllOrders_result:
94 ashish 9570 
  """
9571 
  Attributes:
9572 
   - success
9573 
   - ex
9574 
  """
9575 
 
9576 
  thrift_spec = (
483 rajveer 9577 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 9578 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9579 
  )
9580 
 
9581 
  def __init__(self, success=None, ex=None,):
9582 
    self.success = success
9583 
    self.ex = ex
9584 
 
9585 
  def read(self, iprot):
9586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9588 
      return
9589 
    iprot.readStructBegin()
9590 
    while True:
9591 
      (fname, ftype, fid) = iprot.readFieldBegin()
9592 
      if ftype == TType.STOP:
9593 
        break
9594 
      if fid == 0:
483 rajveer 9595 
        if ftype == TType.LIST:
9596 
          self.success = []
6188 rajveer 9597 
          (_etype130, _size127) = iprot.readListBegin()
9598 
          for _i131 in xrange(_size127):
9599 
            _elem132 = Order()
9600 
            _elem132.read(iprot)
9601 
            self.success.append(_elem132)
483 rajveer 9602 
          iprot.readListEnd()
94 ashish 9603 
        else:
9604 
          iprot.skip(ftype)
9605 
      elif fid == 1:
9606 
        if ftype == TType.STRUCT:
9607 
          self.ex = TransactionServiceException()
9608 
          self.ex.read(iprot)
9609 
        else:
9610 
          iprot.skip(ftype)
9611 
      else:
9612 
        iprot.skip(ftype)
9613 
      iprot.readFieldEnd()
9614 
    iprot.readStructEnd()
9615 
 
9616 
  def write(self, oprot):
9617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9619 
      return
483 rajveer 9620 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 9621 
    if self.success is not None:
483 rajveer 9622 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9623 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9624 
      for iter133 in self.success:
9625 
        iter133.write(oprot)
483 rajveer 9626 
      oprot.writeListEnd()
94 ashish 9627 
      oprot.writeFieldEnd()
3431 rajveer 9628 
    if self.ex is not None:
94 ashish 9629 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9630 
      self.ex.write(oprot)
9631 
      oprot.writeFieldEnd()
9632 
    oprot.writeFieldStop()
9633 
    oprot.writeStructEnd()
9634 
 
3431 rajveer 9635 
  def validate(self):
9636 
    return
9637 
 
9638 
 
94 ashish 9639 
  def __repr__(self):
9640 
    L = ['%s=%r' % (key, value)
9641 
      for key, value in self.__dict__.iteritems()]
9642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9643 
 
9644 
  def __eq__(self, other):
9645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9646 
 
9647 
  def __ne__(self, other):
9648 
    return not (self == other)
9649 
 
4133 chandransh 9650 
class getOrdersInBatch_args:
9651 
  """
9652 
  Attributes:
9653 
   - statuses
9654 
   - offset
9655 
   - limit
9656 
   - warehouse_id
9657 
  """
9658 
 
9659 
  thrift_spec = (
9660 
    None, # 0
9661 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9662 
    (2, TType.I64, 'offset', None, None, ), # 2
9663 
    (3, TType.I64, 'limit', None, None, ), # 3
9664 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9665 
  )
9666 
 
9667 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
9668 
    self.statuses = statuses
9669 
    self.offset = offset
9670 
    self.limit = limit
9671 
    self.warehouse_id = warehouse_id
9672 
 
9673 
  def read(self, iprot):
9674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9676 
      return
9677 
    iprot.readStructBegin()
9678 
    while True:
9679 
      (fname, ftype, fid) = iprot.readFieldBegin()
9680 
      if ftype == TType.STOP:
9681 
        break
9682 
      if fid == 1:
9683 
        if ftype == TType.LIST:
9684 
          self.statuses = []
6188 rajveer 9685 
          (_etype137, _size134) = iprot.readListBegin()
9686 
          for _i138 in xrange(_size134):
9687 
            _elem139 = iprot.readI32();
9688 
            self.statuses.append(_elem139)
4133 chandransh 9689 
          iprot.readListEnd()
9690 
        else:
9691 
          iprot.skip(ftype)
9692 
      elif fid == 2:
9693 
        if ftype == TType.I64:
9694 
          self.offset = iprot.readI64();
9695 
        else:
9696 
          iprot.skip(ftype)
9697 
      elif fid == 3:
9698 
        if ftype == TType.I64:
9699 
          self.limit = iprot.readI64();
9700 
        else:
9701 
          iprot.skip(ftype)
9702 
      elif fid == 4:
9703 
        if ftype == TType.I64:
9704 
          self.warehouse_id = iprot.readI64();
9705 
        else:
9706 
          iprot.skip(ftype)
9707 
      else:
9708 
        iprot.skip(ftype)
9709 
      iprot.readFieldEnd()
9710 
    iprot.readStructEnd()
9711 
 
9712 
  def write(self, oprot):
9713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9715 
      return
9716 
    oprot.writeStructBegin('getOrdersInBatch_args')
9717 
    if self.statuses is not None:
9718 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9719 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9720 
      for iter140 in self.statuses:
9721 
        oprot.writeI32(iter140)
4133 chandransh 9722 
      oprot.writeListEnd()
9723 
      oprot.writeFieldEnd()
9724 
    if self.offset is not None:
9725 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9726 
      oprot.writeI64(self.offset)
9727 
      oprot.writeFieldEnd()
9728 
    if self.limit is not None:
9729 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9730 
      oprot.writeI64(self.limit)
9731 
      oprot.writeFieldEnd()
9732 
    if self.warehouse_id is not None:
9733 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9734 
      oprot.writeI64(self.warehouse_id)
9735 
      oprot.writeFieldEnd()
9736 
    oprot.writeFieldStop()
9737 
    oprot.writeStructEnd()
9738 
 
9739 
  def validate(self):
9740 
    return
9741 
 
9742 
 
9743 
  def __repr__(self):
9744 
    L = ['%s=%r' % (key, value)
9745 
      for key, value in self.__dict__.iteritems()]
9746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9747 
 
9748 
  def __eq__(self, other):
9749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9750 
 
9751 
  def __ne__(self, other):
9752 
    return not (self == other)
9753 
 
9754 
class getOrdersInBatch_result:
9755 
  """
9756 
  Attributes:
9757 
   - success
9758 
   - ex
9759 
  """
9760 
 
9761 
  thrift_spec = (
9762 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9763 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9764 
  )
9765 
 
9766 
  def __init__(self, success=None, ex=None,):
9767 
    self.success = success
9768 
    self.ex = ex
9769 
 
9770 
  def read(self, iprot):
9771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9773 
      return
9774 
    iprot.readStructBegin()
9775 
    while True:
9776 
      (fname, ftype, fid) = iprot.readFieldBegin()
9777 
      if ftype == TType.STOP:
9778 
        break
9779 
      if fid == 0:
9780 
        if ftype == TType.LIST:
9781 
          self.success = []
6188 rajveer 9782 
          (_etype144, _size141) = iprot.readListBegin()
9783 
          for _i145 in xrange(_size141):
9784 
            _elem146 = Order()
9785 
            _elem146.read(iprot)
9786 
            self.success.append(_elem146)
4133 chandransh 9787 
          iprot.readListEnd()
9788 
        else:
9789 
          iprot.skip(ftype)
9790 
      elif fid == 1:
9791 
        if ftype == TType.STRUCT:
9792 
          self.ex = TransactionServiceException()
9793 
          self.ex.read(iprot)
9794 
        else:
9795 
          iprot.skip(ftype)
9796 
      else:
9797 
        iprot.skip(ftype)
9798 
      iprot.readFieldEnd()
9799 
    iprot.readStructEnd()
9800 
 
9801 
  def write(self, oprot):
9802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9804 
      return
9805 
    oprot.writeStructBegin('getOrdersInBatch_result')
9806 
    if self.success is not None:
9807 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9808 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9809 
      for iter147 in self.success:
9810 
        iter147.write(oprot)
4133 chandransh 9811 
      oprot.writeListEnd()
9812 
      oprot.writeFieldEnd()
9813 
    if self.ex is not None:
9814 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9815 
      self.ex.write(oprot)
9816 
      oprot.writeFieldEnd()
9817 
    oprot.writeFieldStop()
9818 
    oprot.writeStructEnd()
9819 
 
9820 
  def validate(self):
9821 
    return
9822 
 
9823 
 
9824 
  def __repr__(self):
9825 
    L = ['%s=%r' % (key, value)
9826 
      for key, value in self.__dict__.iteritems()]
9827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9828 
 
9829 
  def __eq__(self, other):
9830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9831 
 
9832 
  def __ne__(self, other):
9833 
    return not (self == other)
9834 
 
9835 
class getOrderCount_args:
9836 
  """
9837 
  Attributes:
9838 
   - statuses
9839 
   - warehouseId
9840 
  """
9841 
 
9842 
  thrift_spec = (
9843 
    None, # 0
9844 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9845 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
9846 
  )
9847 
 
9848 
  def __init__(self, statuses=None, warehouseId=None,):
9849 
    self.statuses = statuses
9850 
    self.warehouseId = warehouseId
9851 
 
9852 
  def read(self, iprot):
9853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9855 
      return
9856 
    iprot.readStructBegin()
9857 
    while True:
9858 
      (fname, ftype, fid) = iprot.readFieldBegin()
9859 
      if ftype == TType.STOP:
9860 
        break
9861 
      if fid == 1:
9862 
        if ftype == TType.LIST:
9863 
          self.statuses = []
6188 rajveer 9864 
          (_etype151, _size148) = iprot.readListBegin()
9865 
          for _i152 in xrange(_size148):
9866 
            _elem153 = iprot.readI32();
9867 
            self.statuses.append(_elem153)
4133 chandransh 9868 
          iprot.readListEnd()
9869 
        else:
9870 
          iprot.skip(ftype)
9871 
      elif fid == 2:
9872 
        if ftype == TType.I64:
9873 
          self.warehouseId = iprot.readI64();
9874 
        else:
9875 
          iprot.skip(ftype)
9876 
      else:
9877 
        iprot.skip(ftype)
9878 
      iprot.readFieldEnd()
9879 
    iprot.readStructEnd()
9880 
 
9881 
  def write(self, oprot):
9882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9884 
      return
9885 
    oprot.writeStructBegin('getOrderCount_args')
9886 
    if self.statuses is not None:
9887 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9888 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9889 
      for iter154 in self.statuses:
9890 
        oprot.writeI32(iter154)
4133 chandransh 9891 
      oprot.writeListEnd()
9892 
      oprot.writeFieldEnd()
9893 
    if self.warehouseId is not None:
9894 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
9895 
      oprot.writeI64(self.warehouseId)
9896 
      oprot.writeFieldEnd()
9897 
    oprot.writeFieldStop()
9898 
    oprot.writeStructEnd()
9899 
 
9900 
  def validate(self):
9901 
    return
9902 
 
9903 
 
9904 
  def __repr__(self):
9905 
    L = ['%s=%r' % (key, value)
9906 
      for key, value in self.__dict__.iteritems()]
9907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9908 
 
9909 
  def __eq__(self, other):
9910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9911 
 
9912 
  def __ne__(self, other):
9913 
    return not (self == other)
9914 
 
9915 
class getOrderCount_result:
9916 
  """
9917 
  Attributes:
9918 
   - success
9919 
   - ex
9920 
  """
9921 
 
9922 
  thrift_spec = (
9923 
    (0, TType.I32, 'success', None, None, ), # 0
9924 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9925 
  )
9926 
 
9927 
  def __init__(self, success=None, ex=None,):
9928 
    self.success = success
9929 
    self.ex = ex
9930 
 
9931 
  def read(self, iprot):
9932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9934 
      return
9935 
    iprot.readStructBegin()
9936 
    while True:
9937 
      (fname, ftype, fid) = iprot.readFieldBegin()
9938 
      if ftype == TType.STOP:
9939 
        break
9940 
      if fid == 0:
9941 
        if ftype == TType.I32:
9942 
          self.success = iprot.readI32();
9943 
        else:
9944 
          iprot.skip(ftype)
9945 
      elif fid == 1:
9946 
        if ftype == TType.STRUCT:
9947 
          self.ex = TransactionServiceException()
9948 
          self.ex.read(iprot)
9949 
        else:
9950 
          iprot.skip(ftype)
9951 
      else:
9952 
        iprot.skip(ftype)
9953 
      iprot.readFieldEnd()
9954 
    iprot.readStructEnd()
9955 
 
9956 
  def write(self, oprot):
9957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9959 
      return
9960 
    oprot.writeStructBegin('getOrderCount_result')
9961 
    if self.success is not None:
9962 
      oprot.writeFieldBegin('success', TType.I32, 0)
9963 
      oprot.writeI32(self.success)
9964 
      oprot.writeFieldEnd()
9965 
    if self.ex is not None:
9966 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9967 
      self.ex.write(oprot)
9968 
      oprot.writeFieldEnd()
9969 
    oprot.writeFieldStop()
9970 
    oprot.writeStructEnd()
9971 
 
9972 
  def validate(self):
9973 
    return
9974 
 
9975 
 
9976 
  def __repr__(self):
9977 
    L = ['%s=%r' % (key, value)
9978 
      for key, value in self.__dict__.iteritems()]
9979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9980 
 
9981 
  def __eq__(self, other):
9982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9983 
 
9984 
  def __ne__(self, other):
9985 
    return not (self == other)
9986 
 
999 varun.gupt 9987 
class getOrdersByBillingDate_args:
9988 
  """
9989 
  Attributes:
9990 
   - status
9991 
   - start_billing_date
9992 
   - end_billing_date
9993 
   - warehouse_id
9994 
  """
9995 
 
9996 
  thrift_spec = (
9997 
    None, # 0
9998 
    (1, TType.I32, 'status', None, None, ), # 1
9999 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
10000 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
10001 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10002 
  )
10003 
 
10004 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
10005 
    self.status = status
10006 
    self.start_billing_date = start_billing_date
10007 
    self.end_billing_date = end_billing_date
10008 
    self.warehouse_id = warehouse_id
10009 
 
10010 
  def read(self, iprot):
10011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10013 
      return
10014 
    iprot.readStructBegin()
10015 
    while True:
10016 
      (fname, ftype, fid) = iprot.readFieldBegin()
10017 
      if ftype == TType.STOP:
10018 
        break
10019 
      if fid == 1:
10020 
        if ftype == TType.I32:
10021 
          self.status = iprot.readI32();
10022 
        else:
10023 
          iprot.skip(ftype)
10024 
      elif fid == 2:
10025 
        if ftype == TType.I64:
10026 
          self.start_billing_date = iprot.readI64();
10027 
        else:
10028 
          iprot.skip(ftype)
10029 
      elif fid == 3:
10030 
        if ftype == TType.I64:
10031 
          self.end_billing_date = iprot.readI64();
10032 
        else:
10033 
          iprot.skip(ftype)
10034 
      elif fid == 4:
10035 
        if ftype == TType.I64:
10036 
          self.warehouse_id = iprot.readI64();
10037 
        else:
10038 
          iprot.skip(ftype)
10039 
      else:
10040 
        iprot.skip(ftype)
10041 
      iprot.readFieldEnd()
10042 
    iprot.readStructEnd()
10043 
 
10044 
  def write(self, oprot):
10045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10047 
      return
10048 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 10049 
    if self.status is not None:
999 varun.gupt 10050 
      oprot.writeFieldBegin('status', TType.I32, 1)
10051 
      oprot.writeI32(self.status)
10052 
      oprot.writeFieldEnd()
3431 rajveer 10053 
    if self.start_billing_date is not None:
999 varun.gupt 10054 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
10055 
      oprot.writeI64(self.start_billing_date)
10056 
      oprot.writeFieldEnd()
3431 rajveer 10057 
    if self.end_billing_date is not None:
999 varun.gupt 10058 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
10059 
      oprot.writeI64(self.end_billing_date)
10060 
      oprot.writeFieldEnd()
3431 rajveer 10061 
    if self.warehouse_id is not None:
999 varun.gupt 10062 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10063 
      oprot.writeI64(self.warehouse_id)
10064 
      oprot.writeFieldEnd()
10065 
    oprot.writeFieldStop()
10066 
    oprot.writeStructEnd()
10067 
 
3431 rajveer 10068 
  def validate(self):
10069 
    return
10070 
 
10071 
 
999 varun.gupt 10072 
  def __repr__(self):
10073 
    L = ['%s=%r' % (key, value)
10074 
      for key, value in self.__dict__.iteritems()]
10075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10076 
 
10077 
  def __eq__(self, other):
10078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10079 
 
10080 
  def __ne__(self, other):
10081 
    return not (self == other)
10082 
 
10083 
class getOrdersByBillingDate_result:
10084 
  """
10085 
  Attributes:
10086 
   - success
10087 
   - ex
10088 
  """
10089 
 
10090 
  thrift_spec = (
10091 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10092 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10093 
  )
10094 
 
10095 
  def __init__(self, success=None, ex=None,):
10096 
    self.success = success
10097 
    self.ex = ex
10098 
 
10099 
  def read(self, iprot):
10100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10102 
      return
10103 
    iprot.readStructBegin()
10104 
    while True:
10105 
      (fname, ftype, fid) = iprot.readFieldBegin()
10106 
      if ftype == TType.STOP:
10107 
        break
10108 
      if fid == 0:
10109 
        if ftype == TType.LIST:
10110 
          self.success = []
6188 rajveer 10111 
          (_etype158, _size155) = iprot.readListBegin()
10112 
          for _i159 in xrange(_size155):
10113 
            _elem160 = Order()
10114 
            _elem160.read(iprot)
10115 
            self.success.append(_elem160)
999 varun.gupt 10116 
          iprot.readListEnd()
10117 
        else:
10118 
          iprot.skip(ftype)
10119 
      elif fid == 1:
10120 
        if ftype == TType.STRUCT:
10121 
          self.ex = TransactionServiceException()
10122 
          self.ex.read(iprot)
10123 
        else:
10124 
          iprot.skip(ftype)
10125 
      else:
10126 
        iprot.skip(ftype)
10127 
      iprot.readFieldEnd()
10128 
    iprot.readStructEnd()
10129 
 
10130 
  def write(self, oprot):
10131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10133 
      return
10134 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 10135 
    if self.success is not None:
999 varun.gupt 10136 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10137 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10138 
      for iter161 in self.success:
10139 
        iter161.write(oprot)
999 varun.gupt 10140 
      oprot.writeListEnd()
10141 
      oprot.writeFieldEnd()
3431 rajveer 10142 
    if self.ex is not None:
999 varun.gupt 10143 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10144 
      self.ex.write(oprot)
10145 
      oprot.writeFieldEnd()
10146 
    oprot.writeFieldStop()
10147 
    oprot.writeStructEnd()
10148 
 
3431 rajveer 10149 
  def validate(self):
10150 
    return
10151 
 
10152 
 
999 varun.gupt 10153 
  def __repr__(self):
10154 
    L = ['%s=%r' % (key, value)
10155 
      for key, value in self.__dict__.iteritems()]
10156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10157 
 
10158 
  def __eq__(self, other):
10159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10160 
 
10161 
  def __ne__(self, other):
10162 
    return not (self == other)
10163 
 
3427 chandransh 10164 
class getOrdersByShippingDate_args:
10165 
  """
10166 
  Attributes:
10167 
   - fromShippingDate
10168 
   - toShippingDate
10169 
   - providerId
10170 
   - warehouseId
3451 chandransh 10171 
   - cod
3427 chandransh 10172 
  """
10173 
 
10174 
  thrift_spec = (
10175 
    None, # 0
10176 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
10177 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
10178 
    (3, TType.I64, 'providerId', None, None, ), # 3
10179 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 10180 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 10181 
  )
10182 
 
3451 chandransh 10183 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 10184 
    self.fromShippingDate = fromShippingDate
10185 
    self.toShippingDate = toShippingDate
10186 
    self.providerId = providerId
10187 
    self.warehouseId = warehouseId
3451 chandransh 10188 
    self.cod = cod
3427 chandransh 10189 
 
10190 
  def read(self, iprot):
10191 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10192 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10193 
      return
10194 
    iprot.readStructBegin()
10195 
    while True:
10196 
      (fname, ftype, fid) = iprot.readFieldBegin()
10197 
      if ftype == TType.STOP:
10198 
        break
10199 
      if fid == 1:
10200 
        if ftype == TType.I64:
10201 
          self.fromShippingDate = iprot.readI64();
10202 
        else:
10203 
          iprot.skip(ftype)
10204 
      elif fid == 2:
10205 
        if ftype == TType.I64:
10206 
          self.toShippingDate = iprot.readI64();
10207 
        else:
10208 
          iprot.skip(ftype)
10209 
      elif fid == 3:
10210 
        if ftype == TType.I64:
10211 
          self.providerId = iprot.readI64();
10212 
        else:
10213 
          iprot.skip(ftype)
10214 
      elif fid == 4:
10215 
        if ftype == TType.I64:
10216 
          self.warehouseId = iprot.readI64();
10217 
        else:
10218 
          iprot.skip(ftype)
3451 chandransh 10219 
      elif fid == 5:
10220 
        if ftype == TType.BOOL:
10221 
          self.cod = iprot.readBool();
10222 
        else:
10223 
          iprot.skip(ftype)
3427 chandransh 10224 
      else:
10225 
        iprot.skip(ftype)
10226 
      iprot.readFieldEnd()
10227 
    iprot.readStructEnd()
10228 
 
10229 
  def write(self, oprot):
10230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10232 
      return
10233 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 10234 
    if self.fromShippingDate is not None:
3427 chandransh 10235 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
10236 
      oprot.writeI64(self.fromShippingDate)
10237 
      oprot.writeFieldEnd()
3431 rajveer 10238 
    if self.toShippingDate is not None:
3427 chandransh 10239 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
10240 
      oprot.writeI64(self.toShippingDate)
10241 
      oprot.writeFieldEnd()
3431 rajveer 10242 
    if self.providerId is not None:
3427 chandransh 10243 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
10244 
      oprot.writeI64(self.providerId)
10245 
      oprot.writeFieldEnd()
3431 rajveer 10246 
    if self.warehouseId is not None:
3427 chandransh 10247 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
10248 
      oprot.writeI64(self.warehouseId)
10249 
      oprot.writeFieldEnd()
3451 chandransh 10250 
    if self.cod is not None:
10251 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
10252 
      oprot.writeBool(self.cod)
10253 
      oprot.writeFieldEnd()
3427 chandransh 10254 
    oprot.writeFieldStop()
10255 
    oprot.writeStructEnd()
10256 
 
3431 rajveer 10257 
  def validate(self):
10258 
    return
10259 
 
10260 
 
3427 chandransh 10261 
  def __repr__(self):
10262 
    L = ['%s=%r' % (key, value)
10263 
      for key, value in self.__dict__.iteritems()]
10264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10265 
 
10266 
  def __eq__(self, other):
10267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10268 
 
10269 
  def __ne__(self, other):
10270 
    return not (self == other)
10271 
 
10272 
class getOrdersByShippingDate_result:
10273 
  """
10274 
  Attributes:
10275 
   - success
10276 
   - ex
10277 
  """
10278 
 
10279 
  thrift_spec = (
10280 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10281 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10282 
  )
10283 
 
10284 
  def __init__(self, success=None, ex=None,):
10285 
    self.success = success
10286 
    self.ex = ex
10287 
 
10288 
  def read(self, iprot):
10289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10291 
      return
10292 
    iprot.readStructBegin()
10293 
    while True:
10294 
      (fname, ftype, fid) = iprot.readFieldBegin()
10295 
      if ftype == TType.STOP:
10296 
        break
10297 
      if fid == 0:
10298 
        if ftype == TType.LIST:
10299 
          self.success = []
6188 rajveer 10300 
          (_etype165, _size162) = iprot.readListBegin()
10301 
          for _i166 in xrange(_size162):
10302 
            _elem167 = Order()
10303 
            _elem167.read(iprot)
10304 
            self.success.append(_elem167)
3427 chandransh 10305 
          iprot.readListEnd()
10306 
        else:
10307 
          iprot.skip(ftype)
10308 
      elif fid == 1:
10309 
        if ftype == TType.STRUCT:
10310 
          self.ex = TransactionServiceException()
10311 
          self.ex.read(iprot)
10312 
        else:
10313 
          iprot.skip(ftype)
10314 
      else:
10315 
        iprot.skip(ftype)
10316 
      iprot.readFieldEnd()
10317 
    iprot.readStructEnd()
10318 
 
10319 
  def write(self, oprot):
10320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10322 
      return
10323 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10324 
    if self.success is not None:
3427 chandransh 10325 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10326 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10327 
      for iter168 in self.success:
10328 
        iter168.write(oprot)
3427 chandransh 10329 
      oprot.writeListEnd()
10330 
      oprot.writeFieldEnd()
3431 rajveer 10331 
    if self.ex is not None:
3427 chandransh 10332 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10333 
      self.ex.write(oprot)
10334 
      oprot.writeFieldEnd()
10335 
    oprot.writeFieldStop()
10336 
    oprot.writeStructEnd()
10337 
 
3431 rajveer 10338 
  def validate(self):
10339 
    return
10340 
 
10341 
 
3427 chandransh 10342 
  def __repr__(self):
10343 
    L = ['%s=%r' % (key, value)
10344 
      for key, value in self.__dict__.iteritems()]
10345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10346 
 
10347 
  def __eq__(self, other):
10348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10349 
 
10350 
  def __ne__(self, other):
10351 
    return not (self == other)
10352 
 
1382 varun.gupt 10353 
class getReturnableOrdersForCustomer_args:
10354 
  """
10355 
  Attributes:
10356 
   - customer_id
10357 
   - limit
10358 
  """
10359 
 
10360 
  thrift_spec = (
10361 
    None, # 0
10362 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10363 
    (2, TType.I64, 'limit', None, None, ), # 2
10364 
  )
10365 
 
10366 
  def __init__(self, customer_id=None, limit=None,):
10367 
    self.customer_id = customer_id
10368 
    self.limit = limit
10369 
 
10370 
  def read(self, iprot):
10371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10373 
      return
10374 
    iprot.readStructBegin()
10375 
    while True:
10376 
      (fname, ftype, fid) = iprot.readFieldBegin()
10377 
      if ftype == TType.STOP:
10378 
        break
10379 
      if fid == 1:
10380 
        if ftype == TType.I64:
10381 
          self.customer_id = iprot.readI64();
10382 
        else:
10383 
          iprot.skip(ftype)
10384 
      elif fid == 2:
10385 
        if ftype == TType.I64:
10386 
          self.limit = iprot.readI64();
10387 
        else:
10388 
          iprot.skip(ftype)
10389 
      else:
10390 
        iprot.skip(ftype)
10391 
      iprot.readFieldEnd()
10392 
    iprot.readStructEnd()
10393 
 
10394 
  def write(self, oprot):
10395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10397 
      return
10398 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 10399 
    if self.customer_id is not None:
1382 varun.gupt 10400 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10401 
      oprot.writeI64(self.customer_id)
10402 
      oprot.writeFieldEnd()
3431 rajveer 10403 
    if self.limit is not None:
1382 varun.gupt 10404 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10405 
      oprot.writeI64(self.limit)
10406 
      oprot.writeFieldEnd()
10407 
    oprot.writeFieldStop()
10408 
    oprot.writeStructEnd()
10409 
 
3431 rajveer 10410 
  def validate(self):
10411 
    return
10412 
 
10413 
 
1382 varun.gupt 10414 
  def __repr__(self):
10415 
    L = ['%s=%r' % (key, value)
10416 
      for key, value in self.__dict__.iteritems()]
10417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10418 
 
10419 
  def __eq__(self, other):
10420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10421 
 
10422 
  def __ne__(self, other):
10423 
    return not (self == other)
10424 
 
10425 
class getReturnableOrdersForCustomer_result:
10426 
  """
10427 
  Attributes:
10428 
   - success
10429 
   - ex
10430 
  """
10431 
 
10432 
  thrift_spec = (
10433 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10434 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10435 
  )
10436 
 
10437 
  def __init__(self, success=None, ex=None,):
10438 
    self.success = success
10439 
    self.ex = ex
10440 
 
10441 
  def read(self, iprot):
10442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10444 
      return
10445 
    iprot.readStructBegin()
10446 
    while True:
10447 
      (fname, ftype, fid) = iprot.readFieldBegin()
10448 
      if ftype == TType.STOP:
10449 
        break
10450 
      if fid == 0:
10451 
        if ftype == TType.LIST:
10452 
          self.success = []
6188 rajveer 10453 
          (_etype172, _size169) = iprot.readListBegin()
10454 
          for _i173 in xrange(_size169):
10455 
            _elem174 = iprot.readI64();
10456 
            self.success.append(_elem174)
1382 varun.gupt 10457 
          iprot.readListEnd()
10458 
        else:
10459 
          iprot.skip(ftype)
10460 
      elif fid == 1:
10461 
        if ftype == TType.STRUCT:
10462 
          self.ex = TransactionServiceException()
10463 
          self.ex.read(iprot)
10464 
        else:
10465 
          iprot.skip(ftype)
10466 
      else:
10467 
        iprot.skip(ftype)
10468 
      iprot.readFieldEnd()
10469 
    iprot.readStructEnd()
10470 
 
10471 
  def write(self, oprot):
10472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10474 
      return
10475 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10476 
    if self.success is not None:
1382 varun.gupt 10477 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10478 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10479 
      for iter175 in self.success:
10480 
        oprot.writeI64(iter175)
1382 varun.gupt 10481 
      oprot.writeListEnd()
10482 
      oprot.writeFieldEnd()
3431 rajveer 10483 
    if self.ex is not None:
1382 varun.gupt 10484 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10485 
      self.ex.write(oprot)
10486 
      oprot.writeFieldEnd()
10487 
    oprot.writeFieldStop()
10488 
    oprot.writeStructEnd()
10489 
 
3431 rajveer 10490 
  def validate(self):
10491 
    return
10492 
 
10493 
 
1382 varun.gupt 10494 
  def __repr__(self):
10495 
    L = ['%s=%r' % (key, value)
10496 
      for key, value in self.__dict__.iteritems()]
10497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10498 
 
10499 
  def __eq__(self, other):
10500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10501 
 
10502 
  def __ne__(self, other):
10503 
    return not (self == other)
10504 
 
10505 
class getCancellableOrdersForCustomer_args:
10506 
  """
10507 
  Attributes:
10508 
   - customer_id
10509 
   - limit
10510 
  """
10511 
 
10512 
  thrift_spec = (
10513 
    None, # 0
10514 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10515 
    (2, TType.I64, 'limit', None, None, ), # 2
10516 
  )
10517 
 
10518 
  def __init__(self, customer_id=None, limit=None,):
10519 
    self.customer_id = customer_id
10520 
    self.limit = limit
10521 
 
10522 
  def read(self, iprot):
10523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10525 
      return
10526 
    iprot.readStructBegin()
10527 
    while True:
10528 
      (fname, ftype, fid) = iprot.readFieldBegin()
10529 
      if ftype == TType.STOP:
10530 
        break
10531 
      if fid == 1:
10532 
        if ftype == TType.I64:
10533 
          self.customer_id = iprot.readI64();
10534 
        else:
10535 
          iprot.skip(ftype)
10536 
      elif fid == 2:
10537 
        if ftype == TType.I64:
10538 
          self.limit = iprot.readI64();
10539 
        else:
10540 
          iprot.skip(ftype)
10541 
      else:
10542 
        iprot.skip(ftype)
10543 
      iprot.readFieldEnd()
10544 
    iprot.readStructEnd()
10545 
 
10546 
  def write(self, oprot):
10547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10549 
      return
10550 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 10551 
    if self.customer_id is not None:
1382 varun.gupt 10552 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10553 
      oprot.writeI64(self.customer_id)
10554 
      oprot.writeFieldEnd()
3431 rajveer 10555 
    if self.limit is not None:
1382 varun.gupt 10556 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10557 
      oprot.writeI64(self.limit)
10558 
      oprot.writeFieldEnd()
10559 
    oprot.writeFieldStop()
10560 
    oprot.writeStructEnd()
10561 
 
3431 rajveer 10562 
  def validate(self):
10563 
    return
10564 
 
10565 
 
1382 varun.gupt 10566 
  def __repr__(self):
10567 
    L = ['%s=%r' % (key, value)
10568 
      for key, value in self.__dict__.iteritems()]
10569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10570 
 
10571 
  def __eq__(self, other):
10572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10573 
 
10574 
  def __ne__(self, other):
10575 
    return not (self == other)
10576 
 
10577 
class getCancellableOrdersForCustomer_result:
10578 
  """
10579 
  Attributes:
10580 
   - success
10581 
   - ex
10582 
  """
10583 
 
10584 
  thrift_spec = (
10585 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10586 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10587 
  )
10588 
 
10589 
  def __init__(self, success=None, ex=None,):
10590 
    self.success = success
10591 
    self.ex = ex
10592 
 
10593 
  def read(self, iprot):
10594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10596 
      return
10597 
    iprot.readStructBegin()
10598 
    while True:
10599 
      (fname, ftype, fid) = iprot.readFieldBegin()
10600 
      if ftype == TType.STOP:
10601 
        break
10602 
      if fid == 0:
10603 
        if ftype == TType.LIST:
10604 
          self.success = []
6188 rajveer 10605 
          (_etype179, _size176) = iprot.readListBegin()
10606 
          for _i180 in xrange(_size176):
10607 
            _elem181 = iprot.readI64();
10608 
            self.success.append(_elem181)
1382 varun.gupt 10609 
          iprot.readListEnd()
10610 
        else:
10611 
          iprot.skip(ftype)
10612 
      elif fid == 1:
10613 
        if ftype == TType.STRUCT:
10614 
          self.ex = TransactionServiceException()
10615 
          self.ex.read(iprot)
10616 
        else:
10617 
          iprot.skip(ftype)
10618 
      else:
10619 
        iprot.skip(ftype)
10620 
      iprot.readFieldEnd()
10621 
    iprot.readStructEnd()
10622 
 
10623 
  def write(self, oprot):
10624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10626 
      return
10627 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 10628 
    if self.success is not None:
1382 varun.gupt 10629 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10630 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10631 
      for iter182 in self.success:
10632 
        oprot.writeI64(iter182)
1382 varun.gupt 10633 
      oprot.writeListEnd()
10634 
      oprot.writeFieldEnd()
3431 rajveer 10635 
    if self.ex is not None:
1382 varun.gupt 10636 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10637 
      self.ex.write(oprot)
10638 
      oprot.writeFieldEnd()
10639 
    oprot.writeFieldStop()
10640 
    oprot.writeStructEnd()
10641 
 
3431 rajveer 10642 
  def validate(self):
10643 
    return
10644 
 
10645 
 
1382 varun.gupt 10646 
  def __repr__(self):
10647 
    L = ['%s=%r' % (key, value)
10648 
      for key, value in self.__dict__.iteritems()]
10649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10650 
 
10651 
  def __eq__(self, other):
10652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10653 
 
10654 
  def __ne__(self, other):
10655 
    return not (self == other)
10656 
 
483 rajveer 10657 
class changeOrderStatus_args:
94 ashish 10658 
  """
10659 
  Attributes:
483 rajveer 10660 
   - orderId
10661 
   - status
10662 
   - description
94 ashish 10663 
  """
10664 
 
10665 
  thrift_spec = (
10666 
    None, # 0
483 rajveer 10667 
    (1, TType.I64, 'orderId', None, None, ), # 1
10668 
    (2, TType.I32, 'status', None, None, ), # 2
10669 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10670 
  )
10671 
 
483 rajveer 10672 
  def __init__(self, orderId=None, status=None, description=None,):
10673 
    self.orderId = orderId
10674 
    self.status = status
10675 
    self.description = description
94 ashish 10676 
 
10677 
  def read(self, iprot):
10678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10680 
      return
10681 
    iprot.readStructBegin()
10682 
    while True:
10683 
      (fname, ftype, fid) = iprot.readFieldBegin()
10684 
      if ftype == TType.STOP:
10685 
        break
10686 
      if fid == 1:
10687 
        if ftype == TType.I64:
483 rajveer 10688 
          self.orderId = iprot.readI64();
94 ashish 10689 
        else:
10690 
          iprot.skip(ftype)
10691 
      elif fid == 2:
483 rajveer 10692 
        if ftype == TType.I32:
10693 
          self.status = iprot.readI32();
94 ashish 10694 
        else:
10695 
          iprot.skip(ftype)
483 rajveer 10696 
      elif fid == 3:
10697 
        if ftype == TType.STRING:
10698 
          self.description = iprot.readString();
10699 
        else:
10700 
          iprot.skip(ftype)
94 ashish 10701 
      else:
10702 
        iprot.skip(ftype)
10703 
      iprot.readFieldEnd()
10704 
    iprot.readStructEnd()
10705 
 
10706 
  def write(self, oprot):
10707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10709 
      return
483 rajveer 10710 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 10711 
    if self.orderId is not None:
483 rajveer 10712 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10713 
      oprot.writeI64(self.orderId)
94 ashish 10714 
      oprot.writeFieldEnd()
3431 rajveer 10715 
    if self.status is not None:
483 rajveer 10716 
      oprot.writeFieldBegin('status', TType.I32, 2)
10717 
      oprot.writeI32(self.status)
94 ashish 10718 
      oprot.writeFieldEnd()
3431 rajveer 10719 
    if self.description is not None:
483 rajveer 10720 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10721 
      oprot.writeString(self.description)
10722 
      oprot.writeFieldEnd()
94 ashish 10723 
    oprot.writeFieldStop()
10724 
    oprot.writeStructEnd()
10725 
 
3431 rajveer 10726 
  def validate(self):
10727 
    return
10728 
 
10729 
 
94 ashish 10730 
  def __repr__(self):
10731 
    L = ['%s=%r' % (key, value)
10732 
      for key, value in self.__dict__.iteritems()]
10733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10734 
 
10735 
  def __eq__(self, other):
10736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10737 
 
10738 
  def __ne__(self, other):
10739 
    return not (self == other)
10740 
 
483 rajveer 10741 
class changeOrderStatus_result:
94 ashish 10742 
  """
10743 
  Attributes:
10744 
   - success
10745 
   - ex
10746 
  """
10747 
 
10748 
  thrift_spec = (
10749 
    (0, TType.BOOL, 'success', None, None, ), # 0
10750 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10751 
  )
10752 
 
10753 
  def __init__(self, success=None, ex=None,):
10754 
    self.success = success
10755 
    self.ex = ex
10756 
 
10757 
  def read(self, iprot):
10758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10760 
      return
10761 
    iprot.readStructBegin()
10762 
    while True:
10763 
      (fname, ftype, fid) = iprot.readFieldBegin()
10764 
      if ftype == TType.STOP:
10765 
        break
10766 
      if fid == 0:
10767 
        if ftype == TType.BOOL:
10768 
          self.success = iprot.readBool();
10769 
        else:
10770 
          iprot.skip(ftype)
10771 
      elif fid == 1:
10772 
        if ftype == TType.STRUCT:
10773 
          self.ex = TransactionServiceException()
10774 
          self.ex.read(iprot)
10775 
        else:
10776 
          iprot.skip(ftype)
10777 
      else:
10778 
        iprot.skip(ftype)
10779 
      iprot.readFieldEnd()
10780 
    iprot.readStructEnd()
10781 
 
10782 
  def write(self, oprot):
10783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10785 
      return
483 rajveer 10786 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 10787 
    if self.success is not None:
94 ashish 10788 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10789 
      oprot.writeBool(self.success)
10790 
      oprot.writeFieldEnd()
3431 rajveer 10791 
    if self.ex is not None:
94 ashish 10792 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10793 
      self.ex.write(oprot)
10794 
      oprot.writeFieldEnd()
10795 
    oprot.writeFieldStop()
10796 
    oprot.writeStructEnd()
10797 
 
3431 rajveer 10798 
  def validate(self):
10799 
    return
10800 
 
10801 
 
94 ashish 10802 
  def __repr__(self):
10803 
    L = ['%s=%r' % (key, value)
10804 
      for key, value in self.__dict__.iteritems()]
10805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10806 
 
10807 
  def __eq__(self, other):
10808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10809 
 
10810 
  def __ne__(self, other):
10811 
    return not (self == other)
10812 
 
3064 chandransh 10813 
class getOrdersForTransaction_args:
494 rajveer 10814 
  """
10815 
  Attributes:
3064 chandransh 10816 
   - transactionId
10817 
   - customerId
494 rajveer 10818 
  """
10819 
 
10820 
  thrift_spec = (
10821 
    None, # 0
3064 chandransh 10822 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10823 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 10824 
  )
10825 
 
3064 chandransh 10826 
  def __init__(self, transactionId=None, customerId=None,):
10827 
    self.transactionId = transactionId
10828 
    self.customerId = customerId
494 rajveer 10829 
 
10830 
  def read(self, iprot):
10831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10833 
      return
10834 
    iprot.readStructBegin()
10835 
    while True:
10836 
      (fname, ftype, fid) = iprot.readFieldBegin()
10837 
      if ftype == TType.STOP:
10838 
        break
10839 
      if fid == 1:
10840 
        if ftype == TType.I64:
3064 chandransh 10841 
          self.transactionId = iprot.readI64();
494 rajveer 10842 
        else:
10843 
          iprot.skip(ftype)
10844 
      elif fid == 2:
3064 chandransh 10845 
        if ftype == TType.I64:
10846 
          self.customerId = iprot.readI64();
494 rajveer 10847 
        else:
10848 
          iprot.skip(ftype)
10849 
      else:
10850 
        iprot.skip(ftype)
10851 
      iprot.readFieldEnd()
10852 
    iprot.readStructEnd()
10853 
 
10854 
  def write(self, oprot):
10855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10857 
      return
3064 chandransh 10858 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 10859 
    if self.transactionId is not None:
3064 chandransh 10860 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10861 
      oprot.writeI64(self.transactionId)
494 rajveer 10862 
      oprot.writeFieldEnd()
3431 rajveer 10863 
    if self.customerId is not None:
3064 chandransh 10864 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
10865 
      oprot.writeI64(self.customerId)
494 rajveer 10866 
      oprot.writeFieldEnd()
10867 
    oprot.writeFieldStop()
10868 
    oprot.writeStructEnd()
10869 
 
3431 rajveer 10870 
  def validate(self):
10871 
    return
10872 
 
10873 
 
494 rajveer 10874 
  def __repr__(self):
10875 
    L = ['%s=%r' % (key, value)
10876 
      for key, value in self.__dict__.iteritems()]
10877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10878 
 
10879 
  def __eq__(self, other):
10880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10881 
 
10882 
  def __ne__(self, other):
10883 
    return not (self == other)
10884 
 
3064 chandransh 10885 
class getOrdersForTransaction_result:
494 rajveer 10886 
  """
10887 
  Attributes:
10888 
   - success
10889 
   - ex
10890 
  """
10891 
 
10892 
  thrift_spec = (
3064 chandransh 10893 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 10894 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10895 
  )
10896 
 
10897 
  def __init__(self, success=None, ex=None,):
10898 
    self.success = success
10899 
    self.ex = ex
10900 
 
10901 
  def read(self, iprot):
10902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10904 
      return
10905 
    iprot.readStructBegin()
10906 
    while True:
10907 
      (fname, ftype, fid) = iprot.readFieldBegin()
10908 
      if ftype == TType.STOP:
10909 
        break
10910 
      if fid == 0:
3064 chandransh 10911 
        if ftype == TType.LIST:
10912 
          self.success = []
6188 rajveer 10913 
          (_etype186, _size183) = iprot.readListBegin()
10914 
          for _i187 in xrange(_size183):
10915 
            _elem188 = Order()
10916 
            _elem188.read(iprot)
10917 
            self.success.append(_elem188)
3064 chandransh 10918 
          iprot.readListEnd()
494 rajveer 10919 
        else:
10920 
          iprot.skip(ftype)
10921 
      elif fid == 1:
10922 
        if ftype == TType.STRUCT:
10923 
          self.ex = TransactionServiceException()
10924 
          self.ex.read(iprot)
10925 
        else:
10926 
          iprot.skip(ftype)
10927 
      else:
10928 
        iprot.skip(ftype)
10929 
      iprot.readFieldEnd()
10930 
    iprot.readStructEnd()
10931 
 
10932 
  def write(self, oprot):
10933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10935 
      return
3064 chandransh 10936 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 10937 
    if self.success is not None:
3064 chandransh 10938 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10939 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10940 
      for iter189 in self.success:
10941 
        iter189.write(oprot)
3064 chandransh 10942 
      oprot.writeListEnd()
494 rajveer 10943 
      oprot.writeFieldEnd()
3431 rajveer 10944 
    if self.ex is not None:
494 rajveer 10945 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10946 
      self.ex.write(oprot)
10947 
      oprot.writeFieldEnd()
10948 
    oprot.writeFieldStop()
10949 
    oprot.writeStructEnd()
10950 
 
3431 rajveer 10951 
  def validate(self):
10952 
    return
10953 
 
10954 
 
494 rajveer 10955 
  def __repr__(self):
10956 
    L = ['%s=%r' % (key, value)
10957 
      for key, value in self.__dict__.iteritems()]
10958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10959 
 
10960 
  def __eq__(self, other):
10961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10962 
 
10963 
  def __ne__(self, other):
10964 
    return not (self == other)
10965 
 
3064 chandransh 10966 
class getOrdersForCustomer_args:
1149 chandransh 10967 
  """
10968 
  Attributes:
3064 chandransh 10969 
   - customerId
10970 
   - from_date
10971 
   - to_date
10972 
   - statuses
1149 chandransh 10973 
  """
10974 
 
10975 
  thrift_spec = (
10976 
    None, # 0
3064 chandransh 10977 
    (1, TType.I64, 'customerId', None, None, ), # 1
10978 
    (2, TType.I64, 'from_date', None, None, ), # 2
10979 
    (3, TType.I64, 'to_date', None, None, ), # 3
10980 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 10981 
  )
10982 
 
3064 chandransh 10983 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
10984 
    self.customerId = customerId
10985 
    self.from_date = from_date
10986 
    self.to_date = to_date
10987 
    self.statuses = statuses
1149 chandransh 10988 
 
10989 
  def read(self, iprot):
10990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10992 
      return
10993 
    iprot.readStructBegin()
10994 
    while True:
10995 
      (fname, ftype, fid) = iprot.readFieldBegin()
10996 
      if ftype == TType.STOP:
10997 
        break
10998 
      if fid == 1:
10999 
        if ftype == TType.I64:
3064 chandransh 11000 
          self.customerId = iprot.readI64();
1149 chandransh 11001 
        else:
11002 
          iprot.skip(ftype)
11003 
      elif fid == 2:
11004 
        if ftype == TType.I64:
3064 chandransh 11005 
          self.from_date = iprot.readI64();
1149 chandransh 11006 
        else:
11007 
          iprot.skip(ftype)
2783 chandransh 11008 
      elif fid == 3:
11009 
        if ftype == TType.I64:
3064 chandransh 11010 
          self.to_date = iprot.readI64();
2783 chandransh 11011 
        else:
11012 
          iprot.skip(ftype)
11013 
      elif fid == 4:
3064 chandransh 11014 
        if ftype == TType.LIST:
11015 
          self.statuses = []
6188 rajveer 11016 
          (_etype193, _size190) = iprot.readListBegin()
11017 
          for _i194 in xrange(_size190):
11018 
            _elem195 = iprot.readI32();
11019 
            self.statuses.append(_elem195)
3064 chandransh 11020 
          iprot.readListEnd()
2783 chandransh 11021 
        else:
11022 
          iprot.skip(ftype)
1149 chandransh 11023 
      else:
11024 
        iprot.skip(ftype)
11025 
      iprot.readFieldEnd()
11026 
    iprot.readStructEnd()
11027 
 
11028 
  def write(self, oprot):
11029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11031 
      return
3064 chandransh 11032 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 11033 
    if self.customerId is not None:
3064 chandransh 11034 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
11035 
      oprot.writeI64(self.customerId)
1149 chandransh 11036 
      oprot.writeFieldEnd()
3431 rajveer 11037 
    if self.from_date is not None:
3064 chandransh 11038 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
11039 
      oprot.writeI64(self.from_date)
1149 chandransh 11040 
      oprot.writeFieldEnd()
3431 rajveer 11041 
    if self.to_date is not None:
3064 chandransh 11042 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
11043 
      oprot.writeI64(self.to_date)
2783 chandransh 11044 
      oprot.writeFieldEnd()
3431 rajveer 11045 
    if self.statuses is not None:
3064 chandransh 11046 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
11047 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11048 
      for iter196 in self.statuses:
11049 
        oprot.writeI32(iter196)
3064 chandransh 11050 
      oprot.writeListEnd()
2783 chandransh 11051 
      oprot.writeFieldEnd()
1149 chandransh 11052 
    oprot.writeFieldStop()
11053 
    oprot.writeStructEnd()
11054 
 
3431 rajveer 11055 
  def validate(self):
11056 
    return
11057 
 
11058 
 
1149 chandransh 11059 
  def __repr__(self):
11060 
    L = ['%s=%r' % (key, value)
11061 
      for key, value in self.__dict__.iteritems()]
11062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11063 
 
11064 
  def __eq__(self, other):
11065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11066 
 
11067 
  def __ne__(self, other):
11068 
    return not (self == other)
11069 
 
3064 chandransh 11070 
class getOrdersForCustomer_result:
1149 chandransh 11071 
  """
11072 
  Attributes:
11073 
   - success
11074 
   - ex
11075 
  """
11076 
 
11077 
  thrift_spec = (
3064 chandransh 11078 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 11079 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11080 
  )
11081 
 
11082 
  def __init__(self, success=None, ex=None,):
11083 
    self.success = success
11084 
    self.ex = ex
11085 
 
11086 
  def read(self, iprot):
11087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11089 
      return
11090 
    iprot.readStructBegin()
11091 
    while True:
11092 
      (fname, ftype, fid) = iprot.readFieldBegin()
11093 
      if ftype == TType.STOP:
11094 
        break
11095 
      if fid == 0:
3064 chandransh 11096 
        if ftype == TType.LIST:
11097 
          self.success = []
6188 rajveer 11098 
          (_etype200, _size197) = iprot.readListBegin()
11099 
          for _i201 in xrange(_size197):
11100 
            _elem202 = Order()
11101 
            _elem202.read(iprot)
11102 
            self.success.append(_elem202)
3064 chandransh 11103 
          iprot.readListEnd()
1149 chandransh 11104 
        else:
11105 
          iprot.skip(ftype)
11106 
      elif fid == 1:
11107 
        if ftype == TType.STRUCT:
11108 
          self.ex = TransactionServiceException()
11109 
          self.ex.read(iprot)
11110 
        else:
11111 
          iprot.skip(ftype)
11112 
      else:
11113 
        iprot.skip(ftype)
11114 
      iprot.readFieldEnd()
11115 
    iprot.readStructEnd()
11116 
 
11117 
  def write(self, oprot):
11118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11120 
      return
3064 chandransh 11121 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 11122 
    if self.success is not None:
3064 chandransh 11123 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11124 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11125 
      for iter203 in self.success:
11126 
        iter203.write(oprot)
3064 chandransh 11127 
      oprot.writeListEnd()
1149 chandransh 11128 
      oprot.writeFieldEnd()
3431 rajveer 11129 
    if self.ex is not None:
1149 chandransh 11130 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11131 
      self.ex.write(oprot)
11132 
      oprot.writeFieldEnd()
11133 
    oprot.writeFieldStop()
11134 
    oprot.writeStructEnd()
11135 
 
3431 rajveer 11136 
  def validate(self):
11137 
    return
11138 
 
11139 
 
1149 chandransh 11140 
  def __repr__(self):
11141 
    L = ['%s=%r' % (key, value)
11142 
      for key, value in self.__dict__.iteritems()]
11143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11144 
 
11145 
  def __eq__(self, other):
11146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11147 
 
11148 
  def __ne__(self, other):
11149 
    return not (self == other)
11150 
 
3064 chandransh 11151 
class createOrder_args:
921 rajveer 11152 
  """
11153 
  Attributes:
3064 chandransh 11154 
   - order
921 rajveer 11155 
  """
11156 
 
11157 
  thrift_spec = (
11158 
    None, # 0
3064 chandransh 11159 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 11160 
  )
11161 
 
3064 chandransh 11162 
  def __init__(self, order=None,):
11163 
    self.order = order
921 rajveer 11164 
 
11165 
  def read(self, iprot):
11166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11168 
      return
11169 
    iprot.readStructBegin()
11170 
    while True:
11171 
      (fname, ftype, fid) = iprot.readFieldBegin()
11172 
      if ftype == TType.STOP:
11173 
        break
11174 
      if fid == 1:
3064 chandransh 11175 
        if ftype == TType.STRUCT:
11176 
          self.order = Order()
11177 
          self.order.read(iprot)
921 rajveer 11178 
        else:
11179 
          iprot.skip(ftype)
11180 
      else:
11181 
        iprot.skip(ftype)
11182 
      iprot.readFieldEnd()
11183 
    iprot.readStructEnd()
11184 
 
11185 
  def write(self, oprot):
11186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11188 
      return
3064 chandransh 11189 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 11190 
    if self.order is not None:
3064 chandransh 11191 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
11192 
      self.order.write(oprot)
921 rajveer 11193 
      oprot.writeFieldEnd()
11194 
    oprot.writeFieldStop()
11195 
    oprot.writeStructEnd()
11196 
 
3431 rajveer 11197 
  def validate(self):
11198 
    return
11199 
 
11200 
 
921 rajveer 11201 
  def __repr__(self):
11202 
    L = ['%s=%r' % (key, value)
11203 
      for key, value in self.__dict__.iteritems()]
11204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11205 
 
11206 
  def __eq__(self, other):
11207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11208 
 
11209 
  def __ne__(self, other):
11210 
    return not (self == other)
11211 
 
3064 chandransh 11212 
class createOrder_result:
921 rajveer 11213 
  """
11214 
  Attributes:
11215 
   - success
11216 
   - ex
11217 
  """
11218 
 
11219 
  thrift_spec = (
3064 chandransh 11220 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 11221 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11222 
  )
11223 
 
11224 
  def __init__(self, success=None, ex=None,):
11225 
    self.success = success
11226 
    self.ex = ex
11227 
 
11228 
  def read(self, iprot):
11229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11231 
      return
11232 
    iprot.readStructBegin()
11233 
    while True:
11234 
      (fname, ftype, fid) = iprot.readFieldBegin()
11235 
      if ftype == TType.STOP:
11236 
        break
11237 
      if fid == 0:
3064 chandransh 11238 
        if ftype == TType.I64:
11239 
          self.success = iprot.readI64();
921 rajveer 11240 
        else:
11241 
          iprot.skip(ftype)
11242 
      elif fid == 1:
11243 
        if ftype == TType.STRUCT:
11244 
          self.ex = TransactionServiceException()
11245 
          self.ex.read(iprot)
11246 
        else:
11247 
          iprot.skip(ftype)
11248 
      else:
11249 
        iprot.skip(ftype)
11250 
      iprot.readFieldEnd()
11251 
    iprot.readStructEnd()
11252 
 
11253 
  def write(self, oprot):
11254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11256 
      return
3064 chandransh 11257 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 11258 
    if self.success is not None:
3064 chandransh 11259 
      oprot.writeFieldBegin('success', TType.I64, 0)
11260 
      oprot.writeI64(self.success)
921 rajveer 11261 
      oprot.writeFieldEnd()
3431 rajveer 11262 
    if self.ex is not None:
921 rajveer 11263 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11264 
      self.ex.write(oprot)
11265 
      oprot.writeFieldEnd()
11266 
    oprot.writeFieldStop()
11267 
    oprot.writeStructEnd()
11268 
 
3431 rajveer 11269 
  def validate(self):
11270 
    return
11271 
 
11272 
 
921 rajveer 11273 
  def __repr__(self):
11274 
    L = ['%s=%r' % (key, value)
11275 
      for key, value in self.__dict__.iteritems()]
11276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11277 
 
11278 
  def __eq__(self, other):
11279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11280 
 
11281 
  def __ne__(self, other):
11282 
    return not (self == other)
11283 
 
3064 chandransh 11284 
class getOrder_args:
921 rajveer 11285 
  """
11286 
  Attributes:
3064 chandransh 11287 
   - id
921 rajveer 11288 
  """
11289 
 
11290 
  thrift_spec = (
11291 
    None, # 0
3064 chandransh 11292 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11293 
  )
11294 
 
3064 chandransh 11295 
  def __init__(self, id=None,):
11296 
    self.id = id
921 rajveer 11297 
 
11298 
  def read(self, iprot):
11299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11301 
      return
11302 
    iprot.readStructBegin()
11303 
    while True:
11304 
      (fname, ftype, fid) = iprot.readFieldBegin()
11305 
      if ftype == TType.STOP:
11306 
        break
11307 
      if fid == 1:
11308 
        if ftype == TType.I64:
3064 chandransh 11309 
          self.id = iprot.readI64();
921 rajveer 11310 
        else:
11311 
          iprot.skip(ftype)
11312 
      else:
11313 
        iprot.skip(ftype)
11314 
      iprot.readFieldEnd()
11315 
    iprot.readStructEnd()
11316 
 
11317 
  def write(self, oprot):
11318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11320 
      return
3064 chandransh 11321 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 11322 
    if self.id is not None:
3064 chandransh 11323 
      oprot.writeFieldBegin('id', TType.I64, 1)
11324 
      oprot.writeI64(self.id)
921 rajveer 11325 
      oprot.writeFieldEnd()
11326 
    oprot.writeFieldStop()
11327 
    oprot.writeStructEnd()
11328 
 
3431 rajveer 11329 
  def validate(self):
11330 
    return
11331 
 
11332 
 
921 rajveer 11333 
  def __repr__(self):
11334 
    L = ['%s=%r' % (key, value)
11335 
      for key, value in self.__dict__.iteritems()]
11336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11337 
 
11338 
  def __eq__(self, other):
11339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11340 
 
11341 
  def __ne__(self, other):
11342 
    return not (self == other)
11343 
 
3064 chandransh 11344 
class getOrder_result:
921 rajveer 11345 
  """
11346 
  Attributes:
11347 
   - success
11348 
   - ex
11349 
  """
11350 
 
11351 
  thrift_spec = (
3064 chandransh 11352 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 11353 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11354 
  )
11355 
 
11356 
  def __init__(self, success=None, ex=None,):
11357 
    self.success = success
11358 
    self.ex = ex
11359 
 
11360 
  def read(self, iprot):
11361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11363 
      return
11364 
    iprot.readStructBegin()
11365 
    while True:
11366 
      (fname, ftype, fid) = iprot.readFieldBegin()
11367 
      if ftype == TType.STOP:
11368 
        break
11369 
      if fid == 0:
3064 chandransh 11370 
        if ftype == TType.STRUCT:
11371 
          self.success = Order()
11372 
          self.success.read(iprot)
921 rajveer 11373 
        else:
11374 
          iprot.skip(ftype)
11375 
      elif fid == 1:
11376 
        if ftype == TType.STRUCT:
11377 
          self.ex = TransactionServiceException()
11378 
          self.ex.read(iprot)
11379 
        else:
11380 
          iprot.skip(ftype)
11381 
      else:
11382 
        iprot.skip(ftype)
11383 
      iprot.readFieldEnd()
11384 
    iprot.readStructEnd()
11385 
 
11386 
  def write(self, oprot):
11387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11389 
      return
3064 chandransh 11390 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 11391 
    if self.success is not None:
3064 chandransh 11392 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11393 
      self.success.write(oprot)
921 rajveer 11394 
      oprot.writeFieldEnd()
3431 rajveer 11395 
    if self.ex is not None:
921 rajveer 11396 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11397 
      self.ex.write(oprot)
11398 
      oprot.writeFieldEnd()
11399 
    oprot.writeFieldStop()
11400 
    oprot.writeStructEnd()
11401 
 
3431 rajveer 11402 
  def validate(self):
11403 
    return
11404 
 
11405 
 
921 rajveer 11406 
  def __repr__(self):
11407 
    L = ['%s=%r' % (key, value)
11408 
      for key, value in self.__dict__.iteritems()]
11409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11410 
 
11411 
  def __eq__(self, other):
11412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11413 
 
11414 
  def __ne__(self, other):
11415 
    return not (self == other)
11416 
 
3064 chandransh 11417 
class getLineItemsForOrder_args:
94 ashish 11418 
  """
11419 
  Attributes:
3064 chandransh 11420 
   - orderId
94 ashish 11421 
  """
11422 
 
11423 
  thrift_spec = (
11424 
    None, # 0
3064 chandransh 11425 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11426 
  )
11427 
 
3064 chandransh 11428 
  def __init__(self, orderId=None,):
11429 
    self.orderId = orderId
94 ashish 11430 
 
11431 
  def read(self, iprot):
11432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11434 
      return
11435 
    iprot.readStructBegin()
11436 
    while True:
11437 
      (fname, ftype, fid) = iprot.readFieldBegin()
11438 
      if ftype == TType.STOP:
11439 
        break
11440 
      if fid == 1:
11441 
        if ftype == TType.I64:
3064 chandransh 11442 
          self.orderId = iprot.readI64();
94 ashish 11443 
        else:
11444 
          iprot.skip(ftype)
11445 
      else:
11446 
        iprot.skip(ftype)
11447 
      iprot.readFieldEnd()
11448 
    iprot.readStructEnd()
11449 
 
11450 
  def write(self, oprot):
11451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11453 
      return
3064 chandransh 11454 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 11455 
    if self.orderId is not None:
3064 chandransh 11456 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11457 
      oprot.writeI64(self.orderId)
94 ashish 11458 
      oprot.writeFieldEnd()
11459 
    oprot.writeFieldStop()
11460 
    oprot.writeStructEnd()
11461 
 
3431 rajveer 11462 
  def validate(self):
11463 
    return
11464 
 
11465 
 
94 ashish 11466 
  def __repr__(self):
11467 
    L = ['%s=%r' % (key, value)
11468 
      for key, value in self.__dict__.iteritems()]
11469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11470 
 
11471 
  def __eq__(self, other):
11472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11473 
 
11474 
  def __ne__(self, other):
11475 
    return not (self == other)
11476 
 
3064 chandransh 11477 
class getLineItemsForOrder_result:
94 ashish 11478 
  """
11479 
  Attributes:
11480 
   - success
11481 
   - ex
11482 
  """
11483 
 
11484 
  thrift_spec = (
3064 chandransh 11485 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 11486 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11487 
  )
11488 
 
11489 
  def __init__(self, success=None, ex=None,):
11490 
    self.success = success
11491 
    self.ex = ex
11492 
 
11493 
  def read(self, iprot):
11494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11496 
      return
11497 
    iprot.readStructBegin()
11498 
    while True:
11499 
      (fname, ftype, fid) = iprot.readFieldBegin()
11500 
      if ftype == TType.STOP:
11501 
        break
11502 
      if fid == 0:
483 rajveer 11503 
        if ftype == TType.LIST:
11504 
          self.success = []
6188 rajveer 11505 
          (_etype207, _size204) = iprot.readListBegin()
11506 
          for _i208 in xrange(_size204):
11507 
            _elem209 = LineItem()
11508 
            _elem209.read(iprot)
11509 
            self.success.append(_elem209)
483 rajveer 11510 
          iprot.readListEnd()
94 ashish 11511 
        else:
11512 
          iprot.skip(ftype)
11513 
      elif fid == 1:
11514 
        if ftype == TType.STRUCT:
11515 
          self.ex = TransactionServiceException()
11516 
          self.ex.read(iprot)
11517 
        else:
11518 
          iprot.skip(ftype)
11519 
      else:
11520 
        iprot.skip(ftype)
11521 
      iprot.readFieldEnd()
11522 
    iprot.readStructEnd()
11523 
 
11524 
  def write(self, oprot):
11525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11527 
      return
3064 chandransh 11528 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 11529 
    if self.success is not None:
483 rajveer 11530 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11531 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11532 
      for iter210 in self.success:
11533 
        iter210.write(oprot)
483 rajveer 11534 
      oprot.writeListEnd()
94 ashish 11535 
      oprot.writeFieldEnd()
3431 rajveer 11536 
    if self.ex is not None:
94 ashish 11537 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11538 
      self.ex.write(oprot)
11539 
      oprot.writeFieldEnd()
11540 
    oprot.writeFieldStop()
11541 
    oprot.writeStructEnd()
11542 
 
3431 rajveer 11543 
  def validate(self):
11544 
    return
11545 
 
11546 
 
94 ashish 11547 
  def __repr__(self):
11548 
    L = ['%s=%r' % (key, value)
11549 
      for key, value in self.__dict__.iteritems()]
11550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11551 
 
11552 
  def __eq__(self, other):
11553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11554 
 
11555 
  def __ne__(self, other):
11556 
    return not (self == other)
11557 
 
4999 phani.kuma 11558 
class getOrderList_args:
11559 
  """
11560 
  Attributes:
11561 
   - order_ids
11562 
  """
11563 
 
11564 
  thrift_spec = (
11565 
    None, # 0
11566 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11567 
  )
11568 
 
11569 
  def __init__(self, order_ids=None,):
11570 
    self.order_ids = order_ids
11571 
 
11572 
  def read(self, iprot):
11573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11575 
      return
11576 
    iprot.readStructBegin()
11577 
    while True:
11578 
      (fname, ftype, fid) = iprot.readFieldBegin()
11579 
      if ftype == TType.STOP:
11580 
        break
11581 
      if fid == 1:
11582 
        if ftype == TType.LIST:
11583 
          self.order_ids = []
6188 rajveer 11584 
          (_etype214, _size211) = iprot.readListBegin()
11585 
          for _i215 in xrange(_size211):
11586 
            _elem216 = iprot.readI64();
11587 
            self.order_ids.append(_elem216)
4999 phani.kuma 11588 
          iprot.readListEnd()
11589 
        else:
11590 
          iprot.skip(ftype)
11591 
      else:
11592 
        iprot.skip(ftype)
11593 
      iprot.readFieldEnd()
11594 
    iprot.readStructEnd()
11595 
 
11596 
  def write(self, oprot):
11597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11599 
      return
11600 
    oprot.writeStructBegin('getOrderList_args')
11601 
    if self.order_ids is not None:
11602 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11603 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11604 
      for iter217 in self.order_ids:
11605 
        oprot.writeI64(iter217)
4999 phani.kuma 11606 
      oprot.writeListEnd()
11607 
      oprot.writeFieldEnd()
11608 
    oprot.writeFieldStop()
11609 
    oprot.writeStructEnd()
11610 
 
11611 
  def validate(self):
11612 
    return
11613 
 
11614 
 
11615 
  def __repr__(self):
11616 
    L = ['%s=%r' % (key, value)
11617 
      for key, value in self.__dict__.iteritems()]
11618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11619 
 
11620 
  def __eq__(self, other):
11621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11622 
 
11623 
  def __ne__(self, other):
11624 
    return not (self == other)
11625 
 
11626 
class getOrderList_result:
11627 
  """
11628 
  Attributes:
11629 
   - success
11630 
  """
11631 
 
11632 
  thrift_spec = (
11633 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11634 
  )
11635 
 
11636 
  def __init__(self, success=None,):
11637 
    self.success = success
11638 
 
11639 
  def read(self, iprot):
11640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11642 
      return
11643 
    iprot.readStructBegin()
11644 
    while True:
11645 
      (fname, ftype, fid) = iprot.readFieldBegin()
11646 
      if ftype == TType.STOP:
11647 
        break
11648 
      if fid == 0:
11649 
        if ftype == TType.LIST:
11650 
          self.success = []
6188 rajveer 11651 
          (_etype221, _size218) = iprot.readListBegin()
11652 
          for _i222 in xrange(_size218):
11653 
            _elem223 = Order()
11654 
            _elem223.read(iprot)
11655 
            self.success.append(_elem223)
4999 phani.kuma 11656 
          iprot.readListEnd()
11657 
        else:
11658 
          iprot.skip(ftype)
11659 
      else:
11660 
        iprot.skip(ftype)
11661 
      iprot.readFieldEnd()
11662 
    iprot.readStructEnd()
11663 
 
11664 
  def write(self, oprot):
11665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11667 
      return
11668 
    oprot.writeStructBegin('getOrderList_result')
11669 
    if self.success is not None:
11670 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11671 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11672 
      for iter224 in self.success:
11673 
        iter224.write(oprot)
4999 phani.kuma 11674 
      oprot.writeListEnd()
11675 
      oprot.writeFieldEnd()
11676 
    oprot.writeFieldStop()
11677 
    oprot.writeStructEnd()
11678 
 
11679 
  def validate(self):
11680 
    return
11681 
 
11682 
 
11683 
  def __repr__(self):
11684 
    L = ['%s=%r' % (key, value)
11685 
      for key, value in self.__dict__.iteritems()]
11686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11687 
 
11688 
  def __eq__(self, other):
11689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11690 
 
11691 
  def __ne__(self, other):
11692 
    return not (self == other)
11693 
 
5386 phani.kuma 11694 
class getOrderListForVendor_args:
11695 
  """
11696 
  Attributes:
11697 
   - order_ids
11698 
   - vendorId
11699 
  """
11700 
 
11701 
  thrift_spec = (
11702 
    None, # 0
11703 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11704 
    (2, TType.I64, 'vendorId', None, None, ), # 2
11705 
  )
11706 
 
11707 
  def __init__(self, order_ids=None, vendorId=None,):
11708 
    self.order_ids = order_ids
11709 
    self.vendorId = vendorId
11710 
 
11711 
  def read(self, iprot):
11712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11714 
      return
11715 
    iprot.readStructBegin()
11716 
    while True:
11717 
      (fname, ftype, fid) = iprot.readFieldBegin()
11718 
      if ftype == TType.STOP:
11719 
        break
11720 
      if fid == 1:
11721 
        if ftype == TType.LIST:
11722 
          self.order_ids = []
6188 rajveer 11723 
          (_etype228, _size225) = iprot.readListBegin()
11724 
          for _i229 in xrange(_size225):
11725 
            _elem230 = iprot.readI64();
11726 
            self.order_ids.append(_elem230)
5386 phani.kuma 11727 
          iprot.readListEnd()
11728 
        else:
11729 
          iprot.skip(ftype)
11730 
      elif fid == 2:
11731 
        if ftype == TType.I64:
11732 
          self.vendorId = iprot.readI64();
11733 
        else:
11734 
          iprot.skip(ftype)
11735 
      else:
11736 
        iprot.skip(ftype)
11737 
      iprot.readFieldEnd()
11738 
    iprot.readStructEnd()
11739 
 
11740 
  def write(self, oprot):
11741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11743 
      return
11744 
    oprot.writeStructBegin('getOrderListForVendor_args')
11745 
    if self.order_ids is not None:
11746 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11747 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11748 
      for iter231 in self.order_ids:
11749 
        oprot.writeI64(iter231)
5386 phani.kuma 11750 
      oprot.writeListEnd()
11751 
      oprot.writeFieldEnd()
11752 
    if self.vendorId is not None:
11753 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
11754 
      oprot.writeI64(self.vendorId)
11755 
      oprot.writeFieldEnd()
11756 
    oprot.writeFieldStop()
11757 
    oprot.writeStructEnd()
11758 
 
11759 
  def validate(self):
11760 
    return
11761 
 
11762 
 
11763 
  def __repr__(self):
11764 
    L = ['%s=%r' % (key, value)
11765 
      for key, value in self.__dict__.iteritems()]
11766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11767 
 
11768 
  def __eq__(self, other):
11769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11770 
 
11771 
  def __ne__(self, other):
11772 
    return not (self == other)
11773 
 
11774 
class getOrderListForVendor_result:
11775 
  """
11776 
  Attributes:
11777 
   - success
11778 
  """
11779 
 
11780 
  thrift_spec = (
11781 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11782 
  )
11783 
 
11784 
  def __init__(self, success=None,):
11785 
    self.success = success
11786 
 
11787 
  def read(self, iprot):
11788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11790 
      return
11791 
    iprot.readStructBegin()
11792 
    while True:
11793 
      (fname, ftype, fid) = iprot.readFieldBegin()
11794 
      if ftype == TType.STOP:
11795 
        break
11796 
      if fid == 0:
11797 
        if ftype == TType.LIST:
11798 
          self.success = []
6188 rajveer 11799 
          (_etype235, _size232) = iprot.readListBegin()
11800 
          for _i236 in xrange(_size232):
11801 
            _elem237 = Order()
11802 
            _elem237.read(iprot)
11803 
            self.success.append(_elem237)
5386 phani.kuma 11804 
          iprot.readListEnd()
11805 
        else:
11806 
          iprot.skip(ftype)
11807 
      else:
11808 
        iprot.skip(ftype)
11809 
      iprot.readFieldEnd()
11810 
    iprot.readStructEnd()
11811 
 
11812 
  def write(self, oprot):
11813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11815 
      return
11816 
    oprot.writeStructBegin('getOrderListForVendor_result')
11817 
    if self.success is not None:
11818 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11819 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11820 
      for iter238 in self.success:
11821 
        iter238.write(oprot)
5386 phani.kuma 11822 
      oprot.writeListEnd()
11823 
      oprot.writeFieldEnd()
11824 
    oprot.writeFieldStop()
11825 
    oprot.writeStructEnd()
11826 
 
11827 
  def validate(self):
11828 
    return
11829 
 
11830 
 
11831 
  def __repr__(self):
11832 
    L = ['%s=%r' % (key, value)
11833 
      for key, value in self.__dict__.iteritems()]
11834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11835 
 
11836 
  def __eq__(self, other):
11837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11838 
 
11839 
  def __ne__(self, other):
11840 
    return not (self == other)
11841 
 
3064 chandransh 11842 
class getOrderForCustomer_args:
94 ashish 11843 
  """
11844 
  Attributes:
3064 chandransh 11845 
   - orderId
483 rajveer 11846 
   - customerId
94 ashish 11847 
  """
11848 
 
11849 
  thrift_spec = (
11850 
    None, # 0
3064 chandransh 11851 
    (1, TType.I64, 'orderId', None, None, ), # 1
11852 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 11853 
  )
11854 
 
3064 chandransh 11855 
  def __init__(self, orderId=None, customerId=None,):
11856 
    self.orderId = orderId
483 rajveer 11857 
    self.customerId = customerId
94 ashish 11858 
 
11859 
  def read(self, iprot):
11860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11862 
      return
11863 
    iprot.readStructBegin()
11864 
    while True:
11865 
      (fname, ftype, fid) = iprot.readFieldBegin()
11866 
      if ftype == TType.STOP:
11867 
        break
11868 
      if fid == 1:
11869 
        if ftype == TType.I64:
3064 chandransh 11870 
          self.orderId = iprot.readI64();
94 ashish 11871 
        else:
11872 
          iprot.skip(ftype)
11873 
      elif fid == 2:
11874 
        if ftype == TType.I64:
3064 chandransh 11875 
          self.customerId = iprot.readI64();
94 ashish 11876 
        else:
11877 
          iprot.skip(ftype)
11878 
      else:
11879 
        iprot.skip(ftype)
11880 
      iprot.readFieldEnd()
11881 
    iprot.readStructEnd()
11882 
 
11883 
  def write(self, oprot):
11884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11886 
      return
3064 chandransh 11887 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 11888 
    if self.orderId is not None:
3064 chandransh 11889 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11890 
      oprot.writeI64(self.orderId)
11891 
      oprot.writeFieldEnd()
3431 rajveer 11892 
    if self.customerId is not None:
3064 chandransh 11893 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 11894 
      oprot.writeI64(self.customerId)
94 ashish 11895 
      oprot.writeFieldEnd()
11896 
    oprot.writeFieldStop()
11897 
    oprot.writeStructEnd()
11898 
 
3431 rajveer 11899 
  def validate(self):
11900 
    return
11901 
 
11902 
 
94 ashish 11903 
  def __repr__(self):
11904 
    L = ['%s=%r' % (key, value)
11905 
      for key, value in self.__dict__.iteritems()]
11906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11907 
 
11908 
  def __eq__(self, other):
11909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11910 
 
11911 
  def __ne__(self, other):
11912 
    return not (self == other)
11913 
 
3064 chandransh 11914 
class getOrderForCustomer_result:
94 ashish 11915 
  """
11916 
  Attributes:
11917 
   - success
11918 
   - ex
11919 
  """
11920 
 
11921 
  thrift_spec = (
3064 chandransh 11922 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 11923 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11924 
  )
11925 
 
11926 
  def __init__(self, success=None, ex=None,):
11927 
    self.success = success
11928 
    self.ex = ex
11929 
 
11930 
  def read(self, iprot):
11931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11933 
      return
11934 
    iprot.readStructBegin()
11935 
    while True:
11936 
      (fname, ftype, fid) = iprot.readFieldBegin()
11937 
      if ftype == TType.STOP:
11938 
        break
11939 
      if fid == 0:
3064 chandransh 11940 
        if ftype == TType.STRUCT:
11941 
          self.success = Order()
11942 
          self.success.read(iprot)
94 ashish 11943 
        else:
11944 
          iprot.skip(ftype)
11945 
      elif fid == 1:
11946 
        if ftype == TType.STRUCT:
11947 
          self.ex = TransactionServiceException()
11948 
          self.ex.read(iprot)
11949 
        else:
11950 
          iprot.skip(ftype)
11951 
      else:
11952 
        iprot.skip(ftype)
11953 
      iprot.readFieldEnd()
11954 
    iprot.readStructEnd()
11955 
 
11956 
  def write(self, oprot):
11957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11959 
      return
3064 chandransh 11960 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 11961 
    if self.success is not None:
3064 chandransh 11962 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11963 
      self.success.write(oprot)
94 ashish 11964 
      oprot.writeFieldEnd()
3431 rajveer 11965 
    if self.ex is not None:
94 ashish 11966 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11967 
      self.ex.write(oprot)
11968 
      oprot.writeFieldEnd()
11969 
    oprot.writeFieldStop()
11970 
    oprot.writeStructEnd()
11971 
 
3431 rajveer 11972 
  def validate(self):
11973 
    return
11974 
 
11975 
 
94 ashish 11976 
  def __repr__(self):
11977 
    L = ['%s=%r' % (key, value)
11978 
      for key, value in self.__dict__.iteritems()]
11979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11980 
 
11981 
  def __eq__(self, other):
11982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11983 
 
11984 
  def __ne__(self, other):
11985 
    return not (self == other)
11986 
 
3064 chandransh 11987 
class getAlerts_args:
94 ashish 11988 
  """
11989 
  Attributes:
4394 rajveer 11990 
   - type
4444 rajveer 11991 
   - warehouseId
4394 rajveer 11992 
   - status
11993 
   - timestamp
94 ashish 11994 
  """
11995 
 
11996 
  thrift_spec = (
11997 
    None, # 0
4394 rajveer 11998 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 11999 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12000 
    (3, TType.I64, 'status', None, None, ), # 3
12001 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 12002 
  )
12003 
 
4444 rajveer 12004 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 12005 
    self.type = type
4444 rajveer 12006 
    self.warehouseId = warehouseId
4394 rajveer 12007 
    self.status = status
12008 
    self.timestamp = timestamp
94 ashish 12009 
 
12010 
  def read(self, iprot):
12011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12013 
      return
12014 
    iprot.readStructBegin()
12015 
    while True:
12016 
      (fname, ftype, fid) = iprot.readFieldBegin()
12017 
      if ftype == TType.STOP:
12018 
        break
12019 
      if fid == 1:
3064 chandransh 12020 
        if ftype == TType.I64:
4394 rajveer 12021 
          self.type = iprot.readI64();
94 ashish 12022 
        else:
12023 
          iprot.skip(ftype)
3064 chandransh 12024 
      elif fid == 2:
4394 rajveer 12025 
        if ftype == TType.I64:
4444 rajveer 12026 
          self.warehouseId = iprot.readI64();
3064 chandransh 12027 
        else:
12028 
          iprot.skip(ftype)
4394 rajveer 12029 
      elif fid == 3:
12030 
        if ftype == TType.I64:
4444 rajveer 12031 
          self.status = iprot.readI64();
12032 
        else:
12033 
          iprot.skip(ftype)
12034 
      elif fid == 4:
12035 
        if ftype == TType.I64:
4394 rajveer 12036 
          self.timestamp = iprot.readI64();
12037 
        else:
12038 
          iprot.skip(ftype)
94 ashish 12039 
      else:
12040 
        iprot.skip(ftype)
12041 
      iprot.readFieldEnd()
12042 
    iprot.readStructEnd()
12043 
 
12044 
  def write(self, oprot):
12045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12047 
      return
3064 chandransh 12048 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 12049 
    if self.type is not None:
12050 
      oprot.writeFieldBegin('type', TType.I64, 1)
12051 
      oprot.writeI64(self.type)
94 ashish 12052 
      oprot.writeFieldEnd()
4444 rajveer 12053 
    if self.warehouseId is not None:
12054 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12055 
      oprot.writeI64(self.warehouseId)
12056 
      oprot.writeFieldEnd()
4394 rajveer 12057 
    if self.status is not None:
4444 rajveer 12058 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 12059 
      oprot.writeI64(self.status)
3064 chandransh 12060 
      oprot.writeFieldEnd()
4394 rajveer 12061 
    if self.timestamp is not None:
4444 rajveer 12062 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 12063 
      oprot.writeI64(self.timestamp)
12064 
      oprot.writeFieldEnd()
94 ashish 12065 
    oprot.writeFieldStop()
12066 
    oprot.writeStructEnd()
12067 
 
3431 rajveer 12068 
  def validate(self):
12069 
    return
12070 
 
12071 
 
94 ashish 12072 
  def __repr__(self):
12073 
    L = ['%s=%r' % (key, value)
12074 
      for key, value in self.__dict__.iteritems()]
12075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12076 
 
12077 
  def __eq__(self, other):
12078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12079 
 
12080 
  def __ne__(self, other):
12081 
    return not (self == other)
12082 
 
3064 chandransh 12083 
class getAlerts_result:
94 ashish 12084 
  """
12085 
  Attributes:
12086 
   - success
12087 
  """
12088 
 
12089 
  thrift_spec = (
3064 chandransh 12090 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 12091 
  )
12092 
 
3064 chandransh 12093 
  def __init__(self, success=None,):
94 ashish 12094 
    self.success = success
12095 
 
12096 
  def read(self, iprot):
12097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12099 
      return
12100 
    iprot.readStructBegin()
12101 
    while True:
12102 
      (fname, ftype, fid) = iprot.readFieldBegin()
12103 
      if ftype == TType.STOP:
12104 
        break
12105 
      if fid == 0:
3064 chandransh 12106 
        if ftype == TType.LIST:
12107 
          self.success = []
6188 rajveer 12108 
          (_etype242, _size239) = iprot.readListBegin()
12109 
          for _i243 in xrange(_size239):
12110 
            _elem244 = Alert()
12111 
            _elem244.read(iprot)
12112 
            self.success.append(_elem244)
3064 chandransh 12113 
          iprot.readListEnd()
94 ashish 12114 
        else:
12115 
          iprot.skip(ftype)
12116 
      else:
12117 
        iprot.skip(ftype)
12118 
      iprot.readFieldEnd()
12119 
    iprot.readStructEnd()
12120 
 
12121 
  def write(self, oprot):
12122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12124 
      return
3064 chandransh 12125 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 12126 
    if self.success is not None:
3064 chandransh 12127 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12128 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12129 
      for iter245 in self.success:
12130 
        iter245.write(oprot)
3064 chandransh 12131 
      oprot.writeListEnd()
94 ashish 12132 
      oprot.writeFieldEnd()
12133 
    oprot.writeFieldStop()
12134 
    oprot.writeStructEnd()
12135 
 
3431 rajveer 12136 
  def validate(self):
12137 
    return
12138 
 
12139 
 
94 ashish 12140 
  def __repr__(self):
12141 
    L = ['%s=%r' % (key, value)
12142 
      for key, value in self.__dict__.iteritems()]
12143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12144 
 
12145 
  def __eq__(self, other):
12146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12147 
 
12148 
  def __ne__(self, other):
12149 
    return not (self == other)
12150 
 
4394 rajveer 12151 
class addAlert_args:
94 ashish 12152 
  """
12153 
  Attributes:
3064 chandransh 12154 
   - type
4444 rajveer 12155 
   - warehouseId
4394 rajveer 12156 
   - description
94 ashish 12157 
  """
12158 
 
12159 
  thrift_spec = (
12160 
    None, # 0
4394 rajveer 12161 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12162 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12163 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12164 
  )
12165 
 
4444 rajveer 12166 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 12167 
    self.type = type
4444 rajveer 12168 
    self.warehouseId = warehouseId
4394 rajveer 12169 
    self.description = description
94 ashish 12170 
 
12171 
  def read(self, iprot):
12172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12174 
      return
12175 
    iprot.readStructBegin()
12176 
    while True:
12177 
      (fname, ftype, fid) = iprot.readFieldBegin()
12178 
      if ftype == TType.STOP:
12179 
        break
12180 
      if fid == 1:
12181 
        if ftype == TType.I64:
4394 rajveer 12182 
          self.type = iprot.readI64();
94 ashish 12183 
        else:
12184 
          iprot.skip(ftype)
3064 chandransh 12185 
      elif fid == 2:
4444 rajveer 12186 
        if ftype == TType.I64:
12187 
          self.warehouseId = iprot.readI64();
12188 
        else:
12189 
          iprot.skip(ftype)
12190 
      elif fid == 3:
3064 chandransh 12191 
        if ftype == TType.STRING:
4394 rajveer 12192 
          self.description = iprot.readString();
3064 chandransh 12193 
        else:
12194 
          iprot.skip(ftype)
94 ashish 12195 
      else:
12196 
        iprot.skip(ftype)
12197 
      iprot.readFieldEnd()
12198 
    iprot.readStructEnd()
12199 
 
12200 
  def write(self, oprot):
12201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12203 
      return
4394 rajveer 12204 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 12205 
    if self.type is not None:
4394 rajveer 12206 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 12207 
      oprot.writeI64(self.type)
12208 
      oprot.writeFieldEnd()
4444 rajveer 12209 
    if self.warehouseId is not None:
12210 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12211 
      oprot.writeI64(self.warehouseId)
12212 
      oprot.writeFieldEnd()
4394 rajveer 12213 
    if self.description is not None:
4444 rajveer 12214 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 12215 
      oprot.writeString(self.description)
3064 chandransh 12216 
      oprot.writeFieldEnd()
94 ashish 12217 
    oprot.writeFieldStop()
12218 
    oprot.writeStructEnd()
12219 
 
3431 rajveer 12220 
  def validate(self):
12221 
    return
12222 
 
12223 
 
94 ashish 12224 
  def __repr__(self):
12225 
    L = ['%s=%r' % (key, value)
12226 
      for key, value in self.__dict__.iteritems()]
12227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12228 
 
12229 
  def __eq__(self, other):
12230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12231 
 
12232 
  def __ne__(self, other):
12233 
    return not (self == other)
12234 
 
4394 rajveer 12235 
class addAlert_result:
3064 chandransh 12236 
 
12237 
  thrift_spec = (
12238 
  )
12239 
 
12240 
  def read(self, iprot):
12241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12243 
      return
12244 
    iprot.readStructBegin()
12245 
    while True:
12246 
      (fname, ftype, fid) = iprot.readFieldBegin()
12247 
      if ftype == TType.STOP:
12248 
        break
12249 
      else:
12250 
        iprot.skip(ftype)
12251 
      iprot.readFieldEnd()
12252 
    iprot.readStructEnd()
12253 
 
12254 
  def write(self, oprot):
12255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12257 
      return
4394 rajveer 12258 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 12259 
    oprot.writeFieldStop()
12260 
    oprot.writeStructEnd()
12261 
 
3431 rajveer 12262 
  def validate(self):
12263 
    return
12264 
 
12265 
 
3064 chandransh 12266 
  def __repr__(self):
12267 
    L = ['%s=%r' % (key, value)
12268 
      for key, value in self.__dict__.iteritems()]
12269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12270 
 
12271 
  def __eq__(self, other):
12272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12273 
 
12274 
  def __ne__(self, other):
12275 
    return not (self == other)
12276 
 
4444 rajveer 12277 
class markAlertsAsSeen_args:
12278 
  """
12279 
  Attributes:
12280 
   - warehouseId
12281 
  """
12282 
 
12283 
  thrift_spec = (
12284 
    None, # 0
12285 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12286 
  )
12287 
 
12288 
  def __init__(self, warehouseId=None,):
12289 
    self.warehouseId = warehouseId
12290 
 
12291 
  def read(self, iprot):
12292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12294 
      return
12295 
    iprot.readStructBegin()
12296 
    while True:
12297 
      (fname, ftype, fid) = iprot.readFieldBegin()
12298 
      if ftype == TType.STOP:
12299 
        break
12300 
      if fid == 1:
12301 
        if ftype == TType.I64:
12302 
          self.warehouseId = iprot.readI64();
12303 
        else:
12304 
          iprot.skip(ftype)
12305 
      else:
12306 
        iprot.skip(ftype)
12307 
      iprot.readFieldEnd()
12308 
    iprot.readStructEnd()
12309 
 
12310 
  def write(self, oprot):
12311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12313 
      return
12314 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12315 
    if self.warehouseId is not None:
12316 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12317 
      oprot.writeI64(self.warehouseId)
12318 
      oprot.writeFieldEnd()
12319 
    oprot.writeFieldStop()
12320 
    oprot.writeStructEnd()
12321 
 
12322 
  def validate(self):
12323 
    return
12324 
 
12325 
 
12326 
  def __repr__(self):
12327 
    L = ['%s=%r' % (key, value)
12328 
      for key, value in self.__dict__.iteritems()]
12329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12330 
 
12331 
  def __eq__(self, other):
12332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12333 
 
12334 
  def __ne__(self, other):
12335 
    return not (self == other)
12336 
 
12337 
class markAlertsAsSeen_result:
12338 
 
12339 
  thrift_spec = (
12340 
  )
12341 
 
12342 
  def read(self, iprot):
12343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12345 
      return
12346 
    iprot.readStructBegin()
12347 
    while True:
12348 
      (fname, ftype, fid) = iprot.readFieldBegin()
12349 
      if ftype == TType.STOP:
12350 
        break
12351 
      else:
12352 
        iprot.skip(ftype)
12353 
      iprot.readFieldEnd()
12354 
    iprot.readStructEnd()
12355 
 
12356 
  def write(self, oprot):
12357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12359 
      return
12360 
    oprot.writeStructBegin('markAlertsAsSeen_result')
12361 
    oprot.writeFieldStop()
12362 
    oprot.writeStructEnd()
12363 
 
12364 
  def validate(self):
12365 
    return
12366 
 
12367 
 
12368 
  def __repr__(self):
12369 
    L = ['%s=%r' % (key, value)
12370 
      for key, value in self.__dict__.iteritems()]
12371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12372 
 
12373 
  def __eq__(self, other):
12374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12375 
 
12376 
  def __ne__(self, other):
12377 
    return not (self == other)
12378 
 
3064 chandransh 12379 
class getValidOrderCount_args:
12380 
 
12381 
  thrift_spec = (
12382 
  )
12383 
 
12384 
  def read(self, iprot):
12385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12387 
      return
12388 
    iprot.readStructBegin()
12389 
    while True:
12390 
      (fname, ftype, fid) = iprot.readFieldBegin()
12391 
      if ftype == TType.STOP:
12392 
        break
12393 
      else:
12394 
        iprot.skip(ftype)
12395 
      iprot.readFieldEnd()
12396 
    iprot.readStructEnd()
12397 
 
12398 
  def write(self, oprot):
12399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12401 
      return
12402 
    oprot.writeStructBegin('getValidOrderCount_args')
12403 
    oprot.writeFieldStop()
12404 
    oprot.writeStructEnd()
12405 
 
3431 rajveer 12406 
  def validate(self):
12407 
    return
12408 
 
12409 
 
3064 chandransh 12410 
  def __repr__(self):
12411 
    L = ['%s=%r' % (key, value)
12412 
      for key, value in self.__dict__.iteritems()]
12413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12414 
 
12415 
  def __eq__(self, other):
12416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12417 
 
12418 
  def __ne__(self, other):
12419 
    return not (self == other)
12420 
 
12421 
class getValidOrderCount_result:
94 ashish 12422 
  """
12423 
  Attributes:
12424 
   - success
12425 
  """
12426 
 
12427 
  thrift_spec = (
3064 chandransh 12428 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12429 
  )
12430 
 
3064 chandransh 12431 
  def __init__(self, success=None,):
94 ashish 12432 
    self.success = success
12433 
 
12434 
  def read(self, iprot):
12435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12437 
      return
12438 
    iprot.readStructBegin()
12439 
    while True:
12440 
      (fname, ftype, fid) = iprot.readFieldBegin()
12441 
      if ftype == TType.STOP:
12442 
        break
12443 
      if fid == 0:
3064 chandransh 12444 
        if ftype == TType.I64:
12445 
          self.success = iprot.readI64();
94 ashish 12446 
        else:
12447 
          iprot.skip(ftype)
12448 
      else:
12449 
        iprot.skip(ftype)
12450 
      iprot.readFieldEnd()
12451 
    iprot.readStructEnd()
12452 
 
12453 
  def write(self, oprot):
12454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12456 
      return
3064 chandransh 12457 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12458 
    if self.success is not None:
3064 chandransh 12459 
      oprot.writeFieldBegin('success', TType.I64, 0)
12460 
      oprot.writeI64(self.success)
94 ashish 12461 
      oprot.writeFieldEnd()
12462 
    oprot.writeFieldStop()
12463 
    oprot.writeStructEnd()
12464 
 
3431 rajveer 12465 
  def validate(self):
12466 
    return
12467 
 
12468 
 
94 ashish 12469 
  def __repr__(self):
12470 
    L = ['%s=%r' % (key, value)
12471 
      for key, value in self.__dict__.iteritems()]
12472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12473 
 
12474 
  def __eq__(self, other):
12475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12476 
 
12477 
  def __ne__(self, other):
12478 
    return not (self == other)
12479 
 
3064 chandransh 12480 
class getNoOfCustomersWithSuccessfulTransaction_args:
12481 
 
12482 
  thrift_spec = (
12483 
  )
12484 
 
12485 
  def read(self, iprot):
12486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12488 
      return
12489 
    iprot.readStructBegin()
12490 
    while True:
12491 
      (fname, ftype, fid) = iprot.readFieldBegin()
12492 
      if ftype == TType.STOP:
12493 
        break
12494 
      else:
12495 
        iprot.skip(ftype)
12496 
      iprot.readFieldEnd()
12497 
    iprot.readStructEnd()
12498 
 
12499 
  def write(self, oprot):
12500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12502 
      return
12503 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
12504 
    oprot.writeFieldStop()
12505 
    oprot.writeStructEnd()
12506 
 
3431 rajveer 12507 
  def validate(self):
12508 
    return
12509 
 
12510 
 
3064 chandransh 12511 
  def __repr__(self):
12512 
    L = ['%s=%r' % (key, value)
12513 
      for key, value in self.__dict__.iteritems()]
12514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12515 
 
12516 
  def __eq__(self, other):
12517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12518 
 
12519 
  def __ne__(self, other):
12520 
    return not (self == other)
12521 
 
12522 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 12523 
  """
12524 
  Attributes:
3064 chandransh 12525 
   - success
94 ashish 12526 
  """
12527 
 
12528 
  thrift_spec = (
3064 chandransh 12529 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12530 
  )
12531 
 
3064 chandransh 12532 
  def __init__(self, success=None,):
12533 
    self.success = success
94 ashish 12534 
 
12535 
  def read(self, iprot):
12536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12538 
      return
12539 
    iprot.readStructBegin()
12540 
    while True:
12541 
      (fname, ftype, fid) = iprot.readFieldBegin()
12542 
      if ftype == TType.STOP:
12543 
        break
3064 chandransh 12544 
      if fid == 0:
94 ashish 12545 
        if ftype == TType.I64:
3064 chandransh 12546 
          self.success = iprot.readI64();
94 ashish 12547 
        else:
12548 
          iprot.skip(ftype)
12549 
      else:
12550 
        iprot.skip(ftype)
12551 
      iprot.readFieldEnd()
12552 
    iprot.readStructEnd()
12553 
 
12554 
  def write(self, oprot):
12555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12557 
      return
3064 chandransh 12558 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 12559 
    if self.success is not None:
3064 chandransh 12560 
      oprot.writeFieldBegin('success', TType.I64, 0)
12561 
      oprot.writeI64(self.success)
94 ashish 12562 
      oprot.writeFieldEnd()
12563 
    oprot.writeFieldStop()
12564 
    oprot.writeStructEnd()
12565 
 
3431 rajveer 12566 
  def validate(self):
12567 
    return
12568 
 
12569 
 
94 ashish 12570 
  def __repr__(self):
12571 
    L = ['%s=%r' % (key, value)
12572 
      for key, value in self.__dict__.iteritems()]
12573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12574 
 
12575 
  def __eq__(self, other):
12576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12577 
 
12578 
  def __ne__(self, other):
12579 
    return not (self == other)
12580 
 
3064 chandransh 12581 
class getValidOrdersAmountRange_args:
12582 
 
12583 
  thrift_spec = (
12584 
  )
12585 
 
12586 
  def read(self, iprot):
12587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12589 
      return
12590 
    iprot.readStructBegin()
12591 
    while True:
12592 
      (fname, ftype, fid) = iprot.readFieldBegin()
12593 
      if ftype == TType.STOP:
12594 
        break
12595 
      else:
12596 
        iprot.skip(ftype)
12597 
      iprot.readFieldEnd()
12598 
    iprot.readStructEnd()
12599 
 
12600 
  def write(self, oprot):
12601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12603 
      return
12604 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
12605 
    oprot.writeFieldStop()
12606 
    oprot.writeStructEnd()
12607 
 
3431 rajveer 12608 
  def validate(self):
12609 
    return
12610 
 
12611 
 
3064 chandransh 12612 
  def __repr__(self):
12613 
    L = ['%s=%r' % (key, value)
12614 
      for key, value in self.__dict__.iteritems()]
12615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12616 
 
12617 
  def __eq__(self, other):
12618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12619 
 
12620 
  def __ne__(self, other):
12621 
    return not (self == other)
12622 
 
12623 
class getValidOrdersAmountRange_result:
94 ashish 12624 
  """
12625 
  Attributes:
12626 
   - success
12627 
  """
12628 
 
12629 
  thrift_spec = (
3064 chandransh 12630 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 12631 
  )
12632 
 
3064 chandransh 12633 
  def __init__(self, success=None,):
94 ashish 12634 
    self.success = success
12635 
 
12636 
  def read(self, iprot):
12637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12639 
      return
12640 
    iprot.readStructBegin()
12641 
    while True:
12642 
      (fname, ftype, fid) = iprot.readFieldBegin()
12643 
      if ftype == TType.STOP:
12644 
        break
12645 
      if fid == 0:
483 rajveer 12646 
        if ftype == TType.LIST:
12647 
          self.success = []
6188 rajveer 12648 
          (_etype249, _size246) = iprot.readListBegin()
12649 
          for _i250 in xrange(_size246):
12650 
            _elem251 = iprot.readDouble();
12651 
            self.success.append(_elem251)
483 rajveer 12652 
          iprot.readListEnd()
94 ashish 12653 
        else:
12654 
          iprot.skip(ftype)
12655 
      else:
12656 
        iprot.skip(ftype)
12657 
      iprot.readFieldEnd()
12658 
    iprot.readStructEnd()
12659 
 
12660 
  def write(self, oprot):
12661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12663 
      return
3064 chandransh 12664 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 12665 
    if self.success is not None:
483 rajveer 12666 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 12667 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 12668 
      for iter252 in self.success:
12669 
        oprot.writeDouble(iter252)
483 rajveer 12670 
      oprot.writeListEnd()
94 ashish 12671 
      oprot.writeFieldEnd()
12672 
    oprot.writeFieldStop()
12673 
    oprot.writeStructEnd()
12674 
 
3431 rajveer 12675 
  def validate(self):
12676 
    return
12677 
 
12678 
 
94 ashish 12679 
  def __repr__(self):
12680 
    L = ['%s=%r' % (key, value)
12681 
      for key, value in self.__dict__.iteritems()]
12682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12683 
 
12684 
  def __eq__(self, other):
12685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12686 
 
12687 
  def __ne__(self, other):
12688 
    return not (self == other)
12689 
 
3064 chandransh 12690 
class getValidOrders_args:
1528 ankur.sing 12691 
  """
12692 
  Attributes:
3064 chandransh 12693 
   - limit
5874 rajveer 12694 
   - onlyStore
1528 ankur.sing 12695 
  """
12696 
 
12697 
  thrift_spec = (
12698 
    None, # 0
3064 chandransh 12699 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 12700 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 12701 
  )
12702 
 
5874 rajveer 12703 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 12704 
    self.limit = limit
5874 rajveer 12705 
    self.onlyStore = onlyStore
1528 ankur.sing 12706 
 
12707 
  def read(self, iprot):
12708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12710 
      return
12711 
    iprot.readStructBegin()
12712 
    while True:
12713 
      (fname, ftype, fid) = iprot.readFieldBegin()
12714 
      if ftype == TType.STOP:
12715 
        break
12716 
      if fid == 1:
12717 
        if ftype == TType.I64:
3064 chandransh 12718 
          self.limit = iprot.readI64();
1528 ankur.sing 12719 
        else:
12720 
          iprot.skip(ftype)
5874 rajveer 12721 
      elif fid == 2:
12722 
        if ftype == TType.BOOL:
12723 
          self.onlyStore = iprot.readBool();
12724 
        else:
12725 
          iprot.skip(ftype)
1528 ankur.sing 12726 
      else:
12727 
        iprot.skip(ftype)
12728 
      iprot.readFieldEnd()
12729 
    iprot.readStructEnd()
12730 
 
12731 
  def write(self, oprot):
12732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12734 
      return
3064 chandransh 12735 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 12736 
    if self.limit is not None:
3064 chandransh 12737 
      oprot.writeFieldBegin('limit', TType.I64, 1)
12738 
      oprot.writeI64(self.limit)
1528 ankur.sing 12739 
      oprot.writeFieldEnd()
5874 rajveer 12740 
    if self.onlyStore is not None:
12741 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
12742 
      oprot.writeBool(self.onlyStore)
12743 
      oprot.writeFieldEnd()
1528 ankur.sing 12744 
    oprot.writeFieldStop()
12745 
    oprot.writeStructEnd()
12746 
 
3431 rajveer 12747 
  def validate(self):
12748 
    return
12749 
 
12750 
 
1528 ankur.sing 12751 
  def __repr__(self):
12752 
    L = ['%s=%r' % (key, value)
12753 
      for key, value in self.__dict__.iteritems()]
12754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12755 
 
12756 
  def __eq__(self, other):
12757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12758 
 
12759 
  def __ne__(self, other):
12760 
    return not (self == other)
12761 
 
3064 chandransh 12762 
class getValidOrders_result:
1528 ankur.sing 12763 
  """
12764 
  Attributes:
12765 
   - success
12766 
  """
12767 
 
12768 
  thrift_spec = (
3064 chandransh 12769 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 12770 
  )
12771 
 
3064 chandransh 12772 
  def __init__(self, success=None,):
1528 ankur.sing 12773 
    self.success = success
12774 
 
12775 
  def read(self, iprot):
12776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12778 
      return
12779 
    iprot.readStructBegin()
12780 
    while True:
12781 
      (fname, ftype, fid) = iprot.readFieldBegin()
12782 
      if ftype == TType.STOP:
12783 
        break
12784 
      if fid == 0:
3064 chandransh 12785 
        if ftype == TType.LIST:
12786 
          self.success = []
6188 rajveer 12787 
          (_etype256, _size253) = iprot.readListBegin()
12788 
          for _i257 in xrange(_size253):
12789 
            _elem258 = Order()
12790 
            _elem258.read(iprot)
12791 
            self.success.append(_elem258)
3064 chandransh 12792 
          iprot.readListEnd()
1528 ankur.sing 12793 
        else:
12794 
          iprot.skip(ftype)
12795 
      else:
12796 
        iprot.skip(ftype)
12797 
      iprot.readFieldEnd()
12798 
    iprot.readStructEnd()
12799 
 
12800 
  def write(self, oprot):
12801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12803 
      return
3064 chandransh 12804 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 12805 
    if self.success is not None:
3064 chandransh 12806 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12807 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12808 
      for iter259 in self.success:
12809 
        iter259.write(oprot)
3064 chandransh 12810 
      oprot.writeListEnd()
1528 ankur.sing 12811 
      oprot.writeFieldEnd()
12812 
    oprot.writeFieldStop()
12813 
    oprot.writeStructEnd()
12814 
 
3431 rajveer 12815 
  def validate(self):
12816 
    return
12817 
 
12818 
 
1528 ankur.sing 12819 
  def __repr__(self):
12820 
    L = ['%s=%r' % (key, value)
12821 
      for key, value in self.__dict__.iteritems()]
12822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12823 
 
12824 
  def __eq__(self, other):
12825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12826 
 
12827 
  def __ne__(self, other):
12828 
    return not (self == other)
12829 
 
1220 chandransh 12830 
class batchOrders_args:
12831 
  """
12832 
  Attributes:
12833 
   - warehouseId
12834 
  """
12835 
 
12836 
  thrift_spec = (
12837 
    None, # 0
12838 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12839 
  )
12840 
 
12841 
  def __init__(self, warehouseId=None,):
12842 
    self.warehouseId = warehouseId
12843 
 
12844 
  def read(self, iprot):
12845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12847 
      return
12848 
    iprot.readStructBegin()
12849 
    while True:
12850 
      (fname, ftype, fid) = iprot.readFieldBegin()
12851 
      if ftype == TType.STOP:
12852 
        break
12853 
      if fid == 1:
12854 
        if ftype == TType.I64:
12855 
          self.warehouseId = iprot.readI64();
12856 
        else:
12857 
          iprot.skip(ftype)
12858 
      else:
12859 
        iprot.skip(ftype)
12860 
      iprot.readFieldEnd()
12861 
    iprot.readStructEnd()
12862 
 
12863 
  def write(self, oprot):
12864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12866 
      return
12867 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 12868 
    if self.warehouseId is not None:
1220 chandransh 12869 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12870 
      oprot.writeI64(self.warehouseId)
12871 
      oprot.writeFieldEnd()
12872 
    oprot.writeFieldStop()
12873 
    oprot.writeStructEnd()
12874 
 
3431 rajveer 12875 
  def validate(self):
12876 
    return
12877 
 
12878 
 
1220 chandransh 12879 
  def __repr__(self):
12880 
    L = ['%s=%r' % (key, value)
12881 
      for key, value in self.__dict__.iteritems()]
12882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12883 
 
12884 
  def __eq__(self, other):
12885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12886 
 
12887 
  def __ne__(self, other):
12888 
    return not (self == other)
12889 
 
12890 
class batchOrders_result:
12891 
  """
12892 
  Attributes:
12893 
   - success
12894 
   - ex
12895 
  """
12896 
 
12897 
  thrift_spec = (
12898 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12899 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12900 
  )
12901 
 
12902 
  def __init__(self, success=None, ex=None,):
12903 
    self.success = success
12904 
    self.ex = ex
12905 
 
12906 
  def read(self, iprot):
12907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12909 
      return
12910 
    iprot.readStructBegin()
12911 
    while True:
12912 
      (fname, ftype, fid) = iprot.readFieldBegin()
12913 
      if ftype == TType.STOP:
12914 
        break
12915 
      if fid == 0:
12916 
        if ftype == TType.LIST:
12917 
          self.success = []
6188 rajveer 12918 
          (_etype263, _size260) = iprot.readListBegin()
12919 
          for _i264 in xrange(_size260):
12920 
            _elem265 = Order()
12921 
            _elem265.read(iprot)
12922 
            self.success.append(_elem265)
1220 chandransh 12923 
          iprot.readListEnd()
12924 
        else:
12925 
          iprot.skip(ftype)
12926 
      elif fid == 1:
12927 
        if ftype == TType.STRUCT:
12928 
          self.ex = TransactionServiceException()
12929 
          self.ex.read(iprot)
12930 
        else:
12931 
          iprot.skip(ftype)
12932 
      else:
12933 
        iprot.skip(ftype)
12934 
      iprot.readFieldEnd()
12935 
    iprot.readStructEnd()
12936 
 
12937 
  def write(self, oprot):
12938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12940 
      return
12941 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 12942 
    if self.success is not None:
1220 chandransh 12943 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12944 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12945 
      for iter266 in self.success:
12946 
        iter266.write(oprot)
1220 chandransh 12947 
      oprot.writeListEnd()
12948 
      oprot.writeFieldEnd()
3431 rajveer 12949 
    if self.ex is not None:
1220 chandransh 12950 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12951 
      self.ex.write(oprot)
12952 
      oprot.writeFieldEnd()
12953 
    oprot.writeFieldStop()
12954 
    oprot.writeStructEnd()
12955 
 
3431 rajveer 12956 
  def validate(self):
12957 
    return
12958 
 
12959 
 
1220 chandransh 12960 
  def __repr__(self):
12961 
    L = ['%s=%r' % (key, value)
12962 
      for key, value in self.__dict__.iteritems()]
12963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12964 
 
12965 
  def __eq__(self, other):
12966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12967 
 
12968 
  def __ne__(self, other):
12969 
    return not (self == other)
12970 
 
1208 chandransh 12971 
class markOrderAsOutOfStock_args:
12972 
  """
12973 
  Attributes:
12974 
   - orderId
12975 
  """
12976 
 
12977 
  thrift_spec = (
12978 
    None, # 0
12979 
    (1, TType.I64, 'orderId', None, None, ), # 1
12980 
  )
12981 
 
12982 
  def __init__(self, orderId=None,):
12983 
    self.orderId = orderId
12984 
 
12985 
  def read(self, iprot):
12986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12988 
      return
12989 
    iprot.readStructBegin()
12990 
    while True:
12991 
      (fname, ftype, fid) = iprot.readFieldBegin()
12992 
      if ftype == TType.STOP:
12993 
        break
12994 
      if fid == 1:
12995 
        if ftype == TType.I64:
12996 
          self.orderId = iprot.readI64();
12997 
        else:
12998 
          iprot.skip(ftype)
12999 
      else:
13000 
        iprot.skip(ftype)
13001 
      iprot.readFieldEnd()
13002 
    iprot.readStructEnd()
13003 
 
13004 
  def write(self, oprot):
13005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13007 
      return
13008 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 13009 
    if self.orderId is not None:
1208 chandransh 13010 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13011 
      oprot.writeI64(self.orderId)
13012 
      oprot.writeFieldEnd()
13013 
    oprot.writeFieldStop()
13014 
    oprot.writeStructEnd()
13015 
 
3431 rajveer 13016 
  def validate(self):
13017 
    return
13018 
 
13019 
 
1208 chandransh 13020 
  def __repr__(self):
13021 
    L = ['%s=%r' % (key, value)
13022 
      for key, value in self.__dict__.iteritems()]
13023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13024 
 
13025 
  def __eq__(self, other):
13026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13027 
 
13028 
  def __ne__(self, other):
13029 
    return not (self == other)
13030 
 
13031 
class markOrderAsOutOfStock_result:
13032 
  """
13033 
  Attributes:
13034 
   - success
13035 
   - ex
13036 
  """
13037 
 
13038 
  thrift_spec = (
13039 
    (0, TType.BOOL, 'success', None, None, ), # 0
13040 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13041 
  )
13042 
 
13043 
  def __init__(self, success=None, ex=None,):
13044 
    self.success = success
13045 
    self.ex = ex
13046 
 
13047 
  def read(self, iprot):
13048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13050 
      return
13051 
    iprot.readStructBegin()
13052 
    while True:
13053 
      (fname, ftype, fid) = iprot.readFieldBegin()
13054 
      if ftype == TType.STOP:
13055 
        break
13056 
      if fid == 0:
13057 
        if ftype == TType.BOOL:
13058 
          self.success = iprot.readBool();
13059 
        else:
13060 
          iprot.skip(ftype)
13061 
      elif fid == 1:
13062 
        if ftype == TType.STRUCT:
13063 
          self.ex = TransactionServiceException()
13064 
          self.ex.read(iprot)
13065 
        else:
13066 
          iprot.skip(ftype)
13067 
      else:
13068 
        iprot.skip(ftype)
13069 
      iprot.readFieldEnd()
13070 
    iprot.readStructEnd()
13071 
 
13072 
  def write(self, oprot):
13073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13075 
      return
13076 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 13077 
    if self.success is not None:
1208 chandransh 13078 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13079 
      oprot.writeBool(self.success)
13080 
      oprot.writeFieldEnd()
3431 rajveer 13081 
    if self.ex is not None:
1208 chandransh 13082 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13083 
      self.ex.write(oprot)
13084 
      oprot.writeFieldEnd()
13085 
    oprot.writeFieldStop()
13086 
    oprot.writeStructEnd()
13087 
 
3431 rajveer 13088 
  def validate(self):
13089 
    return
13090 
 
13091 
 
1208 chandransh 13092 
  def __repr__(self):
13093 
    L = ['%s=%r' % (key, value)
13094 
      for key, value in self.__dict__.iteritems()]
13095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13096 
 
13097 
  def __eq__(self, other):
13098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13099 
 
13100 
  def __ne__(self, other):
13101 
    return not (self == other)
13102 
 
3064 chandransh 13103 
class verifyOrder_args:
759 chandransh 13104 
  """
13105 
  Attributes:
3064 chandransh 13106 
   - orderId
759 chandransh 13107 
  """
13108 
 
13109 
  thrift_spec = (
13110 
    None, # 0
3064 chandransh 13111 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 13112 
  )
13113 
 
3064 chandransh 13114 
  def __init__(self, orderId=None,):
13115 
    self.orderId = orderId
759 chandransh 13116 
 
13117 
  def read(self, iprot):
13118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13120 
      return
13121 
    iprot.readStructBegin()
13122 
    while True:
13123 
      (fname, ftype, fid) = iprot.readFieldBegin()
13124 
      if ftype == TType.STOP:
13125 
        break
13126 
      if fid == 1:
13127 
        if ftype == TType.I64:
3064 chandransh 13128 
          self.orderId = iprot.readI64();
759 chandransh 13129 
        else:
13130 
          iprot.skip(ftype)
13131 
      else:
13132 
        iprot.skip(ftype)
13133 
      iprot.readFieldEnd()
13134 
    iprot.readStructEnd()
13135 
 
13136 
  def write(self, oprot):
13137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13139 
      return
3064 chandransh 13140 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 13141 
    if self.orderId is not None:
3064 chandransh 13142 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13143 
      oprot.writeI64(self.orderId)
759 chandransh 13144 
      oprot.writeFieldEnd()
13145 
    oprot.writeFieldStop()
13146 
    oprot.writeStructEnd()
13147 
 
3431 rajveer 13148 
  def validate(self):
13149 
    return
13150 
 
13151 
 
759 chandransh 13152 
  def __repr__(self):
13153 
    L = ['%s=%r' % (key, value)
13154 
      for key, value in self.__dict__.iteritems()]
13155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13156 
 
13157 
  def __eq__(self, other):
13158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13159 
 
13160 
  def __ne__(self, other):
13161 
    return not (self == other)
13162 
 
3064 chandransh 13163 
class verifyOrder_result:
759 chandransh 13164 
  """
13165 
  Attributes:
13166 
   - success
13167 
   - ex
13168 
  """
13169 
 
13170 
  thrift_spec = (
13171 
    (0, TType.BOOL, 'success', None, None, ), # 0
13172 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13173 
  )
13174 
 
13175 
  def __init__(self, success=None, ex=None,):
13176 
    self.success = success
13177 
    self.ex = ex
13178 
 
13179 
  def read(self, iprot):
13180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13182 
      return
13183 
    iprot.readStructBegin()
13184 
    while True:
13185 
      (fname, ftype, fid) = iprot.readFieldBegin()
13186 
      if ftype == TType.STOP:
13187 
        break
13188 
      if fid == 0:
13189 
        if ftype == TType.BOOL:
13190 
          self.success = iprot.readBool();
13191 
        else:
13192 
          iprot.skip(ftype)
13193 
      elif fid == 1:
13194 
        if ftype == TType.STRUCT:
13195 
          self.ex = TransactionServiceException()
13196 
          self.ex.read(iprot)
13197 
        else:
13198 
          iprot.skip(ftype)
13199 
      else:
13200 
        iprot.skip(ftype)
13201 
      iprot.readFieldEnd()
13202 
    iprot.readStructEnd()
13203 
 
13204 
  def write(self, oprot):
13205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13207 
      return
3064 chandransh 13208 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 13209 
    if self.success is not None:
759 chandransh 13210 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13211 
      oprot.writeBool(self.success)
13212 
      oprot.writeFieldEnd()
3431 rajveer 13213 
    if self.ex is not None:
759 chandransh 13214 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13215 
      self.ex.write(oprot)
13216 
      oprot.writeFieldEnd()
13217 
    oprot.writeFieldStop()
13218 
    oprot.writeStructEnd()
13219 
 
3431 rajveer 13220 
  def validate(self):
13221 
    return
13222 
 
13223 
 
759 chandransh 13224 
  def __repr__(self):
13225 
    L = ['%s=%r' % (key, value)
13226 
      for key, value in self.__dict__.iteritems()]
13227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13228 
 
13229 
  def __eq__(self, other):
13230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13231 
 
13232 
  def __ne__(self, other):
13233 
    return not (self == other)
13234 
 
3064 chandransh 13235 
class acceptOrder_args:
1113 chandransh 13236 
  """
13237 
  Attributes:
3064 chandransh 13238 
   - orderId
1113 chandransh 13239 
  """
13240 
 
13241 
  thrift_spec = (
13242 
    None, # 0
3064 chandransh 13243 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 13244 
  )
13245 
 
3064 chandransh 13246 
  def __init__(self, orderId=None,):
13247 
    self.orderId = orderId
1113 chandransh 13248 
 
13249 
  def read(self, iprot):
13250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13252 
      return
13253 
    iprot.readStructBegin()
13254 
    while True:
13255 
      (fname, ftype, fid) = iprot.readFieldBegin()
13256 
      if ftype == TType.STOP:
13257 
        break
13258 
      if fid == 1:
13259 
        if ftype == TType.I64:
3064 chandransh 13260 
          self.orderId = iprot.readI64();
1113 chandransh 13261 
        else:
13262 
          iprot.skip(ftype)
13263 
      else:
13264 
        iprot.skip(ftype)
13265 
      iprot.readFieldEnd()
13266 
    iprot.readStructEnd()
13267 
 
13268 
  def write(self, oprot):
13269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13271 
      return
3064 chandransh 13272 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 13273 
    if self.orderId is not None:
3064 chandransh 13274 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13275 
      oprot.writeI64(self.orderId)
1113 chandransh 13276 
      oprot.writeFieldEnd()
13277 
    oprot.writeFieldStop()
13278 
    oprot.writeStructEnd()
13279 
 
3431 rajveer 13280 
  def validate(self):
13281 
    return
13282 
 
13283 
 
1113 chandransh 13284 
  def __repr__(self):
13285 
    L = ['%s=%r' % (key, value)
13286 
      for key, value in self.__dict__.iteritems()]
13287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13288 
 
13289 
  def __eq__(self, other):
13290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13291 
 
13292 
  def __ne__(self, other):
13293 
    return not (self == other)
13294 
 
3064 chandransh 13295 
class acceptOrder_result:
1113 chandransh 13296 
  """
13297 
  Attributes:
13298 
   - success
13299 
   - ex
13300 
  """
13301 
 
13302 
  thrift_spec = (
3064 chandransh 13303 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13304 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13305 
  )
13306 
 
13307 
  def __init__(self, success=None, ex=None,):
13308 
    self.success = success
13309 
    self.ex = ex
13310 
 
13311 
  def read(self, iprot):
13312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13314 
      return
13315 
    iprot.readStructBegin()
13316 
    while True:
13317 
      (fname, ftype, fid) = iprot.readFieldBegin()
13318 
      if ftype == TType.STOP:
13319 
        break
13320 
      if fid == 0:
3064 chandransh 13321 
        if ftype == TType.BOOL:
13322 
          self.success = iprot.readBool();
1113 chandransh 13323 
        else:
13324 
          iprot.skip(ftype)
13325 
      elif fid == 1:
13326 
        if ftype == TType.STRUCT:
13327 
          self.ex = TransactionServiceException()
13328 
          self.ex.read(iprot)
13329 
        else:
13330 
          iprot.skip(ftype)
13331 
      else:
13332 
        iprot.skip(ftype)
13333 
      iprot.readFieldEnd()
13334 
    iprot.readStructEnd()
13335 
 
13336 
  def write(self, oprot):
13337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13339 
      return
3064 chandransh 13340 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 13341 
    if self.success is not None:
3064 chandransh 13342 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13343 
      oprot.writeBool(self.success)
1113 chandransh 13344 
      oprot.writeFieldEnd()
3431 rajveer 13345 
    if self.ex is not None:
1113 chandransh 13346 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13347 
      self.ex.write(oprot)
13348 
      oprot.writeFieldEnd()
13349 
    oprot.writeFieldStop()
13350 
    oprot.writeStructEnd()
13351 
 
3431 rajveer 13352 
  def validate(self):
13353 
    return
13354 
 
13355 
 
1113 chandransh 13356 
  def __repr__(self):
13357 
    L = ['%s=%r' % (key, value)
13358 
      for key, value in self.__dict__.iteritems()]
13359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13360 
 
13361 
  def __eq__(self, other):
13362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13363 
 
13364 
  def __ne__(self, other):
13365 
    return not (self == other)
13366 
 
3064 chandransh 13367 
class addBillingDetails_args:
1135 chandransh 13368 
  """
13369 
  Attributes:
3064 chandransh 13370 
   - orderId
13371 
   - invoice_number
4658 mandeep.dh 13372 
   - serialNumber
4283 anupam.sin 13373 
   - itemNumber
3064 chandransh 13374 
   - billed_by
4264 rajveer 13375 
   - jacketNumber
4283 anupam.sin 13376 
   - billingType
5110 mandeep.dh 13377 
   - fulfilmentWarehouseId
4763 rajveer 13378 
   - authorize
1135 chandransh 13379 
  """
13380 
 
13381 
  thrift_spec = (
13382 
    None, # 0
3064 chandransh 13383 
    (1, TType.I64, 'orderId', None, None, ), # 1
13384 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 13385 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
13386 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 13387 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
13388 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
13389 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 13390 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 13391 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 13392 
  )
13393 
 
5110 mandeep.dh 13394 
  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 13395 
    self.orderId = orderId
13396 
    self.invoice_number = invoice_number
4658 mandeep.dh 13397 
    self.serialNumber = serialNumber
4283 anupam.sin 13398 
    self.itemNumber = itemNumber
3064 chandransh 13399 
    self.billed_by = billed_by
4264 rajveer 13400 
    self.jacketNumber = jacketNumber
4283 anupam.sin 13401 
    self.billingType = billingType
5110 mandeep.dh 13402 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 13403 
    self.authorize = authorize
1135 chandransh 13404 
 
13405 
  def read(self, iprot):
13406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13408 
      return
13409 
    iprot.readStructBegin()
13410 
    while True:
13411 
      (fname, ftype, fid) = iprot.readFieldBegin()
13412 
      if ftype == TType.STOP:
13413 
        break
13414 
      if fid == 1:
13415 
        if ftype == TType.I64:
3064 chandransh 13416 
          self.orderId = iprot.readI64();
1135 chandransh 13417 
        else:
13418 
          iprot.skip(ftype)
13419 
      elif fid == 2:
3064 chandransh 13420 
        if ftype == TType.STRING:
13421 
          self.invoice_number = iprot.readString();
1135 chandransh 13422 
        else:
13423 
          iprot.skip(ftype)
3064 chandransh 13424 
      elif fid == 3:
5411 rajveer 13425 
        if ftype == TType.LIST:
13426 
          self.serialNumber = []
6188 rajveer 13427 
          (_etype270, _size267) = iprot.readListBegin()
13428 
          for _i271 in xrange(_size267):
13429 
            _elem272 = iprot.readString();
13430 
            self.serialNumber.append(_elem272)
5411 rajveer 13431 
          iprot.readListEnd()
3064 chandransh 13432 
        else:
13433 
          iprot.skip(ftype)
13434 
      elif fid == 4:
5411 rajveer 13435 
        if ftype == TType.LIST:
13436 
          self.itemNumber = []
6188 rajveer 13437 
          (_etype276, _size273) = iprot.readListBegin()
13438 
          for _i277 in xrange(_size273):
13439 
            _elem278 = iprot.readString();
13440 
            self.itemNumber.append(_elem278)
5411 rajveer 13441 
          iprot.readListEnd()
3064 chandransh 13442 
        else:
13443 
          iprot.skip(ftype)
13444 
      elif fid == 5:
13445 
        if ftype == TType.STRING:
4283 anupam.sin 13446 
          self.billed_by = iprot.readString();
3064 chandransh 13447 
        else:
13448 
          iprot.skip(ftype)
13449 
      elif fid == 6:
13450 
        if ftype == TType.I64:
4283 anupam.sin 13451 
          self.jacketNumber = iprot.readI64();
13452 
        else:
13453 
          iprot.skip(ftype)
13454 
      elif fid == 7:
13455 
        if ftype == TType.I64:
3064 chandransh 13456 
          self.billingType = iprot.readI64();
13457 
        else:
13458 
          iprot.skip(ftype)
4283 anupam.sin 13459 
      elif fid == 8:
13460 
        if ftype == TType.I64:
5110 mandeep.dh 13461 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13462 
        else:
13463 
          iprot.skip(ftype)
4763 rajveer 13464 
      elif fid == 9:
13465 
        if ftype == TType.BOOL:
13466 
          self.authorize = iprot.readBool();
13467 
        else:
13468 
          iprot.skip(ftype)
1246 chandransh 13469 
      else:
13470 
        iprot.skip(ftype)
13471 
      iprot.readFieldEnd()
13472 
    iprot.readStructEnd()
13473 
 
13474 
  def write(self, oprot):
13475 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13476 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13477 
      return
4283 anupam.sin 13478 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 13479 
    if self.orderId is not None:
3064 chandransh 13480 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13481 
      oprot.writeI64(self.orderId)
1246 chandransh 13482 
      oprot.writeFieldEnd()
4283 anupam.sin 13483 
    if self.invoice_number is not None:
13484 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
13485 
      oprot.writeString(self.invoice_number)
1246 chandransh 13486 
      oprot.writeFieldEnd()
4658 mandeep.dh 13487 
    if self.serialNumber is not None:
5411 rajveer 13488 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
13489 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 13490 
      for iter279 in self.serialNumber:
13491 
        oprot.writeString(iter279)
5411 rajveer 13492 
      oprot.writeListEnd()
3064 chandransh 13493 
      oprot.writeFieldEnd()
3431 rajveer 13494 
    if self.itemNumber is not None:
5411 rajveer 13495 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
13496 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 13497 
      for iter280 in self.itemNumber:
13498 
        oprot.writeString(iter280)
5411 rajveer 13499 
      oprot.writeListEnd()
3064 chandransh 13500 
      oprot.writeFieldEnd()
4283 anupam.sin 13501 
    if self.billed_by is not None:
13502 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
13503 
      oprot.writeString(self.billed_by)
3064 chandransh 13504 
      oprot.writeFieldEnd()
4283 anupam.sin 13505 
    if self.jacketNumber is not None:
13506 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
13507 
      oprot.writeI64(self.jacketNumber)
13508 
      oprot.writeFieldEnd()
3431 rajveer 13509 
    if self.billingType is not None:
4283 anupam.sin 13510 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 13511 
      oprot.writeI64(self.billingType)
13512 
      oprot.writeFieldEnd()
5110 mandeep.dh 13513 
    if self.fulfilmentWarehouseId is not None:
13514 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
13515 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 13516 
      oprot.writeFieldEnd()
4763 rajveer 13517 
    if self.authorize is not None:
13518 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
13519 
      oprot.writeBool(self.authorize)
13520 
      oprot.writeFieldEnd()
1246 chandransh 13521 
    oprot.writeFieldStop()
13522 
    oprot.writeStructEnd()
13523 
 
3431 rajveer 13524 
  def validate(self):
13525 
    return
13526 
 
13527 
 
1246 chandransh 13528 
  def __repr__(self):
13529 
    L = ['%s=%r' % (key, value)
13530 
      for key, value in self.__dict__.iteritems()]
13531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13532 
 
13533 
  def __eq__(self, other):
13534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13535 
 
13536 
  def __ne__(self, other):
13537 
    return not (self == other)
13538 
 
4283 anupam.sin 13539 
class addBillingDetails_result:
1246 chandransh 13540 
  """
13541 
  Attributes:
3064 chandransh 13542 
   - success
1246 chandransh 13543 
   - ex
13544 
  """
13545 
 
13546 
  thrift_spec = (
3064 chandransh 13547 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 13548 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13549 
  )
13550 
 
3064 chandransh 13551 
  def __init__(self, success=None, ex=None,):
13552 
    self.success = success
1246 chandransh 13553 
    self.ex = ex
13554 
 
13555 
  def read(self, iprot):
13556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13558 
      return
13559 
    iprot.readStructBegin()
13560 
    while True:
13561 
      (fname, ftype, fid) = iprot.readFieldBegin()
13562 
      if ftype == TType.STOP:
13563 
        break
3064 chandransh 13564 
      if fid == 0:
13565 
        if ftype == TType.BOOL:
13566 
          self.success = iprot.readBool();
13567 
        else:
13568 
          iprot.skip(ftype)
13569 
      elif fid == 1:
1246 chandransh 13570 
        if ftype == TType.STRUCT:
13571 
          self.ex = TransactionServiceException()
13572 
          self.ex.read(iprot)
13573 
        else:
13574 
          iprot.skip(ftype)
13575 
      else:
13576 
        iprot.skip(ftype)
13577 
      iprot.readFieldEnd()
13578 
    iprot.readStructEnd()
13579 
 
13580 
  def write(self, oprot):
13581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13583 
      return
4283 anupam.sin 13584 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 13585 
    if self.success is not None:
3064 chandransh 13586 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13587 
      oprot.writeBool(self.success)
13588 
      oprot.writeFieldEnd()
3431 rajveer 13589 
    if self.ex is not None:
1246 chandransh 13590 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13591 
      self.ex.write(oprot)
13592 
      oprot.writeFieldEnd()
13593 
    oprot.writeFieldStop()
13594 
    oprot.writeStructEnd()
13595 
 
3431 rajveer 13596 
  def validate(self):
13597 
    return
13598 
 
13599 
 
1246 chandransh 13600 
  def __repr__(self):
13601 
    L = ['%s=%r' % (key, value)
13602 
      for key, value in self.__dict__.iteritems()]
13603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13604 
 
13605 
  def __eq__(self, other):
13606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13607 
 
13608 
  def __ne__(self, other):
13609 
    return not (self == other)
13610 
 
4579 rajveer 13611 
class addInvoiceNumber_args:
13612 
  """
13613 
  Attributes:
13614 
   - orderId
13615 
   - invoiceNumber
4763 rajveer 13616 
   - color
4579 rajveer 13617 
  """
13618 
 
13619 
  thrift_spec = (
13620 
    None, # 0
13621 
    (1, TType.I64, 'orderId', None, None, ), # 1
13622 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 13623 
    (3, TType.STRING, 'color', None, None, ), # 3
4579 rajveer 13624 
  )
13625 
 
4763 rajveer 13626 
  def __init__(self, orderId=None, invoiceNumber=None, color=None,):
4579 rajveer 13627 
    self.orderId = orderId
13628 
    self.invoiceNumber = invoiceNumber
4763 rajveer 13629 
    self.color = color
4579 rajveer 13630 
 
13631 
  def read(self, iprot):
13632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13634 
      return
13635 
    iprot.readStructBegin()
13636 
    while True:
13637 
      (fname, ftype, fid) = iprot.readFieldBegin()
13638 
      if ftype == TType.STOP:
13639 
        break
13640 
      if fid == 1:
13641 
        if ftype == TType.I64:
13642 
          self.orderId = iprot.readI64();
13643 
        else:
13644 
          iprot.skip(ftype)
13645 
      elif fid == 2:
13646 
        if ftype == TType.STRING:
13647 
          self.invoiceNumber = iprot.readString();
13648 
        else:
13649 
          iprot.skip(ftype)
4763 rajveer 13650 
      elif fid == 3:
13651 
        if ftype == TType.STRING:
13652 
          self.color = iprot.readString();
13653 
        else:
13654 
          iprot.skip(ftype)
4579 rajveer 13655 
      else:
13656 
        iprot.skip(ftype)
13657 
      iprot.readFieldEnd()
13658 
    iprot.readStructEnd()
13659 
 
13660 
  def write(self, oprot):
13661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13663 
      return
13664 
    oprot.writeStructBegin('addInvoiceNumber_args')
13665 
    if self.orderId is not None:
13666 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13667 
      oprot.writeI64(self.orderId)
13668 
      oprot.writeFieldEnd()
13669 
    if self.invoiceNumber is not None:
13670 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
13671 
      oprot.writeString(self.invoiceNumber)
13672 
      oprot.writeFieldEnd()
4763 rajveer 13673 
    if self.color is not None:
13674 
      oprot.writeFieldBegin('color', TType.STRING, 3)
13675 
      oprot.writeString(self.color)
13676 
      oprot.writeFieldEnd()
4579 rajveer 13677 
    oprot.writeFieldStop()
13678 
    oprot.writeStructEnd()
13679 
 
13680 
  def validate(self):
13681 
    return
13682 
 
13683 
 
13684 
  def __repr__(self):
13685 
    L = ['%s=%r' % (key, value)
13686 
      for key, value in self.__dict__.iteritems()]
13687 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13688 
 
13689 
  def __eq__(self, other):
13690 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13691 
 
13692 
  def __ne__(self, other):
13693 
    return not (self == other)
13694 
 
13695 
class addInvoiceNumber_result:
13696 
  """
13697 
  Attributes:
13698 
   - ex
13699 
  """
13700 
 
13701 
  thrift_spec = (
13702 
    None, # 0
13703 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13704 
  )
13705 
 
13706 
  def __init__(self, ex=None,):
13707 
    self.ex = ex
13708 
 
13709 
  def read(self, iprot):
13710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13712 
      return
13713 
    iprot.readStructBegin()
13714 
    while True:
13715 
      (fname, ftype, fid) = iprot.readFieldBegin()
13716 
      if ftype == TType.STOP:
13717 
        break
13718 
      if fid == 1:
13719 
        if ftype == TType.STRUCT:
13720 
          self.ex = TransactionServiceException()
13721 
          self.ex.read(iprot)
13722 
        else:
13723 
          iprot.skip(ftype)
13724 
      else:
13725 
        iprot.skip(ftype)
13726 
      iprot.readFieldEnd()
13727 
    iprot.readStructEnd()
13728 
 
13729 
  def write(self, oprot):
13730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13732 
      return
13733 
    oprot.writeStructBegin('addInvoiceNumber_result')
13734 
    if self.ex is not None:
13735 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13736 
      self.ex.write(oprot)
13737 
      oprot.writeFieldEnd()
13738 
    oprot.writeFieldStop()
13739 
    oprot.writeStructEnd()
13740 
 
13741 
  def validate(self):
13742 
    return
13743 
 
13744 
 
13745 
  def __repr__(self):
13746 
    L = ['%s=%r' % (key, value)
13747 
      for key, value in self.__dict__.iteritems()]
13748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13749 
 
13750 
  def __eq__(self, other):
13751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13752 
 
13753 
  def __ne__(self, other):
13754 
    return not (self == other)
13755 
 
4910 phani.kuma 13756 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 13757 
  """
13758 
  Attributes:
3064 chandransh 13759 
   - warehouseId
1408 ankur.sing 13760 
   - providerId
3064 chandransh 13761 
   - cod
4910 phani.kuma 13762 
   - orderIds
1408 ankur.sing 13763 
  """
13764 
 
13765 
  thrift_spec = (
13766 
    None, # 0
3064 chandransh 13767 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13768 
    (2, TType.I64, 'providerId', None, None, ), # 2
13769 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 13770 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 13771 
  )
13772 
 
4910 phani.kuma 13773 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 13774 
    self.warehouseId = warehouseId
1408 ankur.sing 13775 
    self.providerId = providerId
3064 chandransh 13776 
    self.cod = cod
4910 phani.kuma 13777 
    self.orderIds = orderIds
1408 ankur.sing 13778 
 
13779 
  def read(self, iprot):
13780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13782 
      return
13783 
    iprot.readStructBegin()
13784 
    while True:
13785 
      (fname, ftype, fid) = iprot.readFieldBegin()
13786 
      if ftype == TType.STOP:
13787 
        break
13788 
      if fid == 1:
13789 
        if ftype == TType.I64:
3064 chandransh 13790 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 13791 
        else:
13792 
          iprot.skip(ftype)
13793 
      elif fid == 2:
13794 
        if ftype == TType.I64:
3064 chandransh 13795 
          self.providerId = iprot.readI64();
1408 ankur.sing 13796 
        else:
13797 
          iprot.skip(ftype)
3064 chandransh 13798 
      elif fid == 3:
13799 
        if ftype == TType.BOOL:
13800 
          self.cod = iprot.readBool();
13801 
        else:
13802 
          iprot.skip(ftype)
4910 phani.kuma 13803 
      elif fid == 4:
13804 
        if ftype == TType.LIST:
13805 
          self.orderIds = []
6188 rajveer 13806 
          (_etype284, _size281) = iprot.readListBegin()
13807 
          for _i285 in xrange(_size281):
13808 
            _elem286 = iprot.readI64();
13809 
            self.orderIds.append(_elem286)
4910 phani.kuma 13810 
          iprot.readListEnd()
13811 
        else:
13812 
          iprot.skip(ftype)
1408 ankur.sing 13813 
      else:
13814 
        iprot.skip(ftype)
13815 
      iprot.readFieldEnd()
13816 
    iprot.readStructEnd()
13817 
 
13818 
  def write(self, oprot):
13819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13821 
      return
4910 phani.kuma 13822 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 13823 
    if self.warehouseId is not None:
3064 chandransh 13824 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13825 
      oprot.writeI64(self.warehouseId)
13826 
      oprot.writeFieldEnd()
3431 rajveer 13827 
    if self.providerId is not None:
3064 chandransh 13828 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 13829 
      oprot.writeI64(self.providerId)
13830 
      oprot.writeFieldEnd()
3431 rajveer 13831 
    if self.cod is not None:
3064 chandransh 13832 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
13833 
      oprot.writeBool(self.cod)
1408 ankur.sing 13834 
      oprot.writeFieldEnd()
4910 phani.kuma 13835 
    if self.orderIds is not None:
13836 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
13837 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 13838 
      for iter287 in self.orderIds:
13839 
        oprot.writeI64(iter287)
4910 phani.kuma 13840 
      oprot.writeListEnd()
13841 
      oprot.writeFieldEnd()
1408 ankur.sing 13842 
    oprot.writeFieldStop()
13843 
    oprot.writeStructEnd()
13844 
 
3431 rajveer 13845 
  def validate(self):
13846 
    return
13847 
 
13848 
 
1408 ankur.sing 13849 
  def __repr__(self):
13850 
    L = ['%s=%r' % (key, value)
13851 
      for key, value in self.__dict__.iteritems()]
13852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13853 
 
13854 
  def __eq__(self, other):
13855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13856 
 
13857 
  def __ne__(self, other):
13858 
    return not (self == other)
13859 
 
4910 phani.kuma 13860 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 13861 
  """
13862 
  Attributes:
13863 
   - success
3064 chandransh 13864 
   - ex
1408 ankur.sing 13865 
  """
13866 
 
13867 
  thrift_spec = (
3064 chandransh 13868 
    (0, TType.BOOL, 'success', None, None, ), # 0
13869 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 13870 
  )
13871 
 
3064 chandransh 13872 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 13873 
    self.success = success
3064 chandransh 13874 
    self.ex = ex
1408 ankur.sing 13875 
 
13876 
  def read(self, iprot):
13877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13879 
      return
13880 
    iprot.readStructBegin()
13881 
    while True:
13882 
      (fname, ftype, fid) = iprot.readFieldBegin()
13883 
      if ftype == TType.STOP:
13884 
        break
13885 
      if fid == 0:
3064 chandransh 13886 
        if ftype == TType.BOOL:
13887 
          self.success = iprot.readBool();
1408 ankur.sing 13888 
        else:
13889 
          iprot.skip(ftype)
3064 chandransh 13890 
      elif fid == 1:
13891 
        if ftype == TType.STRUCT:
13892 
          self.ex = TransactionServiceException()
13893 
          self.ex.read(iprot)
13894 
        else:
13895 
          iprot.skip(ftype)
1408 ankur.sing 13896 
      else:
13897 
        iprot.skip(ftype)
13898 
      iprot.readFieldEnd()
13899 
    iprot.readStructEnd()
13900 
 
13901 
  def write(self, oprot):
13902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13904 
      return
4910 phani.kuma 13905 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 13906 
    if self.success is not None:
3064 chandransh 13907 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13908 
      oprot.writeBool(self.success)
1408 ankur.sing 13909 
      oprot.writeFieldEnd()
3431 rajveer 13910 
    if self.ex is not None:
3064 chandransh 13911 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13912 
      self.ex.write(oprot)
13913 
      oprot.writeFieldEnd()
1408 ankur.sing 13914 
    oprot.writeFieldStop()
13915 
    oprot.writeStructEnd()
13916 
 
3431 rajveer 13917 
  def validate(self):
13918 
    return
13919 
 
13920 
 
1408 ankur.sing 13921 
  def __repr__(self):
13922 
    L = ['%s=%r' % (key, value)
13923 
      for key, value in self.__dict__.iteritems()]
13924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13925 
 
13926 
  def __eq__(self, other):
13927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13928 
 
13929 
  def __ne__(self, other):
13930 
    return not (self == other)
13931 
 
5676 rajveer 13932 
class markOrdersAsReturnedFromStore_args:
13933 
  """
13934 
  Attributes:
13935 
   - providerId
13936 
   - orderIds
5713 rajveer 13937 
   - awbs
5676 rajveer 13938 
  """
13939 
 
13940 
  thrift_spec = (
13941 
    None, # 0
13942 
    (1, TType.I64, 'providerId', None, None, ), # 1
13943 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 13944 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 13945 
  )
13946 
 
5713 rajveer 13947 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 13948 
    self.providerId = providerId
13949 
    self.orderIds = orderIds
5713 rajveer 13950 
    self.awbs = awbs
5676 rajveer 13951 
 
13952 
  def read(self, iprot):
13953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13955 
      return
13956 
    iprot.readStructBegin()
13957 
    while True:
13958 
      (fname, ftype, fid) = iprot.readFieldBegin()
13959 
      if ftype == TType.STOP:
13960 
        break
13961 
      if fid == 1:
13962 
        if ftype == TType.I64:
13963 
          self.providerId = iprot.readI64();
13964 
        else:
13965 
          iprot.skip(ftype)
13966 
      elif fid == 2:
13967 
        if ftype == TType.LIST:
13968 
          self.orderIds = []
6188 rajveer 13969 
          (_etype291, _size288) = iprot.readListBegin()
13970 
          for _i292 in xrange(_size288):
13971 
            _elem293 = iprot.readI64();
13972 
            self.orderIds.append(_elem293)
5676 rajveer 13973 
          iprot.readListEnd()
13974 
        else:
13975 
          iprot.skip(ftype)
5713 rajveer 13976 
      elif fid == 3:
13977 
        if ftype == TType.LIST:
13978 
          self.awbs = []
6188 rajveer 13979 
          (_etype297, _size294) = iprot.readListBegin()
13980 
          for _i298 in xrange(_size294):
13981 
            _elem299 = iprot.readString();
13982 
            self.awbs.append(_elem299)
5713 rajveer 13983 
          iprot.readListEnd()
13984 
        else:
13985 
          iprot.skip(ftype)
5676 rajveer 13986 
      else:
13987 
        iprot.skip(ftype)
13988 
      iprot.readFieldEnd()
13989 
    iprot.readStructEnd()
13990 
 
13991 
  def write(self, oprot):
13992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13994 
      return
13995 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
13996 
    if self.providerId is not None:
13997 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
13998 
      oprot.writeI64(self.providerId)
13999 
      oprot.writeFieldEnd()
14000 
    if self.orderIds is not None:
14001 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
14002 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14003 
      for iter300 in self.orderIds:
14004 
        oprot.writeI64(iter300)
5676 rajveer 14005 
      oprot.writeListEnd()
14006 
      oprot.writeFieldEnd()
5713 rajveer 14007 
    if self.awbs is not None:
14008 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
14009 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 14010 
      for iter301 in self.awbs:
14011 
        oprot.writeString(iter301)
5713 rajveer 14012 
      oprot.writeListEnd()
14013 
      oprot.writeFieldEnd()
5676 rajveer 14014 
    oprot.writeFieldStop()
14015 
    oprot.writeStructEnd()
14016 
 
14017 
  def validate(self):
14018 
    return
14019 
 
14020 
 
14021 
  def __repr__(self):
14022 
    L = ['%s=%r' % (key, value)
14023 
      for key, value in self.__dict__.iteritems()]
14024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14025 
 
14026 
  def __eq__(self, other):
14027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14028 
 
14029 
  def __ne__(self, other):
14030 
    return not (self == other)
14031 
 
14032 
class markOrdersAsReturnedFromStore_result:
14033 
  """
14034 
  Attributes:
14035 
   - success
14036 
   - ex
14037 
  """
14038 
 
14039 
  thrift_spec = (
14040 
    (0, TType.BOOL, 'success', None, None, ), # 0
14041 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14042 
  )
14043 
 
14044 
  def __init__(self, success=None, ex=None,):
14045 
    self.success = success
14046 
    self.ex = ex
14047 
 
14048 
  def read(self, iprot):
14049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14051 
      return
14052 
    iprot.readStructBegin()
14053 
    while True:
14054 
      (fname, ftype, fid) = iprot.readFieldBegin()
14055 
      if ftype == TType.STOP:
14056 
        break
14057 
      if fid == 0:
14058 
        if ftype == TType.BOOL:
14059 
          self.success = iprot.readBool();
14060 
        else:
14061 
          iprot.skip(ftype)
14062 
      elif fid == 1:
14063 
        if ftype == TType.STRUCT:
14064 
          self.ex = TransactionServiceException()
14065 
          self.ex.read(iprot)
14066 
        else:
14067 
          iprot.skip(ftype)
14068 
      else:
14069 
        iprot.skip(ftype)
14070 
      iprot.readFieldEnd()
14071 
    iprot.readStructEnd()
14072 
 
14073 
  def write(self, oprot):
14074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14076 
      return
14077 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
14078 
    if self.success is not None:
14079 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14080 
      oprot.writeBool(self.success)
14081 
      oprot.writeFieldEnd()
14082 
    if self.ex is not None:
14083 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14084 
      self.ex.write(oprot)
14085 
      oprot.writeFieldEnd()
14086 
    oprot.writeFieldStop()
14087 
    oprot.writeStructEnd()
14088 
 
14089 
  def validate(self):
14090 
    return
14091 
 
14092 
 
14093 
  def __repr__(self):
14094 
    L = ['%s=%r' % (key, value)
14095 
      for key, value in self.__dict__.iteritems()]
14096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14097 
 
14098 
  def __eq__(self, other):
14099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14100 
 
14101 
  def __ne__(self, other):
14102 
    return not (self == other)
14103 
 
4910 phani.kuma 14104 
class markOrdersAsPickedUp_args:
4410 rajveer 14105 
  """
14106 
  Attributes:
14107 
   - providerId
4910 phani.kuma 14108 
   - pickupDetails
4410 rajveer 14109 
  """
14110 
 
14111 
  thrift_spec = (
14112 
    None, # 0
4910 phani.kuma 14113 
    (1, TType.I64, 'providerId', None, None, ), # 1
14114 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 14115 
  )
14116 
 
4910 phani.kuma 14117 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 14118 
    self.providerId = providerId
4910 phani.kuma 14119 
    self.pickupDetails = pickupDetails
4410 rajveer 14120 
 
14121 
  def read(self, iprot):
14122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14124 
      return
14125 
    iprot.readStructBegin()
14126 
    while True:
14127 
      (fname, ftype, fid) = iprot.readFieldBegin()
14128 
      if ftype == TType.STOP:
14129 
        break
14130 
      if fid == 1:
14131 
        if ftype == TType.I64:
4910 phani.kuma 14132 
          self.providerId = iprot.readI64();
4410 rajveer 14133 
        else:
14134 
          iprot.skip(ftype)
14135 
      elif fid == 2:
4910 phani.kuma 14136 
        if ftype == TType.MAP:
14137 
          self.pickupDetails = {}
6188 rajveer 14138 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
14139 
          for _i306 in xrange(_size302):
14140 
            _key307 = iprot.readString();
14141 
            _val308 = iprot.readString();
14142 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 14143 
          iprot.readMapEnd()
4410 rajveer 14144 
        else:
14145 
          iprot.skip(ftype)
14146 
      else:
14147 
        iprot.skip(ftype)
14148 
      iprot.readFieldEnd()
14149 
    iprot.readStructEnd()
14150 
 
14151 
  def write(self, oprot):
14152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14154 
      return
4910 phani.kuma 14155 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 14156 
    if self.providerId is not None:
4910 phani.kuma 14157 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 14158 
      oprot.writeI64(self.providerId)
14159 
      oprot.writeFieldEnd()
4910 phani.kuma 14160 
    if self.pickupDetails is not None:
14161 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14162 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 14163 
      for kiter309,viter310 in self.pickupDetails.items():
14164 
        oprot.writeString(kiter309)
14165 
        oprot.writeString(viter310)
4910 phani.kuma 14166 
      oprot.writeMapEnd()
4410 rajveer 14167 
      oprot.writeFieldEnd()
14168 
    oprot.writeFieldStop()
14169 
    oprot.writeStructEnd()
14170 
 
14171 
  def validate(self):
14172 
    return
14173 
 
14174 
 
14175 
  def __repr__(self):
14176 
    L = ['%s=%r' % (key, value)
14177 
      for key, value in self.__dict__.iteritems()]
14178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14179 
 
14180 
  def __eq__(self, other):
14181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14182 
 
14183 
  def __ne__(self, other):
14184 
    return not (self == other)
14185 
 
4910 phani.kuma 14186 
class markOrdersAsPickedUp_result:
4410 rajveer 14187 
  """
14188 
  Attributes:
14189 
   - ex
14190 
  """
14191 
 
14192 
  thrift_spec = (
4910 phani.kuma 14193 
    None, # 0
4410 rajveer 14194 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14195 
  )
14196 
 
4910 phani.kuma 14197 
  def __init__(self, ex=None,):
4410 rajveer 14198 
    self.ex = ex
14199 
 
14200 
  def read(self, iprot):
14201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14203 
      return
14204 
    iprot.readStructBegin()
14205 
    while True:
14206 
      (fname, ftype, fid) = iprot.readFieldBegin()
14207 
      if ftype == TType.STOP:
14208 
        break
4910 phani.kuma 14209 
      if fid == 1:
4410 rajveer 14210 
        if ftype == TType.STRUCT:
14211 
          self.ex = TransactionServiceException()
14212 
          self.ex.read(iprot)
14213 
        else:
14214 
          iprot.skip(ftype)
14215 
      else:
14216 
        iprot.skip(ftype)
14217 
      iprot.readFieldEnd()
14218 
    iprot.readStructEnd()
14219 
 
14220 
  def write(self, oprot):
14221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14223 
      return
4910 phani.kuma 14224 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 14225 
    if self.ex is not None:
14226 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14227 
      self.ex.write(oprot)
14228 
      oprot.writeFieldEnd()
14229 
    oprot.writeFieldStop()
14230 
    oprot.writeStructEnd()
14231 
 
14232 
  def validate(self):
14233 
    return
14234 
 
14235 
 
14236 
  def __repr__(self):
14237 
    L = ['%s=%r' % (key, value)
14238 
      for key, value in self.__dict__.iteritems()]
14239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14240 
 
14241 
  def __eq__(self, other):
14242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14243 
 
14244 
  def __ne__(self, other):
14245 
    return not (self == other)
14246 
 
4910 phani.kuma 14247 
class getOrdersNotPickedUp_args:
304 ashish 14248 
  """
14249 
  Attributes:
3064 chandransh 14250 
   - providerId
304 ashish 14251 
  """
94 ashish 14252 
 
304 ashish 14253 
  thrift_spec = (
14254 
    None, # 0
3064 chandransh 14255 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 14256 
  )
14257 
 
4910 phani.kuma 14258 
  def __init__(self, providerId=None,):
3064 chandransh 14259 
    self.providerId = providerId
304 ashish 14260 
 
14261 
  def read(self, iprot):
14262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14264 
      return
14265 
    iprot.readStructBegin()
14266 
    while True:
14267 
      (fname, ftype, fid) = iprot.readFieldBegin()
14268 
      if ftype == TType.STOP:
14269 
        break
14270 
      if fid == 1:
14271 
        if ftype == TType.I64:
3064 chandransh 14272 
          self.providerId = iprot.readI64();
304 ashish 14273 
        else:
14274 
          iprot.skip(ftype)
14275 
      else:
14276 
        iprot.skip(ftype)
14277 
      iprot.readFieldEnd()
14278 
    iprot.readStructEnd()
14279 
 
14280 
  def write(self, oprot):
14281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14283 
      return
4910 phani.kuma 14284 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14285 
    if self.providerId is not None:
3064 chandransh 14286 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14287 
      oprot.writeI64(self.providerId)
304 ashish 14288 
      oprot.writeFieldEnd()
14289 
    oprot.writeFieldStop()
14290 
    oprot.writeStructEnd()
14291 
 
3431 rajveer 14292 
  def validate(self):
14293 
    return
14294 
 
14295 
 
304 ashish 14296 
  def __repr__(self):
14297 
    L = ['%s=%r' % (key, value)
14298 
      for key, value in self.__dict__.iteritems()]
14299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14300 
 
14301 
  def __eq__(self, other):
14302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14303 
 
14304 
  def __ne__(self, other):
14305 
    return not (self == other)
14306 
 
4910 phani.kuma 14307 
class getOrdersNotPickedUp_result:
304 ashish 14308 
  """
14309 
  Attributes:
14310 
   - success
14311 
  """
14312 
 
14313 
  thrift_spec = (
3064 chandransh 14314 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 14315 
  )
14316 
 
4910 phani.kuma 14317 
  def __init__(self, success=None,):
304 ashish 14318 
    self.success = success
14319 
 
14320 
  def read(self, iprot):
14321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14323 
      return
14324 
    iprot.readStructBegin()
14325 
    while True:
14326 
      (fname, ftype, fid) = iprot.readFieldBegin()
14327 
      if ftype == TType.STOP:
14328 
        break
14329 
      if fid == 0:
14330 
        if ftype == TType.LIST:
14331 
          self.success = []
6188 rajveer 14332 
          (_etype314, _size311) = iprot.readListBegin()
14333 
          for _i315 in xrange(_size311):
14334 
            _elem316 = Order()
14335 
            _elem316.read(iprot)
14336 
            self.success.append(_elem316)
304 ashish 14337 
          iprot.readListEnd()
14338 
        else:
14339 
          iprot.skip(ftype)
14340 
      else:
14341 
        iprot.skip(ftype)
14342 
      iprot.readFieldEnd()
14343 
    iprot.readStructEnd()
14344 
 
14345 
  def write(self, oprot):
14346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14348 
      return
4910 phani.kuma 14349 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 14350 
    if self.success is not None:
304 ashish 14351 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14352 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14353 
      for iter317 in self.success:
14354 
        iter317.write(oprot)
304 ashish 14355 
      oprot.writeListEnd()
14356 
      oprot.writeFieldEnd()
14357 
    oprot.writeFieldStop()
14358 
    oprot.writeStructEnd()
14359 
 
3431 rajveer 14360 
  def validate(self):
14361 
    return
14362 
 
14363 
 
304 ashish 14364 
  def __repr__(self):
14365 
    L = ['%s=%r' % (key, value)
14366 
      for key, value in self.__dict__.iteritems()]
14367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14368 
 
14369 
  def __eq__(self, other):
14370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14371 
 
14372 
  def __ne__(self, other):
14373 
    return not (self == other)
14374 
 
3064 chandransh 14375 
class markOrdersAsDelivered_args:
304 ashish 14376 
  """
14377 
  Attributes:
3064 chandransh 14378 
   - providerId
14379 
   - deliveredOrders
304 ashish 14380 
  """
14381 
 
14382 
  thrift_spec = (
14383 
    None, # 0
3064 chandransh 14384 
    (1, TType.I64, 'providerId', None, None, ), # 1
14385 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 14386 
  )
14387 
 
3064 chandransh 14388 
  def __init__(self, providerId=None, deliveredOrders=None,):
14389 
    self.providerId = providerId
14390 
    self.deliveredOrders = deliveredOrders
304 ashish 14391 
 
14392 
  def read(self, iprot):
14393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14395 
      return
14396 
    iprot.readStructBegin()
14397 
    while True:
14398 
      (fname, ftype, fid) = iprot.readFieldBegin()
14399 
      if ftype == TType.STOP:
14400 
        break
14401 
      if fid == 1:
14402 
        if ftype == TType.I64:
3064 chandransh 14403 
          self.providerId = iprot.readI64();
304 ashish 14404 
        else:
14405 
          iprot.skip(ftype)
14406 
      elif fid == 2:
3064 chandransh 14407 
        if ftype == TType.MAP:
14408 
          self.deliveredOrders = {}
6188 rajveer 14409 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
14410 
          for _i322 in xrange(_size318):
14411 
            _key323 = iprot.readString();
14412 
            _val324 = iprot.readString();
14413 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 14414 
          iprot.readMapEnd()
304 ashish 14415 
        else:
14416 
          iprot.skip(ftype)
14417 
      else:
14418 
        iprot.skip(ftype)
14419 
      iprot.readFieldEnd()
14420 
    iprot.readStructEnd()
14421 
 
14422 
  def write(self, oprot):
14423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14425 
      return
3064 chandransh 14426 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14427 
    if self.providerId is not None:
3064 chandransh 14428 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14429 
      oprot.writeI64(self.providerId)
304 ashish 14430 
      oprot.writeFieldEnd()
3431 rajveer 14431 
    if self.deliveredOrders is not None:
3064 chandransh 14432 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14433 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 14434 
      for kiter325,viter326 in self.deliveredOrders.items():
14435 
        oprot.writeString(kiter325)
14436 
        oprot.writeString(viter326)
3064 chandransh 14437 
      oprot.writeMapEnd()
304 ashish 14438 
      oprot.writeFieldEnd()
14439 
    oprot.writeFieldStop()
14440 
    oprot.writeStructEnd()
14441 
 
3431 rajveer 14442 
  def validate(self):
14443 
    return
14444 
 
14445 
 
304 ashish 14446 
  def __repr__(self):
14447 
    L = ['%s=%r' % (key, value)
14448 
      for key, value in self.__dict__.iteritems()]
14449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14450 
 
14451 
  def __eq__(self, other):
14452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14453 
 
14454 
  def __ne__(self, other):
14455 
    return not (self == other)
14456 
 
3064 chandransh 14457 
class markOrdersAsDelivered_result:
14458 
  """
14459 
  Attributes:
14460 
   - ex
14461 
  """
304 ashish 14462 
 
14463 
  thrift_spec = (
3064 chandransh 14464 
    None, # 0
14465 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 14466 
  )
14467 
 
3064 chandransh 14468 
  def __init__(self, ex=None,):
14469 
    self.ex = ex
304 ashish 14470 
 
1596 ankur.sing 14471 
  def read(self, iprot):
14472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14474 
      return
14475 
    iprot.readStructBegin()
14476 
    while True:
14477 
      (fname, ftype, fid) = iprot.readFieldBegin()
14478 
      if ftype == TType.STOP:
14479 
        break
3064 chandransh 14480 
      if fid == 1:
14481 
        if ftype == TType.STRUCT:
14482 
          self.ex = TransactionServiceException()
14483 
          self.ex.read(iprot)
14484 
        else:
14485 
          iprot.skip(ftype)
1596 ankur.sing 14486 
      else:
14487 
        iprot.skip(ftype)
14488 
      iprot.readFieldEnd()
14489 
    iprot.readStructEnd()
14490 
 
14491 
  def write(self, oprot):
14492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14494 
      return
3064 chandransh 14495 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 14496 
    if self.ex is not None:
3064 chandransh 14497 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14498 
      self.ex.write(oprot)
14499 
      oprot.writeFieldEnd()
1596 ankur.sing 14500 
    oprot.writeFieldStop()
14501 
    oprot.writeStructEnd()
14502 
 
3431 rajveer 14503 
  def validate(self):
14504 
    return
14505 
 
14506 
 
1596 ankur.sing 14507 
  def __repr__(self):
14508 
    L = ['%s=%r' % (key, value)
14509 
      for key, value in self.__dict__.iteritems()]
14510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14511 
 
14512 
  def __eq__(self, other):
14513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14514 
 
14515 
  def __ne__(self, other):
14516 
    return not (self == other)
14517 
 
4910 phani.kuma 14518 
class markAsRTOrders_args:
1596 ankur.sing 14519 
  """
14520 
  Attributes:
3064 chandransh 14521 
   - providerId
14522 
   - returnedOrders
1596 ankur.sing 14523 
  """
14524 
 
14525 
  thrift_spec = (
3064 chandransh 14526 
    None, # 0
14527 
    (1, TType.I64, 'providerId', None, None, ), # 1
14528 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 14529 
  )
14530 
 
3064 chandransh 14531 
  def __init__(self, providerId=None, returnedOrders=None,):
14532 
    self.providerId = providerId
14533 
    self.returnedOrders = returnedOrders
1596 ankur.sing 14534 
 
14535 
  def read(self, iprot):
14536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14538 
      return
14539 
    iprot.readStructBegin()
14540 
    while True:
14541 
      (fname, ftype, fid) = iprot.readFieldBegin()
14542 
      if ftype == TType.STOP:
14543 
        break
3064 chandransh 14544 
      if fid == 1:
1596 ankur.sing 14545 
        if ftype == TType.I64:
3064 chandransh 14546 
          self.providerId = iprot.readI64();
1596 ankur.sing 14547 
        else:
14548 
          iprot.skip(ftype)
3064 chandransh 14549 
      elif fid == 2:
14550 
        if ftype == TType.MAP:
14551 
          self.returnedOrders = {}
6188 rajveer 14552 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
14553 
          for _i331 in xrange(_size327):
14554 
            _key332 = iprot.readString();
14555 
            _val333 = iprot.readString();
14556 
            self.returnedOrders[_key332] = _val333
3064 chandransh 14557 
          iprot.readMapEnd()
14558 
        else:
14559 
          iprot.skip(ftype)
1596 ankur.sing 14560 
      else:
14561 
        iprot.skip(ftype)
14562 
      iprot.readFieldEnd()
14563 
    iprot.readStructEnd()
14564 
 
14565 
  def write(self, oprot):
14566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14568 
      return
4910 phani.kuma 14569 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 14570 
    if self.providerId is not None:
3064 chandransh 14571 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14572 
      oprot.writeI64(self.providerId)
1596 ankur.sing 14573 
      oprot.writeFieldEnd()
3431 rajveer 14574 
    if self.returnedOrders is not None:
3064 chandransh 14575 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
14576 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 14577 
      for kiter334,viter335 in self.returnedOrders.items():
14578 
        oprot.writeString(kiter334)
14579 
        oprot.writeString(viter335)
3064 chandransh 14580 
      oprot.writeMapEnd()
14581 
      oprot.writeFieldEnd()
1596 ankur.sing 14582 
    oprot.writeFieldStop()
14583 
    oprot.writeStructEnd()
14584 
 
3431 rajveer 14585 
  def validate(self):
14586 
    return
14587 
 
14588 
 
1596 ankur.sing 14589 
  def __repr__(self):
14590 
    L = ['%s=%r' % (key, value)
14591 
      for key, value in self.__dict__.iteritems()]
14592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14593 
 
14594 
  def __eq__(self, other):
14595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14596 
 
14597 
  def __ne__(self, other):
14598 
    return not (self == other)
14599 
 
4910 phani.kuma 14600 
class markAsRTOrders_result:
3064 chandransh 14601 
  """
14602 
  Attributes:
14603 
   - ex
14604 
  """
1596 ankur.sing 14605 
 
1627 ankur.sing 14606 
  thrift_spec = (
3064 chandransh 14607 
    None, # 0
14608 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14609 
  )
14610 
 
3064 chandransh 14611 
  def __init__(self, ex=None,):
14612 
    self.ex = ex
14613 
 
1627 ankur.sing 14614 
  def read(self, iprot):
14615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14617 
      return
14618 
    iprot.readStructBegin()
14619 
    while True:
14620 
      (fname, ftype, fid) = iprot.readFieldBegin()
14621 
      if ftype == TType.STOP:
14622 
        break
3064 chandransh 14623 
      if fid == 1:
14624 
        if ftype == TType.STRUCT:
14625 
          self.ex = TransactionServiceException()
14626 
          self.ex.read(iprot)
14627 
        else:
14628 
          iprot.skip(ftype)
1627 ankur.sing 14629 
      else:
14630 
        iprot.skip(ftype)
14631 
      iprot.readFieldEnd()
14632 
    iprot.readStructEnd()
14633 
 
14634 
  def write(self, oprot):
14635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14637 
      return
4910 phani.kuma 14638 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 14639 
    if self.ex is not None:
3064 chandransh 14640 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14641 
      self.ex.write(oprot)
14642 
      oprot.writeFieldEnd()
1627 ankur.sing 14643 
    oprot.writeFieldStop()
14644 
    oprot.writeStructEnd()
14645 
 
3431 rajveer 14646 
  def validate(self):
14647 
    return
14648 
 
14649 
 
1627 ankur.sing 14650 
  def __repr__(self):
14651 
    L = ['%s=%r' % (key, value)
14652 
      for key, value in self.__dict__.iteritems()]
14653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14654 
 
14655 
  def __eq__(self, other):
14656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14657 
 
14658 
  def __ne__(self, other):
14659 
    return not (self == other)
14660 
 
4910 phani.kuma 14661 
class getRTOrders_args:
14662 
  """
14663 
  Attributes:
14664 
   - providerId
14665 
  """
14666 
 
14667 
  thrift_spec = (
14668 
    None, # 0
14669 
    (1, TType.I64, 'providerId', None, None, ), # 1
14670 
  )
14671 
 
14672 
  def __init__(self, providerId=None,):
14673 
    self.providerId = providerId
14674 
 
14675 
  def read(self, iprot):
14676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14678 
      return
14679 
    iprot.readStructBegin()
14680 
    while True:
14681 
      (fname, ftype, fid) = iprot.readFieldBegin()
14682 
      if ftype == TType.STOP:
14683 
        break
14684 
      if fid == 1:
14685 
        if ftype == TType.I64:
14686 
          self.providerId = iprot.readI64();
14687 
        else:
14688 
          iprot.skip(ftype)
14689 
      else:
14690 
        iprot.skip(ftype)
14691 
      iprot.readFieldEnd()
14692 
    iprot.readStructEnd()
14693 
 
14694 
  def write(self, oprot):
14695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14697 
      return
14698 
    oprot.writeStructBegin('getRTOrders_args')
14699 
    if self.providerId is not None:
14700 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14701 
      oprot.writeI64(self.providerId)
14702 
      oprot.writeFieldEnd()
14703 
    oprot.writeFieldStop()
14704 
    oprot.writeStructEnd()
14705 
 
14706 
  def validate(self):
14707 
    return
14708 
 
14709 
 
14710 
  def __repr__(self):
14711 
    L = ['%s=%r' % (key, value)
14712 
      for key, value in self.__dict__.iteritems()]
14713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14714 
 
14715 
  def __eq__(self, other):
14716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14717 
 
14718 
  def __ne__(self, other):
14719 
    return not (self == other)
14720 
 
14721 
class getRTOrders_result:
14722 
  """
14723 
  Attributes:
14724 
   - success
14725 
  """
14726 
 
14727 
  thrift_spec = (
14728 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14729 
  )
14730 
 
14731 
  def __init__(self, success=None,):
14732 
    self.success = success
14733 
 
14734 
  def read(self, iprot):
14735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14737 
      return
14738 
    iprot.readStructBegin()
14739 
    while True:
14740 
      (fname, ftype, fid) = iprot.readFieldBegin()
14741 
      if ftype == TType.STOP:
14742 
        break
14743 
      if fid == 0:
14744 
        if ftype == TType.LIST:
14745 
          self.success = []
6188 rajveer 14746 
          (_etype339, _size336) = iprot.readListBegin()
14747 
          for _i340 in xrange(_size336):
14748 
            _elem341 = Order()
14749 
            _elem341.read(iprot)
14750 
            self.success.append(_elem341)
4910 phani.kuma 14751 
          iprot.readListEnd()
14752 
        else:
14753 
          iprot.skip(ftype)
14754 
      else:
14755 
        iprot.skip(ftype)
14756 
      iprot.readFieldEnd()
14757 
    iprot.readStructEnd()
14758 
 
14759 
  def write(self, oprot):
14760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14762 
      return
14763 
    oprot.writeStructBegin('getRTOrders_result')
14764 
    if self.success is not None:
14765 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14766 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14767 
      for iter342 in self.success:
14768 
        iter342.write(oprot)
4910 phani.kuma 14769 
      oprot.writeListEnd()
14770 
      oprot.writeFieldEnd()
14771 
    oprot.writeFieldStop()
14772 
    oprot.writeStructEnd()
14773 
 
14774 
  def validate(self):
14775 
    return
14776 
 
14777 
 
14778 
  def __repr__(self):
14779 
    L = ['%s=%r' % (key, value)
14780 
      for key, value in self.__dict__.iteritems()]
14781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14782 
 
14783 
  def __eq__(self, other):
14784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14785 
 
14786 
  def __ne__(self, other):
14787 
    return not (self == other)
14788 
 
3064 chandransh 14789 
class updateNonDeliveryReason_args:
1627 ankur.sing 14790 
  """
14791 
  Attributes:
3064 chandransh 14792 
   - providerId
14793 
   - undeliveredOrders
1627 ankur.sing 14794 
  """
14795 
 
14796 
  thrift_spec = (
3064 chandransh 14797 
    None, # 0
14798 
    (1, TType.I64, 'providerId', None, None, ), # 1
14799 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 14800 
  )
14801 
 
3064 chandransh 14802 
  def __init__(self, providerId=None, undeliveredOrders=None,):
14803 
    self.providerId = providerId
14804 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 14805 
 
14806 
  def read(self, iprot):
14807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14809 
      return
14810 
    iprot.readStructBegin()
14811 
    while True:
14812 
      (fname, ftype, fid) = iprot.readFieldBegin()
14813 
      if ftype == TType.STOP:
14814 
        break
3064 chandransh 14815 
      if fid == 1:
1627 ankur.sing 14816 
        if ftype == TType.I64:
3064 chandransh 14817 
          self.providerId = iprot.readI64();
1627 ankur.sing 14818 
        else:
14819 
          iprot.skip(ftype)
3064 chandransh 14820 
      elif fid == 2:
14821 
        if ftype == TType.MAP:
14822 
          self.undeliveredOrders = {}
6188 rajveer 14823 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
14824 
          for _i347 in xrange(_size343):
14825 
            _key348 = iprot.readString();
14826 
            _val349 = iprot.readString();
14827 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 14828 
          iprot.readMapEnd()
14829 
        else:
14830 
          iprot.skip(ftype)
1627 ankur.sing 14831 
      else:
14832 
        iprot.skip(ftype)
14833 
      iprot.readFieldEnd()
14834 
    iprot.readStructEnd()
14835 
 
14836 
  def write(self, oprot):
14837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14839 
      return
3064 chandransh 14840 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 14841 
    if self.providerId is not None:
3064 chandransh 14842 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14843 
      oprot.writeI64(self.providerId)
1627 ankur.sing 14844 
      oprot.writeFieldEnd()
3431 rajveer 14845 
    if self.undeliveredOrders is not None:
3064 chandransh 14846 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
14847 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 14848 
      for kiter350,viter351 in self.undeliveredOrders.items():
14849 
        oprot.writeString(kiter350)
14850 
        oprot.writeString(viter351)
3064 chandransh 14851 
      oprot.writeMapEnd()
14852 
      oprot.writeFieldEnd()
1627 ankur.sing 14853 
    oprot.writeFieldStop()
14854 
    oprot.writeStructEnd()
14855 
 
3431 rajveer 14856 
  def validate(self):
14857 
    return
14858 
 
14859 
 
1627 ankur.sing 14860 
  def __repr__(self):
14861 
    L = ['%s=%r' % (key, value)
14862 
      for key, value in self.__dict__.iteritems()]
14863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14864 
 
14865 
  def __eq__(self, other):
14866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14867 
 
14868 
  def __ne__(self, other):
14869 
    return not (self == other)
14870 
 
3064 chandransh 14871 
class updateNonDeliveryReason_result:
1627 ankur.sing 14872 
  """
14873 
  Attributes:
3064 chandransh 14874 
   - ex
1627 ankur.sing 14875 
  """
14876 
 
14877 
  thrift_spec = (
4910 phani.kuma 14878 
    None, # 0
3064 chandransh 14879 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14880 
  )
14881 
 
4910 phani.kuma 14882 
  def __init__(self, ex=None,):
3064 chandransh 14883 
    self.ex = ex
1627 ankur.sing 14884 
 
14885 
  def read(self, iprot):
14886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14888 
      return
14889 
    iprot.readStructBegin()
14890 
    while True:
14891 
      (fname, ftype, fid) = iprot.readFieldBegin()
14892 
      if ftype == TType.STOP:
14893 
        break
4910 phani.kuma 14894 
      if fid == 1:
14895 
        if ftype == TType.STRUCT:
14896 
          self.ex = TransactionServiceException()
14897 
          self.ex.read(iprot)
14898 
        else:
14899 
          iprot.skip(ftype)
14900 
      else:
14901 
        iprot.skip(ftype)
14902 
      iprot.readFieldEnd()
14903 
    iprot.readStructEnd()
14904 
 
14905 
  def write(self, oprot):
14906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14908 
      return
14909 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
14910 
    if self.ex is not None:
14911 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14912 
      self.ex.write(oprot)
14913 
      oprot.writeFieldEnd()
14914 
    oprot.writeFieldStop()
14915 
    oprot.writeStructEnd()
14916 
 
14917 
  def validate(self):
14918 
    return
14919 
 
14920 
 
14921 
  def __repr__(self):
14922 
    L = ['%s=%r' % (key, value)
14923 
      for key, value in self.__dict__.iteritems()]
14924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14925 
 
14926 
  def __eq__(self, other):
14927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14928 
 
14929 
  def __ne__(self, other):
14930 
    return not (self == other)
14931 
 
14932 
class getNonDeliveredOrdersbyCourier_args:
14933 
  """
14934 
  Attributes:
14935 
   - providerId
14936 
  """
14937 
 
14938 
  thrift_spec = (
14939 
    None, # 0
14940 
    (1, TType.I64, 'providerId', None, None, ), # 1
14941 
  )
14942 
 
14943 
  def __init__(self, providerId=None,):
14944 
    self.providerId = providerId
14945 
 
14946 
  def read(self, iprot):
14947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14949 
      return
14950 
    iprot.readStructBegin()
14951 
    while True:
14952 
      (fname, ftype, fid) = iprot.readFieldBegin()
14953 
      if ftype == TType.STOP:
14954 
        break
14955 
      if fid == 1:
14956 
        if ftype == TType.I64:
14957 
          self.providerId = iprot.readI64();
14958 
        else:
14959 
          iprot.skip(ftype)
14960 
      else:
14961 
        iprot.skip(ftype)
14962 
      iprot.readFieldEnd()
14963 
    iprot.readStructEnd()
14964 
 
14965 
  def write(self, oprot):
14966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14968 
      return
14969 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
14970 
    if self.providerId is not None:
14971 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14972 
      oprot.writeI64(self.providerId)
14973 
      oprot.writeFieldEnd()
14974 
    oprot.writeFieldStop()
14975 
    oprot.writeStructEnd()
14976 
 
14977 
  def validate(self):
14978 
    return
14979 
 
14980 
 
14981 
  def __repr__(self):
14982 
    L = ['%s=%r' % (key, value)
14983 
      for key, value in self.__dict__.iteritems()]
14984 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14985 
 
14986 
  def __eq__(self, other):
14987 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14988 
 
14989 
  def __ne__(self, other):
14990 
    return not (self == other)
14991 
 
14992 
class getNonDeliveredOrdersbyCourier_result:
14993 
  """
14994 
  Attributes:
14995 
   - success
14996 
  """
14997 
 
14998 
  thrift_spec = (
14999 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15000 
  )
15001 
 
15002 
  def __init__(self, success=None,):
15003 
    self.success = success
15004 
 
15005 
  def read(self, iprot):
15006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15008 
      return
15009 
    iprot.readStructBegin()
15010 
    while True:
15011 
      (fname, ftype, fid) = iprot.readFieldBegin()
15012 
      if ftype == TType.STOP:
15013 
        break
4581 phani.kuma 15014 
      if fid == 0:
15015 
        if ftype == TType.LIST:
15016 
          self.success = []
6188 rajveer 15017 
          (_etype355, _size352) = iprot.readListBegin()
15018 
          for _i356 in xrange(_size352):
15019 
            _elem357 = Order()
15020 
            _elem357.read(iprot)
15021 
            self.success.append(_elem357)
4581 phani.kuma 15022 
          iprot.readListEnd()
15023 
        else:
15024 
          iprot.skip(ftype)
4910 phani.kuma 15025 
      else:
15026 
        iprot.skip(ftype)
15027 
      iprot.readFieldEnd()
15028 
    iprot.readStructEnd()
15029 
 
15030 
  def write(self, oprot):
15031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15033 
      return
15034 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
15035 
    if self.success is not None:
15036 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15037 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15038 
      for iter358 in self.success:
15039 
        iter358.write(oprot)
4910 phani.kuma 15040 
      oprot.writeListEnd()
15041 
      oprot.writeFieldEnd()
15042 
    oprot.writeFieldStop()
15043 
    oprot.writeStructEnd()
15044 
 
15045 
  def validate(self):
15046 
    return
15047 
 
15048 
 
15049 
  def __repr__(self):
15050 
    L = ['%s=%r' % (key, value)
15051 
      for key, value in self.__dict__.iteritems()]
15052 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15053 
 
15054 
  def __eq__(self, other):
15055 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15056 
 
15057 
  def __ne__(self, other):
15058 
    return not (self == other)
15059 
 
15060 
class markOrdersAsLocalConnected_args:
15061 
  """
15062 
  Attributes:
15063 
   - providerId
15064 
   - local_connected_orders
15065 
  """
15066 
 
15067 
  thrift_spec = (
15068 
    None, # 0
15069 
    (1, TType.I64, 'providerId', None, None, ), # 1
15070 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15071 
  )
15072 
 
15073 
  def __init__(self, providerId=None, local_connected_orders=None,):
15074 
    self.providerId = providerId
15075 
    self.local_connected_orders = local_connected_orders
15076 
 
15077 
  def read(self, iprot):
15078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15080 
      return
15081 
    iprot.readStructBegin()
15082 
    while True:
15083 
      (fname, ftype, fid) = iprot.readFieldBegin()
15084 
      if ftype == TType.STOP:
15085 
        break
15086 
      if fid == 1:
15087 
        if ftype == TType.I64:
15088 
          self.providerId = iprot.readI64();
15089 
        else:
15090 
          iprot.skip(ftype)
15091 
      elif fid == 2:
15092 
        if ftype == TType.MAP:
15093 
          self.local_connected_orders = {}
6188 rajveer 15094 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
15095 
          for _i363 in xrange(_size359):
15096 
            _key364 = iprot.readString();
15097 
            _val365 = iprot.readString();
15098 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 15099 
          iprot.readMapEnd()
15100 
        else:
15101 
          iprot.skip(ftype)
15102 
      else:
15103 
        iprot.skip(ftype)
15104 
      iprot.readFieldEnd()
15105 
    iprot.readStructEnd()
15106 
 
15107 
  def write(self, oprot):
15108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15110 
      return
15111 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
15112 
    if self.providerId is not None:
15113 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15114 
      oprot.writeI64(self.providerId)
15115 
      oprot.writeFieldEnd()
15116 
    if self.local_connected_orders is not None:
15117 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
15118 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 15119 
      for kiter366,viter367 in self.local_connected_orders.items():
15120 
        oprot.writeString(kiter366)
15121 
        oprot.writeString(viter367)
4910 phani.kuma 15122 
      oprot.writeMapEnd()
15123 
      oprot.writeFieldEnd()
15124 
    oprot.writeFieldStop()
15125 
    oprot.writeStructEnd()
15126 
 
15127 
  def validate(self):
15128 
    return
15129 
 
15130 
 
15131 
  def __repr__(self):
15132 
    L = ['%s=%r' % (key, value)
15133 
      for key, value in self.__dict__.iteritems()]
15134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15135 
 
15136 
  def __eq__(self, other):
15137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15138 
 
15139 
  def __ne__(self, other):
15140 
    return not (self == other)
15141 
 
15142 
class markOrdersAsLocalConnected_result:
15143 
  """
15144 
  Attributes:
15145 
   - ex
15146 
  """
15147 
 
15148 
  thrift_spec = (
15149 
    None, # 0
15150 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15151 
  )
15152 
 
15153 
  def __init__(self, ex=None,):
15154 
    self.ex = ex
15155 
 
15156 
  def read(self, iprot):
15157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15159 
      return
15160 
    iprot.readStructBegin()
15161 
    while True:
15162 
      (fname, ftype, fid) = iprot.readFieldBegin()
15163 
      if ftype == TType.STOP:
15164 
        break
15165 
      if fid == 1:
3064 chandransh 15166 
        if ftype == TType.STRUCT:
15167 
          self.ex = TransactionServiceException()
15168 
          self.ex.read(iprot)
1627 ankur.sing 15169 
        else:
15170 
          iprot.skip(ftype)
15171 
      else:
15172 
        iprot.skip(ftype)
15173 
      iprot.readFieldEnd()
15174 
    iprot.readStructEnd()
15175 
 
15176 
  def write(self, oprot):
15177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15179 
      return
4910 phani.kuma 15180 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
15181 
    if self.ex is not None:
15182 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15183 
      self.ex.write(oprot)
15184 
      oprot.writeFieldEnd()
15185 
    oprot.writeFieldStop()
15186 
    oprot.writeStructEnd()
15187 
 
15188 
  def validate(self):
15189 
    return
15190 
 
15191 
 
15192 
  def __repr__(self):
15193 
    L = ['%s=%r' % (key, value)
15194 
      for key, value in self.__dict__.iteritems()]
15195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15196 
 
15197 
  def __eq__(self, other):
15198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15199 
 
15200 
  def __ne__(self, other):
15201 
    return not (self == other)
15202 
 
15203 
class getOrdersNotLocalConnected_args:
15204 
  """
15205 
  Attributes:
15206 
   - providerId
15207 
  """
15208 
 
15209 
  thrift_spec = (
15210 
    None, # 0
15211 
    (1, TType.I64, 'providerId', None, None, ), # 1
15212 
  )
15213 
 
15214 
  def __init__(self, providerId=None,):
15215 
    self.providerId = providerId
15216 
 
15217 
  def read(self, iprot):
15218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15220 
      return
15221 
    iprot.readStructBegin()
15222 
    while True:
15223 
      (fname, ftype, fid) = iprot.readFieldBegin()
15224 
      if ftype == TType.STOP:
15225 
        break
15226 
      if fid == 1:
15227 
        if ftype == TType.I64:
15228 
          self.providerId = iprot.readI64();
15229 
        else:
15230 
          iprot.skip(ftype)
15231 
      else:
15232 
        iprot.skip(ftype)
15233 
      iprot.readFieldEnd()
15234 
    iprot.readStructEnd()
15235 
 
15236 
  def write(self, oprot):
15237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15239 
      return
15240 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
15241 
    if self.providerId is not None:
15242 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15243 
      oprot.writeI64(self.providerId)
15244 
      oprot.writeFieldEnd()
15245 
    oprot.writeFieldStop()
15246 
    oprot.writeStructEnd()
15247 
 
15248 
  def validate(self):
15249 
    return
15250 
 
15251 
 
15252 
  def __repr__(self):
15253 
    L = ['%s=%r' % (key, value)
15254 
      for key, value in self.__dict__.iteritems()]
15255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15256 
 
15257 
  def __eq__(self, other):
15258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15259 
 
15260 
  def __ne__(self, other):
15261 
    return not (self == other)
15262 
 
15263 
class getOrdersNotLocalConnected_result:
15264 
  """
15265 
  Attributes:
15266 
   - success
15267 
  """
15268 
 
15269 
  thrift_spec = (
15270 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15271 
  )
15272 
 
15273 
  def __init__(self, success=None,):
15274 
    self.success = success
15275 
 
15276 
  def read(self, iprot):
15277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15279 
      return
15280 
    iprot.readStructBegin()
15281 
    while True:
15282 
      (fname, ftype, fid) = iprot.readFieldBegin()
15283 
      if ftype == TType.STOP:
15284 
        break
15285 
      if fid == 0:
15286 
        if ftype == TType.LIST:
15287 
          self.success = []
6188 rajveer 15288 
          (_etype371, _size368) = iprot.readListBegin()
15289 
          for _i372 in xrange(_size368):
15290 
            _elem373 = Order()
15291 
            _elem373.read(iprot)
15292 
            self.success.append(_elem373)
4910 phani.kuma 15293 
          iprot.readListEnd()
15294 
        else:
15295 
          iprot.skip(ftype)
15296 
      else:
15297 
        iprot.skip(ftype)
15298 
      iprot.readFieldEnd()
15299 
    iprot.readStructEnd()
15300 
 
15301 
  def write(self, oprot):
15302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15304 
      return
15305 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 15306 
    if self.success is not None:
15307 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15308 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15309 
      for iter374 in self.success:
15310 
        iter374.write(oprot)
4581 phani.kuma 15311 
      oprot.writeListEnd()
15312 
      oprot.writeFieldEnd()
4910 phani.kuma 15313 
    oprot.writeFieldStop()
15314 
    oprot.writeStructEnd()
15315 
 
15316 
  def validate(self):
15317 
    return
15318 
 
15319 
 
15320 
  def __repr__(self):
15321 
    L = ['%s=%r' % (key, value)
15322 
      for key, value in self.__dict__.iteritems()]
15323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15324 
 
15325 
  def __eq__(self, other):
15326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15327 
 
15328 
  def __ne__(self, other):
15329 
    return not (self == other)
15330 
 
15331 
class markOrdersAsDestinationCityReached_args:
15332 
  """
15333 
  Attributes:
15334 
   - providerId
15335 
   - destination_city_reached_orders
15336 
  """
15337 
 
15338 
  thrift_spec = (
15339 
    None, # 0
15340 
    (1, TType.I64, 'providerId', None, None, ), # 1
15341 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15342 
  )
15343 
 
15344 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
15345 
    self.providerId = providerId
15346 
    self.destination_city_reached_orders = destination_city_reached_orders
15347 
 
15348 
  def read(self, iprot):
15349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15351 
      return
15352 
    iprot.readStructBegin()
15353 
    while True:
15354 
      (fname, ftype, fid) = iprot.readFieldBegin()
15355 
      if ftype == TType.STOP:
15356 
        break
15357 
      if fid == 1:
15358 
        if ftype == TType.I64:
15359 
          self.providerId = iprot.readI64();
15360 
        else:
15361 
          iprot.skip(ftype)
15362 
      elif fid == 2:
15363 
        if ftype == TType.MAP:
15364 
          self.destination_city_reached_orders = {}
6188 rajveer 15365 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
15366 
          for _i379 in xrange(_size375):
15367 
            _key380 = iprot.readString();
15368 
            _val381 = iprot.readString();
15369 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 15370 
          iprot.readMapEnd()
15371 
        else:
15372 
          iprot.skip(ftype)
15373 
      else:
15374 
        iprot.skip(ftype)
15375 
      iprot.readFieldEnd()
15376 
    iprot.readStructEnd()
15377 
 
15378 
  def write(self, oprot):
15379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15381 
      return
15382 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
15383 
    if self.providerId is not None:
15384 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15385 
      oprot.writeI64(self.providerId)
15386 
      oprot.writeFieldEnd()
15387 
    if self.destination_city_reached_orders is not None:
15388 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
15389 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 15390 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
15391 
        oprot.writeString(kiter382)
15392 
        oprot.writeString(viter383)
4910 phani.kuma 15393 
      oprot.writeMapEnd()
15394 
      oprot.writeFieldEnd()
15395 
    oprot.writeFieldStop()
15396 
    oprot.writeStructEnd()
15397 
 
15398 
  def validate(self):
15399 
    return
15400 
 
15401 
 
15402 
  def __repr__(self):
15403 
    L = ['%s=%r' % (key, value)
15404 
      for key, value in self.__dict__.iteritems()]
15405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15406 
 
15407 
  def __eq__(self, other):
15408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15409 
 
15410 
  def __ne__(self, other):
15411 
    return not (self == other)
15412 
 
15413 
class markOrdersAsDestinationCityReached_result:
15414 
  """
15415 
  Attributes:
15416 
   - ex
15417 
  """
15418 
 
15419 
  thrift_spec = (
15420 
    None, # 0
15421 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15422 
  )
15423 
 
15424 
  def __init__(self, ex=None,):
15425 
    self.ex = ex
15426 
 
15427 
  def read(self, iprot):
15428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15430 
      return
15431 
    iprot.readStructBegin()
15432 
    while True:
15433 
      (fname, ftype, fid) = iprot.readFieldBegin()
15434 
      if ftype == TType.STOP:
15435 
        break
15436 
      if fid == 1:
15437 
        if ftype == TType.STRUCT:
15438 
          self.ex = TransactionServiceException()
15439 
          self.ex.read(iprot)
15440 
        else:
15441 
          iprot.skip(ftype)
15442 
      else:
15443 
        iprot.skip(ftype)
15444 
      iprot.readFieldEnd()
15445 
    iprot.readStructEnd()
15446 
 
15447 
  def write(self, oprot):
15448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15450 
      return
15451 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15452 
    if self.ex is not None:
3064 chandransh 15453 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15454 
      self.ex.write(oprot)
1627 ankur.sing 15455 
      oprot.writeFieldEnd()
15456 
    oprot.writeFieldStop()
15457 
    oprot.writeStructEnd()
15458 
 
3431 rajveer 15459 
  def validate(self):
15460 
    return
15461 
 
15462 
 
1627 ankur.sing 15463 
  def __repr__(self):
15464 
    L = ['%s=%r' % (key, value)
15465 
      for key, value in self.__dict__.iteritems()]
15466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15467 
 
15468 
  def __eq__(self, other):
15469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15470 
 
15471 
  def __ne__(self, other):
15472 
    return not (self == other)
15473 
 
4910 phani.kuma 15474 
class markOrdersAsFirstDeliveryAttempted_args:
15475 
  """
15476 
  Attributes:
15477 
   - providerId
15478 
   - first_atdl_orders
15479 
  """
15480 
 
15481 
  thrift_spec = (
15482 
    None, # 0
15483 
    (1, TType.I64, 'providerId', None, None, ), # 1
15484 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15485 
  )
15486 
 
15487 
  def __init__(self, providerId=None, first_atdl_orders=None,):
15488 
    self.providerId = providerId
15489 
    self.first_atdl_orders = first_atdl_orders
15490 
 
15491 
  def read(self, iprot):
15492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15494 
      return
15495 
    iprot.readStructBegin()
15496 
    while True:
15497 
      (fname, ftype, fid) = iprot.readFieldBegin()
15498 
      if ftype == TType.STOP:
15499 
        break
15500 
      if fid == 1:
15501 
        if ftype == TType.I64:
15502 
          self.providerId = iprot.readI64();
15503 
        else:
15504 
          iprot.skip(ftype)
15505 
      elif fid == 2:
15506 
        if ftype == TType.MAP:
15507 
          self.first_atdl_orders = {}
6188 rajveer 15508 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
15509 
          for _i388 in xrange(_size384):
15510 
            _key389 = iprot.readString();
15511 
            _val390 = iprot.readString();
15512 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 15513 
          iprot.readMapEnd()
15514 
        else:
15515 
          iprot.skip(ftype)
15516 
      else:
15517 
        iprot.skip(ftype)
15518 
      iprot.readFieldEnd()
15519 
    iprot.readStructEnd()
15520 
 
15521 
  def write(self, oprot):
15522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15524 
      return
15525 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
15526 
    if self.providerId is not None:
15527 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15528 
      oprot.writeI64(self.providerId)
15529 
      oprot.writeFieldEnd()
15530 
    if self.first_atdl_orders is not None:
15531 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
15532 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 15533 
      for kiter391,viter392 in self.first_atdl_orders.items():
15534 
        oprot.writeString(kiter391)
15535 
        oprot.writeString(viter392)
4910 phani.kuma 15536 
      oprot.writeMapEnd()
15537 
      oprot.writeFieldEnd()
15538 
    oprot.writeFieldStop()
15539 
    oprot.writeStructEnd()
15540 
 
15541 
  def validate(self):
15542 
    return
15543 
 
15544 
 
15545 
  def __repr__(self):
15546 
    L = ['%s=%r' % (key, value)
15547 
      for key, value in self.__dict__.iteritems()]
15548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15549 
 
15550 
  def __eq__(self, other):
15551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15552 
 
15553 
  def __ne__(self, other):
15554 
    return not (self == other)
15555 
 
15556 
class markOrdersAsFirstDeliveryAttempted_result:
15557 
  """
15558 
  Attributes:
15559 
   - ex
15560 
  """
15561 
 
15562 
  thrift_spec = (
15563 
    None, # 0
15564 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15565 
  )
15566 
 
15567 
  def __init__(self, ex=None,):
15568 
    self.ex = ex
15569 
 
15570 
  def read(self, iprot):
15571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15573 
      return
15574 
    iprot.readStructBegin()
15575 
    while True:
15576 
      (fname, ftype, fid) = iprot.readFieldBegin()
15577 
      if ftype == TType.STOP:
15578 
        break
15579 
      if fid == 1:
15580 
        if ftype == TType.STRUCT:
15581 
          self.ex = TransactionServiceException()
15582 
          self.ex.read(iprot)
15583 
        else:
15584 
          iprot.skip(ftype)
15585 
      else:
15586 
        iprot.skip(ftype)
15587 
      iprot.readFieldEnd()
15588 
    iprot.readStructEnd()
15589 
 
15590 
  def write(self, oprot):
15591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15593 
      return
15594 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
15595 
    if self.ex is not None:
15596 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15597 
      self.ex.write(oprot)
15598 
      oprot.writeFieldEnd()
15599 
    oprot.writeFieldStop()
15600 
    oprot.writeStructEnd()
15601 
 
15602 
  def validate(self):
15603 
    return
15604 
 
15605 
 
15606 
  def __repr__(self):
15607 
    L = ['%s=%r' % (key, value)
15608 
      for key, value in self.__dict__.iteritems()]
15609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15610 
 
15611 
  def __eq__(self, other):
15612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15613 
 
15614 
  def __ne__(self, other):
15615 
    return not (self == other)
15616 
 
3064 chandransh 15617 
class getUndeliveredOrders_args:
1886 ankur.sing 15618 
  """
15619 
  Attributes:
3064 chandransh 15620 
   - providerId
15621 
   - warehouseId
1886 ankur.sing 15622 
  """
1627 ankur.sing 15623 
 
1886 ankur.sing 15624 
  thrift_spec = (
15625 
    None, # 0
3064 chandransh 15626 
    (1, TType.I64, 'providerId', None, None, ), # 1
15627 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 15628 
  )
15629 
 
3064 chandransh 15630 
  def __init__(self, providerId=None, warehouseId=None,):
15631 
    self.providerId = providerId
15632 
    self.warehouseId = warehouseId
1886 ankur.sing 15633 
 
15634 
  def read(self, iprot):
15635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15637 
      return
15638 
    iprot.readStructBegin()
15639 
    while True:
15640 
      (fname, ftype, fid) = iprot.readFieldBegin()
15641 
      if ftype == TType.STOP:
15642 
        break
15643 
      if fid == 1:
15644 
        if ftype == TType.I64:
3064 chandransh 15645 
          self.providerId = iprot.readI64();
1886 ankur.sing 15646 
        else:
15647 
          iprot.skip(ftype)
3064 chandransh 15648 
      elif fid == 2:
15649 
        if ftype == TType.I64:
15650 
          self.warehouseId = iprot.readI64();
15651 
        else:
15652 
          iprot.skip(ftype)
1886 ankur.sing 15653 
      else:
15654 
        iprot.skip(ftype)
15655 
      iprot.readFieldEnd()
15656 
    iprot.readStructEnd()
15657 
 
15658 
  def write(self, oprot):
15659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15661 
      return
3064 chandransh 15662 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 15663 
    if self.providerId is not None:
3064 chandransh 15664 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15665 
      oprot.writeI64(self.providerId)
1886 ankur.sing 15666 
      oprot.writeFieldEnd()
3431 rajveer 15667 
    if self.warehouseId is not None:
3064 chandransh 15668 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
15669 
      oprot.writeI64(self.warehouseId)
15670 
      oprot.writeFieldEnd()
1886 ankur.sing 15671 
    oprot.writeFieldStop()
15672 
    oprot.writeStructEnd()
15673 
 
3431 rajveer 15674 
  def validate(self):
15675 
    return
15676 
 
15677 
 
1886 ankur.sing 15678 
  def __repr__(self):
15679 
    L = ['%s=%r' % (key, value)
15680 
      for key, value in self.__dict__.iteritems()]
15681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15682 
 
15683 
  def __eq__(self, other):
15684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15685 
 
15686 
  def __ne__(self, other):
15687 
    return not (self == other)
15688 
 
3064 chandransh 15689 
class getUndeliveredOrders_result:
1886 ankur.sing 15690 
  """
15691 
  Attributes:
15692 
   - success
15693 
  """
15694 
 
15695 
  thrift_spec = (
15696 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15697 
  )
15698 
 
15699 
  def __init__(self, success=None,):
15700 
    self.success = success
15701 
 
15702 
  def read(self, iprot):
15703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15705 
      return
15706 
    iprot.readStructBegin()
15707 
    while True:
15708 
      (fname, ftype, fid) = iprot.readFieldBegin()
15709 
      if ftype == TType.STOP:
15710 
        break
15711 
      if fid == 0:
15712 
        if ftype == TType.LIST:
15713 
          self.success = []
6188 rajveer 15714 
          (_etype396, _size393) = iprot.readListBegin()
15715 
          for _i397 in xrange(_size393):
15716 
            _elem398 = Order()
15717 
            _elem398.read(iprot)
15718 
            self.success.append(_elem398)
1886 ankur.sing 15719 
          iprot.readListEnd()
15720 
        else:
15721 
          iprot.skip(ftype)
15722 
      else:
15723 
        iprot.skip(ftype)
15724 
      iprot.readFieldEnd()
15725 
    iprot.readStructEnd()
15726 
 
15727 
  def write(self, oprot):
15728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15730 
      return
3064 chandransh 15731 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 15732 
    if self.success is not None:
1886 ankur.sing 15733 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15734 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15735 
      for iter399 in self.success:
15736 
        iter399.write(oprot)
1886 ankur.sing 15737 
      oprot.writeListEnd()
15738 
      oprot.writeFieldEnd()
15739 
    oprot.writeFieldStop()
15740 
    oprot.writeStructEnd()
15741 
 
3431 rajveer 15742 
  def validate(self):
15743 
    return
15744 
 
15745 
 
1886 ankur.sing 15746 
  def __repr__(self):
15747 
    L = ['%s=%r' % (key, value)
15748 
      for key, value in self.__dict__.iteritems()]
15749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15750 
 
15751 
  def __eq__(self, other):
15752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15753 
 
15754 
  def __ne__(self, other):
15755 
    return not (self == other)
15756 
 
4783 phani.kuma 15757 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
15758 
 
15759 
  thrift_spec = (
15760 
  )
15761 
 
15762 
  def read(self, iprot):
15763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15765 
      return
15766 
    iprot.readStructBegin()
15767 
    while True:
15768 
      (fname, ftype, fid) = iprot.readFieldBegin()
15769 
      if ftype == TType.STOP:
15770 
        break
15771 
      else:
15772 
        iprot.skip(ftype)
15773 
      iprot.readFieldEnd()
15774 
    iprot.readStructEnd()
15775 
 
15776 
  def write(self, oprot):
15777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15779 
      return
15780 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
15781 
    oprot.writeFieldStop()
15782 
    oprot.writeStructEnd()
15783 
 
15784 
  def validate(self):
15785 
    return
15786 
 
15787 
 
15788 
  def __repr__(self):
15789 
    L = ['%s=%r' % (key, value)
15790 
      for key, value in self.__dict__.iteritems()]
15791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15792 
 
15793 
  def __eq__(self, other):
15794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15795 
 
15796 
  def __ne__(self, other):
15797 
    return not (self == other)
15798 
 
15799 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
15800 
  """
15801 
  Attributes:
15802 
   - success
15803 
  """
15804 
 
15805 
  thrift_spec = (
15806 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15807 
  )
15808 
 
15809 
  def __init__(self, success=None,):
15810 
    self.success = success
15811 
 
15812 
  def read(self, iprot):
15813 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15814 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15815 
      return
15816 
    iprot.readStructBegin()
15817 
    while True:
15818 
      (fname, ftype, fid) = iprot.readFieldBegin()
15819 
      if ftype == TType.STOP:
15820 
        break
15821 
      if fid == 0:
15822 
        if ftype == TType.LIST:
15823 
          self.success = []
6188 rajveer 15824 
          (_etype403, _size400) = iprot.readListBegin()
15825 
          for _i404 in xrange(_size400):
15826 
            _elem405 = Order()
15827 
            _elem405.read(iprot)
15828 
            self.success.append(_elem405)
4783 phani.kuma 15829 
          iprot.readListEnd()
15830 
        else:
15831 
          iprot.skip(ftype)
15832 
      else:
15833 
        iprot.skip(ftype)
15834 
      iprot.readFieldEnd()
15835 
    iprot.readStructEnd()
15836 
 
15837 
  def write(self, oprot):
15838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15840 
      return
15841 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
15842 
    if self.success is not None:
15843 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15844 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15845 
      for iter406 in self.success:
15846 
        iter406.write(oprot)
4783 phani.kuma 15847 
      oprot.writeListEnd()
15848 
      oprot.writeFieldEnd()
15849 
    oprot.writeFieldStop()
15850 
    oprot.writeStructEnd()
15851 
 
15852 
  def validate(self):
15853 
    return
15854 
 
15855 
 
15856 
  def __repr__(self):
15857 
    L = ['%s=%r' % (key, value)
15858 
      for key, value in self.__dict__.iteritems()]
15859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15860 
 
15861 
  def __eq__(self, other):
15862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15863 
 
15864 
  def __ne__(self, other):
15865 
    return not (self == other)
15866 
 
2536 chandransh 15867 
class toggleDOAFlag_args:
15868 
  """
15869 
  Attributes:
15870 
   - orderId
15871 
  """
1886 ankur.sing 15872 
 
2536 chandransh 15873 
  thrift_spec = (
15874 
    None, # 0
15875 
    (1, TType.I64, 'orderId', None, None, ), # 1
15876 
  )
15877 
 
15878 
  def __init__(self, orderId=None,):
15879 
    self.orderId = orderId
15880 
 
15881 
  def read(self, iprot):
15882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15884 
      return
15885 
    iprot.readStructBegin()
15886 
    while True:
15887 
      (fname, ftype, fid) = iprot.readFieldBegin()
15888 
      if ftype == TType.STOP:
15889 
        break
15890 
      if fid == 1:
15891 
        if ftype == TType.I64:
15892 
          self.orderId = iprot.readI64();
15893 
        else:
15894 
          iprot.skip(ftype)
15895 
      else:
15896 
        iprot.skip(ftype)
15897 
      iprot.readFieldEnd()
15898 
    iprot.readStructEnd()
15899 
 
15900 
  def write(self, oprot):
15901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15903 
      return
15904 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 15905 
    if self.orderId is not None:
2536 chandransh 15906 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
15907 
      oprot.writeI64(self.orderId)
15908 
      oprot.writeFieldEnd()
15909 
    oprot.writeFieldStop()
15910 
    oprot.writeStructEnd()
15911 
 
3431 rajveer 15912 
  def validate(self):
15913 
    return
15914 
 
15915 
 
2536 chandransh 15916 
  def __repr__(self):
15917 
    L = ['%s=%r' % (key, value)
15918 
      for key, value in self.__dict__.iteritems()]
15919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15920 
 
15921 
  def __eq__(self, other):
15922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15923 
 
15924 
  def __ne__(self, other):
15925 
    return not (self == other)
15926 
 
15927 
class toggleDOAFlag_result:
15928 
  """
15929 
  Attributes:
15930 
   - success
15931 
   - ex
15932 
  """
15933 
 
15934 
  thrift_spec = (
15935 
    (0, TType.BOOL, 'success', None, None, ), # 0
15936 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15937 
  )
15938 
 
15939 
  def __init__(self, success=None, ex=None,):
15940 
    self.success = success
15941 
    self.ex = ex
15942 
 
15943 
  def read(self, iprot):
15944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15946 
      return
15947 
    iprot.readStructBegin()
15948 
    while True:
15949 
      (fname, ftype, fid) = iprot.readFieldBegin()
15950 
      if ftype == TType.STOP:
15951 
        break
15952 
      if fid == 0:
15953 
        if ftype == TType.BOOL:
15954 
          self.success = iprot.readBool();
15955 
        else:
15956 
          iprot.skip(ftype)
15957 
      elif fid == 1:
15958 
        if ftype == TType.STRUCT:
15959 
          self.ex = TransactionServiceException()
15960 
          self.ex.read(iprot)
15961 
        else:
15962 
          iprot.skip(ftype)
15963 
      else:
15964 
        iprot.skip(ftype)
15965 
      iprot.readFieldEnd()
15966 
    iprot.readStructEnd()
15967 
 
15968 
  def write(self, oprot):
15969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15971 
      return
15972 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 15973 
    if self.success is not None:
2536 chandransh 15974 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15975 
      oprot.writeBool(self.success)
15976 
      oprot.writeFieldEnd()
3431 rajveer 15977 
    if self.ex is not None:
2536 chandransh 15978 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15979 
      self.ex.write(oprot)
15980 
      oprot.writeFieldEnd()
15981 
    oprot.writeFieldStop()
15982 
    oprot.writeStructEnd()
15983 
 
3431 rajveer 15984 
  def validate(self):
15985 
    return
15986 
 
15987 
 
2536 chandransh 15988 
  def __repr__(self):
15989 
    L = ['%s=%r' % (key, value)
15990 
      for key, value in self.__dict__.iteritems()]
15991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15992 
 
15993 
  def __eq__(self, other):
15994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15995 
 
15996 
  def __ne__(self, other):
15997 
    return not (self == other)
15998 
 
4712 rajveer 15999 
class markOrderAsDelivered_args:
16000 
  """
16001 
  Attributes:
16002 
   - orderId
16003 
   - deliveryTimestamp
16004 
   - receiver
16005 
  """
16006 
 
16007 
  thrift_spec = None
16008 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
16009 
    self.orderId = orderId
16010 
    self.deliveryTimestamp = deliveryTimestamp
16011 
    self.receiver = receiver
16012 
 
16013 
  def read(self, iprot):
16014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16016 
      return
16017 
    iprot.readStructBegin()
16018 
    while True:
16019 
      (fname, ftype, fid) = iprot.readFieldBegin()
16020 
      if ftype == TType.STOP:
16021 
        break
16022 
      if fid == 1:
16023 
        if ftype == TType.I64:
16024 
          self.orderId = iprot.readI64();
16025 
        else:
16026 
          iprot.skip(ftype)
16027 
      elif fid == 2:
16028 
        if ftype == TType.I64:
16029 
          self.deliveryTimestamp = iprot.readI64();
16030 
        else:
16031 
          iprot.skip(ftype)
16032 
      elif fid == -1:
16033 
        if ftype == TType.STRING:
16034 
          self.receiver = iprot.readString();
16035 
        else:
16036 
          iprot.skip(ftype)
16037 
      else:
16038 
        iprot.skip(ftype)
16039 
      iprot.readFieldEnd()
16040 
    iprot.readStructEnd()
16041 
 
16042 
  def write(self, oprot):
16043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16045 
      return
16046 
    oprot.writeStructBegin('markOrderAsDelivered_args')
16047 
    if self.receiver is not None:
16048 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
16049 
      oprot.writeString(self.receiver)
16050 
      oprot.writeFieldEnd()
16051 
    if self.orderId is not None:
16052 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16053 
      oprot.writeI64(self.orderId)
16054 
      oprot.writeFieldEnd()
16055 
    if self.deliveryTimestamp is not None:
16056 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16057 
      oprot.writeI64(self.deliveryTimestamp)
16058 
      oprot.writeFieldEnd()
16059 
    oprot.writeFieldStop()
16060 
    oprot.writeStructEnd()
16061 
 
16062 
  def validate(self):
16063 
    return
16064 
 
16065 
 
16066 
  def __repr__(self):
16067 
    L = ['%s=%r' % (key, value)
16068 
      for key, value in self.__dict__.iteritems()]
16069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16070 
 
16071 
  def __eq__(self, other):
16072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16073 
 
16074 
  def __ne__(self, other):
16075 
    return not (self == other)
16076 
 
16077 
class markOrderAsDelivered_result:
16078 
  """
16079 
  Attributes:
16080 
   - ex
16081 
  """
16082 
 
16083 
  thrift_spec = (
16084 
    None, # 0
16085 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16086 
  )
16087 
 
16088 
  def __init__(self, ex=None,):
16089 
    self.ex = ex
16090 
 
16091 
  def read(self, iprot):
16092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16094 
      return
16095 
    iprot.readStructBegin()
16096 
    while True:
16097 
      (fname, ftype, fid) = iprot.readFieldBegin()
16098 
      if ftype == TType.STOP:
16099 
        break
16100 
      if fid == 1:
16101 
        if ftype == TType.STRUCT:
16102 
          self.ex = TransactionServiceException()
16103 
          self.ex.read(iprot)
16104 
        else:
16105 
          iprot.skip(ftype)
16106 
      else:
16107 
        iprot.skip(ftype)
16108 
      iprot.readFieldEnd()
16109 
    iprot.readStructEnd()
16110 
 
16111 
  def write(self, oprot):
16112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16114 
      return
16115 
    oprot.writeStructBegin('markOrderAsDelivered_result')
16116 
    if self.ex is not None:
16117 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16118 
      self.ex.write(oprot)
16119 
      oprot.writeFieldEnd()
16120 
    oprot.writeFieldStop()
16121 
    oprot.writeStructEnd()
16122 
 
16123 
  def validate(self):
16124 
    return
16125 
 
16126 
 
16127 
  def __repr__(self):
16128 
    L = ['%s=%r' % (key, value)
16129 
      for key, value in self.__dict__.iteritems()]
16130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16131 
 
16132 
  def __eq__(self, other):
16133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16134 
 
16135 
  def __ne__(self, other):
16136 
    return not (self == other)
16137 
 
5553 rajveer 16138 
class markOrderAsReceivedAtStore_args:
16139 
  """
16140 
  Attributes:
16141 
   - orderId
16142 
   - deliveryTimestamp
16143 
  """
16144 
 
16145 
  thrift_spec = (
16146 
    None, # 0
16147 
    (1, TType.I64, 'orderId', None, None, ), # 1
16148 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
16149 
  )
16150 
 
16151 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
16152 
    self.orderId = orderId
16153 
    self.deliveryTimestamp = deliveryTimestamp
16154 
 
16155 
  def read(self, iprot):
16156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16158 
      return
16159 
    iprot.readStructBegin()
16160 
    while True:
16161 
      (fname, ftype, fid) = iprot.readFieldBegin()
16162 
      if ftype == TType.STOP:
16163 
        break
16164 
      if fid == 1:
16165 
        if ftype == TType.I64:
16166 
          self.orderId = iprot.readI64();
16167 
        else:
16168 
          iprot.skip(ftype)
16169 
      elif fid == 2:
16170 
        if ftype == TType.I64:
16171 
          self.deliveryTimestamp = iprot.readI64();
16172 
        else:
16173 
          iprot.skip(ftype)
16174 
      else:
16175 
        iprot.skip(ftype)
16176 
      iprot.readFieldEnd()
16177 
    iprot.readStructEnd()
16178 
 
16179 
  def write(self, oprot):
16180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16182 
      return
16183 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
16184 
    if self.orderId is not None:
16185 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16186 
      oprot.writeI64(self.orderId)
16187 
      oprot.writeFieldEnd()
16188 
    if self.deliveryTimestamp is not None:
16189 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16190 
      oprot.writeI64(self.deliveryTimestamp)
16191 
      oprot.writeFieldEnd()
16192 
    oprot.writeFieldStop()
16193 
    oprot.writeStructEnd()
16194 
 
16195 
  def validate(self):
16196 
    return
16197 
 
16198 
 
16199 
  def __repr__(self):
16200 
    L = ['%s=%r' % (key, value)
16201 
      for key, value in self.__dict__.iteritems()]
16202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16203 
 
16204 
  def __eq__(self, other):
16205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16206 
 
16207 
  def __ne__(self, other):
16208 
    return not (self == other)
16209 
 
16210 
class markOrderAsReceivedAtStore_result:
16211 
  """
16212 
  Attributes:
16213 
   - ex
16214 
  """
16215 
 
16216 
  thrift_spec = (
16217 
    None, # 0
16218 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16219 
  )
16220 
 
16221 
  def __init__(self, ex=None,):
16222 
    self.ex = ex
16223 
 
16224 
  def read(self, iprot):
16225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16227 
      return
16228 
    iprot.readStructBegin()
16229 
    while True:
16230 
      (fname, ftype, fid) = iprot.readFieldBegin()
16231 
      if ftype == TType.STOP:
16232 
        break
16233 
      if fid == 1:
16234 
        if ftype == TType.STRUCT:
16235 
          self.ex = TransactionServiceException()
16236 
          self.ex.read(iprot)
16237 
        else:
16238 
          iprot.skip(ftype)
16239 
      else:
16240 
        iprot.skip(ftype)
16241 
      iprot.readFieldEnd()
16242 
    iprot.readStructEnd()
16243 
 
16244 
  def write(self, oprot):
16245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16247 
      return
16248 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
16249 
    if self.ex is not None:
16250 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16251 
      self.ex.write(oprot)
16252 
      oprot.writeFieldEnd()
16253 
    oprot.writeFieldStop()
16254 
    oprot.writeStructEnd()
16255 
 
16256 
  def validate(self):
16257 
    return
16258 
 
16259 
 
16260 
  def __repr__(self):
16261 
    L = ['%s=%r' % (key, value)
16262 
      for key, value in self.__dict__.iteritems()]
16263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16264 
 
16265 
  def __eq__(self, other):
16266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16267 
 
16268 
  def __ne__(self, other):
16269 
    return not (self == other)
16270 
 
4454 rajveer 16271 
class markOrderDoaRequestReceived_args:
16272 
  """
16273 
  Attributes:
16274 
   - orderId
16275 
  """
16276 
 
16277 
  thrift_spec = (
16278 
    None, # 0
16279 
    (1, TType.I64, 'orderId', None, None, ), # 1
16280 
  )
16281 
 
16282 
  def __init__(self, orderId=None,):
16283 
    self.orderId = orderId
16284 
 
16285 
  def read(self, iprot):
16286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16288 
      return
16289 
    iprot.readStructBegin()
16290 
    while True:
16291 
      (fname, ftype, fid) = iprot.readFieldBegin()
16292 
      if ftype == TType.STOP:
16293 
        break
16294 
      if fid == 1:
16295 
        if ftype == TType.I64:
16296 
          self.orderId = iprot.readI64();
16297 
        else:
16298 
          iprot.skip(ftype)
16299 
      else:
16300 
        iprot.skip(ftype)
16301 
      iprot.readFieldEnd()
16302 
    iprot.readStructEnd()
16303 
 
16304 
  def write(self, oprot):
16305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16307 
      return
16308 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
16309 
    if self.orderId is not None:
16310 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16311 
      oprot.writeI64(self.orderId)
16312 
      oprot.writeFieldEnd()
16313 
    oprot.writeFieldStop()
16314 
    oprot.writeStructEnd()
16315 
 
16316 
  def validate(self):
16317 
    return
16318 
 
16319 
 
16320 
  def __repr__(self):
16321 
    L = ['%s=%r' % (key, value)
16322 
      for key, value in self.__dict__.iteritems()]
16323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16324 
 
16325 
  def __eq__(self, other):
16326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16327 
 
16328 
  def __ne__(self, other):
16329 
    return not (self == other)
16330 
 
16331 
class markOrderDoaRequestReceived_result:
16332 
  """
16333 
  Attributes:
16334 
   - success
16335 
   - ex
16336 
  """
16337 
 
16338 
  thrift_spec = (
16339 
    (0, TType.BOOL, 'success', None, None, ), # 0
16340 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16341 
  )
16342 
 
16343 
  def __init__(self, success=None, ex=None,):
16344 
    self.success = success
16345 
    self.ex = ex
16346 
 
16347 
  def read(self, iprot):
16348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16350 
      return
16351 
    iprot.readStructBegin()
16352 
    while True:
16353 
      (fname, ftype, fid) = iprot.readFieldBegin()
16354 
      if ftype == TType.STOP:
16355 
        break
16356 
      if fid == 0:
16357 
        if ftype == TType.BOOL:
16358 
          self.success = iprot.readBool();
16359 
        else:
16360 
          iprot.skip(ftype)
16361 
      elif fid == 1:
16362 
        if ftype == TType.STRUCT:
16363 
          self.ex = TransactionServiceException()
16364 
          self.ex.read(iprot)
16365 
        else:
16366 
          iprot.skip(ftype)
16367 
      else:
16368 
        iprot.skip(ftype)
16369 
      iprot.readFieldEnd()
16370 
    iprot.readStructEnd()
16371 
 
16372 
  def write(self, oprot):
16373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16375 
      return
16376 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
16377 
    if self.success is not None:
16378 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16379 
      oprot.writeBool(self.success)
16380 
      oprot.writeFieldEnd()
16381 
    if self.ex is not None:
16382 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16383 
      self.ex.write(oprot)
16384 
      oprot.writeFieldEnd()
16385 
    oprot.writeFieldStop()
16386 
    oprot.writeStructEnd()
16387 
 
16388 
  def validate(self):
16389 
    return
16390 
 
16391 
 
16392 
  def __repr__(self):
16393 
    L = ['%s=%r' % (key, value)
16394 
      for key, value in self.__dict__.iteritems()]
16395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16396 
 
16397 
  def __eq__(self, other):
16398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16399 
 
16400 
  def __ne__(self, other):
16401 
    return not (self == other)
16402 
 
16403 
class markOrderDoaRequestAuthorized_args:
16404 
  """
16405 
  Attributes:
16406 
   - orderId
16407 
   - isAuthorized
16408 
  """
16409 
 
16410 
  thrift_spec = (
16411 
    None, # 0
16412 
    (1, TType.I64, 'orderId', None, None, ), # 1
16413 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16414 
  )
16415 
 
16416 
  def __init__(self, orderId=None, isAuthorized=None,):
16417 
    self.orderId = orderId
16418 
    self.isAuthorized = isAuthorized
16419 
 
16420 
  def read(self, iprot):
16421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16423 
      return
16424 
    iprot.readStructBegin()
16425 
    while True:
16426 
      (fname, ftype, fid) = iprot.readFieldBegin()
16427 
      if ftype == TType.STOP:
16428 
        break
16429 
      if fid == 1:
16430 
        if ftype == TType.I64:
16431 
          self.orderId = iprot.readI64();
16432 
        else:
16433 
          iprot.skip(ftype)
16434 
      elif fid == 2:
16435 
        if ftype == TType.BOOL:
16436 
          self.isAuthorized = iprot.readBool();
16437 
        else:
16438 
          iprot.skip(ftype)
16439 
      else:
16440 
        iprot.skip(ftype)
16441 
      iprot.readFieldEnd()
16442 
    iprot.readStructEnd()
16443 
 
16444 
  def write(self, oprot):
16445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16447 
      return
16448 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16449 
    if self.orderId is not None:
16450 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16451 
      oprot.writeI64(self.orderId)
16452 
      oprot.writeFieldEnd()
16453 
    if self.isAuthorized is not None:
16454 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16455 
      oprot.writeBool(self.isAuthorized)
16456 
      oprot.writeFieldEnd()
16457 
    oprot.writeFieldStop()
16458 
    oprot.writeStructEnd()
16459 
 
16460 
  def validate(self):
16461 
    return
16462 
 
16463 
 
16464 
  def __repr__(self):
16465 
    L = ['%s=%r' % (key, value)
16466 
      for key, value in self.__dict__.iteritems()]
16467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16468 
 
16469 
  def __eq__(self, other):
16470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16471 
 
16472 
  def __ne__(self, other):
16473 
    return not (self == other)
16474 
 
16475 
class markOrderDoaRequestAuthorized_result:
16476 
  """
16477 
  Attributes:
16478 
   - success
16479 
   - ex
16480 
  """
16481 
 
16482 
  thrift_spec = (
16483 
    (0, TType.BOOL, 'success', None, None, ), # 0
16484 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16485 
  )
16486 
 
16487 
  def __init__(self, success=None, ex=None,):
16488 
    self.success = success
16489 
    self.ex = ex
16490 
 
16491 
  def read(self, iprot):
16492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16494 
      return
16495 
    iprot.readStructBegin()
16496 
    while True:
16497 
      (fname, ftype, fid) = iprot.readFieldBegin()
16498 
      if ftype == TType.STOP:
16499 
        break
16500 
      if fid == 0:
16501 
        if ftype == TType.BOOL:
16502 
          self.success = iprot.readBool();
16503 
        else:
16504 
          iprot.skip(ftype)
16505 
      elif fid == 1:
16506 
        if ftype == TType.STRUCT:
16507 
          self.ex = TransactionServiceException()
16508 
          self.ex.read(iprot)
16509 
        else:
16510 
          iprot.skip(ftype)
16511 
      else:
16512 
        iprot.skip(ftype)
16513 
      iprot.readFieldEnd()
16514 
    iprot.readStructEnd()
16515 
 
16516 
  def write(self, oprot):
16517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16519 
      return
16520 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
16521 
    if self.success is not None:
16522 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16523 
      oprot.writeBool(self.success)
16524 
      oprot.writeFieldEnd()
16525 
    if self.ex is not None:
16526 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16527 
      self.ex.write(oprot)
16528 
      oprot.writeFieldEnd()
16529 
    oprot.writeFieldStop()
16530 
    oprot.writeStructEnd()
16531 
 
16532 
  def validate(self):
16533 
    return
16534 
 
16535 
 
16536 
  def __repr__(self):
16537 
    L = ['%s=%r' % (key, value)
16538 
      for key, value in self.__dict__.iteritems()]
16539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16540 
 
16541 
  def __eq__(self, other):
16542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16543 
 
16544 
  def __ne__(self, other):
16545 
    return not (self == other)
16546 
 
4488 rajveer 16547 
class markOrderReturnRequestReceived_args:
16548 
  """
16549 
  Attributes:
16550 
   - orderId
16551 
  """
16552 
 
16553 
  thrift_spec = (
16554 
    None, # 0
16555 
    (1, TType.I64, 'orderId', None, None, ), # 1
16556 
  )
16557 
 
16558 
  def __init__(self, orderId=None,):
16559 
    self.orderId = orderId
16560 
 
16561 
  def read(self, iprot):
16562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16564 
      return
16565 
    iprot.readStructBegin()
16566 
    while True:
16567 
      (fname, ftype, fid) = iprot.readFieldBegin()
16568 
      if ftype == TType.STOP:
16569 
        break
16570 
      if fid == 1:
16571 
        if ftype == TType.I64:
16572 
          self.orderId = iprot.readI64();
16573 
        else:
16574 
          iprot.skip(ftype)
16575 
      else:
16576 
        iprot.skip(ftype)
16577 
      iprot.readFieldEnd()
16578 
    iprot.readStructEnd()
16579 
 
16580 
  def write(self, oprot):
16581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16583 
      return
16584 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
16585 
    if self.orderId is not None:
16586 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16587 
      oprot.writeI64(self.orderId)
16588 
      oprot.writeFieldEnd()
16589 
    oprot.writeFieldStop()
16590 
    oprot.writeStructEnd()
16591 
 
16592 
  def validate(self):
16593 
    return
16594 
 
16595 
 
16596 
  def __repr__(self):
16597 
    L = ['%s=%r' % (key, value)
16598 
      for key, value in self.__dict__.iteritems()]
16599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16600 
 
16601 
  def __eq__(self, other):
16602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16603 
 
16604 
  def __ne__(self, other):
16605 
    return not (self == other)
16606 
 
16607 
class markOrderReturnRequestReceived_result:
16608 
  """
16609 
  Attributes:
16610 
   - success
16611 
   - ex
16612 
  """
16613 
 
16614 
  thrift_spec = (
16615 
    (0, TType.BOOL, 'success', None, None, ), # 0
16616 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16617 
  )
16618 
 
16619 
  def __init__(self, success=None, ex=None,):
16620 
    self.success = success
16621 
    self.ex = ex
16622 
 
16623 
  def read(self, iprot):
16624 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16625 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16626 
      return
16627 
    iprot.readStructBegin()
16628 
    while True:
16629 
      (fname, ftype, fid) = iprot.readFieldBegin()
16630 
      if ftype == TType.STOP:
16631 
        break
16632 
      if fid == 0:
16633 
        if ftype == TType.BOOL:
16634 
          self.success = iprot.readBool();
16635 
        else:
16636 
          iprot.skip(ftype)
16637 
      elif fid == 1:
16638 
        if ftype == TType.STRUCT:
16639 
          self.ex = TransactionServiceException()
16640 
          self.ex.read(iprot)
16641 
        else:
16642 
          iprot.skip(ftype)
16643 
      else:
16644 
        iprot.skip(ftype)
16645 
      iprot.readFieldEnd()
16646 
    iprot.readStructEnd()
16647 
 
16648 
  def write(self, oprot):
16649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16651 
      return
16652 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
16653 
    if self.success is not None:
16654 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16655 
      oprot.writeBool(self.success)
16656 
      oprot.writeFieldEnd()
16657 
    if self.ex is not None:
16658 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16659 
      self.ex.write(oprot)
16660 
      oprot.writeFieldEnd()
16661 
    oprot.writeFieldStop()
16662 
    oprot.writeStructEnd()
16663 
 
16664 
  def validate(self):
16665 
    return
16666 
 
16667 
 
16668 
  def __repr__(self):
16669 
    L = ['%s=%r' % (key, value)
16670 
      for key, value in self.__dict__.iteritems()]
16671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16672 
 
16673 
  def __eq__(self, other):
16674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16675 
 
16676 
  def __ne__(self, other):
16677 
    return not (self == other)
16678 
 
16679 
class markOrderReturnRequestAuthorized_args:
16680 
  """
16681 
  Attributes:
16682 
   - orderId
16683 
   - isAuthorized
16684 
  """
16685 
 
16686 
  thrift_spec = (
16687 
    None, # 0
16688 
    (1, TType.I64, 'orderId', None, None, ), # 1
16689 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16690 
  )
16691 
 
16692 
  def __init__(self, orderId=None, isAuthorized=None,):
16693 
    self.orderId = orderId
16694 
    self.isAuthorized = isAuthorized
16695 
 
16696 
  def read(self, iprot):
16697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16699 
      return
16700 
    iprot.readStructBegin()
16701 
    while True:
16702 
      (fname, ftype, fid) = iprot.readFieldBegin()
16703 
      if ftype == TType.STOP:
16704 
        break
16705 
      if fid == 1:
16706 
        if ftype == TType.I64:
16707 
          self.orderId = iprot.readI64();
16708 
        else:
16709 
          iprot.skip(ftype)
16710 
      elif fid == 2:
16711 
        if ftype == TType.BOOL:
16712 
          self.isAuthorized = iprot.readBool();
16713 
        else:
16714 
          iprot.skip(ftype)
16715 
      else:
16716 
        iprot.skip(ftype)
16717 
      iprot.readFieldEnd()
16718 
    iprot.readStructEnd()
16719 
 
16720 
  def write(self, oprot):
16721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16723 
      return
16724 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
16725 
    if self.orderId is not None:
16726 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16727 
      oprot.writeI64(self.orderId)
16728 
      oprot.writeFieldEnd()
16729 
    if self.isAuthorized is not None:
16730 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16731 
      oprot.writeBool(self.isAuthorized)
16732 
      oprot.writeFieldEnd()
16733 
    oprot.writeFieldStop()
16734 
    oprot.writeStructEnd()
16735 
 
16736 
  def validate(self):
16737 
    return
16738 
 
16739 
 
16740 
  def __repr__(self):
16741 
    L = ['%s=%r' % (key, value)
16742 
      for key, value in self.__dict__.iteritems()]
16743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16744 
 
16745 
  def __eq__(self, other):
16746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16747 
 
16748 
  def __ne__(self, other):
16749 
    return not (self == other)
16750 
 
16751 
class markOrderReturnRequestAuthorized_result:
16752 
  """
16753 
  Attributes:
16754 
   - success
16755 
   - ex
16756 
  """
16757 
 
16758 
  thrift_spec = (
16759 
    (0, TType.BOOL, 'success', None, None, ), # 0
16760 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16761 
  )
16762 
 
16763 
  def __init__(self, success=None, ex=None,):
16764 
    self.success = success
16765 
    self.ex = ex
16766 
 
16767 
  def read(self, iprot):
16768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16770 
      return
16771 
    iprot.readStructBegin()
16772 
    while True:
16773 
      (fname, ftype, fid) = iprot.readFieldBegin()
16774 
      if ftype == TType.STOP:
16775 
        break
16776 
      if fid == 0:
16777 
        if ftype == TType.BOOL:
16778 
          self.success = iprot.readBool();
16779 
        else:
16780 
          iprot.skip(ftype)
16781 
      elif fid == 1:
16782 
        if ftype == TType.STRUCT:
16783 
          self.ex = TransactionServiceException()
16784 
          self.ex.read(iprot)
16785 
        else:
16786 
          iprot.skip(ftype)
16787 
      else:
16788 
        iprot.skip(ftype)
16789 
      iprot.readFieldEnd()
16790 
    iprot.readStructEnd()
16791 
 
16792 
  def write(self, oprot):
16793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16795 
      return
16796 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
16797 
    if self.success is not None:
16798 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16799 
      oprot.writeBool(self.success)
16800 
      oprot.writeFieldEnd()
16801 
    if self.ex is not None:
16802 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16803 
      self.ex.write(oprot)
16804 
      oprot.writeFieldEnd()
16805 
    oprot.writeFieldStop()
16806 
    oprot.writeStructEnd()
16807 
 
16808 
  def validate(self):
16809 
    return
16810 
 
16811 
 
16812 
  def __repr__(self):
16813 
    L = ['%s=%r' % (key, value)
16814 
      for key, value in self.__dict__.iteritems()]
16815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16816 
 
16817 
  def __eq__(self, other):
16818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16819 
 
16820 
  def __ne__(self, other):
16821 
    return not (self == other)
16822 
 
2536 chandransh 16823 
class requestPickupNumber_args:
16824 
  """
16825 
  Attributes:
16826 
   - orderId
4579 rajveer 16827 
   - providerId
2536 chandransh 16828 
  """
16829 
 
16830 
  thrift_spec = (
16831 
    None, # 0
16832 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 16833 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 16834 
  )
16835 
 
4579 rajveer 16836 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 16837 
    self.orderId = orderId
4579 rajveer 16838 
    self.providerId = providerId
2536 chandransh 16839 
 
16840 
  def read(self, iprot):
16841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16843 
      return
16844 
    iprot.readStructBegin()
16845 
    while True:
16846 
      (fname, ftype, fid) = iprot.readFieldBegin()
16847 
      if ftype == TType.STOP:
16848 
        break
16849 
      if fid == 1:
16850 
        if ftype == TType.I64:
16851 
          self.orderId = iprot.readI64();
16852 
        else:
16853 
          iprot.skip(ftype)
4579 rajveer 16854 
      elif fid == 2:
16855 
        if ftype == TType.I64:
16856 
          self.providerId = iprot.readI64();
16857 
        else:
16858 
          iprot.skip(ftype)
2536 chandransh 16859 
      else:
16860 
        iprot.skip(ftype)
16861 
      iprot.readFieldEnd()
16862 
    iprot.readStructEnd()
16863 
 
16864 
  def write(self, oprot):
16865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16867 
      return
16868 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 16869 
    if self.orderId is not None:
2536 chandransh 16870 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16871 
      oprot.writeI64(self.orderId)
16872 
      oprot.writeFieldEnd()
4579 rajveer 16873 
    if self.providerId is not None:
16874 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
16875 
      oprot.writeI64(self.providerId)
16876 
      oprot.writeFieldEnd()
2536 chandransh 16877 
    oprot.writeFieldStop()
16878 
    oprot.writeStructEnd()
16879 
 
3431 rajveer 16880 
  def validate(self):
16881 
    return
16882 
 
16883 
 
2536 chandransh 16884 
  def __repr__(self):
16885 
    L = ['%s=%r' % (key, value)
16886 
      for key, value in self.__dict__.iteritems()]
16887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16888 
 
16889 
  def __eq__(self, other):
16890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16891 
 
16892 
  def __ne__(self, other):
16893 
    return not (self == other)
16894 
 
16895 
class requestPickupNumber_result:
16896 
  """
16897 
  Attributes:
16898 
   - success
16899 
   - ex
16900 
  """
16901 
 
16902 
  thrift_spec = (
16903 
    (0, TType.BOOL, 'success', None, None, ), # 0
16904 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16905 
  )
16906 
 
16907 
  def __init__(self, success=None, ex=None,):
16908 
    self.success = success
16909 
    self.ex = ex
16910 
 
16911 
  def read(self, iprot):
16912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16914 
      return
16915 
    iprot.readStructBegin()
16916 
    while True:
16917 
      (fname, ftype, fid) = iprot.readFieldBegin()
16918 
      if ftype == TType.STOP:
16919 
        break
16920 
      if fid == 0:
16921 
        if ftype == TType.BOOL:
16922 
          self.success = iprot.readBool();
16923 
        else:
16924 
          iprot.skip(ftype)
16925 
      elif fid == 1:
16926 
        if ftype == TType.STRUCT:
16927 
          self.ex = TransactionServiceException()
16928 
          self.ex.read(iprot)
16929 
        else:
16930 
          iprot.skip(ftype)
16931 
      else:
16932 
        iprot.skip(ftype)
16933 
      iprot.readFieldEnd()
16934 
    iprot.readStructEnd()
16935 
 
16936 
  def write(self, oprot):
16937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16939 
      return
16940 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 16941 
    if self.success is not None:
2536 chandransh 16942 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16943 
      oprot.writeBool(self.success)
16944 
      oprot.writeFieldEnd()
3431 rajveer 16945 
    if self.ex is not None:
2536 chandransh 16946 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16947 
      self.ex.write(oprot)
16948 
      oprot.writeFieldEnd()
16949 
    oprot.writeFieldStop()
16950 
    oprot.writeStructEnd()
16951 
 
3431 rajveer 16952 
  def validate(self):
16953 
    return
16954 
 
16955 
 
2536 chandransh 16956 
  def __repr__(self):
16957 
    L = ['%s=%r' % (key, value)
16958 
      for key, value in self.__dict__.iteritems()]
16959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16960 
 
16961 
  def __eq__(self, other):
16962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16963 
 
16964 
  def __ne__(self, other):
16965 
    return not (self == other)
16966 
 
16967 
class authorizePickup_args:
16968 
  """
16969 
  Attributes:
16970 
   - orderId
16971 
   - pickupNumber
4602 rajveer 16972 
   - providerId
2536 chandransh 16973 
  """
16974 
 
16975 
  thrift_spec = (
16976 
    None, # 0
16977 
    (1, TType.I64, 'orderId', None, None, ), # 1
16978 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 16979 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 16980 
  )
16981 
 
4602 rajveer 16982 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 16983 
    self.orderId = orderId
16984 
    self.pickupNumber = pickupNumber
4602 rajveer 16985 
    self.providerId = providerId
2536 chandransh 16986 
 
16987 
  def read(self, iprot):
16988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16990 
      return
16991 
    iprot.readStructBegin()
16992 
    while True:
16993 
      (fname, ftype, fid) = iprot.readFieldBegin()
16994 
      if ftype == TType.STOP:
16995 
        break
16996 
      if fid == 1:
16997 
        if ftype == TType.I64:
16998 
          self.orderId = iprot.readI64();
16999 
        else:
17000 
          iprot.skip(ftype)
17001 
      elif fid == 2:
17002 
        if ftype == TType.STRING:
17003 
          self.pickupNumber = iprot.readString();
17004 
        else:
17005 
          iprot.skip(ftype)
4602 rajveer 17006 
      elif fid == 3:
17007 
        if ftype == TType.I64:
17008 
          self.providerId = iprot.readI64();
17009 
        else:
17010 
          iprot.skip(ftype)
2536 chandransh 17011 
      else:
17012 
        iprot.skip(ftype)
17013 
      iprot.readFieldEnd()
17014 
    iprot.readStructEnd()
17015 
 
17016 
  def write(self, oprot):
17017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17019 
      return
17020 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 17021 
    if self.orderId is not None:
2536 chandransh 17022 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17023 
      oprot.writeI64(self.orderId)
17024 
      oprot.writeFieldEnd()
3431 rajveer 17025 
    if self.pickupNumber is not None:
2536 chandransh 17026 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
17027 
      oprot.writeString(self.pickupNumber)
17028 
      oprot.writeFieldEnd()
4602 rajveer 17029 
    if self.providerId is not None:
17030 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
17031 
      oprot.writeI64(self.providerId)
17032 
      oprot.writeFieldEnd()
2536 chandransh 17033 
    oprot.writeFieldStop()
17034 
    oprot.writeStructEnd()
17035 
 
3431 rajveer 17036 
  def validate(self):
17037 
    return
17038 
 
17039 
 
2536 chandransh 17040 
  def __repr__(self):
17041 
    L = ['%s=%r' % (key, value)
17042 
      for key, value in self.__dict__.iteritems()]
17043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17044 
 
17045 
  def __eq__(self, other):
17046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17047 
 
17048 
  def __ne__(self, other):
17049 
    return not (self == other)
17050 
 
17051 
class authorizePickup_result:
17052 
  """
17053 
  Attributes:
17054 
   - success
17055 
   - ex
17056 
  """
17057 
 
17058 
  thrift_spec = (
17059 
    (0, TType.BOOL, 'success', None, None, ), # 0
17060 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17061 
  )
17062 
 
17063 
  def __init__(self, success=None, ex=None,):
17064 
    self.success = success
17065 
    self.ex = ex
17066 
 
17067 
  def read(self, iprot):
17068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17070 
      return
17071 
    iprot.readStructBegin()
17072 
    while True:
17073 
      (fname, ftype, fid) = iprot.readFieldBegin()
17074 
      if ftype == TType.STOP:
17075 
        break
17076 
      if fid == 0:
17077 
        if ftype == TType.BOOL:
17078 
          self.success = iprot.readBool();
17079 
        else:
17080 
          iprot.skip(ftype)
17081 
      elif fid == 1:
17082 
        if ftype == TType.STRUCT:
17083 
          self.ex = TransactionServiceException()
17084 
          self.ex.read(iprot)
17085 
        else:
17086 
          iprot.skip(ftype)
17087 
      else:
17088 
        iprot.skip(ftype)
17089 
      iprot.readFieldEnd()
17090 
    iprot.readStructEnd()
17091 
 
17092 
  def write(self, oprot):
17093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17095 
      return
17096 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 17097 
    if self.success is not None:
2536 chandransh 17098 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17099 
      oprot.writeBool(self.success)
17100 
      oprot.writeFieldEnd()
3431 rajveer 17101 
    if self.ex is not None:
2536 chandransh 17102 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17103 
      self.ex.write(oprot)
17104 
      oprot.writeFieldEnd()
17105 
    oprot.writeFieldStop()
17106 
    oprot.writeStructEnd()
17107 
 
3431 rajveer 17108 
  def validate(self):
17109 
    return
17110 
 
17111 
 
2536 chandransh 17112 
  def __repr__(self):
17113 
    L = ['%s=%r' % (key, value)
17114 
      for key, value in self.__dict__.iteritems()]
17115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17116 
 
17117 
  def __eq__(self, other):
17118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17119 
 
17120 
  def __ne__(self, other):
17121 
    return not (self == other)
17122 
 
2764 chandransh 17123 
class markDoasAsPickedUp_args:
17124 
  """
17125 
  Attributes:
17126 
   - providerId
17127 
   - pickupDetails
17128 
  """
17129 
 
17130 
  thrift_spec = (
17131 
    None, # 0
17132 
    (1, TType.I64, 'providerId', None, None, ), # 1
17133 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17134 
  )
17135 
 
17136 
  def __init__(self, providerId=None, pickupDetails=None,):
17137 
    self.providerId = providerId
17138 
    self.pickupDetails = pickupDetails
17139 
 
17140 
  def read(self, iprot):
17141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17143 
      return
17144 
    iprot.readStructBegin()
17145 
    while True:
17146 
      (fname, ftype, fid) = iprot.readFieldBegin()
17147 
      if ftype == TType.STOP:
17148 
        break
17149 
      if fid == 1:
17150 
        if ftype == TType.I64:
17151 
          self.providerId = iprot.readI64();
17152 
        else:
17153 
          iprot.skip(ftype)
17154 
      elif fid == 2:
17155 
        if ftype == TType.MAP:
17156 
          self.pickupDetails = {}
6188 rajveer 17157 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
17158 
          for _i411 in xrange(_size407):
17159 
            _key412 = iprot.readString();
17160 
            _val413 = iprot.readString();
17161 
            self.pickupDetails[_key412] = _val413
2764 chandransh 17162 
          iprot.readMapEnd()
17163 
        else:
17164 
          iprot.skip(ftype)
17165 
      else:
17166 
        iprot.skip(ftype)
17167 
      iprot.readFieldEnd()
17168 
    iprot.readStructEnd()
17169 
 
17170 
  def write(self, oprot):
17171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17173 
      return
17174 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 17175 
    if self.providerId is not None:
2764 chandransh 17176 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17177 
      oprot.writeI64(self.providerId)
17178 
      oprot.writeFieldEnd()
3431 rajveer 17179 
    if self.pickupDetails is not None:
2764 chandransh 17180 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17181 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17182 
      for kiter414,viter415 in self.pickupDetails.items():
17183 
        oprot.writeString(kiter414)
17184 
        oprot.writeString(viter415)
2764 chandransh 17185 
      oprot.writeMapEnd()
17186 
      oprot.writeFieldEnd()
17187 
    oprot.writeFieldStop()
17188 
    oprot.writeStructEnd()
17189 
 
3431 rajveer 17190 
  def validate(self):
17191 
    return
17192 
 
17193 
 
2764 chandransh 17194 
  def __repr__(self):
17195 
    L = ['%s=%r' % (key, value)
17196 
      for key, value in self.__dict__.iteritems()]
17197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17198 
 
17199 
  def __eq__(self, other):
17200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17201 
 
17202 
  def __ne__(self, other):
17203 
    return not (self == other)
17204 
 
17205 
class markDoasAsPickedUp_result:
4910 phani.kuma 17206 
 
17207 
  thrift_spec = (
17208 
  )
17209 
 
17210 
  def read(self, iprot):
17211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17213 
      return
17214 
    iprot.readStructBegin()
17215 
    while True:
17216 
      (fname, ftype, fid) = iprot.readFieldBegin()
17217 
      if ftype == TType.STOP:
17218 
        break
17219 
      else:
17220 
        iprot.skip(ftype)
17221 
      iprot.readFieldEnd()
17222 
    iprot.readStructEnd()
17223 
 
17224 
  def write(self, oprot):
17225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17227 
      return
17228 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
17229 
    oprot.writeFieldStop()
17230 
    oprot.writeStructEnd()
17231 
 
17232 
  def validate(self):
17233 
    return
17234 
 
17235 
 
17236 
  def __repr__(self):
17237 
    L = ['%s=%r' % (key, value)
17238 
      for key, value in self.__dict__.iteritems()]
17239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17240 
 
17241 
  def __eq__(self, other):
17242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17243 
 
17244 
  def __ne__(self, other):
17245 
    return not (self == other)
17246 
 
17247 
class getDoasNotPickedUp_args:
2764 chandransh 17248 
  """
17249 
  Attributes:
4910 phani.kuma 17250 
   - providerId
17251 
  """
17252 
 
17253 
  thrift_spec = (
17254 
    None, # 0
17255 
    (1, TType.I64, 'providerId', None, None, ), # 1
17256 
  )
17257 
 
17258 
  def __init__(self, providerId=None,):
17259 
    self.providerId = providerId
17260 
 
17261 
  def read(self, iprot):
17262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17264 
      return
17265 
    iprot.readStructBegin()
17266 
    while True:
17267 
      (fname, ftype, fid) = iprot.readFieldBegin()
17268 
      if ftype == TType.STOP:
17269 
        break
17270 
      if fid == 1:
17271 
        if ftype == TType.I64:
17272 
          self.providerId = iprot.readI64();
17273 
        else:
17274 
          iprot.skip(ftype)
17275 
      else:
17276 
        iprot.skip(ftype)
17277 
      iprot.readFieldEnd()
17278 
    iprot.readStructEnd()
17279 
 
17280 
  def write(self, oprot):
17281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17283 
      return
17284 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17285 
    if self.providerId is not None:
17286 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17287 
      oprot.writeI64(self.providerId)
17288 
      oprot.writeFieldEnd()
17289 
    oprot.writeFieldStop()
17290 
    oprot.writeStructEnd()
17291 
 
17292 
  def validate(self):
17293 
    return
17294 
 
17295 
 
17296 
  def __repr__(self):
17297 
    L = ['%s=%r' % (key, value)
17298 
      for key, value in self.__dict__.iteritems()]
17299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17300 
 
17301 
  def __eq__(self, other):
17302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17303 
 
17304 
  def __ne__(self, other):
17305 
    return not (self == other)
17306 
 
17307 
class getDoasNotPickedUp_result:
17308 
  """
17309 
  Attributes:
2764 chandransh 17310 
   - success
17311 
  """
17312 
 
17313 
  thrift_spec = (
17314 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17315 
  )
17316 
 
17317 
  def __init__(self, success=None,):
17318 
    self.success = success
17319 
 
17320 
  def read(self, iprot):
17321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17323 
      return
17324 
    iprot.readStructBegin()
17325 
    while True:
17326 
      (fname, ftype, fid) = iprot.readFieldBegin()
17327 
      if ftype == TType.STOP:
17328 
        break
17329 
      if fid == 0:
17330 
        if ftype == TType.LIST:
17331 
          self.success = []
6188 rajveer 17332 
          (_etype419, _size416) = iprot.readListBegin()
17333 
          for _i420 in xrange(_size416):
17334 
            _elem421 = Order()
17335 
            _elem421.read(iprot)
17336 
            self.success.append(_elem421)
2764 chandransh 17337 
          iprot.readListEnd()
17338 
        else:
17339 
          iprot.skip(ftype)
17340 
      else:
17341 
        iprot.skip(ftype)
17342 
      iprot.readFieldEnd()
17343 
    iprot.readStructEnd()
17344 
 
17345 
  def write(self, oprot):
17346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17348 
      return
4910 phani.kuma 17349 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 17350 
    if self.success is not None:
2764 chandransh 17351 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17352 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17353 
      for iter422 in self.success:
17354 
        iter422.write(oprot)
2764 chandransh 17355 
      oprot.writeListEnd()
17356 
      oprot.writeFieldEnd()
17357 
    oprot.writeFieldStop()
17358 
    oprot.writeStructEnd()
17359 
 
3431 rajveer 17360 
  def validate(self):
17361 
    return
17362 
 
17363 
 
2764 chandransh 17364 
  def __repr__(self):
17365 
    L = ['%s=%r' % (key, value)
17366 
      for key, value in self.__dict__.iteritems()]
17367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17368 
 
17369 
  def __eq__(self, other):
17370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17371 
 
17372 
  def __ne__(self, other):
17373 
    return not (self == other)
17374 
 
4741 phani.kuma 17375 
class markReturnOrdersAsPickedUp_args:
17376 
  """
17377 
  Attributes:
17378 
   - providerId
17379 
   - pickupDetails
17380 
  """
17381 
 
17382 
  thrift_spec = (
17383 
    None, # 0
17384 
    (1, TType.I64, 'providerId', None, None, ), # 1
17385 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17386 
  )
17387 
 
17388 
  def __init__(self, providerId=None, pickupDetails=None,):
17389 
    self.providerId = providerId
17390 
    self.pickupDetails = pickupDetails
17391 
 
17392 
  def read(self, iprot):
17393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17395 
      return
17396 
    iprot.readStructBegin()
17397 
    while True:
17398 
      (fname, ftype, fid) = iprot.readFieldBegin()
17399 
      if ftype == TType.STOP:
17400 
        break
17401 
      if fid == 1:
17402 
        if ftype == TType.I64:
17403 
          self.providerId = iprot.readI64();
17404 
        else:
17405 
          iprot.skip(ftype)
17406 
      elif fid == 2:
17407 
        if ftype == TType.MAP:
17408 
          self.pickupDetails = {}
6188 rajveer 17409 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
17410 
          for _i427 in xrange(_size423):
17411 
            _key428 = iprot.readString();
17412 
            _val429 = iprot.readString();
17413 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 17414 
          iprot.readMapEnd()
17415 
        else:
17416 
          iprot.skip(ftype)
17417 
      else:
17418 
        iprot.skip(ftype)
17419 
      iprot.readFieldEnd()
17420 
    iprot.readStructEnd()
17421 
 
17422 
  def write(self, oprot):
17423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17425 
      return
17426 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
17427 
    if self.providerId is not None:
17428 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17429 
      oprot.writeI64(self.providerId)
17430 
      oprot.writeFieldEnd()
17431 
    if self.pickupDetails is not None:
17432 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17433 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17434 
      for kiter430,viter431 in self.pickupDetails.items():
17435 
        oprot.writeString(kiter430)
17436 
        oprot.writeString(viter431)
4741 phani.kuma 17437 
      oprot.writeMapEnd()
17438 
      oprot.writeFieldEnd()
17439 
    oprot.writeFieldStop()
17440 
    oprot.writeStructEnd()
17441 
 
17442 
  def validate(self):
17443 
    return
17444 
 
17445 
 
17446 
  def __repr__(self):
17447 
    L = ['%s=%r' % (key, value)
17448 
      for key, value in self.__dict__.iteritems()]
17449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17450 
 
17451 
  def __eq__(self, other):
17452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17453 
 
17454 
  def __ne__(self, other):
17455 
    return not (self == other)
17456 
 
17457 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 17458 
 
17459 
  thrift_spec = (
17460 
  )
17461 
 
17462 
  def read(self, iprot):
17463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17465 
      return
17466 
    iprot.readStructBegin()
17467 
    while True:
17468 
      (fname, ftype, fid) = iprot.readFieldBegin()
17469 
      if ftype == TType.STOP:
17470 
        break
17471 
      else:
17472 
        iprot.skip(ftype)
17473 
      iprot.readFieldEnd()
17474 
    iprot.readStructEnd()
17475 
 
17476 
  def write(self, oprot):
17477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17479 
      return
17480 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
17481 
    oprot.writeFieldStop()
17482 
    oprot.writeStructEnd()
17483 
 
17484 
  def validate(self):
17485 
    return
17486 
 
17487 
 
17488 
  def __repr__(self):
17489 
    L = ['%s=%r' % (key, value)
17490 
      for key, value in self.__dict__.iteritems()]
17491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17492 
 
17493 
  def __eq__(self, other):
17494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17495 
 
17496 
  def __ne__(self, other):
17497 
    return not (self == other)
17498 
 
17499 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 17500 
  """
17501 
  Attributes:
4910 phani.kuma 17502 
   - providerId
17503 
  """
17504 
 
17505 
  thrift_spec = (
17506 
    None, # 0
17507 
    (1, TType.I64, 'providerId', None, None, ), # 1
17508 
  )
17509 
 
17510 
  def __init__(self, providerId=None,):
17511 
    self.providerId = providerId
17512 
 
17513 
  def read(self, iprot):
17514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17516 
      return
17517 
    iprot.readStructBegin()
17518 
    while True:
17519 
      (fname, ftype, fid) = iprot.readFieldBegin()
17520 
      if ftype == TType.STOP:
17521 
        break
17522 
      if fid == 1:
17523 
        if ftype == TType.I64:
17524 
          self.providerId = iprot.readI64();
17525 
        else:
17526 
          iprot.skip(ftype)
17527 
      else:
17528 
        iprot.skip(ftype)
17529 
      iprot.readFieldEnd()
17530 
    iprot.readStructEnd()
17531 
 
17532 
  def write(self, oprot):
17533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17535 
      return
17536 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
17537 
    if self.providerId is not None:
17538 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17539 
      oprot.writeI64(self.providerId)
17540 
      oprot.writeFieldEnd()
17541 
    oprot.writeFieldStop()
17542 
    oprot.writeStructEnd()
17543 
 
17544 
  def validate(self):
17545 
    return
17546 
 
17547 
 
17548 
  def __repr__(self):
17549 
    L = ['%s=%r' % (key, value)
17550 
      for key, value in self.__dict__.iteritems()]
17551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17552 
 
17553 
  def __eq__(self, other):
17554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17555 
 
17556 
  def __ne__(self, other):
17557 
    return not (self == other)
17558 
 
17559 
class getReturnOrdersNotPickedUp_result:
17560 
  """
17561 
  Attributes:
4741 phani.kuma 17562 
   - success
17563 
  """
17564 
 
17565 
  thrift_spec = (
17566 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17567 
  )
17568 
 
17569 
  def __init__(self, success=None,):
17570 
    self.success = success
17571 
 
17572 
  def read(self, iprot):
17573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17575 
      return
17576 
    iprot.readStructBegin()
17577 
    while True:
17578 
      (fname, ftype, fid) = iprot.readFieldBegin()
17579 
      if ftype == TType.STOP:
17580 
        break
17581 
      if fid == 0:
17582 
        if ftype == TType.LIST:
17583 
          self.success = []
6188 rajveer 17584 
          (_etype435, _size432) = iprot.readListBegin()
17585 
          for _i436 in xrange(_size432):
17586 
            _elem437 = Order()
17587 
            _elem437.read(iprot)
17588 
            self.success.append(_elem437)
4741 phani.kuma 17589 
          iprot.readListEnd()
17590 
        else:
17591 
          iprot.skip(ftype)
17592 
      else:
17593 
        iprot.skip(ftype)
17594 
      iprot.readFieldEnd()
17595 
    iprot.readStructEnd()
17596 
 
17597 
  def write(self, oprot):
17598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17600 
      return
4910 phani.kuma 17601 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 17602 
    if self.success is not None:
17603 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17604 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17605 
      for iter438 in self.success:
17606 
        iter438.write(oprot)
4741 phani.kuma 17607 
      oprot.writeListEnd()
17608 
      oprot.writeFieldEnd()
17609 
    oprot.writeFieldStop()
17610 
    oprot.writeStructEnd()
17611 
 
17612 
  def validate(self):
17613 
    return
17614 
 
17615 
 
17616 
  def __repr__(self):
17617 
    L = ['%s=%r' % (key, value)
17618 
      for key, value in self.__dict__.iteritems()]
17619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17620 
 
17621 
  def __eq__(self, other):
17622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17623 
 
17624 
  def __ne__(self, other):
17625 
    return not (self == other)
17626 
 
2616 chandransh 17627 
class receiveReturn_args:
2591 chandransh 17628 
  """
17629 
  Attributes:
17630 
   - orderId
4479 rajveer 17631 
   - receiveCondition
2591 chandransh 17632 
  """
2536 chandransh 17633 
 
2591 chandransh 17634 
  thrift_spec = (
17635 
    None, # 0
17636 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 17637 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 17638 
  )
17639 
 
4479 rajveer 17640 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 17641 
    self.orderId = orderId
4479 rajveer 17642 
    self.receiveCondition = receiveCondition
2591 chandransh 17643 
 
17644 
  def read(self, iprot):
17645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17647 
      return
17648 
    iprot.readStructBegin()
17649 
    while True:
17650 
      (fname, ftype, fid) = iprot.readFieldBegin()
17651 
      if ftype == TType.STOP:
17652 
        break
17653 
      if fid == 1:
17654 
        if ftype == TType.I64:
17655 
          self.orderId = iprot.readI64();
17656 
        else:
17657 
          iprot.skip(ftype)
4479 rajveer 17658 
      elif fid == 2:
17659 
        if ftype == TType.I64:
17660 
          self.receiveCondition = iprot.readI64();
17661 
        else:
17662 
          iprot.skip(ftype)
2591 chandransh 17663 
      else:
17664 
        iprot.skip(ftype)
17665 
      iprot.readFieldEnd()
17666 
    iprot.readStructEnd()
17667 
 
17668 
  def write(self, oprot):
17669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17671 
      return
2616 chandransh 17672 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 17673 
    if self.orderId is not None:
2591 chandransh 17674 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17675 
      oprot.writeI64(self.orderId)
17676 
      oprot.writeFieldEnd()
4479 rajveer 17677 
    if self.receiveCondition is not None:
17678 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
17679 
      oprot.writeI64(self.receiveCondition)
17680 
      oprot.writeFieldEnd()
2591 chandransh 17681 
    oprot.writeFieldStop()
17682 
    oprot.writeStructEnd()
17683 
 
3431 rajveer 17684 
  def validate(self):
17685 
    return
17686 
 
17687 
 
2591 chandransh 17688 
  def __repr__(self):
17689 
    L = ['%s=%r' % (key, value)
17690 
      for key, value in self.__dict__.iteritems()]
17691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17692 
 
17693 
  def __eq__(self, other):
17694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17695 
 
17696 
  def __ne__(self, other):
17697 
    return not (self == other)
17698 
 
2616 chandransh 17699 
class receiveReturn_result:
2591 chandransh 17700 
  """
17701 
  Attributes:
17702 
   - success
17703 
   - ex
17704 
  """
17705 
 
17706 
  thrift_spec = (
17707 
    (0, TType.BOOL, 'success', None, None, ), # 0
17708 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17709 
  )
17710 
 
17711 
  def __init__(self, success=None, ex=None,):
17712 
    self.success = success
17713 
    self.ex = ex
17714 
 
17715 
  def read(self, iprot):
17716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17718 
      return
17719 
    iprot.readStructBegin()
17720 
    while True:
17721 
      (fname, ftype, fid) = iprot.readFieldBegin()
17722 
      if ftype == TType.STOP:
17723 
        break
17724 
      if fid == 0:
17725 
        if ftype == TType.BOOL:
17726 
          self.success = iprot.readBool();
17727 
        else:
17728 
          iprot.skip(ftype)
17729 
      elif fid == 1:
17730 
        if ftype == TType.STRUCT:
17731 
          self.ex = TransactionServiceException()
17732 
          self.ex.read(iprot)
17733 
        else:
17734 
          iprot.skip(ftype)
17735 
      else:
17736 
        iprot.skip(ftype)
17737 
      iprot.readFieldEnd()
17738 
    iprot.readStructEnd()
17739 
 
17740 
  def write(self, oprot):
17741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17743 
      return
2616 chandransh 17744 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 17745 
    if self.success is not None:
2591 chandransh 17746 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17747 
      oprot.writeBool(self.success)
17748 
      oprot.writeFieldEnd()
3431 rajveer 17749 
    if self.ex is not None:
2591 chandransh 17750 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17751 
      self.ex.write(oprot)
17752 
      oprot.writeFieldEnd()
17753 
    oprot.writeFieldStop()
17754 
    oprot.writeStructEnd()
17755 
 
3431 rajveer 17756 
  def validate(self):
17757 
    return
17758 
 
17759 
 
2591 chandransh 17760 
  def __repr__(self):
17761 
    L = ['%s=%r' % (key, value)
17762 
      for key, value in self.__dict__.iteritems()]
17763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17764 
 
17765 
  def __eq__(self, other):
17766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17767 
 
17768 
  def __ne__(self, other):
17769 
    return not (self == other)
17770 
 
17771 
class validateDoa_args:
17772 
  """
17773 
  Attributes:
17774 
   - orderId
17775 
   - isValid
17776 
  """
17777 
 
17778 
  thrift_spec = (
17779 
    None, # 0
17780 
    (1, TType.I64, 'orderId', None, None, ), # 1
17781 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
17782 
  )
17783 
 
17784 
  def __init__(self, orderId=None, isValid=None,):
17785 
    self.orderId = orderId
17786 
    self.isValid = isValid
17787 
 
17788 
  def read(self, iprot):
17789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17791 
      return
17792 
    iprot.readStructBegin()
17793 
    while True:
17794 
      (fname, ftype, fid) = iprot.readFieldBegin()
17795 
      if ftype == TType.STOP:
17796 
        break
17797 
      if fid == 1:
17798 
        if ftype == TType.I64:
17799 
          self.orderId = iprot.readI64();
17800 
        else:
17801 
          iprot.skip(ftype)
17802 
      elif fid == 2:
17803 
        if ftype == TType.BOOL:
17804 
          self.isValid = iprot.readBool();
17805 
        else:
17806 
          iprot.skip(ftype)
17807 
      else:
17808 
        iprot.skip(ftype)
17809 
      iprot.readFieldEnd()
17810 
    iprot.readStructEnd()
17811 
 
17812 
  def write(self, oprot):
17813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17815 
      return
17816 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 17817 
    if self.orderId is not None:
2591 chandransh 17818 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17819 
      oprot.writeI64(self.orderId)
17820 
      oprot.writeFieldEnd()
3431 rajveer 17821 
    if self.isValid is not None:
2591 chandransh 17822 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
17823 
      oprot.writeBool(self.isValid)
17824 
      oprot.writeFieldEnd()
17825 
    oprot.writeFieldStop()
17826 
    oprot.writeStructEnd()
17827 
 
3431 rajveer 17828 
  def validate(self):
17829 
    return
17830 
 
17831 
 
2591 chandransh 17832 
  def __repr__(self):
17833 
    L = ['%s=%r' % (key, value)
17834 
      for key, value in self.__dict__.iteritems()]
17835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17836 
 
17837 
  def __eq__(self, other):
17838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17839 
 
17840 
  def __ne__(self, other):
17841 
    return not (self == other)
17842 
 
17843 
class validateDoa_result:
17844 
  """
17845 
  Attributes:
17846 
   - success
17847 
   - ex
17848 
  """
17849 
 
17850 
  thrift_spec = (
17851 
    (0, TType.BOOL, 'success', None, None, ), # 0
17852 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17853 
  )
17854 
 
17855 
  def __init__(self, success=None, ex=None,):
17856 
    self.success = success
17857 
    self.ex = ex
17858 
 
17859 
  def read(self, iprot):
17860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17862 
      return
17863 
    iprot.readStructBegin()
17864 
    while True:
17865 
      (fname, ftype, fid) = iprot.readFieldBegin()
17866 
      if ftype == TType.STOP:
17867 
        break
17868 
      if fid == 0:
17869 
        if ftype == TType.BOOL:
17870 
          self.success = iprot.readBool();
17871 
        else:
17872 
          iprot.skip(ftype)
17873 
      elif fid == 1:
17874 
        if ftype == TType.STRUCT:
17875 
          self.ex = TransactionServiceException()
17876 
          self.ex.read(iprot)
17877 
        else:
17878 
          iprot.skip(ftype)
17879 
      else:
17880 
        iprot.skip(ftype)
17881 
      iprot.readFieldEnd()
17882 
    iprot.readStructEnd()
17883 
 
17884 
  def write(self, oprot):
17885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17887 
      return
17888 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 17889 
    if self.success is not None:
2591 chandransh 17890 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17891 
      oprot.writeBool(self.success)
17892 
      oprot.writeFieldEnd()
3431 rajveer 17893 
    if self.ex is not None:
2591 chandransh 17894 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17895 
      self.ex.write(oprot)
17896 
      oprot.writeFieldEnd()
17897 
    oprot.writeFieldStop()
17898 
    oprot.writeStructEnd()
17899 
 
3431 rajveer 17900 
  def validate(self):
17901 
    return
17902 
 
17903 
 
2591 chandransh 17904 
  def __repr__(self):
17905 
    L = ['%s=%r' % (key, value)
17906 
      for key, value in self.__dict__.iteritems()]
17907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17908 
 
17909 
  def __eq__(self, other):
17910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17911 
 
17912 
  def __ne__(self, other):
17913 
    return not (self == other)
17914 
 
4495 rajveer 17915 
class validateReturnProduct_args:
17916 
  """
17917 
  Attributes:
17918 
   - orderId
17919 
   - isUsable
17920 
  """
17921 
 
17922 
  thrift_spec = (
17923 
    None, # 0
17924 
    (1, TType.I64, 'orderId', None, None, ), # 1
17925 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
17926 
  )
17927 
 
17928 
  def __init__(self, orderId=None, isUsable=None,):
17929 
    self.orderId = orderId
17930 
    self.isUsable = isUsable
17931 
 
17932 
  def read(self, iprot):
17933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17935 
      return
17936 
    iprot.readStructBegin()
17937 
    while True:
17938 
      (fname, ftype, fid) = iprot.readFieldBegin()
17939 
      if ftype == TType.STOP:
17940 
        break
17941 
      if fid == 1:
17942 
        if ftype == TType.I64:
17943 
          self.orderId = iprot.readI64();
17944 
        else:
17945 
          iprot.skip(ftype)
17946 
      elif fid == 2:
17947 
        if ftype == TType.BOOL:
17948 
          self.isUsable = iprot.readBool();
17949 
        else:
17950 
          iprot.skip(ftype)
17951 
      else:
17952 
        iprot.skip(ftype)
17953 
      iprot.readFieldEnd()
17954 
    iprot.readStructEnd()
17955 
 
17956 
  def write(self, oprot):
17957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17959 
      return
17960 
    oprot.writeStructBegin('validateReturnProduct_args')
17961 
    if self.orderId is not None:
17962 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17963 
      oprot.writeI64(self.orderId)
17964 
      oprot.writeFieldEnd()
17965 
    if self.isUsable is not None:
17966 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
17967 
      oprot.writeBool(self.isUsable)
17968 
      oprot.writeFieldEnd()
17969 
    oprot.writeFieldStop()
17970 
    oprot.writeStructEnd()
17971 
 
17972 
  def validate(self):
17973 
    return
17974 
 
17975 
 
17976 
  def __repr__(self):
17977 
    L = ['%s=%r' % (key, value)
17978 
      for key, value in self.__dict__.iteritems()]
17979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17980 
 
17981 
  def __eq__(self, other):
17982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17983 
 
17984 
  def __ne__(self, other):
17985 
    return not (self == other)
17986 
 
17987 
class validateReturnProduct_result:
17988 
  """
17989 
  Attributes:
17990 
   - success
17991 
   - ex
17992 
  """
17993 
 
17994 
  thrift_spec = (
17995 
    (0, TType.BOOL, 'success', None, None, ), # 0
17996 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17997 
  )
17998 
 
17999 
  def __init__(self, success=None, ex=None,):
18000 
    self.success = success
18001 
    self.ex = ex
18002 
 
18003 
  def read(self, iprot):
18004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18006 
      return
18007 
    iprot.readStructBegin()
18008 
    while True:
18009 
      (fname, ftype, fid) = iprot.readFieldBegin()
18010 
      if ftype == TType.STOP:
18011 
        break
18012 
      if fid == 0:
18013 
        if ftype == TType.BOOL:
18014 
          self.success = iprot.readBool();
18015 
        else:
18016 
          iprot.skip(ftype)
18017 
      elif fid == 1:
18018 
        if ftype == TType.STRUCT:
18019 
          self.ex = TransactionServiceException()
18020 
          self.ex.read(iprot)
18021 
        else:
18022 
          iprot.skip(ftype)
18023 
      else:
18024 
        iprot.skip(ftype)
18025 
      iprot.readFieldEnd()
18026 
    iprot.readStructEnd()
18027 
 
18028 
  def write(self, oprot):
18029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18031 
      return
18032 
    oprot.writeStructBegin('validateReturnProduct_result')
18033 
    if self.success is not None:
18034 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18035 
      oprot.writeBool(self.success)
18036 
      oprot.writeFieldEnd()
18037 
    if self.ex is not None:
18038 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18039 
      self.ex.write(oprot)
18040 
      oprot.writeFieldEnd()
18041 
    oprot.writeFieldStop()
18042 
    oprot.writeStructEnd()
18043 
 
18044 
  def validate(self):
18045 
    return
18046 
 
18047 
 
18048 
  def __repr__(self):
18049 
    L = ['%s=%r' % (key, value)
18050 
      for key, value in self.__dict__.iteritems()]
18051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18052 
 
18053 
  def __eq__(self, other):
18054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18055 
 
18056 
  def __ne__(self, other):
18057 
    return not (self == other)
18058 
 
2616 chandransh 18059 
class reshipOrder_args:
18060 
  """
18061 
  Attributes:
18062 
   - orderId
18063 
  """
2591 chandransh 18064 
 
2616 chandransh 18065 
  thrift_spec = (
18066 
    None, # 0
18067 
    (1, TType.I64, 'orderId', None, None, ), # 1
18068 
  )
18069 
 
18070 
  def __init__(self, orderId=None,):
18071 
    self.orderId = orderId
18072 
 
18073 
  def read(self, iprot):
18074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18076 
      return
18077 
    iprot.readStructBegin()
18078 
    while True:
18079 
      (fname, ftype, fid) = iprot.readFieldBegin()
18080 
      if ftype == TType.STOP:
18081 
        break
18082 
      if fid == 1:
18083 
        if ftype == TType.I64:
18084 
          self.orderId = iprot.readI64();
18085 
        else:
18086 
          iprot.skip(ftype)
18087 
      else:
18088 
        iprot.skip(ftype)
18089 
      iprot.readFieldEnd()
18090 
    iprot.readStructEnd()
18091 
 
18092 
  def write(self, oprot):
18093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18095 
      return
18096 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 18097 
    if self.orderId is not None:
2616 chandransh 18098 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18099 
      oprot.writeI64(self.orderId)
18100 
      oprot.writeFieldEnd()
18101 
    oprot.writeFieldStop()
18102 
    oprot.writeStructEnd()
18103 
 
3431 rajveer 18104 
  def validate(self):
18105 
    return
18106 
 
18107 
 
2616 chandransh 18108 
  def __repr__(self):
18109 
    L = ['%s=%r' % (key, value)
18110 
      for key, value in self.__dict__.iteritems()]
18111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18112 
 
18113 
  def __eq__(self, other):
18114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18115 
 
18116 
  def __ne__(self, other):
18117 
    return not (self == other)
18118 
 
18119 
class reshipOrder_result:
18120 
  """
18121 
  Attributes:
18122 
   - success
18123 
   - ex
18124 
  """
18125 
 
18126 
  thrift_spec = (
18127 
    (0, TType.I64, 'success', None, None, ), # 0
18128 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18129 
  )
18130 
 
18131 
  def __init__(self, success=None, ex=None,):
18132 
    self.success = success
18133 
    self.ex = ex
18134 
 
18135 
  def read(self, iprot):
18136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18138 
      return
18139 
    iprot.readStructBegin()
18140 
    while True:
18141 
      (fname, ftype, fid) = iprot.readFieldBegin()
18142 
      if ftype == TType.STOP:
18143 
        break
18144 
      if fid == 0:
18145 
        if ftype == TType.I64:
18146 
          self.success = iprot.readI64();
18147 
        else:
18148 
          iprot.skip(ftype)
18149 
      elif fid == 1:
18150 
        if ftype == TType.STRUCT:
18151 
          self.ex = TransactionServiceException()
18152 
          self.ex.read(iprot)
18153 
        else:
18154 
          iprot.skip(ftype)
18155 
      else:
18156 
        iprot.skip(ftype)
18157 
      iprot.readFieldEnd()
18158 
    iprot.readStructEnd()
18159 
 
18160 
  def write(self, oprot):
18161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18163 
      return
18164 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 18165 
    if self.success is not None:
2616 chandransh 18166 
      oprot.writeFieldBegin('success', TType.I64, 0)
18167 
      oprot.writeI64(self.success)
18168 
      oprot.writeFieldEnd()
3431 rajveer 18169 
    if self.ex is not None:
2616 chandransh 18170 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18171 
      self.ex.write(oprot)
18172 
      oprot.writeFieldEnd()
18173 
    oprot.writeFieldStop()
18174 
    oprot.writeStructEnd()
18175 
 
3431 rajveer 18176 
  def validate(self):
18177 
    return
18178 
 
18179 
 
2616 chandransh 18180 
  def __repr__(self):
18181 
    L = ['%s=%r' % (key, value)
18182 
      for key, value in self.__dict__.iteritems()]
18183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18184 
 
18185 
  def __eq__(self, other):
18186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18187 
 
18188 
  def __ne__(self, other):
18189 
    return not (self == other)
18190 
 
18191 
class refundOrder_args:
18192 
  """
18193 
  Attributes:
18194 
   - orderId
3226 chandransh 18195 
   - refundedBy
18196 
   - reason
2616 chandransh 18197 
  """
18198 
 
18199 
  thrift_spec = (
18200 
    None, # 0
18201 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 18202 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18203 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 18204 
  )
18205 
 
3226 chandransh 18206 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 18207 
    self.orderId = orderId
3226 chandransh 18208 
    self.refundedBy = refundedBy
18209 
    self.reason = reason
2616 chandransh 18210 
 
18211 
  def read(self, iprot):
18212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18214 
      return
18215 
    iprot.readStructBegin()
18216 
    while True:
18217 
      (fname, ftype, fid) = iprot.readFieldBegin()
18218 
      if ftype == TType.STOP:
18219 
        break
18220 
      if fid == 1:
18221 
        if ftype == TType.I64:
18222 
          self.orderId = iprot.readI64();
18223 
        else:
18224 
          iprot.skip(ftype)
3226 chandransh 18225 
      elif fid == 2:
18226 
        if ftype == TType.STRING:
18227 
          self.refundedBy = iprot.readString();
18228 
        else:
18229 
          iprot.skip(ftype)
18230 
      elif fid == 3:
18231 
        if ftype == TType.STRING:
18232 
          self.reason = iprot.readString();
18233 
        else:
18234 
          iprot.skip(ftype)
2616 chandransh 18235 
      else:
18236 
        iprot.skip(ftype)
18237 
      iprot.readFieldEnd()
18238 
    iprot.readStructEnd()
18239 
 
18240 
  def write(self, oprot):
18241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18243 
      return
18244 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 18245 
    if self.orderId is not None:
2616 chandransh 18246 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18247 
      oprot.writeI64(self.orderId)
18248 
      oprot.writeFieldEnd()
3431 rajveer 18249 
    if self.refundedBy is not None:
3226 chandransh 18250 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18251 
      oprot.writeString(self.refundedBy)
18252 
      oprot.writeFieldEnd()
3431 rajveer 18253 
    if self.reason is not None:
3226 chandransh 18254 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18255 
      oprot.writeString(self.reason)
18256 
      oprot.writeFieldEnd()
2616 chandransh 18257 
    oprot.writeFieldStop()
18258 
    oprot.writeStructEnd()
18259 
 
3431 rajveer 18260 
  def validate(self):
18261 
    return
18262 
 
18263 
 
2616 chandransh 18264 
  def __repr__(self):
18265 
    L = ['%s=%r' % (key, value)
18266 
      for key, value in self.__dict__.iteritems()]
18267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18268 
 
18269 
  def __eq__(self, other):
18270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18271 
 
18272 
  def __ne__(self, other):
18273 
    return not (self == other)
18274 
 
18275 
class refundOrder_result:
18276 
  """
18277 
  Attributes:
18278 
   - success
18279 
   - ex
18280 
  """
18281 
 
18282 
  thrift_spec = (
18283 
    (0, TType.BOOL, 'success', None, None, ), # 0
18284 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18285 
  )
18286 
 
18287 
  def __init__(self, success=None, ex=None,):
18288 
    self.success = success
18289 
    self.ex = ex
18290 
 
18291 
  def read(self, iprot):
18292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18294 
      return
18295 
    iprot.readStructBegin()
18296 
    while True:
18297 
      (fname, ftype, fid) = iprot.readFieldBegin()
18298 
      if ftype == TType.STOP:
18299 
        break
18300 
      if fid == 0:
18301 
        if ftype == TType.BOOL:
18302 
          self.success = iprot.readBool();
18303 
        else:
18304 
          iprot.skip(ftype)
18305 
      elif fid == 1:
18306 
        if ftype == TType.STRUCT:
18307 
          self.ex = TransactionServiceException()
18308 
          self.ex.read(iprot)
18309 
        else:
18310 
          iprot.skip(ftype)
18311 
      else:
18312 
        iprot.skip(ftype)
18313 
      iprot.readFieldEnd()
18314 
    iprot.readStructEnd()
18315 
 
18316 
  def write(self, oprot):
18317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18319 
      return
18320 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 18321 
    if self.success is not None:
2616 chandransh 18322 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18323 
      oprot.writeBool(self.success)
18324 
      oprot.writeFieldEnd()
3431 rajveer 18325 
    if self.ex is not None:
2616 chandransh 18326 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18327 
      self.ex.write(oprot)
18328 
      oprot.writeFieldEnd()
18329 
    oprot.writeFieldStop()
18330 
    oprot.writeStructEnd()
18331 
 
3431 rajveer 18332 
  def validate(self):
18333 
    return
18334 
 
18335 
 
2616 chandransh 18336 
  def __repr__(self):
18337 
    L = ['%s=%r' % (key, value)
18338 
      for key, value in self.__dict__.iteritems()]
18339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18340 
 
18341 
  def __eq__(self, other):
18342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18343 
 
18344 
  def __ne__(self, other):
18345 
    return not (self == other)
18346 
 
2690 chandransh 18347 
class getReturnOrders_args:
18348 
  """
18349 
  Attributes:
18350 
   - warehouseId
18351 
   - fromDate
18352 
   - toDate
18353 
  """
2616 chandransh 18354 
 
2690 chandransh 18355 
  thrift_spec = (
18356 
    None, # 0
18357 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
18358 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18359 
    (3, TType.I64, 'toDate', None, None, ), # 3
18360 
  )
18361 
 
18362 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
18363 
    self.warehouseId = warehouseId
18364 
    self.fromDate = fromDate
18365 
    self.toDate = toDate
18366 
 
18367 
  def read(self, iprot):
18368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18370 
      return
18371 
    iprot.readStructBegin()
18372 
    while True:
18373 
      (fname, ftype, fid) = iprot.readFieldBegin()
18374 
      if ftype == TType.STOP:
18375 
        break
18376 
      if fid == 1:
18377 
        if ftype == TType.I64:
18378 
          self.warehouseId = iprot.readI64();
18379 
        else:
18380 
          iprot.skip(ftype)
18381 
      elif fid == 2:
18382 
        if ftype == TType.I64:
18383 
          self.fromDate = iprot.readI64();
18384 
        else:
18385 
          iprot.skip(ftype)
18386 
      elif fid == 3:
18387 
        if ftype == TType.I64:
18388 
          self.toDate = iprot.readI64();
18389 
        else:
18390 
          iprot.skip(ftype)
18391 
      else:
18392 
        iprot.skip(ftype)
18393 
      iprot.readFieldEnd()
18394 
    iprot.readStructEnd()
18395 
 
18396 
  def write(self, oprot):
18397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18399 
      return
18400 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 18401 
    if self.warehouseId is not None:
2690 chandransh 18402 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
18403 
      oprot.writeI64(self.warehouseId)
18404 
      oprot.writeFieldEnd()
3431 rajveer 18405 
    if self.fromDate is not None:
2690 chandransh 18406 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18407 
      oprot.writeI64(self.fromDate)
18408 
      oprot.writeFieldEnd()
3431 rajveer 18409 
    if self.toDate is not None:
2690 chandransh 18410 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18411 
      oprot.writeI64(self.toDate)
18412 
      oprot.writeFieldEnd()
18413 
    oprot.writeFieldStop()
18414 
    oprot.writeStructEnd()
18415 
 
3431 rajveer 18416 
  def validate(self):
18417 
    return
18418 
 
18419 
 
2690 chandransh 18420 
  def __repr__(self):
18421 
    L = ['%s=%r' % (key, value)
18422 
      for key, value in self.__dict__.iteritems()]
18423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18424 
 
18425 
  def __eq__(self, other):
18426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18427 
 
18428 
  def __ne__(self, other):
18429 
    return not (self == other)
18430 
 
18431 
class getReturnOrders_result:
18432 
  """
18433 
  Attributes:
18434 
   - success
18435 
  """
18436 
 
18437 
  thrift_spec = (
18438 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18439 
  )
18440 
 
18441 
  def __init__(self, success=None,):
18442 
    self.success = success
18443 
 
18444 
  def read(self, iprot):
18445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18447 
      return
18448 
    iprot.readStructBegin()
18449 
    while True:
18450 
      (fname, ftype, fid) = iprot.readFieldBegin()
18451 
      if ftype == TType.STOP:
18452 
        break
18453 
      if fid == 0:
18454 
        if ftype == TType.LIST:
18455 
          self.success = []
6188 rajveer 18456 
          (_etype442, _size439) = iprot.readListBegin()
18457 
          for _i443 in xrange(_size439):
18458 
            _elem444 = ReturnOrder()
18459 
            _elem444.read(iprot)
18460 
            self.success.append(_elem444)
2690 chandransh 18461 
          iprot.readListEnd()
18462 
        else:
18463 
          iprot.skip(ftype)
18464 
      else:
18465 
        iprot.skip(ftype)
18466 
      iprot.readFieldEnd()
18467 
    iprot.readStructEnd()
18468 
 
18469 
  def write(self, oprot):
18470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18472 
      return
18473 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 18474 
    if self.success is not None:
2690 chandransh 18475 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18476 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18477 
      for iter445 in self.success:
18478 
        iter445.write(oprot)
2690 chandransh 18479 
      oprot.writeListEnd()
18480 
      oprot.writeFieldEnd()
18481 
    oprot.writeFieldStop()
18482 
    oprot.writeStructEnd()
18483 
 
3431 rajveer 18484 
  def validate(self):
18485 
    return
18486 
 
18487 
 
2690 chandransh 18488 
  def __repr__(self):
18489 
    L = ['%s=%r' % (key, value)
18490 
      for key, value in self.__dict__.iteritems()]
18491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18492 
 
18493 
  def __eq__(self, other):
18494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18495 
 
18496 
  def __ne__(self, other):
18497 
    return not (self == other)
18498 
 
5481 phani.kuma 18499 
class getAllReturnOrders_args:
18500 
  """
18501 
  Attributes:
18502 
   - onlyNotProcessed
18503 
   - fromDate
18504 
   - toDate
18505 
  """
18506 
 
18507 
  thrift_spec = (
18508 
    None, # 0
18509 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
18510 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18511 
    (3, TType.I64, 'toDate', None, None, ), # 3
18512 
  )
18513 
 
18514 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
18515 
    self.onlyNotProcessed = onlyNotProcessed
18516 
    self.fromDate = fromDate
18517 
    self.toDate = toDate
18518 
 
18519 
  def read(self, iprot):
18520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18522 
      return
18523 
    iprot.readStructBegin()
18524 
    while True:
18525 
      (fname, ftype, fid) = iprot.readFieldBegin()
18526 
      if ftype == TType.STOP:
18527 
        break
18528 
      if fid == 1:
18529 
        if ftype == TType.BOOL:
18530 
          self.onlyNotProcessed = iprot.readBool();
18531 
        else:
18532 
          iprot.skip(ftype)
18533 
      elif fid == 2:
18534 
        if ftype == TType.I64:
18535 
          self.fromDate = iprot.readI64();
18536 
        else:
18537 
          iprot.skip(ftype)
18538 
      elif fid == 3:
18539 
        if ftype == TType.I64:
18540 
          self.toDate = iprot.readI64();
18541 
        else:
18542 
          iprot.skip(ftype)
18543 
      else:
18544 
        iprot.skip(ftype)
18545 
      iprot.readFieldEnd()
18546 
    iprot.readStructEnd()
18547 
 
18548 
  def write(self, oprot):
18549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18551 
      return
18552 
    oprot.writeStructBegin('getAllReturnOrders_args')
18553 
    if self.onlyNotProcessed is not None:
18554 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
18555 
      oprot.writeBool(self.onlyNotProcessed)
18556 
      oprot.writeFieldEnd()
18557 
    if self.fromDate is not None:
18558 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18559 
      oprot.writeI64(self.fromDate)
18560 
      oprot.writeFieldEnd()
18561 
    if self.toDate is not None:
18562 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18563 
      oprot.writeI64(self.toDate)
18564 
      oprot.writeFieldEnd()
18565 
    oprot.writeFieldStop()
18566 
    oprot.writeStructEnd()
18567 
 
18568 
  def validate(self):
18569 
    return
18570 
 
18571 
 
18572 
  def __repr__(self):
18573 
    L = ['%s=%r' % (key, value)
18574 
      for key, value in self.__dict__.iteritems()]
18575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18576 
 
18577 
  def __eq__(self, other):
18578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18579 
 
18580 
  def __ne__(self, other):
18581 
    return not (self == other)
18582 
 
18583 
class getAllReturnOrders_result:
18584 
  """
18585 
  Attributes:
18586 
   - success
18587 
  """
18588 
 
18589 
  thrift_spec = (
18590 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18591 
  )
18592 
 
18593 
  def __init__(self, success=None,):
18594 
    self.success = success
18595 
 
18596 
  def read(self, iprot):
18597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18599 
      return
18600 
    iprot.readStructBegin()
18601 
    while True:
18602 
      (fname, ftype, fid) = iprot.readFieldBegin()
18603 
      if ftype == TType.STOP:
18604 
        break
18605 
      if fid == 0:
18606 
        if ftype == TType.LIST:
18607 
          self.success = []
6188 rajveer 18608 
          (_etype449, _size446) = iprot.readListBegin()
18609 
          for _i450 in xrange(_size446):
18610 
            _elem451 = ReturnOrder()
18611 
            _elem451.read(iprot)
18612 
            self.success.append(_elem451)
5481 phani.kuma 18613 
          iprot.readListEnd()
18614 
        else:
18615 
          iprot.skip(ftype)
18616 
      else:
18617 
        iprot.skip(ftype)
18618 
      iprot.readFieldEnd()
18619 
    iprot.readStructEnd()
18620 
 
18621 
  def write(self, oprot):
18622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18624 
      return
18625 
    oprot.writeStructBegin('getAllReturnOrders_result')
18626 
    if self.success is not None:
18627 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18628 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18629 
      for iter452 in self.success:
18630 
        iter452.write(oprot)
5481 phani.kuma 18631 
      oprot.writeListEnd()
18632 
      oprot.writeFieldEnd()
18633 
    oprot.writeFieldStop()
18634 
    oprot.writeStructEnd()
18635 
 
18636 
  def validate(self):
18637 
    return
18638 
 
18639 
 
18640 
  def __repr__(self):
18641 
    L = ['%s=%r' % (key, value)
18642 
      for key, value in self.__dict__.iteritems()]
18643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18644 
 
18645 
  def __eq__(self, other):
18646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18647 
 
18648 
  def __ne__(self, other):
18649 
    return not (self == other)
18650 
 
2700 chandransh 18651 
class getReturnOrder_args:
18652 
  """
18653 
  Attributes:
18654 
   - id
18655 
  """
18656 
 
18657 
  thrift_spec = (
18658 
    None, # 0
18659 
    (1, TType.I64, 'id', None, None, ), # 1
18660 
  )
18661 
 
18662 
  def __init__(self, id=None,):
18663 
    self.id = id
18664 
 
18665 
  def read(self, iprot):
18666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18668 
      return
18669 
    iprot.readStructBegin()
18670 
    while True:
18671 
      (fname, ftype, fid) = iprot.readFieldBegin()
18672 
      if ftype == TType.STOP:
18673 
        break
18674 
      if fid == 1:
18675 
        if ftype == TType.I64:
18676 
          self.id = iprot.readI64();
18677 
        else:
18678 
          iprot.skip(ftype)
18679 
      else:
18680 
        iprot.skip(ftype)
18681 
      iprot.readFieldEnd()
18682 
    iprot.readStructEnd()
18683 
 
18684 
  def write(self, oprot):
18685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18687 
      return
18688 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 18689 
    if self.id is not None:
2700 chandransh 18690 
      oprot.writeFieldBegin('id', TType.I64, 1)
18691 
      oprot.writeI64(self.id)
18692 
      oprot.writeFieldEnd()
18693 
    oprot.writeFieldStop()
18694 
    oprot.writeStructEnd()
18695 
 
3431 rajveer 18696 
  def validate(self):
18697 
    return
18698 
 
18699 
 
2700 chandransh 18700 
  def __repr__(self):
18701 
    L = ['%s=%r' % (key, value)
18702 
      for key, value in self.__dict__.iteritems()]
18703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18704 
 
18705 
  def __eq__(self, other):
18706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18707 
 
18708 
  def __ne__(self, other):
18709 
    return not (self == other)
18710 
 
18711 
class getReturnOrder_result:
18712 
  """
18713 
  Attributes:
18714 
   - success
18715 
   - ex
18716 
  """
18717 
 
18718 
  thrift_spec = (
18719 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
18720 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18721 
  )
18722 
 
18723 
  def __init__(self, success=None, ex=None,):
18724 
    self.success = success
18725 
    self.ex = ex
18726 
 
18727 
  def read(self, iprot):
18728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18730 
      return
18731 
    iprot.readStructBegin()
18732 
    while True:
18733 
      (fname, ftype, fid) = iprot.readFieldBegin()
18734 
      if ftype == TType.STOP:
18735 
        break
18736 
      if fid == 0:
18737 
        if ftype == TType.STRUCT:
18738 
          self.success = ReturnOrder()
18739 
          self.success.read(iprot)
18740 
        else:
18741 
          iprot.skip(ftype)
18742 
      elif fid == 1:
18743 
        if ftype == TType.STRUCT:
18744 
          self.ex = TransactionServiceException()
18745 
          self.ex.read(iprot)
18746 
        else:
18747 
          iprot.skip(ftype)
18748 
      else:
18749 
        iprot.skip(ftype)
18750 
      iprot.readFieldEnd()
18751 
    iprot.readStructEnd()
18752 
 
18753 
  def write(self, oprot):
18754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18756 
      return
18757 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 18758 
    if self.success is not None:
2700 chandransh 18759 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18760 
      self.success.write(oprot)
18761 
      oprot.writeFieldEnd()
3431 rajveer 18762 
    if self.ex is not None:
2700 chandransh 18763 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18764 
      self.ex.write(oprot)
18765 
      oprot.writeFieldEnd()
18766 
    oprot.writeFieldStop()
18767 
    oprot.writeStructEnd()
18768 
 
3431 rajveer 18769 
  def validate(self):
18770 
    return
18771 
 
18772 
 
2700 chandransh 18773 
  def __repr__(self):
18774 
    L = ['%s=%r' % (key, value)
18775 
      for key, value in self.__dict__.iteritems()]
18776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18777 
 
18778 
  def __eq__(self, other):
18779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18780 
 
18781 
  def __ne__(self, other):
18782 
    return not (self == other)
18783 
 
2690 chandransh 18784 
class processReturn_args:
18785 
  """
18786 
  Attributes:
18787 
   - returnOrderId
18788 
  """
18789 
 
18790 
  thrift_spec = (
18791 
    None, # 0
18792 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
18793 
  )
18794 
 
18795 
  def __init__(self, returnOrderId=None,):
18796 
    self.returnOrderId = returnOrderId
18797 
 
18798 
  def read(self, iprot):
18799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18801 
      return
18802 
    iprot.readStructBegin()
18803 
    while True:
18804 
      (fname, ftype, fid) = iprot.readFieldBegin()
18805 
      if ftype == TType.STOP:
18806 
        break
18807 
      if fid == 1:
18808 
        if ftype == TType.I64:
18809 
          self.returnOrderId = iprot.readI64();
18810 
        else:
18811 
          iprot.skip(ftype)
18812 
      else:
18813 
        iprot.skip(ftype)
18814 
      iprot.readFieldEnd()
18815 
    iprot.readStructEnd()
18816 
 
18817 
  def write(self, oprot):
18818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18820 
      return
18821 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 18822 
    if self.returnOrderId is not None:
2690 chandransh 18823 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
18824 
      oprot.writeI64(self.returnOrderId)
18825 
      oprot.writeFieldEnd()
18826 
    oprot.writeFieldStop()
18827 
    oprot.writeStructEnd()
18828 
 
3431 rajveer 18829 
  def validate(self):
18830 
    return
18831 
 
18832 
 
2690 chandransh 18833 
  def __repr__(self):
18834 
    L = ['%s=%r' % (key, value)
18835 
      for key, value in self.__dict__.iteritems()]
18836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18837 
 
18838 
  def __eq__(self, other):
18839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18840 
 
18841 
  def __ne__(self, other):
18842 
    return not (self == other)
18843 
 
18844 
class processReturn_result:
18845 
  """
18846 
  Attributes:
18847 
   - ex
18848 
  """
18849 
 
18850 
  thrift_spec = (
18851 
    None, # 0
18852 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18853 
  )
18854 
 
18855 
  def __init__(self, ex=None,):
18856 
    self.ex = ex
18857 
 
18858 
  def read(self, iprot):
18859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18861 
      return
18862 
    iprot.readStructBegin()
18863 
    while True:
18864 
      (fname, ftype, fid) = iprot.readFieldBegin()
18865 
      if ftype == TType.STOP:
18866 
        break
18867 
      if fid == 1:
18868 
        if ftype == TType.STRUCT:
18869 
          self.ex = TransactionServiceException()
18870 
          self.ex.read(iprot)
18871 
        else:
18872 
          iprot.skip(ftype)
18873 
      else:
18874 
        iprot.skip(ftype)
18875 
      iprot.readFieldEnd()
18876 
    iprot.readStructEnd()
18877 
 
18878 
  def write(self, oprot):
18879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18881 
      return
18882 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 18883 
    if self.ex is not None:
2690 chandransh 18884 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18885 
      self.ex.write(oprot)
18886 
      oprot.writeFieldEnd()
18887 
    oprot.writeFieldStop()
18888 
    oprot.writeStructEnd()
18889 
 
3431 rajveer 18890 
  def validate(self):
18891 
    return
18892 
 
18893 
 
2690 chandransh 18894 
  def __repr__(self):
18895 
    L = ['%s=%r' % (key, value)
18896 
      for key, value in self.__dict__.iteritems()]
18897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18898 
 
18899 
  def __eq__(self, other):
18900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18901 
 
18902 
  def __ne__(self, other):
18903 
    return not (self == other)
18904 
 
3451 chandransh 18905 
class updateWeight_args:
18906 
  """
18907 
  Attributes:
18908 
   - orderId
18909 
   - weight
18910 
  """
18911 
 
18912 
  thrift_spec = (
18913 
    None, # 0
18914 
    (1, TType.I64, 'orderId', None, None, ), # 1
18915 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
18916 
  )
18917 
 
18918 
  def __init__(self, orderId=None, weight=None,):
18919 
    self.orderId = orderId
18920 
    self.weight = weight
18921 
 
18922 
  def read(self, iprot):
18923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18925 
      return
18926 
    iprot.readStructBegin()
18927 
    while True:
18928 
      (fname, ftype, fid) = iprot.readFieldBegin()
18929 
      if ftype == TType.STOP:
18930 
        break
18931 
      if fid == 1:
18932 
        if ftype == TType.I64:
18933 
          self.orderId = iprot.readI64();
18934 
        else:
18935 
          iprot.skip(ftype)
18936 
      elif fid == 2:
18937 
        if ftype == TType.DOUBLE:
18938 
          self.weight = iprot.readDouble();
18939 
        else:
18940 
          iprot.skip(ftype)
18941 
      else:
18942 
        iprot.skip(ftype)
18943 
      iprot.readFieldEnd()
18944 
    iprot.readStructEnd()
18945 
 
18946 
  def write(self, oprot):
18947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18949 
      return
18950 
    oprot.writeStructBegin('updateWeight_args')
18951 
    if self.orderId is not None:
18952 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18953 
      oprot.writeI64(self.orderId)
18954 
      oprot.writeFieldEnd()
18955 
    if self.weight is not None:
18956 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
18957 
      oprot.writeDouble(self.weight)
18958 
      oprot.writeFieldEnd()
18959 
    oprot.writeFieldStop()
18960 
    oprot.writeStructEnd()
18961 
 
18962 
  def validate(self):
18963 
    return
18964 
 
18965 
 
18966 
  def __repr__(self):
18967 
    L = ['%s=%r' % (key, value)
18968 
      for key, value in self.__dict__.iteritems()]
18969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18970 
 
18971 
  def __eq__(self, other):
18972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18973 
 
18974 
  def __ne__(self, other):
18975 
    return not (self == other)
18976 
 
18977 
class updateWeight_result:
18978 
  """
18979 
  Attributes:
18980 
   - success
18981 
   - ex
18982 
  """
18983 
 
18984 
  thrift_spec = (
18985 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
18986 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18987 
  )
18988 
 
18989 
  def __init__(self, success=None, ex=None,):
18990 
    self.success = success
18991 
    self.ex = ex
18992 
 
18993 
  def read(self, iprot):
18994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18996 
      return
18997 
    iprot.readStructBegin()
18998 
    while True:
18999 
      (fname, ftype, fid) = iprot.readFieldBegin()
19000 
      if ftype == TType.STOP:
19001 
        break
19002 
      if fid == 0:
19003 
        if ftype == TType.STRUCT:
19004 
          self.success = Order()
19005 
          self.success.read(iprot)
19006 
        else:
19007 
          iprot.skip(ftype)
19008 
      elif fid == 1:
19009 
        if ftype == TType.STRUCT:
19010 
          self.ex = TransactionServiceException()
19011 
          self.ex.read(iprot)
19012 
        else:
19013 
          iprot.skip(ftype)
19014 
      else:
19015 
        iprot.skip(ftype)
19016 
      iprot.readFieldEnd()
19017 
    iprot.readStructEnd()
19018 
 
19019 
  def write(self, oprot):
19020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19022 
      return
19023 
    oprot.writeStructBegin('updateWeight_result')
19024 
    if self.success is not None:
19025 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19026 
      self.success.write(oprot)
19027 
      oprot.writeFieldEnd()
19028 
    if self.ex is not None:
19029 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19030 
      self.ex.write(oprot)
19031 
      oprot.writeFieldEnd()
19032 
    oprot.writeFieldStop()
19033 
    oprot.writeStructEnd()
19034 
 
19035 
  def validate(self):
19036 
    return
19037 
 
19038 
 
19039 
  def __repr__(self):
19040 
    L = ['%s=%r' % (key, value)
19041 
      for key, value in self.__dict__.iteritems()]
19042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19043 
 
19044 
  def __eq__(self, other):
19045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19046 
 
19047 
  def __ne__(self, other):
19048 
    return not (self == other)
3469 chandransh 19049 
 
19050 
class changeItem_args:
19051 
  """
19052 
  Attributes:
19053 
   - orderId
19054 
   - itemId
19055 
  """
19056 
 
19057 
  thrift_spec = (
19058 
    None, # 0
19059 
    (1, TType.I64, 'orderId', None, None, ), # 1
19060 
    (2, TType.I64, 'itemId', None, None, ), # 2
19061 
  )
19062 
 
19063 
  def __init__(self, orderId=None, itemId=None,):
19064 
    self.orderId = orderId
19065 
    self.itemId = itemId
19066 
 
19067 
  def read(self, iprot):
19068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19070 
      return
19071 
    iprot.readStructBegin()
19072 
    while True:
19073 
      (fname, ftype, fid) = iprot.readFieldBegin()
19074 
      if ftype == TType.STOP:
19075 
        break
19076 
      if fid == 1:
19077 
        if ftype == TType.I64:
19078 
          self.orderId = iprot.readI64();
19079 
        else:
19080 
          iprot.skip(ftype)
19081 
      elif fid == 2:
19082 
        if ftype == TType.I64:
19083 
          self.itemId = iprot.readI64();
19084 
        else:
19085 
          iprot.skip(ftype)
19086 
      else:
19087 
        iprot.skip(ftype)
19088 
      iprot.readFieldEnd()
19089 
    iprot.readStructEnd()
19090 
 
19091 
  def write(self, oprot):
19092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19094 
      return
19095 
    oprot.writeStructBegin('changeItem_args')
19096 
    if self.orderId is not None:
19097 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19098 
      oprot.writeI64(self.orderId)
19099 
      oprot.writeFieldEnd()
19100 
    if self.itemId is not None:
19101 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19102 
      oprot.writeI64(self.itemId)
19103 
      oprot.writeFieldEnd()
19104 
    oprot.writeFieldStop()
19105 
    oprot.writeStructEnd()
19106 
 
19107 
  def validate(self):
19108 
    return
19109 
 
19110 
 
19111 
  def __repr__(self):
19112 
    L = ['%s=%r' % (key, value)
19113 
      for key, value in self.__dict__.iteritems()]
19114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19115 
 
19116 
  def __eq__(self, other):
19117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19118 
 
19119 
  def __ne__(self, other):
19120 
    return not (self == other)
19121 
 
19122 
class changeItem_result:
19123 
  """
19124 
  Attributes:
19125 
   - success
19126 
   - ex
19127 
  """
19128 
 
19129 
  thrift_spec = (
19130 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19131 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19132 
  )
19133 
 
19134 
  def __init__(self, success=None, ex=None,):
19135 
    self.success = success
19136 
    self.ex = ex
19137 
 
19138 
  def read(self, iprot):
19139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19141 
      return
19142 
    iprot.readStructBegin()
19143 
    while True:
19144 
      (fname, ftype, fid) = iprot.readFieldBegin()
19145 
      if ftype == TType.STOP:
19146 
        break
19147 
      if fid == 0:
19148 
        if ftype == TType.STRUCT:
19149 
          self.success = Order()
19150 
          self.success.read(iprot)
19151 
        else:
19152 
          iprot.skip(ftype)
19153 
      elif fid == 1:
19154 
        if ftype == TType.STRUCT:
19155 
          self.ex = TransactionServiceException()
19156 
          self.ex.read(iprot)
19157 
        else:
19158 
          iprot.skip(ftype)
19159 
      else:
19160 
        iprot.skip(ftype)
19161 
      iprot.readFieldEnd()
19162 
    iprot.readStructEnd()
19163 
 
19164 
  def write(self, oprot):
19165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19167 
      return
19168 
    oprot.writeStructBegin('changeItem_result')
19169 
    if self.success is not None:
19170 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19171 
      self.success.write(oprot)
19172 
      oprot.writeFieldEnd()
19173 
    if self.ex is not None:
19174 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19175 
      self.ex.write(oprot)
19176 
      oprot.writeFieldEnd()
19177 
    oprot.writeFieldStop()
19178 
    oprot.writeStructEnd()
19179 
 
19180 
  def validate(self):
19181 
    return
19182 
 
19183 
 
19184 
  def __repr__(self):
19185 
    L = ['%s=%r' % (key, value)
19186 
      for key, value in self.__dict__.iteritems()]
19187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19188 
 
19189 
  def __eq__(self, other):
19190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19191 
 
19192 
  def __ne__(self, other):
19193 
    return not (self == other)
19194 
 
19195 
class shiftToWarehouse_args:
19196 
  """
19197 
  Attributes:
19198 
   - orderId
19199 
   - warehouseId
19200 
  """
19201 
 
19202 
  thrift_spec = (
19203 
    None, # 0
19204 
    (1, TType.I64, 'orderId', None, None, ), # 1
19205 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
19206 
  )
19207 
 
19208 
  def __init__(self, orderId=None, warehouseId=None,):
19209 
    self.orderId = orderId
19210 
    self.warehouseId = warehouseId
19211 
 
19212 
  def read(self, iprot):
19213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19215 
      return
19216 
    iprot.readStructBegin()
19217 
    while True:
19218 
      (fname, ftype, fid) = iprot.readFieldBegin()
19219 
      if ftype == TType.STOP:
19220 
        break
19221 
      if fid == 1:
19222 
        if ftype == TType.I64:
19223 
          self.orderId = iprot.readI64();
19224 
        else:
19225 
          iprot.skip(ftype)
19226 
      elif fid == 2:
19227 
        if ftype == TType.I64:
19228 
          self.warehouseId = iprot.readI64();
19229 
        else:
19230 
          iprot.skip(ftype)
19231 
      else:
19232 
        iprot.skip(ftype)
19233 
      iprot.readFieldEnd()
19234 
    iprot.readStructEnd()
19235 
 
19236 
  def write(self, oprot):
19237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19239 
      return
19240 
    oprot.writeStructBegin('shiftToWarehouse_args')
19241 
    if self.orderId is not None:
19242 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19243 
      oprot.writeI64(self.orderId)
19244 
      oprot.writeFieldEnd()
19245 
    if self.warehouseId is not None:
19246 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
19247 
      oprot.writeI64(self.warehouseId)
19248 
      oprot.writeFieldEnd()
19249 
    oprot.writeFieldStop()
19250 
    oprot.writeStructEnd()
19251 
 
19252 
  def validate(self):
19253 
    return
19254 
 
19255 
 
19256 
  def __repr__(self):
19257 
    L = ['%s=%r' % (key, value)
19258 
      for key, value in self.__dict__.iteritems()]
19259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19260 
 
19261 
  def __eq__(self, other):
19262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19263 
 
19264 
  def __ne__(self, other):
19265 
    return not (self == other)
19266 
 
19267 
class shiftToWarehouse_result:
19268 
  """
19269 
  Attributes:
19270 
   - success
19271 
   - ex
19272 
  """
19273 
 
19274 
  thrift_spec = (
19275 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19276 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19277 
  )
19278 
 
19279 
  def __init__(self, success=None, ex=None,):
19280 
    self.success = success
19281 
    self.ex = ex
19282 
 
19283 
  def read(self, iprot):
19284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19286 
      return
19287 
    iprot.readStructBegin()
19288 
    while True:
19289 
      (fname, ftype, fid) = iprot.readFieldBegin()
19290 
      if ftype == TType.STOP:
19291 
        break
19292 
      if fid == 0:
19293 
        if ftype == TType.STRUCT:
19294 
          self.success = Order()
19295 
          self.success.read(iprot)
19296 
        else:
19297 
          iprot.skip(ftype)
19298 
      elif fid == 1:
19299 
        if ftype == TType.STRUCT:
19300 
          self.ex = TransactionServiceException()
19301 
          self.ex.read(iprot)
19302 
        else:
19303 
          iprot.skip(ftype)
19304 
      else:
19305 
        iprot.skip(ftype)
19306 
      iprot.readFieldEnd()
19307 
    iprot.readStructEnd()
19308 
 
19309 
  def write(self, oprot):
19310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19312 
      return
19313 
    oprot.writeStructBegin('shiftToWarehouse_result')
19314 
    if self.success is not None:
19315 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19316 
      self.success.write(oprot)
19317 
      oprot.writeFieldEnd()
19318 
    if self.ex is not None:
19319 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19320 
      self.ex.write(oprot)
19321 
      oprot.writeFieldEnd()
19322 
    oprot.writeFieldStop()
19323 
    oprot.writeStructEnd()
19324 
 
19325 
  def validate(self):
19326 
    return
19327 
 
19328 
 
19329 
  def __repr__(self):
19330 
    L = ['%s=%r' % (key, value)
19331 
      for key, value in self.__dict__.iteritems()]
19332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19333 
 
19334 
  def __eq__(self, other):
19335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19336 
 
19337 
  def __ne__(self, other):
19338 
    return not (self == other)
3553 chandransh 19339 
 
19340 
class addDelayReason_args:
19341 
  """
19342 
  Attributes:
19343 
   - orderId
19344 
   - delayReason
3986 chandransh 19345 
   - furtherDelay
4647 rajveer 19346 
   - delayReasonText
3553 chandransh 19347 
  """
19348 
 
19349 
  thrift_spec = (
19350 
    None, # 0
19351 
    (1, TType.I64, 'orderId', None, None, ), # 1
19352 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 19353 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 19354 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 19355 
  )
19356 
 
4647 rajveer 19357 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 19358 
    self.orderId = orderId
19359 
    self.delayReason = delayReason
3986 chandransh 19360 
    self.furtherDelay = furtherDelay
4647 rajveer 19361 
    self.delayReasonText = delayReasonText
3553 chandransh 19362 
 
19363 
  def read(self, iprot):
19364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19366 
      return
19367 
    iprot.readStructBegin()
19368 
    while True:
19369 
      (fname, ftype, fid) = iprot.readFieldBegin()
19370 
      if ftype == TType.STOP:
19371 
        break
19372 
      if fid == 1:
19373 
        if ftype == TType.I64:
19374 
          self.orderId = iprot.readI64();
19375 
        else:
19376 
          iprot.skip(ftype)
19377 
      elif fid == 2:
19378 
        if ftype == TType.I32:
19379 
          self.delayReason = iprot.readI32();
19380 
        else:
19381 
          iprot.skip(ftype)
3986 chandransh 19382 
      elif fid == 3:
19383 
        if ftype == TType.I64:
19384 
          self.furtherDelay = iprot.readI64();
19385 
        else:
19386 
          iprot.skip(ftype)
4647 rajveer 19387 
      elif fid == 4:
19388 
        if ftype == TType.STRING:
19389 
          self.delayReasonText = iprot.readString();
19390 
        else:
19391 
          iprot.skip(ftype)
3553 chandransh 19392 
      else:
19393 
        iprot.skip(ftype)
19394 
      iprot.readFieldEnd()
19395 
    iprot.readStructEnd()
19396 
 
19397 
  def write(self, oprot):
19398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19400 
      return
19401 
    oprot.writeStructBegin('addDelayReason_args')
19402 
    if self.orderId is not None:
19403 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19404 
      oprot.writeI64(self.orderId)
19405 
      oprot.writeFieldEnd()
19406 
    if self.delayReason is not None:
19407 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
19408 
      oprot.writeI32(self.delayReason)
19409 
      oprot.writeFieldEnd()
3986 chandransh 19410 
    if self.furtherDelay is not None:
19411 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
19412 
      oprot.writeI64(self.furtherDelay)
19413 
      oprot.writeFieldEnd()
4647 rajveer 19414 
    if self.delayReasonText is not None:
19415 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
19416 
      oprot.writeString(self.delayReasonText)
19417 
      oprot.writeFieldEnd()
3553 chandransh 19418 
    oprot.writeFieldStop()
19419 
    oprot.writeStructEnd()
19420 
 
19421 
  def validate(self):
19422 
    return
19423 
 
19424 
 
19425 
  def __repr__(self):
19426 
    L = ['%s=%r' % (key, value)
19427 
      for key, value in self.__dict__.iteritems()]
19428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19429 
 
19430 
  def __eq__(self, other):
19431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19432 
 
19433 
  def __ne__(self, other):
19434 
    return not (self == other)
19435 
 
19436 
class addDelayReason_result:
19437 
  """
19438 
  Attributes:
19439 
   - success
19440 
   - ex
19441 
  """
19442 
 
19443 
  thrift_spec = (
19444 
    (0, TType.BOOL, 'success', None, None, ), # 0
19445 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19446 
  )
19447 
 
19448 
  def __init__(self, success=None, ex=None,):
19449 
    self.success = success
19450 
    self.ex = ex
19451 
 
19452 
  def read(self, iprot):
19453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19455 
      return
19456 
    iprot.readStructBegin()
19457 
    while True:
19458 
      (fname, ftype, fid) = iprot.readFieldBegin()
19459 
      if ftype == TType.STOP:
19460 
        break
19461 
      if fid == 0:
19462 
        if ftype == TType.BOOL:
19463 
          self.success = iprot.readBool();
19464 
        else:
19465 
          iprot.skip(ftype)
19466 
      elif fid == 1:
19467 
        if ftype == TType.STRUCT:
19468 
          self.ex = TransactionServiceException()
19469 
          self.ex.read(iprot)
19470 
        else:
19471 
          iprot.skip(ftype)
19472 
      else:
19473 
        iprot.skip(ftype)
19474 
      iprot.readFieldEnd()
19475 
    iprot.readStructEnd()
19476 
 
19477 
  def write(self, oprot):
19478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19480 
      return
19481 
    oprot.writeStructBegin('addDelayReason_result')
19482 
    if self.success is not None:
19483 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19484 
      oprot.writeBool(self.success)
19485 
      oprot.writeFieldEnd()
19486 
    if self.ex is not None:
19487 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19488 
      self.ex.write(oprot)
19489 
      oprot.writeFieldEnd()
19490 
    oprot.writeFieldStop()
19491 
    oprot.writeStructEnd()
19492 
 
19493 
  def validate(self):
19494 
    return
19495 
 
19496 
 
19497 
  def __repr__(self):
19498 
    L = ['%s=%r' % (key, value)
19499 
      for key, value in self.__dict__.iteritems()]
19500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19501 
 
19502 
  def __eq__(self, other):
19503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19504 
 
19505 
  def __ne__(self, other):
19506 
    return not (self == other)
3956 chandransh 19507 
 
19508 
class reconcileCodCollection_args:
19509 
  """
19510 
  Attributes:
19511 
   - collectedAmountMap
19512 
   - xferBy
19513 
   - xferTxnId
19514 
   - xferDate
19515 
  """
19516 
 
19517 
  thrift_spec = (
19518 
    None, # 0
19519 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
19520 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
19521 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
19522 
    (4, TType.I64, 'xferDate', None, None, ), # 4
19523 
  )
19524 
 
19525 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
19526 
    self.collectedAmountMap = collectedAmountMap
19527 
    self.xferBy = xferBy
19528 
    self.xferTxnId = xferTxnId
19529 
    self.xferDate = xferDate
19530 
 
19531 
  def read(self, iprot):
19532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19534 
      return
19535 
    iprot.readStructBegin()
19536 
    while True:
19537 
      (fname, ftype, fid) = iprot.readFieldBegin()
19538 
      if ftype == TType.STOP:
19539 
        break
19540 
      if fid == 1:
19541 
        if ftype == TType.MAP:
19542 
          self.collectedAmountMap = {}
6188 rajveer 19543 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
19544 
          for _i457 in xrange(_size453):
19545 
            _key458 = iprot.readString();
19546 
            _val459 = iprot.readDouble();
19547 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 19548 
          iprot.readMapEnd()
19549 
        else:
19550 
          iprot.skip(ftype)
19551 
      elif fid == 2:
19552 
        if ftype == TType.STRING:
19553 
          self.xferBy = iprot.readString();
19554 
        else:
19555 
          iprot.skip(ftype)
19556 
      elif fid == 3:
19557 
        if ftype == TType.STRING:
19558 
          self.xferTxnId = iprot.readString();
19559 
        else:
19560 
          iprot.skip(ftype)
19561 
      elif fid == 4:
19562 
        if ftype == TType.I64:
19563 
          self.xferDate = iprot.readI64();
19564 
        else:
19565 
          iprot.skip(ftype)
19566 
      else:
19567 
        iprot.skip(ftype)
19568 
      iprot.readFieldEnd()
19569 
    iprot.readStructEnd()
19570 
 
19571 
  def write(self, oprot):
19572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19574 
      return
19575 
    oprot.writeStructBegin('reconcileCodCollection_args')
19576 
    if self.collectedAmountMap is not None:
19577 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
19578 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 19579 
      for kiter460,viter461 in self.collectedAmountMap.items():
19580 
        oprot.writeString(kiter460)
19581 
        oprot.writeDouble(viter461)
3956 chandransh 19582 
      oprot.writeMapEnd()
19583 
      oprot.writeFieldEnd()
19584 
    if self.xferBy is not None:
19585 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
19586 
      oprot.writeString(self.xferBy)
19587 
      oprot.writeFieldEnd()
19588 
    if self.xferTxnId is not None:
19589 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
19590 
      oprot.writeString(self.xferTxnId)
19591 
      oprot.writeFieldEnd()
19592 
    if self.xferDate is not None:
19593 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
19594 
      oprot.writeI64(self.xferDate)
19595 
      oprot.writeFieldEnd()
19596 
    oprot.writeFieldStop()
19597 
    oprot.writeStructEnd()
19598 
 
19599 
  def validate(self):
19600 
    return
19601 
 
19602 
 
19603 
  def __repr__(self):
19604 
    L = ['%s=%r' % (key, value)
19605 
      for key, value in self.__dict__.iteritems()]
19606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19607 
 
19608 
  def __eq__(self, other):
19609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19610 
 
19611 
  def __ne__(self, other):
19612 
    return not (self == other)
19613 
 
19614 
class reconcileCodCollection_result:
19615 
  """
19616 
  Attributes:
19617 
   - success
19618 
   - ex
19619 
  """
19620 
 
19621 
  thrift_spec = (
19622 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
19623 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19624 
  )
19625 
 
19626 
  def __init__(self, success=None, ex=None,):
19627 
    self.success = success
19628 
    self.ex = ex
19629 
 
19630 
  def read(self, iprot):
19631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19633 
      return
19634 
    iprot.readStructBegin()
19635 
    while True:
19636 
      (fname, ftype, fid) = iprot.readFieldBegin()
19637 
      if ftype == TType.STOP:
19638 
        break
19639 
      if fid == 0:
19640 
        if ftype == TType.MAP:
19641 
          self.success = {}
6188 rajveer 19642 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
19643 
          for _i466 in xrange(_size462):
19644 
            _key467 = iprot.readString();
19645 
            _val468 = iprot.readString();
19646 
            self.success[_key467] = _val468
3956 chandransh 19647 
          iprot.readMapEnd()
19648 
        else:
19649 
          iprot.skip(ftype)
19650 
      elif fid == 1:
19651 
        if ftype == TType.STRUCT:
19652 
          self.ex = TransactionServiceException()
19653 
          self.ex.read(iprot)
19654 
        else:
19655 
          iprot.skip(ftype)
19656 
      else:
19657 
        iprot.skip(ftype)
19658 
      iprot.readFieldEnd()
19659 
    iprot.readStructEnd()
19660 
 
19661 
  def write(self, oprot):
19662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19664 
      return
19665 
    oprot.writeStructBegin('reconcileCodCollection_result')
19666 
    if self.success is not None:
19667 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19668 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 19669 
      for kiter469,viter470 in self.success.items():
19670 
        oprot.writeString(kiter469)
19671 
        oprot.writeString(viter470)
3956 chandransh 19672 
      oprot.writeMapEnd()
19673 
      oprot.writeFieldEnd()
19674 
    if self.ex is not None:
19675 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19676 
      self.ex.write(oprot)
19677 
      oprot.writeFieldEnd()
19678 
    oprot.writeFieldStop()
19679 
    oprot.writeStructEnd()
19680 
 
19681 
  def validate(self):
19682 
    return
19683 
 
19684 
 
19685 
  def __repr__(self):
19686 
    L = ['%s=%r' % (key, value)
19687 
      for key, value in self.__dict__.iteritems()]
19688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19689 
 
19690 
  def __eq__(self, other):
19691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19692 
 
19693 
  def __ne__(self, other):
19694 
    return not (self == other)
4008 mandeep.dh 19695 
 
19696 
class getTransactionsRequiringExtraProcessing_args:
19697 
  """
19698 
  Attributes:
19699 
   - category
19700 
  """
19701 
 
19702 
  thrift_spec = (
19703 
    None, # 0
19704 
    (1, TType.I32, 'category', None, None, ), # 1
19705 
  )
19706 
 
19707 
  def __init__(self, category=None,):
19708 
    self.category = category
19709 
 
19710 
  def read(self, iprot):
19711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19713 
      return
19714 
    iprot.readStructBegin()
19715 
    while True:
19716 
      (fname, ftype, fid) = iprot.readFieldBegin()
19717 
      if ftype == TType.STOP:
19718 
        break
19719 
      if fid == 1:
19720 
        if ftype == TType.I32:
19721 
          self.category = iprot.readI32();
19722 
        else:
19723 
          iprot.skip(ftype)
19724 
      else:
19725 
        iprot.skip(ftype)
19726 
      iprot.readFieldEnd()
19727 
    iprot.readStructEnd()
19728 
 
19729 
  def write(self, oprot):
19730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19732 
      return
19733 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
19734 
    if self.category is not None:
19735 
      oprot.writeFieldBegin('category', TType.I32, 1)
19736 
      oprot.writeI32(self.category)
19737 
      oprot.writeFieldEnd()
19738 
    oprot.writeFieldStop()
19739 
    oprot.writeStructEnd()
19740 
 
19741 
  def validate(self):
19742 
    return
19743 
 
19744 
 
19745 
  def __repr__(self):
19746 
    L = ['%s=%r' % (key, value)
19747 
      for key, value in self.__dict__.iteritems()]
19748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19749 
 
19750 
  def __eq__(self, other):
19751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19752 
 
19753 
  def __ne__(self, other):
19754 
    return not (self == other)
19755 
 
19756 
class getTransactionsRequiringExtraProcessing_result:
19757 
  """
19758 
  Attributes:
19759 
   - success
19760 
  """
19761 
 
19762 
  thrift_spec = (
19763 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19764 
  )
19765 
 
19766 
  def __init__(self, success=None,):
19767 
    self.success = success
19768 
 
19769 
  def read(self, iprot):
19770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19772 
      return
19773 
    iprot.readStructBegin()
19774 
    while True:
19775 
      (fname, ftype, fid) = iprot.readFieldBegin()
19776 
      if ftype == TType.STOP:
19777 
        break
19778 
      if fid == 0:
19779 
        if ftype == TType.LIST:
19780 
          self.success = []
6188 rajveer 19781 
          (_etype474, _size471) = iprot.readListBegin()
19782 
          for _i475 in xrange(_size471):
19783 
            _elem476 = iprot.readI64();
19784 
            self.success.append(_elem476)
4008 mandeep.dh 19785 
          iprot.readListEnd()
19786 
        else:
19787 
          iprot.skip(ftype)
19788 
      else:
19789 
        iprot.skip(ftype)
19790 
      iprot.readFieldEnd()
19791 
    iprot.readStructEnd()
19792 
 
19793 
  def write(self, oprot):
19794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19796 
      return
19797 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
19798 
    if self.success is not None:
19799 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19800 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 19801 
      for iter477 in self.success:
19802 
        oprot.writeI64(iter477)
4008 mandeep.dh 19803 
      oprot.writeListEnd()
19804 
      oprot.writeFieldEnd()
19805 
    oprot.writeFieldStop()
19806 
    oprot.writeStructEnd()
19807 
 
19808 
  def validate(self):
19809 
    return
19810 
 
19811 
 
19812 
  def __repr__(self):
19813 
    L = ['%s=%r' % (key, value)
19814 
      for key, value in self.__dict__.iteritems()]
19815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19816 
 
19817 
  def __eq__(self, other):
19818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19819 
 
19820 
  def __ne__(self, other):
19821 
    return not (self == other)
19822 
 
19823 
class markTransactionAsProcessed_args:
19824 
  """
19825 
  Attributes:
19826 
   - transactionId
19827 
   - category
19828 
  """
19829 
 
19830 
  thrift_spec = (
19831 
    None, # 0
19832 
    (1, TType.I64, 'transactionId', None, None, ), # 1
19833 
    (2, TType.I32, 'category', None, None, ), # 2
19834 
  )
19835 
 
19836 
  def __init__(self, transactionId=None, category=None,):
19837 
    self.transactionId = transactionId
19838 
    self.category = category
19839 
 
19840 
  def read(self, iprot):
19841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19843 
      return
19844 
    iprot.readStructBegin()
19845 
    while True:
19846 
      (fname, ftype, fid) = iprot.readFieldBegin()
19847 
      if ftype == TType.STOP:
19848 
        break
19849 
      if fid == 1:
19850 
        if ftype == TType.I64:
19851 
          self.transactionId = iprot.readI64();
19852 
        else:
19853 
          iprot.skip(ftype)
19854 
      elif fid == 2:
19855 
        if ftype == TType.I32:
19856 
          self.category = iprot.readI32();
19857 
        else:
19858 
          iprot.skip(ftype)
19859 
      else:
19860 
        iprot.skip(ftype)
19861 
      iprot.readFieldEnd()
19862 
    iprot.readStructEnd()
19863 
 
19864 
  def write(self, oprot):
19865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19867 
      return
19868 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
19869 
    if self.transactionId is not None:
19870 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
19871 
      oprot.writeI64(self.transactionId)
19872 
      oprot.writeFieldEnd()
19873 
    if self.category is not None:
19874 
      oprot.writeFieldBegin('category', TType.I32, 2)
19875 
      oprot.writeI32(self.category)
19876 
      oprot.writeFieldEnd()
19877 
    oprot.writeFieldStop()
19878 
    oprot.writeStructEnd()
19879 
 
19880 
  def validate(self):
19881 
    return
19882 
 
19883 
 
19884 
  def __repr__(self):
19885 
    L = ['%s=%r' % (key, value)
19886 
      for key, value in self.__dict__.iteritems()]
19887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19888 
 
19889 
  def __eq__(self, other):
19890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19891 
 
19892 
  def __ne__(self, other):
19893 
    return not (self == other)
19894 
 
19895 
class markTransactionAsProcessed_result:
19896 
 
19897 
  thrift_spec = (
19898 
  )
19899 
 
19900 
  def read(self, iprot):
19901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19903 
      return
19904 
    iprot.readStructBegin()
19905 
    while True:
19906 
      (fname, ftype, fid) = iprot.readFieldBegin()
19907 
      if ftype == TType.STOP:
19908 
        break
19909 
      else:
19910 
        iprot.skip(ftype)
19911 
      iprot.readFieldEnd()
19912 
    iprot.readStructEnd()
19913 
 
19914 
  def write(self, oprot):
19915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19917 
      return
19918 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
19919 
    oprot.writeFieldStop()
19920 
    oprot.writeStructEnd()
19921 
 
19922 
  def validate(self):
19923 
    return
19924 
 
19925 
 
19926 
  def __repr__(self):
19927 
    L = ['%s=%r' % (key, value)
19928 
      for key, value in self.__dict__.iteritems()]
19929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19930 
 
19931 
  def __eq__(self, other):
19932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19933 
 
19934 
  def __ne__(self, other):
19935 
    return not (self == other)
4018 chandransh 19936 
 
19937 
class getItemWiseRiskyOrdersCount_args:
19938 
 
19939 
  thrift_spec = (
19940 
  )
19941 
 
19942 
  def read(self, iprot):
19943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19945 
      return
19946 
    iprot.readStructBegin()
19947 
    while True:
19948 
      (fname, ftype, fid) = iprot.readFieldBegin()
19949 
      if ftype == TType.STOP:
19950 
        break
19951 
      else:
19952 
        iprot.skip(ftype)
19953 
      iprot.readFieldEnd()
19954 
    iprot.readStructEnd()
19955 
 
19956 
  def write(self, oprot):
19957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19959 
      return
19960 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
19961 
    oprot.writeFieldStop()
19962 
    oprot.writeStructEnd()
19963 
 
19964 
  def validate(self):
19965 
    return
19966 
 
19967 
 
19968 
  def __repr__(self):
19969 
    L = ['%s=%r' % (key, value)
19970 
      for key, value in self.__dict__.iteritems()]
19971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19972 
 
19973 
  def __eq__(self, other):
19974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19975 
 
19976 
  def __ne__(self, other):
19977 
    return not (self == other)
19978 
 
19979 
class getItemWiseRiskyOrdersCount_result:
19980 
  """
19981 
  Attributes:
19982 
   - success
19983 
  """
19984 
 
19985 
  thrift_spec = (
19986 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
19987 
  )
19988 
 
19989 
  def __init__(self, success=None,):
19990 
    self.success = success
19991 
 
19992 
  def read(self, iprot):
19993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19995 
      return
19996 
    iprot.readStructBegin()
19997 
    while True:
19998 
      (fname, ftype, fid) = iprot.readFieldBegin()
19999 
      if ftype == TType.STOP:
20000 
        break
20001 
      if fid == 0:
20002 
        if ftype == TType.MAP:
20003 
          self.success = {}
6188 rajveer 20004 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
20005 
          for _i482 in xrange(_size478):
20006 
            _key483 = iprot.readI64();
20007 
            _val484 = iprot.readI64();
20008 
            self.success[_key483] = _val484
4018 chandransh 20009 
          iprot.readMapEnd()
20010 
        else:
20011 
          iprot.skip(ftype)
20012 
      else:
20013 
        iprot.skip(ftype)
20014 
      iprot.readFieldEnd()
20015 
    iprot.readStructEnd()
20016 
 
20017 
  def write(self, oprot):
20018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20020 
      return
20021 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
20022 
    if self.success is not None:
20023 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20024 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 20025 
      for kiter485,viter486 in self.success.items():
20026 
        oprot.writeI64(kiter485)
20027 
        oprot.writeI64(viter486)
4018 chandransh 20028 
      oprot.writeMapEnd()
20029 
      oprot.writeFieldEnd()
20030 
    oprot.writeFieldStop()
20031 
    oprot.writeStructEnd()
20032 
 
20033 
  def validate(self):
20034 
    return
20035 
 
20036 
 
20037 
  def __repr__(self):
20038 
    L = ['%s=%r' % (key, value)
20039 
      for key, value in self.__dict__.iteritems()]
20040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20041 
 
20042 
  def __eq__(self, other):
20043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20044 
 
20045 
  def __ne__(self, other):
20046 
    return not (self == other)
4247 rajveer 20047 
 
4295 varun.gupt 20048 
class getOrdersForItemIds_args:
20049 
  """
20050 
  Attributes:
20051 
   - itemIds
20052 
  """
20053 
 
20054 
  thrift_spec = (
20055 
    None, # 0
20056 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20057 
  )
20058 
 
20059 
  def __init__(self, itemIds=None,):
20060 
    self.itemIds = itemIds
20061 
 
20062 
  def read(self, iprot):
20063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20065 
      return
20066 
    iprot.readStructBegin()
20067 
    while True:
20068 
      (fname, ftype, fid) = iprot.readFieldBegin()
20069 
      if ftype == TType.STOP:
20070 
        break
20071 
      if fid == 1:
20072 
        if ftype == TType.LIST:
20073 
          self.itemIds = []
6188 rajveer 20074 
          (_etype490, _size487) = iprot.readListBegin()
20075 
          for _i491 in xrange(_size487):
20076 
            _elem492 = iprot.readI64();
20077 
            self.itemIds.append(_elem492)
4295 varun.gupt 20078 
          iprot.readListEnd()
20079 
        else:
20080 
          iprot.skip(ftype)
20081 
      else:
20082 
        iprot.skip(ftype)
20083 
      iprot.readFieldEnd()
20084 
    iprot.readStructEnd()
20085 
 
20086 
  def write(self, oprot):
20087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20089 
      return
20090 
    oprot.writeStructBegin('getOrdersForItemIds_args')
20091 
    if self.itemIds is not None:
20092 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20093 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 20094 
      for iter493 in self.itemIds:
20095 
        oprot.writeI64(iter493)
4295 varun.gupt 20096 
      oprot.writeListEnd()
20097 
      oprot.writeFieldEnd()
20098 
    oprot.writeFieldStop()
20099 
    oprot.writeStructEnd()
20100 
 
20101 
  def validate(self):
20102 
    return
20103 
 
20104 
 
20105 
  def __repr__(self):
20106 
    L = ['%s=%r' % (key, value)
20107 
      for key, value in self.__dict__.iteritems()]
20108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20109 
 
20110 
  def __eq__(self, other):
20111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20112 
 
20113 
  def __ne__(self, other):
20114 
    return not (self == other)
20115 
 
20116 
class getOrdersForItemIds_result:
20117 
  """
20118 
  Attributes:
20119 
   - success
20120 
  """
20121 
 
20122 
  thrift_spec = (
20123 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20124 
  )
20125 
 
20126 
  def __init__(self, success=None,):
20127 
    self.success = success
20128 
 
20129 
  def read(self, iprot):
20130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20132 
      return
20133 
    iprot.readStructBegin()
20134 
    while True:
20135 
      (fname, ftype, fid) = iprot.readFieldBegin()
20136 
      if ftype == TType.STOP:
20137 
        break
20138 
      if fid == 0:
20139 
        if ftype == TType.LIST:
20140 
          self.success = []
6188 rajveer 20141 
          (_etype497, _size494) = iprot.readListBegin()
20142 
          for _i498 in xrange(_size494):
20143 
            _elem499 = Order()
20144 
            _elem499.read(iprot)
20145 
            self.success.append(_elem499)
4295 varun.gupt 20146 
          iprot.readListEnd()
20147 
        else:
20148 
          iprot.skip(ftype)
20149 
      else:
20150 
        iprot.skip(ftype)
20151 
      iprot.readFieldEnd()
20152 
    iprot.readStructEnd()
20153 
 
20154 
  def write(self, oprot):
20155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20157 
      return
20158 
    oprot.writeStructBegin('getOrdersForItemIds_result')
20159 
    if self.success is not None:
20160 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20161 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20162 
      for iter500 in self.success:
20163 
        iter500.write(oprot)
4295 varun.gupt 20164 
      oprot.writeListEnd()
20165 
      oprot.writeFieldEnd()
20166 
    oprot.writeFieldStop()
20167 
    oprot.writeStructEnd()
20168 
 
20169 
  def validate(self):
20170 
    return
20171 
 
20172 
 
20173 
  def __repr__(self):
20174 
    L = ['%s=%r' % (key, value)
20175 
      for key, value in self.__dict__.iteritems()]
20176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20177 
 
20178 
  def __eq__(self, other):
20179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20180 
 
20181 
  def __ne__(self, other):
20182 
    return not (self == other)
20183 
 
4247 rajveer 20184 
class markOrderCancellationRequestReceived_args:
20185 
  """
20186 
  Attributes:
20187 
   - orderId
20188 
  """
20189 
 
20190 
  thrift_spec = (
20191 
    None, # 0
20192 
    (1, TType.I64, 'orderId', None, None, ), # 1
20193 
  )
20194 
 
20195 
  def __init__(self, orderId=None,):
20196 
    self.orderId = orderId
20197 
 
20198 
  def read(self, iprot):
20199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20201 
      return
20202 
    iprot.readStructBegin()
20203 
    while True:
20204 
      (fname, ftype, fid) = iprot.readFieldBegin()
20205 
      if ftype == TType.STOP:
20206 
        break
20207 
      if fid == 1:
20208 
        if ftype == TType.I64:
20209 
          self.orderId = iprot.readI64();
20210 
        else:
20211 
          iprot.skip(ftype)
20212 
      else:
20213 
        iprot.skip(ftype)
20214 
      iprot.readFieldEnd()
20215 
    iprot.readStructEnd()
20216 
 
20217 
  def write(self, oprot):
20218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20220 
      return
20221 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
20222 
    if self.orderId is not None:
20223 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20224 
      oprot.writeI64(self.orderId)
20225 
      oprot.writeFieldEnd()
20226 
    oprot.writeFieldStop()
20227 
    oprot.writeStructEnd()
20228 
 
20229 
  def validate(self):
20230 
    return
20231 
 
20232 
 
20233 
  def __repr__(self):
20234 
    L = ['%s=%r' % (key, value)
20235 
      for key, value in self.__dict__.iteritems()]
20236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20237 
 
20238 
  def __eq__(self, other):
20239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20240 
 
20241 
  def __ne__(self, other):
20242 
    return not (self == other)
20243 
 
20244 
class markOrderCancellationRequestReceived_result:
20245 
  """
20246 
  Attributes:
20247 
   - ex
20248 
  """
20249 
 
20250 
  thrift_spec = (
20251 
    None, # 0
20252 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20253 
  )
20254 
 
20255 
  def __init__(self, ex=None,):
20256 
    self.ex = ex
20257 
 
20258 
  def read(self, iprot):
20259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20261 
      return
20262 
    iprot.readStructBegin()
20263 
    while True:
20264 
      (fname, ftype, fid) = iprot.readFieldBegin()
20265 
      if ftype == TType.STOP:
20266 
        break
20267 
      if fid == 1:
20268 
        if ftype == TType.STRUCT:
20269 
          self.ex = TransactionServiceException()
20270 
          self.ex.read(iprot)
20271 
        else:
20272 
          iprot.skip(ftype)
20273 
      else:
20274 
        iprot.skip(ftype)
20275 
      iprot.readFieldEnd()
20276 
    iprot.readStructEnd()
20277 
 
20278 
  def write(self, oprot):
20279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20281 
      return
20282 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20283 
    if self.ex is not None:
20284 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20285 
      self.ex.write(oprot)
20286 
      oprot.writeFieldEnd()
20287 
    oprot.writeFieldStop()
20288 
    oprot.writeStructEnd()
20289 
 
20290 
  def validate(self):
20291 
    return
20292 
 
20293 
 
20294 
  def __repr__(self):
20295 
    L = ['%s=%r' % (key, value)
20296 
      for key, value in self.__dict__.iteritems()]
20297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20298 
 
20299 
  def __eq__(self, other):
20300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20301 
 
20302 
  def __ne__(self, other):
20303 
    return not (self == other)
20304 
 
20305 
class markOrderCancellationRequestConfirmed_args:
20306 
  """
20307 
  Attributes:
20308 
   - orderId
20309 
  """
20310 
 
20311 
  thrift_spec = (
20312 
    None, # 0
20313 
    (1, TType.I64, 'orderId', None, None, ), # 1
20314 
  )
20315 
 
20316 
  def __init__(self, orderId=None,):
20317 
    self.orderId = orderId
20318 
 
20319 
  def read(self, iprot):
20320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20322 
      return
20323 
    iprot.readStructBegin()
20324 
    while True:
20325 
      (fname, ftype, fid) = iprot.readFieldBegin()
20326 
      if ftype == TType.STOP:
20327 
        break
20328 
      if fid == 1:
20329 
        if ftype == TType.I64:
20330 
          self.orderId = iprot.readI64();
20331 
        else:
20332 
          iprot.skip(ftype)
20333 
      else:
20334 
        iprot.skip(ftype)
20335 
      iprot.readFieldEnd()
20336 
    iprot.readStructEnd()
20337 
 
20338 
  def write(self, oprot):
20339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20341 
      return
20342 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
20343 
    if self.orderId is not None:
20344 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20345 
      oprot.writeI64(self.orderId)
20346 
      oprot.writeFieldEnd()
20347 
    oprot.writeFieldStop()
20348 
    oprot.writeStructEnd()
20349 
 
20350 
  def validate(self):
20351 
    return
20352 
 
20353 
 
20354 
  def __repr__(self):
20355 
    L = ['%s=%r' % (key, value)
20356 
      for key, value in self.__dict__.iteritems()]
20357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20358 
 
20359 
  def __eq__(self, other):
20360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20361 
 
20362 
  def __ne__(self, other):
20363 
    return not (self == other)
20364 
 
20365 
class markOrderCancellationRequestConfirmed_result:
20366 
  """
20367 
  Attributes:
20368 
   - ex
20369 
  """
20370 
 
20371 
  thrift_spec = (
20372 
    None, # 0
20373 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20374 
  )
20375 
 
20376 
  def __init__(self, ex=None,):
20377 
    self.ex = ex
20378 
 
20379 
  def read(self, iprot):
20380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20382 
      return
20383 
    iprot.readStructBegin()
20384 
    while True:
20385 
      (fname, ftype, fid) = iprot.readFieldBegin()
20386 
      if ftype == TType.STOP:
20387 
        break
20388 
      if fid == 1:
20389 
        if ftype == TType.STRUCT:
20390 
          self.ex = TransactionServiceException()
20391 
          self.ex.read(iprot)
20392 
        else:
20393 
          iprot.skip(ftype)
20394 
      else:
20395 
        iprot.skip(ftype)
20396 
      iprot.readFieldEnd()
20397 
    iprot.readStructEnd()
20398 
 
20399 
  def write(self, oprot):
20400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20402 
      return
20403 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
20404 
    if self.ex is not None:
20405 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20406 
      self.ex.write(oprot)
20407 
      oprot.writeFieldEnd()
20408 
    oprot.writeFieldStop()
20409 
    oprot.writeStructEnd()
20410 
 
20411 
  def validate(self):
20412 
    return
20413 
 
20414 
 
20415 
  def __repr__(self):
20416 
    L = ['%s=%r' % (key, value)
20417 
      for key, value in self.__dict__.iteritems()]
20418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20419 
 
20420 
  def __eq__(self, other):
20421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20422 
 
20423 
  def __ne__(self, other):
20424 
    return not (self == other)
20425 
 
20426 
class markOrderCancellationRequestDenied_args:
20427 
  """
20428 
  Attributes:
20429 
   - orderId
20430 
  """
20431 
 
20432 
  thrift_spec = (
20433 
    None, # 0
20434 
    (1, TType.I64, 'orderId', None, None, ), # 1
20435 
  )
20436 
 
20437 
  def __init__(self, orderId=None,):
20438 
    self.orderId = orderId
20439 
 
20440 
  def read(self, iprot):
20441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20443 
      return
20444 
    iprot.readStructBegin()
20445 
    while True:
20446 
      (fname, ftype, fid) = iprot.readFieldBegin()
20447 
      if ftype == TType.STOP:
20448 
        break
20449 
      if fid == 1:
20450 
        if ftype == TType.I64:
20451 
          self.orderId = iprot.readI64();
20452 
        else:
20453 
          iprot.skip(ftype)
20454 
      else:
20455 
        iprot.skip(ftype)
20456 
      iprot.readFieldEnd()
20457 
    iprot.readStructEnd()
20458 
 
20459 
  def write(self, oprot):
20460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20462 
      return
20463 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
20464 
    if self.orderId is not None:
20465 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20466 
      oprot.writeI64(self.orderId)
20467 
      oprot.writeFieldEnd()
20468 
    oprot.writeFieldStop()
20469 
    oprot.writeStructEnd()
20470 
 
20471 
  def validate(self):
20472 
    return
20473 
 
20474 
 
20475 
  def __repr__(self):
20476 
    L = ['%s=%r' % (key, value)
20477 
      for key, value in self.__dict__.iteritems()]
20478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20479 
 
20480 
  def __eq__(self, other):
20481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20482 
 
20483 
  def __ne__(self, other):
20484 
    return not (self == other)
20485 
 
20486 
class markOrderCancellationRequestDenied_result:
20487 
  """
20488 
  Attributes:
20489 
   - ex
20490 
  """
20491 
 
20492 
  thrift_spec = (
20493 
    None, # 0
20494 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20495 
  )
20496 
 
20497 
  def __init__(self, ex=None,):
20498 
    self.ex = ex
20499 
 
20500 
  def read(self, iprot):
20501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20503 
      return
20504 
    iprot.readStructBegin()
20505 
    while True:
20506 
      (fname, ftype, fid) = iprot.readFieldBegin()
20507 
      if ftype == TType.STOP:
20508 
        break
20509 
      if fid == 1:
20510 
        if ftype == TType.STRUCT:
20511 
          self.ex = TransactionServiceException()
20512 
          self.ex.read(iprot)
20513 
        else:
20514 
          iprot.skip(ftype)
20515 
      else:
20516 
        iprot.skip(ftype)
20517 
      iprot.readFieldEnd()
20518 
    iprot.readStructEnd()
20519 
 
20520 
  def write(self, oprot):
20521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20523 
      return
20524 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
20525 
    if self.ex is not None:
20526 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20527 
      self.ex.write(oprot)
20528 
      oprot.writeFieldEnd()
20529 
    oprot.writeFieldStop()
20530 
    oprot.writeStructEnd()
20531 
 
20532 
  def validate(self):
20533 
    return
20534 
 
20535 
 
20536 
  def __repr__(self):
20537 
    L = ['%s=%r' % (key, value)
20538 
      for key, value in self.__dict__.iteritems()]
20539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20540 
 
20541 
  def __eq__(self, other):
20542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20543 
 
20544 
  def __ne__(self, other):
20545 
    return not (self == other)
20546 
 
4258 rajveer 20547 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 20548 
  """
20549 
  Attributes:
4258 rajveer 20550 
   - transactionId
4247 rajveer 20551 
  """
20552 
 
20553 
  thrift_spec = (
20554 
    None, # 0
4258 rajveer 20555 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 20556 
  )
20557 
 
4258 rajveer 20558 
  def __init__(self, transactionId=None,):
20559 
    self.transactionId = transactionId
4247 rajveer 20560 
 
20561 
  def read(self, iprot):
20562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20564 
      return
20565 
    iprot.readStructBegin()
20566 
    while True:
20567 
      (fname, ftype, fid) = iprot.readFieldBegin()
20568 
      if ftype == TType.STOP:
20569 
        break
20570 
      if fid == 1:
20571 
        if ftype == TType.I64:
4258 rajveer 20572 
          self.transactionId = iprot.readI64();
4247 rajveer 20573 
        else:
20574 
          iprot.skip(ftype)
20575 
      else:
20576 
        iprot.skip(ftype)
20577 
      iprot.readFieldEnd()
20578 
    iprot.readStructEnd()
20579 
 
20580 
  def write(self, oprot):
20581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20583 
      return
4258 rajveer 20584 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
20585 
    if self.transactionId is not None:
20586 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20587 
      oprot.writeI64(self.transactionId)
4247 rajveer 20588 
      oprot.writeFieldEnd()
20589 
    oprot.writeFieldStop()
20590 
    oprot.writeStructEnd()
20591 
 
20592 
  def validate(self):
20593 
    return
20594 
 
20595 
 
20596 
  def __repr__(self):
20597 
    L = ['%s=%r' % (key, value)
20598 
      for key, value in self.__dict__.iteritems()]
20599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20600 
 
20601 
  def __eq__(self, other):
20602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20603 
 
20604 
  def __ne__(self, other):
20605 
    return not (self == other)
20606 
 
4258 rajveer 20607 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 20608 
  """
20609 
  Attributes:
20610 
   - ex
20611 
  """
20612 
 
20613 
  thrift_spec = (
20614 
    None, # 0
20615 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20616 
  )
20617 
 
20618 
  def __init__(self, ex=None,):
20619 
    self.ex = ex
20620 
 
20621 
  def read(self, iprot):
20622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20624 
      return
20625 
    iprot.readStructBegin()
20626 
    while True:
20627 
      (fname, ftype, fid) = iprot.readFieldBegin()
20628 
      if ftype == TType.STOP:
20629 
        break
20630 
      if fid == 1:
20631 
        if ftype == TType.STRUCT:
20632 
          self.ex = TransactionServiceException()
20633 
          self.ex.read(iprot)
20634 
        else:
20635 
          iprot.skip(ftype)
20636 
      else:
20637 
        iprot.skip(ftype)
20638 
      iprot.readFieldEnd()
20639 
    iprot.readStructEnd()
20640 
 
20641 
  def write(self, oprot):
20642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20644 
      return
4258 rajveer 20645 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 20646 
    if self.ex is not None:
20647 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20648 
      self.ex.write(oprot)
20649 
      oprot.writeFieldEnd()
20650 
    oprot.writeFieldStop()
20651 
    oprot.writeStructEnd()
20652 
 
20653 
  def validate(self):
20654 
    return
20655 
 
20656 
 
20657 
  def __repr__(self):
20658 
    L = ['%s=%r' % (key, value)
20659 
      for key, value in self.__dict__.iteritems()]
20660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20661 
 
20662 
  def __eq__(self, other):
20663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20664 
 
20665 
  def __ne__(self, other):
20666 
    return not (self == other)
4259 anupam.sin 20667 
 
20668 
class refundTransaction_args:
20669 
  """
20670 
  Attributes:
20671 
   - transactionId
20672 
   - refundedBy
20673 
   - reason
20674 
  """
20675 
 
20676 
  thrift_spec = (
20677 
    None, # 0
20678 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20679 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
20680 
    (3, TType.STRING, 'reason', None, None, ), # 3
20681 
  )
20682 
 
20683 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
20684 
    self.transactionId = transactionId
20685 
    self.refundedBy = refundedBy
20686 
    self.reason = reason
20687 
 
20688 
  def read(self, iprot):
20689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20691 
      return
20692 
    iprot.readStructBegin()
20693 
    while True:
20694 
      (fname, ftype, fid) = iprot.readFieldBegin()
20695 
      if ftype == TType.STOP:
20696 
        break
20697 
      if fid == 1:
20698 
        if ftype == TType.I64:
20699 
          self.transactionId = iprot.readI64();
20700 
        else:
20701 
          iprot.skip(ftype)
20702 
      elif fid == 2:
20703 
        if ftype == TType.STRING:
20704 
          self.refundedBy = iprot.readString();
20705 
        else:
20706 
          iprot.skip(ftype)
20707 
      elif fid == 3:
20708 
        if ftype == TType.STRING:
20709 
          self.reason = iprot.readString();
20710 
        else:
20711 
          iprot.skip(ftype)
20712 
      else:
20713 
        iprot.skip(ftype)
20714 
      iprot.readFieldEnd()
20715 
    iprot.readStructEnd()
20716 
 
20717 
  def write(self, oprot):
20718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20720 
      return
20721 
    oprot.writeStructBegin('refundTransaction_args')
20722 
    if self.transactionId is not None:
20723 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20724 
      oprot.writeI64(self.transactionId)
20725 
      oprot.writeFieldEnd()
20726 
    if self.refundedBy is not None:
20727 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
20728 
      oprot.writeString(self.refundedBy)
20729 
      oprot.writeFieldEnd()
20730 
    if self.reason is not None:
20731 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
20732 
      oprot.writeString(self.reason)
20733 
      oprot.writeFieldEnd()
20734 
    oprot.writeFieldStop()
20735 
    oprot.writeStructEnd()
20736 
 
20737 
  def validate(self):
20738 
    return
20739 
 
20740 
 
20741 
  def __repr__(self):
20742 
    L = ['%s=%r' % (key, value)
20743 
      for key, value in self.__dict__.iteritems()]
20744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20745 
 
20746 
  def __eq__(self, other):
20747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20748 
 
20749 
  def __ne__(self, other):
20750 
    return not (self == other)
20751 
 
20752 
class refundTransaction_result:
20753 
  """
20754 
  Attributes:
20755 
   - ex
20756 
  """
20757 
 
20758 
  thrift_spec = (
20759 
    None, # 0
20760 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20761 
  )
20762 
 
20763 
  def __init__(self, ex=None,):
20764 
    self.ex = ex
20765 
 
20766 
  def read(self, iprot):
20767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20769 
      return
20770 
    iprot.readStructBegin()
20771 
    while True:
20772 
      (fname, ftype, fid) = iprot.readFieldBegin()
20773 
      if ftype == TType.STOP:
20774 
        break
20775 
      if fid == 1:
20776 
        if ftype == TType.STRUCT:
20777 
          self.ex = TransactionServiceException()
20778 
          self.ex.read(iprot)
20779 
        else:
20780 
          iprot.skip(ftype)
20781 
      else:
20782 
        iprot.skip(ftype)
20783 
      iprot.readFieldEnd()
20784 
    iprot.readStructEnd()
20785 
 
20786 
  def write(self, oprot):
20787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20789 
      return
20790 
    oprot.writeStructBegin('refundTransaction_result')
20791 
    if self.ex is not None:
20792 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20793 
      self.ex.write(oprot)
20794 
      oprot.writeFieldEnd()
20795 
    oprot.writeFieldStop()
20796 
    oprot.writeStructEnd()
20797 
 
20798 
  def validate(self):
20799 
    return
20800 
 
20801 
 
20802 
  def __repr__(self):
20803 
    L = ['%s=%r' % (key, value)
20804 
      for key, value in self.__dict__.iteritems()]
20805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20806 
 
20807 
  def __eq__(self, other):
20808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20809 
 
20810 
  def __ne__(self, other):
20811 
    return not (self == other)
4285 rajveer 20812 
 
4324 mandeep.dh 20813 
class updateShipmentAddress_args:
20814 
  """
20815 
  Attributes:
20816 
   - orderId
20817 
   - addressId
20818 
  """
20819 
 
20820 
  thrift_spec = (
20821 
    None, # 0
20822 
    (1, TType.I64, 'orderId', None, None, ), # 1
20823 
    (2, TType.I64, 'addressId', None, None, ), # 2
20824 
  )
20825 
 
20826 
  def __init__(self, orderId=None, addressId=None,):
20827 
    self.orderId = orderId
20828 
    self.addressId = addressId
20829 
 
20830 
  def read(self, iprot):
20831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20833 
      return
20834 
    iprot.readStructBegin()
20835 
    while True:
20836 
      (fname, ftype, fid) = iprot.readFieldBegin()
20837 
      if ftype == TType.STOP:
20838 
        break
20839 
      if fid == 1:
20840 
        if ftype == TType.I64:
20841 
          self.orderId = iprot.readI64();
20842 
        else:
20843 
          iprot.skip(ftype)
20844 
      elif fid == 2:
20845 
        if ftype == TType.I64:
20846 
          self.addressId = iprot.readI64();
20847 
        else:
20848 
          iprot.skip(ftype)
20849 
      else:
20850 
        iprot.skip(ftype)
20851 
      iprot.readFieldEnd()
20852 
    iprot.readStructEnd()
20853 
 
20854 
  def write(self, oprot):
20855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20857 
      return
20858 
    oprot.writeStructBegin('updateShipmentAddress_args')
20859 
    if self.orderId is not None:
20860 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20861 
      oprot.writeI64(self.orderId)
20862 
      oprot.writeFieldEnd()
20863 
    if self.addressId is not None:
20864 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
20865 
      oprot.writeI64(self.addressId)
20866 
      oprot.writeFieldEnd()
20867 
    oprot.writeFieldStop()
20868 
    oprot.writeStructEnd()
20869 
 
20870 
  def validate(self):
20871 
    return
20872 
 
20873 
 
20874 
  def __repr__(self):
20875 
    L = ['%s=%r' % (key, value)
20876 
      for key, value in self.__dict__.iteritems()]
20877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20878 
 
20879 
  def __eq__(self, other):
20880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20881 
 
20882 
  def __ne__(self, other):
20883 
    return not (self == other)
20884 
 
20885 
class updateShipmentAddress_result:
20886 
  """
20887 
  Attributes:
20888 
   - ex
20889 
  """
20890 
 
20891 
  thrift_spec = (
20892 
    None, # 0
20893 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20894 
  )
20895 
 
20896 
  def __init__(self, ex=None,):
20897 
    self.ex = ex
20898 
 
20899 
  def read(self, iprot):
20900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20902 
      return
20903 
    iprot.readStructBegin()
20904 
    while True:
20905 
      (fname, ftype, fid) = iprot.readFieldBegin()
20906 
      if ftype == TType.STOP:
20907 
        break
20908 
      if fid == 1:
20909 
        if ftype == TType.STRUCT:
20910 
          self.ex = TransactionServiceException()
20911 
          self.ex.read(iprot)
20912 
        else:
20913 
          iprot.skip(ftype)
20914 
      else:
20915 
        iprot.skip(ftype)
20916 
      iprot.readFieldEnd()
20917 
    iprot.readStructEnd()
20918 
 
20919 
  def write(self, oprot):
20920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20922 
      return
20923 
    oprot.writeStructBegin('updateShipmentAddress_result')
20924 
    if self.ex is not None:
20925 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20926 
      self.ex.write(oprot)
20927 
      oprot.writeFieldEnd()
20928 
    oprot.writeFieldStop()
20929 
    oprot.writeStructEnd()
20930 
 
20931 
  def validate(self):
20932 
    return
20933 
 
20934 
 
20935 
  def __repr__(self):
20936 
    L = ['%s=%r' % (key, value)
20937 
      for key, value in self.__dict__.iteritems()]
20938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20939 
 
20940 
  def __eq__(self, other):
20941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20942 
 
20943 
  def __ne__(self, other):
20944 
    return not (self == other)
20945 
 
4285 rajveer 20946 
class acceptOrdersForItemId_args:
20947 
  """
20948 
  Attributes:
20949 
   - itemId
20950 
   - inventory
20951 
  """
20952 
 
20953 
  thrift_spec = (
20954 
    None, # 0
20955 
    (1, TType.I64, 'itemId', None, None, ), # 1
20956 
    (2, TType.I64, 'inventory', None, None, ), # 2
20957 
  )
20958 
 
20959 
  def __init__(self, itemId=None, inventory=None,):
20960 
    self.itemId = itemId
20961 
    self.inventory = inventory
20962 
 
20963 
  def read(self, iprot):
20964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20966 
      return
20967 
    iprot.readStructBegin()
20968 
    while True:
20969 
      (fname, ftype, fid) = iprot.readFieldBegin()
20970 
      if ftype == TType.STOP:
20971 
        break
20972 
      if fid == 1:
20973 
        if ftype == TType.I64:
20974 
          self.itemId = iprot.readI64();
20975 
        else:
20976 
          iprot.skip(ftype)
20977 
      elif fid == 2:
20978 
        if ftype == TType.I64:
20979 
          self.inventory = iprot.readI64();
20980 
        else:
20981 
          iprot.skip(ftype)
20982 
      else:
20983 
        iprot.skip(ftype)
20984 
      iprot.readFieldEnd()
20985 
    iprot.readStructEnd()
20986 
 
20987 
  def write(self, oprot):
20988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20990 
      return
20991 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
20992 
    if self.itemId is not None:
20993 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
20994 
      oprot.writeI64(self.itemId)
20995 
      oprot.writeFieldEnd()
20996 
    if self.inventory is not None:
20997 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
20998 
      oprot.writeI64(self.inventory)
20999 
      oprot.writeFieldEnd()
21000 
    oprot.writeFieldStop()
21001 
    oprot.writeStructEnd()
21002 
 
21003 
  def validate(self):
21004 
    return
21005 
 
21006 
 
21007 
  def __repr__(self):
21008 
    L = ['%s=%r' % (key, value)
21009 
      for key, value in self.__dict__.iteritems()]
21010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21011 
 
21012 
  def __eq__(self, other):
21013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21014 
 
21015 
  def __ne__(self, other):
21016 
    return not (self == other)
21017 
 
21018 
class acceptOrdersForItemId_result:
21019 
  """
21020 
  Attributes:
21021 
   - success
21022 
   - ex
21023 
  """
21024 
 
21025 
  thrift_spec = (
21026 
    (0, TType.BOOL, 'success', None, None, ), # 0
21027 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21028 
  )
21029 
 
21030 
  def __init__(self, success=None, ex=None,):
21031 
    self.success = success
21032 
    self.ex = ex
21033 
 
21034 
  def read(self, iprot):
21035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21037 
      return
21038 
    iprot.readStructBegin()
21039 
    while True:
21040 
      (fname, ftype, fid) = iprot.readFieldBegin()
21041 
      if ftype == TType.STOP:
21042 
        break
21043 
      if fid == 0:
21044 
        if ftype == TType.BOOL:
21045 
          self.success = iprot.readBool();
21046 
        else:
21047 
          iprot.skip(ftype)
21048 
      elif fid == 1:
21049 
        if ftype == TType.STRUCT:
21050 
          self.ex = TransactionServiceException()
21051 
          self.ex.read(iprot)
21052 
        else:
21053 
          iprot.skip(ftype)
21054 
      else:
21055 
        iprot.skip(ftype)
21056 
      iprot.readFieldEnd()
21057 
    iprot.readStructEnd()
21058 
 
21059 
  def write(self, oprot):
21060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21062 
      return
21063 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
21064 
    if self.success is not None:
21065 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21066 
      oprot.writeBool(self.success)
21067 
      oprot.writeFieldEnd()
21068 
    if self.ex is not None:
21069 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21070 
      self.ex.write(oprot)
21071 
      oprot.writeFieldEnd()
21072 
    oprot.writeFieldStop()
21073 
    oprot.writeStructEnd()
21074 
 
21075 
  def validate(self):
21076 
    return
21077 
 
21078 
 
21079 
  def __repr__(self):
21080 
    L = ['%s=%r' % (key, value)
21081 
      for key, value in self.__dict__.iteritems()]
21082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21083 
 
21084 
  def __eq__(self, other):
21085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21086 
 
21087 
  def __ne__(self, other):
21088 
    return not (self == other)
4303 rajveer 21089 
 
21090 
class markOrdersAsPORaised_args:
21091 
  """
21092 
  Attributes:
21093 
   - vendorId
21094 
   - itemId
21095 
   - quantity
21096 
   - estimate
4369 rajveer 21097 
   - isReminder
4303 rajveer 21098 
  """
21099 
 
21100 
  thrift_spec = (
21101 
    None, # 0
21102 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21103 
    (2, TType.I64, 'itemId', None, None, ), # 2
21104 
    (3, TType.I64, 'quantity', None, None, ), # 3
21105 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21106 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21107 
  )
21108 
 
4369 rajveer 21109 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21110 
    self.vendorId = vendorId
21111 
    self.itemId = itemId
21112 
    self.quantity = quantity
21113 
    self.estimate = estimate
4369 rajveer 21114 
    self.isReminder = isReminder
4303 rajveer 21115 
 
21116 
  def read(self, iprot):
21117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21119 
      return
21120 
    iprot.readStructBegin()
21121 
    while True:
21122 
      (fname, ftype, fid) = iprot.readFieldBegin()
21123 
      if ftype == TType.STOP:
21124 
        break
21125 
      if fid == 1:
21126 
        if ftype == TType.I64:
21127 
          self.vendorId = iprot.readI64();
21128 
        else:
21129 
          iprot.skip(ftype)
21130 
      elif fid == 2:
21131 
        if ftype == TType.I64:
21132 
          self.itemId = iprot.readI64();
21133 
        else:
21134 
          iprot.skip(ftype)
21135 
      elif fid == 3:
21136 
        if ftype == TType.I64:
21137 
          self.quantity = iprot.readI64();
21138 
        else:
21139 
          iprot.skip(ftype)
21140 
      elif fid == 4:
21141 
        if ftype == TType.I64:
21142 
          self.estimate = iprot.readI64();
21143 
        else:
21144 
          iprot.skip(ftype)
4369 rajveer 21145 
      elif fid == 5:
21146 
        if ftype == TType.BOOL:
21147 
          self.isReminder = iprot.readBool();
21148 
        else:
21149 
          iprot.skip(ftype)
4303 rajveer 21150 
      else:
21151 
        iprot.skip(ftype)
21152 
      iprot.readFieldEnd()
21153 
    iprot.readStructEnd()
21154 
 
21155 
  def write(self, oprot):
21156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21158 
      return
21159 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
21160 
    if self.vendorId is not None:
21161 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21162 
      oprot.writeI64(self.vendorId)
21163 
      oprot.writeFieldEnd()
21164 
    if self.itemId is not None:
21165 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21166 
      oprot.writeI64(self.itemId)
21167 
      oprot.writeFieldEnd()
21168 
    if self.quantity is not None:
21169 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21170 
      oprot.writeI64(self.quantity)
21171 
      oprot.writeFieldEnd()
21172 
    if self.estimate is not None:
21173 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21174 
      oprot.writeI64(self.estimate)
21175 
      oprot.writeFieldEnd()
4369 rajveer 21176 
    if self.isReminder is not None:
21177 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21178 
      oprot.writeBool(self.isReminder)
21179 
      oprot.writeFieldEnd()
4303 rajveer 21180 
    oprot.writeFieldStop()
21181 
    oprot.writeStructEnd()
21182 
 
21183 
  def validate(self):
21184 
    return
21185 
 
21186 
 
21187 
  def __repr__(self):
21188 
    L = ['%s=%r' % (key, value)
21189 
      for key, value in self.__dict__.iteritems()]
21190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21191 
 
21192 
  def __eq__(self, other):
21193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21194 
 
21195 
  def __ne__(self, other):
21196 
    return not (self == other)
21197 
 
21198 
class markOrdersAsPORaised_result:
21199 
  """
21200 
  Attributes:
21201 
   - ex
21202 
  """
21203 
 
21204 
  thrift_spec = (
21205 
    None, # 0
21206 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21207 
  )
21208 
 
21209 
  def __init__(self, ex=None,):
21210 
    self.ex = ex
21211 
 
21212 
  def read(self, iprot):
21213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21215 
      return
21216 
    iprot.readStructBegin()
21217 
    while True:
21218 
      (fname, ftype, fid) = iprot.readFieldBegin()
21219 
      if ftype == TType.STOP:
21220 
        break
21221 
      if fid == 1:
21222 
        if ftype == TType.STRUCT:
21223 
          self.ex = TransactionServiceException()
21224 
          self.ex.read(iprot)
21225 
        else:
21226 
          iprot.skip(ftype)
21227 
      else:
21228 
        iprot.skip(ftype)
21229 
      iprot.readFieldEnd()
21230 
    iprot.readStructEnd()
21231 
 
21232 
  def write(self, oprot):
21233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21235 
      return
21236 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
21237 
    if self.ex is not None:
21238 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21239 
      self.ex.write(oprot)
21240 
      oprot.writeFieldEnd()
21241 
    oprot.writeFieldStop()
21242 
    oprot.writeStructEnd()
21243 
 
21244 
  def validate(self):
21245 
    return
21246 
 
21247 
 
21248 
  def __repr__(self):
21249 
    L = ['%s=%r' % (key, value)
21250 
      for key, value in self.__dict__.iteritems()]
21251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21252 
 
21253 
  def __eq__(self, other):
21254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21255 
 
21256 
  def __ne__(self, other):
21257 
    return not (self == other)
21258 
 
21259 
class markOrdersAsReversalInitiated_args:
21260 
  """
21261 
  Attributes:
21262 
   - vendorId
21263 
   - itemId
21264 
   - quantity
21265 
   - estimate
4369 rajveer 21266 
   - isReminder
4303 rajveer 21267 
  """
21268 
 
21269 
  thrift_spec = (
21270 
    None, # 0
21271 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21272 
    (2, TType.I64, 'itemId', None, None, ), # 2
21273 
    (3, TType.I64, 'quantity', None, None, ), # 3
21274 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21275 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21276 
  )
21277 
 
4369 rajveer 21278 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21279 
    self.vendorId = vendorId
21280 
    self.itemId = itemId
21281 
    self.quantity = quantity
21282 
    self.estimate = estimate
4369 rajveer 21283 
    self.isReminder = isReminder
4303 rajveer 21284 
 
21285 
  def read(self, iprot):
21286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21288 
      return
21289 
    iprot.readStructBegin()
21290 
    while True:
21291 
      (fname, ftype, fid) = iprot.readFieldBegin()
21292 
      if ftype == TType.STOP:
21293 
        break
21294 
      if fid == 1:
21295 
        if ftype == TType.I64:
21296 
          self.vendorId = iprot.readI64();
21297 
        else:
21298 
          iprot.skip(ftype)
21299 
      elif fid == 2:
21300 
        if ftype == TType.I64:
21301 
          self.itemId = iprot.readI64();
21302 
        else:
21303 
          iprot.skip(ftype)
21304 
      elif fid == 3:
21305 
        if ftype == TType.I64:
21306 
          self.quantity = iprot.readI64();
21307 
        else:
21308 
          iprot.skip(ftype)
21309 
      elif fid == 4:
21310 
        if ftype == TType.I64:
21311 
          self.estimate = iprot.readI64();
21312 
        else:
21313 
          iprot.skip(ftype)
4369 rajveer 21314 
      elif fid == 5:
21315 
        if ftype == TType.BOOL:
21316 
          self.isReminder = iprot.readBool();
21317 
        else:
21318 
          iprot.skip(ftype)
4303 rajveer 21319 
      else:
21320 
        iprot.skip(ftype)
21321 
      iprot.readFieldEnd()
21322 
    iprot.readStructEnd()
21323 
 
21324 
  def write(self, oprot):
21325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21327 
      return
21328 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
21329 
    if self.vendorId is not None:
21330 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21331 
      oprot.writeI64(self.vendorId)
21332 
      oprot.writeFieldEnd()
21333 
    if self.itemId is not None:
21334 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21335 
      oprot.writeI64(self.itemId)
21336 
      oprot.writeFieldEnd()
21337 
    if self.quantity is not None:
21338 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21339 
      oprot.writeI64(self.quantity)
21340 
      oprot.writeFieldEnd()
21341 
    if self.estimate is not None:
21342 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21343 
      oprot.writeI64(self.estimate)
21344 
      oprot.writeFieldEnd()
4369 rajveer 21345 
    if self.isReminder is not None:
21346 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21347 
      oprot.writeBool(self.isReminder)
21348 
      oprot.writeFieldEnd()
4303 rajveer 21349 
    oprot.writeFieldStop()
21350 
    oprot.writeStructEnd()
21351 
 
21352 
  def validate(self):
21353 
    return
21354 
 
21355 
 
21356 
  def __repr__(self):
21357 
    L = ['%s=%r' % (key, value)
21358 
      for key, value in self.__dict__.iteritems()]
21359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21360 
 
21361 
  def __eq__(self, other):
21362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21363 
 
21364 
  def __ne__(self, other):
21365 
    return not (self == other)
21366 
 
21367 
class markOrdersAsReversalInitiated_result:
21368 
  """
21369 
  Attributes:
21370 
   - ex
21371 
  """
21372 
 
21373 
  thrift_spec = (
21374 
    None, # 0
21375 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21376 
  )
21377 
 
21378 
  def __init__(self, ex=None,):
21379 
    self.ex = ex
21380 
 
21381 
  def read(self, iprot):
21382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21384 
      return
21385 
    iprot.readStructBegin()
21386 
    while True:
21387 
      (fname, ftype, fid) = iprot.readFieldBegin()
21388 
      if ftype == TType.STOP:
21389 
        break
21390 
      if fid == 1:
21391 
        if ftype == TType.STRUCT:
21392 
          self.ex = TransactionServiceException()
21393 
          self.ex.read(iprot)
21394 
        else:
21395 
          iprot.skip(ftype)
21396 
      else:
21397 
        iprot.skip(ftype)
21398 
      iprot.readFieldEnd()
21399 
    iprot.readStructEnd()
21400 
 
21401 
  def write(self, oprot):
21402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21404 
      return
21405 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
21406 
    if self.ex is not None:
21407 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21408 
      self.ex.write(oprot)
21409 
      oprot.writeFieldEnd()
21410 
    oprot.writeFieldStop()
21411 
    oprot.writeStructEnd()
21412 
 
21413 
  def validate(self):
21414 
    return
21415 
 
21416 
 
21417 
  def __repr__(self):
21418 
    L = ['%s=%r' % (key, value)
21419 
      for key, value in self.__dict__.iteritems()]
21420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21421 
 
21422 
  def __eq__(self, other):
21423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21424 
 
21425 
  def __ne__(self, other):
21426 
    return not (self == other)
21427 
 
21428 
class markOrdersAsNotAvailabke_args:
21429 
  """
21430 
  Attributes:
21431 
   - vendorId
21432 
   - itemId
21433 
   - quantity
21434 
   - estimate
4369 rajveer 21435 
   - isReminder
4303 rajveer 21436 
  """
21437 
 
21438 
  thrift_spec = (
21439 
    None, # 0
21440 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21441 
    (2, TType.I64, 'itemId', None, None, ), # 2
21442 
    (3, TType.I64, 'quantity', None, None, ), # 3
21443 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21444 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21445 
  )
21446 
 
4369 rajveer 21447 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21448 
    self.vendorId = vendorId
21449 
    self.itemId = itemId
21450 
    self.quantity = quantity
21451 
    self.estimate = estimate
4369 rajveer 21452 
    self.isReminder = isReminder
4303 rajveer 21453 
 
21454 
  def read(self, iprot):
21455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21457 
      return
21458 
    iprot.readStructBegin()
21459 
    while True:
21460 
      (fname, ftype, fid) = iprot.readFieldBegin()
21461 
      if ftype == TType.STOP:
21462 
        break
21463 
      if fid == 1:
21464 
        if ftype == TType.I64:
21465 
          self.vendorId = iprot.readI64();
21466 
        else:
21467 
          iprot.skip(ftype)
21468 
      elif fid == 2:
21469 
        if ftype == TType.I64:
21470 
          self.itemId = iprot.readI64();
21471 
        else:
21472 
          iprot.skip(ftype)
21473 
      elif fid == 3:
21474 
        if ftype == TType.I64:
21475 
          self.quantity = iprot.readI64();
21476 
        else:
21477 
          iprot.skip(ftype)
21478 
      elif fid == 4:
21479 
        if ftype == TType.I64:
21480 
          self.estimate = iprot.readI64();
21481 
        else:
21482 
          iprot.skip(ftype)
4369 rajveer 21483 
      elif fid == 5:
21484 
        if ftype == TType.BOOL:
21485 
          self.isReminder = iprot.readBool();
21486 
        else:
21487 
          iprot.skip(ftype)
4303 rajveer 21488 
      else:
21489 
        iprot.skip(ftype)
21490 
      iprot.readFieldEnd()
21491 
    iprot.readStructEnd()
21492 
 
21493 
  def write(self, oprot):
21494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21496 
      return
21497 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
21498 
    if self.vendorId is not None:
21499 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21500 
      oprot.writeI64(self.vendorId)
21501 
      oprot.writeFieldEnd()
21502 
    if self.itemId is not None:
21503 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21504 
      oprot.writeI64(self.itemId)
21505 
      oprot.writeFieldEnd()
21506 
    if self.quantity is not None:
21507 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21508 
      oprot.writeI64(self.quantity)
21509 
      oprot.writeFieldEnd()
21510 
    if self.estimate is not None:
21511 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21512 
      oprot.writeI64(self.estimate)
21513 
      oprot.writeFieldEnd()
4369 rajveer 21514 
    if self.isReminder is not None:
21515 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21516 
      oprot.writeBool(self.isReminder)
21517 
      oprot.writeFieldEnd()
4303 rajveer 21518 
    oprot.writeFieldStop()
21519 
    oprot.writeStructEnd()
21520 
 
21521 
  def validate(self):
21522 
    return
21523 
 
21524 
 
21525 
  def __repr__(self):
21526 
    L = ['%s=%r' % (key, value)
21527 
      for key, value in self.__dict__.iteritems()]
21528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21529 
 
21530 
  def __eq__(self, other):
21531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21532 
 
21533 
  def __ne__(self, other):
21534 
    return not (self == other)
21535 
 
21536 
class markOrdersAsNotAvailabke_result:
21537 
  """
21538 
  Attributes:
21539 
   - ex
21540 
  """
21541 
 
21542 
  thrift_spec = (
21543 
    None, # 0
21544 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21545 
  )
21546 
 
21547 
  def __init__(self, ex=None,):
21548 
    self.ex = ex
21549 
 
21550 
  def read(self, iprot):
21551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21553 
      return
21554 
    iprot.readStructBegin()
21555 
    while True:
21556 
      (fname, ftype, fid) = iprot.readFieldBegin()
21557 
      if ftype == TType.STOP:
21558 
        break
21559 
      if fid == 1:
21560 
        if ftype == TType.STRUCT:
21561 
          self.ex = TransactionServiceException()
21562 
          self.ex.read(iprot)
21563 
        else:
21564 
          iprot.skip(ftype)
21565 
      else:
21566 
        iprot.skip(ftype)
21567 
      iprot.readFieldEnd()
21568 
    iprot.readStructEnd()
21569 
 
21570 
  def write(self, oprot):
21571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21573 
      return
21574 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
21575 
    if self.ex is not None:
21576 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21577 
      self.ex.write(oprot)
21578 
      oprot.writeFieldEnd()
21579 
    oprot.writeFieldStop()
21580 
    oprot.writeStructEnd()
21581 
 
21582 
  def validate(self):
21583 
    return
21584 
 
21585 
 
21586 
  def __repr__(self):
21587 
    L = ['%s=%r' % (key, value)
21588 
      for key, value in self.__dict__.iteritems()]
21589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21590 
 
21591 
  def __eq__(self, other):
21592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21593 
 
21594 
  def __ne__(self, other):
21595 
    return not (self == other)
4369 rajveer 21596 
 
21597 
class markOrdersAsTimeout_args:
21598 
  """
21599 
  Attributes:
21600 
   - vendorId
21601 
  """
21602 
 
21603 
  thrift_spec = (
21604 
    None, # 0
21605 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21606 
  )
21607 
 
21608 
  def __init__(self, vendorId=None,):
21609 
    self.vendorId = vendorId
21610 
 
21611 
  def read(self, iprot):
21612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21614 
      return
21615 
    iprot.readStructBegin()
21616 
    while True:
21617 
      (fname, ftype, fid) = iprot.readFieldBegin()
21618 
      if ftype == TType.STOP:
21619 
        break
21620 
      if fid == 1:
21621 
        if ftype == TType.I64:
21622 
          self.vendorId = iprot.readI64();
21623 
        else:
21624 
          iprot.skip(ftype)
21625 
      else:
21626 
        iprot.skip(ftype)
21627 
      iprot.readFieldEnd()
21628 
    iprot.readStructEnd()
21629 
 
21630 
  def write(self, oprot):
21631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21633 
      return
21634 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
21635 
    if self.vendorId is not None:
21636 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21637 
      oprot.writeI64(self.vendorId)
21638 
      oprot.writeFieldEnd()
21639 
    oprot.writeFieldStop()
21640 
    oprot.writeStructEnd()
21641 
 
21642 
  def validate(self):
21643 
    return
21644 
 
21645 
 
21646 
  def __repr__(self):
21647 
    L = ['%s=%r' % (key, value)
21648 
      for key, value in self.__dict__.iteritems()]
21649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21650 
 
21651 
  def __eq__(self, other):
21652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21653 
 
21654 
  def __ne__(self, other):
21655 
    return not (self == other)
21656 
 
21657 
class markOrdersAsTimeout_result:
21658 
  """
21659 
  Attributes:
21660 
   - success
21661 
   - ex
21662 
  """
21663 
 
21664 
  thrift_spec = (
21665 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
21666 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21667 
  )
21668 
 
21669 
  def __init__(self, success=None, ex=None,):
21670 
    self.success = success
21671 
    self.ex = ex
21672 
 
21673 
  def read(self, iprot):
21674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21676 
      return
21677 
    iprot.readStructBegin()
21678 
    while True:
21679 
      (fname, ftype, fid) = iprot.readFieldBegin()
21680 
      if ftype == TType.STOP:
21681 
        break
21682 
      if fid == 0:
21683 
        if ftype == TType.MAP:
21684 
          self.success = {}
6188 rajveer 21685 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
21686 
          for _i505 in xrange(_size501):
21687 
            _key506 = iprot.readI32();
21688 
            _val507 = TimeoutSummary()
21689 
            _val507.read(iprot)
21690 
            self.success[_key506] = _val507
4369 rajveer 21691 
          iprot.readMapEnd()
21692 
        else:
21693 
          iprot.skip(ftype)
21694 
      elif fid == 1:
21695 
        if ftype == TType.STRUCT:
21696 
          self.ex = TransactionServiceException()
21697 
          self.ex.read(iprot)
21698 
        else:
21699 
          iprot.skip(ftype)
21700 
      else:
21701 
        iprot.skip(ftype)
21702 
      iprot.readFieldEnd()
21703 
    iprot.readStructEnd()
21704 
 
21705 
  def write(self, oprot):
21706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21708 
      return
21709 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
21710 
    if self.success is not None:
21711 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21712 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 21713 
      for kiter508,viter509 in self.success.items():
21714 
        oprot.writeI32(kiter508)
21715 
        viter509.write(oprot)
4369 rajveer 21716 
      oprot.writeMapEnd()
21717 
      oprot.writeFieldEnd()
21718 
    if self.ex is not None:
21719 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21720 
      self.ex.write(oprot)
21721 
      oprot.writeFieldEnd()
21722 
    oprot.writeFieldStop()
21723 
    oprot.writeStructEnd()
21724 
 
21725 
  def validate(self):
21726 
    return
21727 
 
21728 
 
21729 
  def __repr__(self):
21730 
    L = ['%s=%r' % (key, value)
21731 
      for key, value in self.__dict__.iteritems()]
21732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21733 
 
21734 
  def __eq__(self, other):
21735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21736 
 
21737 
  def __ne__(self, other):
21738 
    return not (self == other)
4386 anupam.sin 21739 
 
4662 rajveer 21740 
class markOrderAsLostInTransit_args:
21741 
  """
21742 
  Attributes:
21743 
   - orderId
21744 
  """
21745 
 
21746 
  thrift_spec = (
21747 
    None, # 0
21748 
    (1, TType.I64, 'orderId', None, None, ), # 1
21749 
  )
21750 
 
21751 
  def __init__(self, orderId=None,):
21752 
    self.orderId = orderId
21753 
 
21754 
  def read(self, iprot):
21755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21757 
      return
21758 
    iprot.readStructBegin()
21759 
    while True:
21760 
      (fname, ftype, fid) = iprot.readFieldBegin()
21761 
      if ftype == TType.STOP:
21762 
        break
21763 
      if fid == 1:
21764 
        if ftype == TType.I64:
21765 
          self.orderId = iprot.readI64();
21766 
        else:
21767 
          iprot.skip(ftype)
21768 
      else:
21769 
        iprot.skip(ftype)
21770 
      iprot.readFieldEnd()
21771 
    iprot.readStructEnd()
21772 
 
21773 
  def write(self, oprot):
21774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21776 
      return
21777 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
21778 
    if self.orderId is not None:
21779 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21780 
      oprot.writeI64(self.orderId)
21781 
      oprot.writeFieldEnd()
21782 
    oprot.writeFieldStop()
21783 
    oprot.writeStructEnd()
21784 
 
21785 
  def validate(self):
21786 
    return
21787 
 
21788 
 
21789 
  def __repr__(self):
21790 
    L = ['%s=%r' % (key, value)
21791 
      for key, value in self.__dict__.iteritems()]
21792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21793 
 
21794 
  def __eq__(self, other):
21795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21796 
 
21797 
  def __ne__(self, other):
21798 
    return not (self == other)
21799 
 
21800 
class markOrderAsLostInTransit_result:
21801 
  """
21802 
  Attributes:
21803 
   - success
21804 
   - ex
21805 
  """
21806 
 
21807 
  thrift_spec = (
21808 
    (0, TType.BOOL, 'success', None, None, ), # 0
21809 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21810 
  )
21811 
 
21812 
  def __init__(self, success=None, ex=None,):
21813 
    self.success = success
21814 
    self.ex = ex
21815 
 
21816 
  def read(self, iprot):
21817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21819 
      return
21820 
    iprot.readStructBegin()
21821 
    while True:
21822 
      (fname, ftype, fid) = iprot.readFieldBegin()
21823 
      if ftype == TType.STOP:
21824 
        break
21825 
      if fid == 0:
21826 
        if ftype == TType.BOOL:
21827 
          self.success = iprot.readBool();
21828 
        else:
21829 
          iprot.skip(ftype)
21830 
      elif fid == 1:
21831 
        if ftype == TType.STRUCT:
21832 
          self.ex = TransactionServiceException()
21833 
          self.ex.read(iprot)
21834 
        else:
21835 
          iprot.skip(ftype)
21836 
      else:
21837 
        iprot.skip(ftype)
21838 
      iprot.readFieldEnd()
21839 
    iprot.readStructEnd()
21840 
 
21841 
  def write(self, oprot):
21842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21844 
      return
21845 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
21846 
    if self.success is not None:
21847 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21848 
      oprot.writeBool(self.success)
21849 
      oprot.writeFieldEnd()
21850 
    if self.ex is not None:
21851 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21852 
      self.ex.write(oprot)
21853 
      oprot.writeFieldEnd()
21854 
    oprot.writeFieldStop()
21855 
    oprot.writeStructEnd()
21856 
 
21857 
  def validate(self):
21858 
    return
21859 
 
21860 
 
21861 
  def __repr__(self):
21862 
    L = ['%s=%r' % (key, value)
21863 
      for key, value in self.__dict__.iteritems()]
21864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21865 
 
21866 
  def __eq__(self, other):
21867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21868 
 
21869 
  def __ne__(self, other):
21870 
    return not (self == other)
21871 
 
4386 anupam.sin 21872 
class getOrderForAwb_args:
21873 
  """
21874 
  Attributes:
21875 
   - awb
21876 
  """
21877 
 
21878 
  thrift_spec = (
21879 
    None, # 0
21880 
    (1, TType.STRING, 'awb', None, None, ), # 1
21881 
  )
21882 
 
21883 
  def __init__(self, awb=None,):
21884 
    self.awb = awb
21885 
 
21886 
  def read(self, iprot):
21887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21889 
      return
21890 
    iprot.readStructBegin()
21891 
    while True:
21892 
      (fname, ftype, fid) = iprot.readFieldBegin()
21893 
      if ftype == TType.STOP:
21894 
        break
21895 
      if fid == 1:
21896 
        if ftype == TType.STRING:
21897 
          self.awb = iprot.readString();
21898 
        else:
21899 
          iprot.skip(ftype)
21900 
      else:
21901 
        iprot.skip(ftype)
21902 
      iprot.readFieldEnd()
21903 
    iprot.readStructEnd()
21904 
 
21905 
  def write(self, oprot):
21906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21908 
      return
21909 
    oprot.writeStructBegin('getOrderForAwb_args')
21910 
    if self.awb is not None:
21911 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
21912 
      oprot.writeString(self.awb)
21913 
      oprot.writeFieldEnd()
21914 
    oprot.writeFieldStop()
21915 
    oprot.writeStructEnd()
21916 
 
21917 
  def validate(self):
21918 
    return
21919 
 
21920 
 
21921 
  def __repr__(self):
21922 
    L = ['%s=%r' % (key, value)
21923 
      for key, value in self.__dict__.iteritems()]
21924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21925 
 
21926 
  def __eq__(self, other):
21927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21928 
 
21929 
  def __ne__(self, other):
21930 
    return not (self == other)
21931 
 
21932 
class getOrderForAwb_result:
21933 
  """
21934 
  Attributes:
21935 
   - success
21936 
   - ex
21937 
  """
21938 
 
21939 
  thrift_spec = (
21940 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
21941 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21942 
  )
21943 
 
21944 
  def __init__(self, success=None, ex=None,):
21945 
    self.success = success
21946 
    self.ex = ex
21947 
 
21948 
  def read(self, iprot):
21949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21951 
      return
21952 
    iprot.readStructBegin()
21953 
    while True:
21954 
      (fname, ftype, fid) = iprot.readFieldBegin()
21955 
      if ftype == TType.STOP:
21956 
        break
21957 
      if fid == 0:
21958 
        if ftype == TType.STRUCT:
21959 
          self.success = Order()
21960 
          self.success.read(iprot)
21961 
        else:
21962 
          iprot.skip(ftype)
21963 
      elif fid == 1:
21964 
        if ftype == TType.STRUCT:
21965 
          self.ex = TransactionServiceException()
21966 
          self.ex.read(iprot)
21967 
        else:
21968 
          iprot.skip(ftype)
21969 
      else:
21970 
        iprot.skip(ftype)
21971 
      iprot.readFieldEnd()
21972 
    iprot.readStructEnd()
21973 
 
21974 
  def write(self, oprot):
21975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21977 
      return
21978 
    oprot.writeStructBegin('getOrderForAwb_result')
21979 
    if self.success is not None:
21980 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
21981 
      self.success.write(oprot)
21982 
      oprot.writeFieldEnd()
21983 
    if self.ex is not None:
21984 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21985 
      self.ex.write(oprot)
21986 
      oprot.writeFieldEnd()
21987 
    oprot.writeFieldStop()
21988 
    oprot.writeStructEnd()
21989 
 
21990 
  def validate(self):
21991 
    return
21992 
 
21993 
 
21994 
  def __repr__(self):
21995 
    L = ['%s=%r' % (key, value)
21996 
      for key, value in self.__dict__.iteritems()]
21997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21998 
 
21999 
  def __eq__(self, other):
22000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22001 
 
22002 
  def __ne__(self, other):
22003 
    return not (self == other)
4506 phani.kuma 22004 
 
22005 
class getOrdersForProviderForStatus_args:
22006 
  """
22007 
  Attributes:
22008 
   - logistics_provider_id
4910 phani.kuma 22009 
   - order_status_list
4506 phani.kuma 22010 
  """
22011 
 
22012 
  thrift_spec = (
22013 
    None, # 0
22014 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 22015 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 22016 
  )
22017 
 
4910 phani.kuma 22018 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 22019 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 22020 
    self.order_status_list = order_status_list
4506 phani.kuma 22021 
 
22022 
  def read(self, iprot):
22023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22025 
      return
22026 
    iprot.readStructBegin()
22027 
    while True:
22028 
      (fname, ftype, fid) = iprot.readFieldBegin()
22029 
      if ftype == TType.STOP:
22030 
        break
22031 
      if fid == 1:
22032 
        if ftype == TType.I64:
22033 
          self.logistics_provider_id = iprot.readI64();
22034 
        else:
22035 
          iprot.skip(ftype)
22036 
      elif fid == 2:
4910 phani.kuma 22037 
        if ftype == TType.LIST:
22038 
          self.order_status_list = []
6188 rajveer 22039 
          (_etype513, _size510) = iprot.readListBegin()
22040 
          for _i514 in xrange(_size510):
22041 
            _elem515 = iprot.readI32();
22042 
            self.order_status_list.append(_elem515)
4910 phani.kuma 22043 
          iprot.readListEnd()
4506 phani.kuma 22044 
        else:
22045 
          iprot.skip(ftype)
22046 
      else:
22047 
        iprot.skip(ftype)
22048 
      iprot.readFieldEnd()
22049 
    iprot.readStructEnd()
22050 
 
22051 
  def write(self, oprot):
22052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22054 
      return
22055 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
22056 
    if self.logistics_provider_id is not None:
22057 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
22058 
      oprot.writeI64(self.logistics_provider_id)
22059 
      oprot.writeFieldEnd()
4910 phani.kuma 22060 
    if self.order_status_list is not None:
22061 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
22062 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 22063 
      for iter516 in self.order_status_list:
22064 
        oprot.writeI32(iter516)
4910 phani.kuma 22065 
      oprot.writeListEnd()
4506 phani.kuma 22066 
      oprot.writeFieldEnd()
22067 
    oprot.writeFieldStop()
22068 
    oprot.writeStructEnd()
22069 
 
22070 
  def validate(self):
22071 
    return
22072 
 
22073 
 
22074 
  def __repr__(self):
22075 
    L = ['%s=%r' % (key, value)
22076 
      for key, value in self.__dict__.iteritems()]
22077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22078 
 
22079 
  def __eq__(self, other):
22080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22081 
 
22082 
  def __ne__(self, other):
22083 
    return not (self == other)
22084 
 
22085 
class getOrdersForProviderForStatus_result:
22086 
  """
22087 
  Attributes:
22088 
   - success
22089 
   - ex
22090 
  """
22091 
 
22092 
  thrift_spec = (
22093 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22094 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22095 
  )
22096 
 
22097 
  def __init__(self, success=None, ex=None,):
22098 
    self.success = success
22099 
    self.ex = ex
22100 
 
22101 
  def read(self, iprot):
22102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22104 
      return
22105 
    iprot.readStructBegin()
22106 
    while True:
22107 
      (fname, ftype, fid) = iprot.readFieldBegin()
22108 
      if ftype == TType.STOP:
22109 
        break
22110 
      if fid == 0:
22111 
        if ftype == TType.LIST:
22112 
          self.success = []
6188 rajveer 22113 
          (_etype520, _size517) = iprot.readListBegin()
22114 
          for _i521 in xrange(_size517):
22115 
            _elem522 = Order()
22116 
            _elem522.read(iprot)
22117 
            self.success.append(_elem522)
4506 phani.kuma 22118 
          iprot.readListEnd()
22119 
        else:
22120 
          iprot.skip(ftype)
22121 
      elif fid == 1:
22122 
        if ftype == TType.STRUCT:
22123 
          self.ex = TransactionServiceException()
22124 
          self.ex.read(iprot)
22125 
        else:
22126 
          iprot.skip(ftype)
22127 
      else:
22128 
        iprot.skip(ftype)
22129 
      iprot.readFieldEnd()
22130 
    iprot.readStructEnd()
22131 
 
22132 
  def write(self, oprot):
22133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22135 
      return
22136 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
22137 
    if self.success is not None:
22138 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22139 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22140 
      for iter523 in self.success:
22141 
        iter523.write(oprot)
4506 phani.kuma 22142 
      oprot.writeListEnd()
22143 
      oprot.writeFieldEnd()
22144 
    if self.ex is not None:
22145 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22146 
      self.ex.write(oprot)
22147 
      oprot.writeFieldEnd()
22148 
    oprot.writeFieldStop()
22149 
    oprot.writeStructEnd()
22150 
 
22151 
  def validate(self):
22152 
    return
22153 
 
22154 
 
22155 
  def __repr__(self):
22156 
    L = ['%s=%r' % (key, value)
22157 
      for key, value in self.__dict__.iteritems()]
22158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22159 
 
22160 
  def __eq__(self, other):
22161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22162 
 
22163 
  def __ne__(self, other):
22164 
    return not (self == other)
4600 varun.gupt 22165 
 
22166 
class getBilledOrdersForVendor_args:
22167 
  """
22168 
  Attributes:
22169 
   - vendorId
22170 
   - billingDateFrom
22171 
   - billingDateTo
22172 
  """
22173 
 
22174 
  thrift_spec = (
22175 
    None, # 0
22176 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22177 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
22178 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
22179 
  )
22180 
 
22181 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
22182 
    self.vendorId = vendorId
22183 
    self.billingDateFrom = billingDateFrom
22184 
    self.billingDateTo = billingDateTo
22185 
 
22186 
  def read(self, iprot):
22187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22189 
      return
22190 
    iprot.readStructBegin()
22191 
    while True:
22192 
      (fname, ftype, fid) = iprot.readFieldBegin()
22193 
      if ftype == TType.STOP:
22194 
        break
22195 
      if fid == 1:
22196 
        if ftype == TType.I64:
22197 
          self.vendorId = iprot.readI64();
22198 
        else:
22199 
          iprot.skip(ftype)
22200 
      elif fid == 2:
22201 
        if ftype == TType.I64:
22202 
          self.billingDateFrom = iprot.readI64();
22203 
        else:
22204 
          iprot.skip(ftype)
22205 
      elif fid == 3:
22206 
        if ftype == TType.I64:
22207 
          self.billingDateTo = iprot.readI64();
22208 
        else:
22209 
          iprot.skip(ftype)
22210 
      else:
22211 
        iprot.skip(ftype)
22212 
      iprot.readFieldEnd()
22213 
    iprot.readStructEnd()
22214 
 
22215 
  def write(self, oprot):
22216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22218 
      return
22219 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
22220 
    if self.vendorId is not None:
22221 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22222 
      oprot.writeI64(self.vendorId)
22223 
      oprot.writeFieldEnd()
22224 
    if self.billingDateFrom is not None:
22225 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
22226 
      oprot.writeI64(self.billingDateFrom)
22227 
      oprot.writeFieldEnd()
22228 
    if self.billingDateTo is not None:
22229 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
22230 
      oprot.writeI64(self.billingDateTo)
22231 
      oprot.writeFieldEnd()
22232 
    oprot.writeFieldStop()
22233 
    oprot.writeStructEnd()
22234 
 
22235 
  def validate(self):
22236 
    return
22237 
 
22238 
 
22239 
  def __repr__(self):
22240 
    L = ['%s=%r' % (key, value)
22241 
      for key, value in self.__dict__.iteritems()]
22242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22243 
 
22244 
  def __eq__(self, other):
22245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22246 
 
22247 
  def __ne__(self, other):
22248 
    return not (self == other)
22249 
 
22250 
class getBilledOrdersForVendor_result:
22251 
  """
22252 
  Attributes:
22253 
   - success
22254 
   - ex
22255 
  """
22256 
 
22257 
  thrift_spec = (
22258 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22259 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22260 
  )
22261 
 
22262 
  def __init__(self, success=None, ex=None,):
22263 
    self.success = success
22264 
    self.ex = ex
22265 
 
22266 
  def read(self, iprot):
22267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22269 
      return
22270 
    iprot.readStructBegin()
22271 
    while True:
22272 
      (fname, ftype, fid) = iprot.readFieldBegin()
22273 
      if ftype == TType.STOP:
22274 
        break
22275 
      if fid == 0:
22276 
        if ftype == TType.LIST:
22277 
          self.success = []
6188 rajveer 22278 
          (_etype527, _size524) = iprot.readListBegin()
22279 
          for _i528 in xrange(_size524):
22280 
            _elem529 = Order()
22281 
            _elem529.read(iprot)
22282 
            self.success.append(_elem529)
4600 varun.gupt 22283 
          iprot.readListEnd()
22284 
        else:
22285 
          iprot.skip(ftype)
22286 
      elif fid == 1:
22287 
        if ftype == TType.STRUCT:
22288 
          self.ex = TransactionServiceException()
22289 
          self.ex.read(iprot)
22290 
        else:
22291 
          iprot.skip(ftype)
22292 
      else:
22293 
        iprot.skip(ftype)
22294 
      iprot.readFieldEnd()
22295 
    iprot.readStructEnd()
22296 
 
22297 
  def write(self, oprot):
22298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22300 
      return
22301 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
22302 
    if self.success is not None:
22303 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22304 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22305 
      for iter530 in self.success:
22306 
        iter530.write(oprot)
4600 varun.gupt 22307 
      oprot.writeListEnd()
22308 
      oprot.writeFieldEnd()
22309 
    if self.ex is not None:
22310 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22311 
      self.ex.write(oprot)
22312 
      oprot.writeFieldEnd()
22313 
    oprot.writeFieldStop()
22314 
    oprot.writeStructEnd()
22315 
 
22316 
  def validate(self):
22317 
    return
22318 
 
22319 
 
22320 
  def __repr__(self):
22321 
    L = ['%s=%r' % (key, value)
22322 
      for key, value in self.__dict__.iteritems()]
22323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22324 
 
22325 
  def __eq__(self, other):
22326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22327 
 
22328 
  def __ne__(self, other):
22329 
    return not (self == other)
22330 
 
4607 rajveer 22331 
class getSlippedSippingDateOrders_args:
22332 
 
22333 
  thrift_spec = (
22334 
  )
22335 
 
22336 
  def read(self, iprot):
22337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22339 
      return
22340 
    iprot.readStructBegin()
22341 
    while True:
22342 
      (fname, ftype, fid) = iprot.readFieldBegin()
22343 
      if ftype == TType.STOP:
22344 
        break
22345 
      else:
22346 
        iprot.skip(ftype)
22347 
      iprot.readFieldEnd()
22348 
    iprot.readStructEnd()
22349 
 
22350 
  def write(self, oprot):
22351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22353 
      return
22354 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
22355 
    oprot.writeFieldStop()
22356 
    oprot.writeStructEnd()
22357 
 
22358 
  def validate(self):
22359 
    return
22360 
 
22361 
 
22362 
  def __repr__(self):
22363 
    L = ['%s=%r' % (key, value)
22364 
      for key, value in self.__dict__.iteritems()]
22365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22366 
 
22367 
  def __eq__(self, other):
22368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22369 
 
22370 
  def __ne__(self, other):
22371 
    return not (self == other)
22372 
 
22373 
class getSlippedSippingDateOrders_result:
22374 
  """
22375 
  Attributes:
22376 
   - success
22377 
   - ex
22378 
  """
22379 
 
22380 
  thrift_spec = (
22381 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22382 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22383 
  )
22384 
 
22385 
  def __init__(self, success=None, ex=None,):
22386 
    self.success = success
22387 
    self.ex = ex
22388 
 
22389 
  def read(self, iprot):
22390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22392 
      return
22393 
    iprot.readStructBegin()
22394 
    while True:
22395 
      (fname, ftype, fid) = iprot.readFieldBegin()
22396 
      if ftype == TType.STOP:
22397 
        break
22398 
      if fid == 0:
22399 
        if ftype == TType.LIST:
22400 
          self.success = []
6188 rajveer 22401 
          (_etype534, _size531) = iprot.readListBegin()
22402 
          for _i535 in xrange(_size531):
22403 
            _elem536 = Order()
22404 
            _elem536.read(iprot)
22405 
            self.success.append(_elem536)
4607 rajveer 22406 
          iprot.readListEnd()
22407 
        else:
22408 
          iprot.skip(ftype)
22409 
      elif fid == 1:
22410 
        if ftype == TType.STRUCT:
22411 
          self.ex = TransactionServiceException()
22412 
          self.ex.read(iprot)
22413 
        else:
22414 
          iprot.skip(ftype)
22415 
      else:
22416 
        iprot.skip(ftype)
22417 
      iprot.readFieldEnd()
22418 
    iprot.readStructEnd()
22419 
 
22420 
  def write(self, oprot):
22421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22423 
      return
22424 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22425 
    if self.success is not None:
22426 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22427 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22428 
      for iter537 in self.success:
22429 
        iter537.write(oprot)
4607 rajveer 22430 
      oprot.writeListEnd()
22431 
      oprot.writeFieldEnd()
22432 
    if self.ex is not None:
22433 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22434 
      self.ex.write(oprot)
22435 
      oprot.writeFieldEnd()
22436 
    oprot.writeFieldStop()
22437 
    oprot.writeStructEnd()
22438 
 
22439 
  def validate(self):
22440 
    return
22441 
 
22442 
 
22443 
  def __repr__(self):
22444 
    L = ['%s=%r' % (key, value)
22445 
      for key, value in self.__dict__.iteritems()]
22446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22447 
 
22448 
  def __eq__(self, other):
22449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22450 
 
22451 
  def __ne__(self, other):
22452 
    return not (self == other)
22453 
 
4709 rajveer 22454 
class getCancelledOrders_args:
22455 
  """
22456 
  Attributes:
22457 
   - cancelDateFrom
22458 
   - cancelDateTo
22459 
  """
22460 
 
22461 
  thrift_spec = (
22462 
    None, # 0
22463 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
22464 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
22465 
  )
22466 
 
22467 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
22468 
    self.cancelDateFrom = cancelDateFrom
22469 
    self.cancelDateTo = cancelDateTo
22470 
 
22471 
  def read(self, iprot):
22472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22474 
      return
22475 
    iprot.readStructBegin()
22476 
    while True:
22477 
      (fname, ftype, fid) = iprot.readFieldBegin()
22478 
      if ftype == TType.STOP:
22479 
        break
22480 
      if fid == 1:
22481 
        if ftype == TType.I64:
22482 
          self.cancelDateFrom = iprot.readI64();
22483 
        else:
22484 
          iprot.skip(ftype)
22485 
      elif fid == 2:
22486 
        if ftype == TType.I64:
22487 
          self.cancelDateTo = iprot.readI64();
22488 
        else:
22489 
          iprot.skip(ftype)
22490 
      else:
22491 
        iprot.skip(ftype)
22492 
      iprot.readFieldEnd()
22493 
    iprot.readStructEnd()
22494 
 
22495 
  def write(self, oprot):
22496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22498 
      return
22499 
    oprot.writeStructBegin('getCancelledOrders_args')
22500 
    if self.cancelDateFrom is not None:
22501 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
22502 
      oprot.writeI64(self.cancelDateFrom)
22503 
      oprot.writeFieldEnd()
22504 
    if self.cancelDateTo is not None:
22505 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
22506 
      oprot.writeI64(self.cancelDateTo)
22507 
      oprot.writeFieldEnd()
22508 
    oprot.writeFieldStop()
22509 
    oprot.writeStructEnd()
22510 
 
22511 
  def validate(self):
22512 
    return
22513 
 
22514 
 
22515 
  def __repr__(self):
22516 
    L = ['%s=%r' % (key, value)
22517 
      for key, value in self.__dict__.iteritems()]
22518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22519 
 
22520 
  def __eq__(self, other):
22521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22522 
 
22523 
  def __ne__(self, other):
22524 
    return not (self == other)
22525 
 
22526 
class getCancelledOrders_result:
22527 
  """
22528 
  Attributes:
22529 
   - success
22530 
   - ex
22531 
  """
22532 
 
22533 
  thrift_spec = (
22534 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22535 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22536 
  )
22537 
 
22538 
  def __init__(self, success=None, ex=None,):
22539 
    self.success = success
22540 
    self.ex = ex
22541 
 
22542 
  def read(self, iprot):
22543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22545 
      return
22546 
    iprot.readStructBegin()
22547 
    while True:
22548 
      (fname, ftype, fid) = iprot.readFieldBegin()
22549 
      if ftype == TType.STOP:
22550 
        break
22551 
      if fid == 0:
22552 
        if ftype == TType.LIST:
22553 
          self.success = []
6188 rajveer 22554 
          (_etype541, _size538) = iprot.readListBegin()
22555 
          for _i542 in xrange(_size538):
22556 
            _elem543 = Order()
22557 
            _elem543.read(iprot)
22558 
            self.success.append(_elem543)
4709 rajveer 22559 
          iprot.readListEnd()
22560 
        else:
22561 
          iprot.skip(ftype)
22562 
      elif fid == 1:
22563 
        if ftype == TType.STRUCT:
22564 
          self.ex = TransactionServiceException()
22565 
          self.ex.read(iprot)
22566 
        else:
22567 
          iprot.skip(ftype)
22568 
      else:
22569 
        iprot.skip(ftype)
22570 
      iprot.readFieldEnd()
22571 
    iprot.readStructEnd()
22572 
 
22573 
  def write(self, oprot):
22574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22576 
      return
22577 
    oprot.writeStructBegin('getCancelledOrders_result')
22578 
    if self.success is not None:
22579 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22580 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22581 
      for iter544 in self.success:
22582 
        iter544.write(oprot)
4709 rajveer 22583 
      oprot.writeListEnd()
22584 
      oprot.writeFieldEnd()
22585 
    if self.ex is not None:
22586 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22587 
      self.ex.write(oprot)
22588 
      oprot.writeFieldEnd()
22589 
    oprot.writeFieldStop()
22590 
    oprot.writeStructEnd()
22591 
 
22592 
  def validate(self):
22593 
    return
22594 
 
22595 
 
22596 
  def __repr__(self):
22597 
    L = ['%s=%r' % (key, value)
22598 
      for key, value in self.__dict__.iteritems()]
22599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22600 
 
22601 
  def __eq__(self, other):
22602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22603 
 
22604 
  def __ne__(self, other):
22605 
    return not (self == other)
22606 
 
4600 varun.gupt 22607 
class saveBluedartSettlements_args:
22608 
  """
22609 
  Attributes:
22610 
   - mapAWBAndAmount
22611 
  """
22612 
 
22613 
  thrift_spec = (
22614 
    None, # 0
22615 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
22616 
  )
22617 
 
22618 
  def __init__(self, mapAWBAndAmount=None,):
22619 
    self.mapAWBAndAmount = mapAWBAndAmount
22620 
 
22621 
  def read(self, iprot):
22622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22624 
      return
22625 
    iprot.readStructBegin()
22626 
    while True:
22627 
      (fname, ftype, fid) = iprot.readFieldBegin()
22628 
      if ftype == TType.STOP:
22629 
        break
22630 
      if fid == 1:
22631 
        if ftype == TType.MAP:
22632 
          self.mapAWBAndAmount = {}
6188 rajveer 22633 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
22634 
          for _i549 in xrange(_size545):
22635 
            _key550 = iprot.readI64();
22636 
            _val551 = iprot.readDouble();
22637 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 22638 
          iprot.readMapEnd()
22639 
        else:
22640 
          iprot.skip(ftype)
22641 
      else:
22642 
        iprot.skip(ftype)
22643 
      iprot.readFieldEnd()
22644 
    iprot.readStructEnd()
22645 
 
22646 
  def write(self, oprot):
22647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22649 
      return
22650 
    oprot.writeStructBegin('saveBluedartSettlements_args')
22651 
    if self.mapAWBAndAmount is not None:
22652 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
22653 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 22654 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
22655 
        oprot.writeI64(kiter552)
22656 
        oprot.writeDouble(viter553)
4600 varun.gupt 22657 
      oprot.writeMapEnd()
22658 
      oprot.writeFieldEnd()
22659 
    oprot.writeFieldStop()
22660 
    oprot.writeStructEnd()
22661 
 
22662 
  def validate(self):
22663 
    return
22664 
 
22665 
 
22666 
  def __repr__(self):
22667 
    L = ['%s=%r' % (key, value)
22668 
      for key, value in self.__dict__.iteritems()]
22669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22670 
 
22671 
  def __eq__(self, other):
22672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22673 
 
22674 
  def __ne__(self, other):
22675 
    return not (self == other)
22676 
 
22677 
class saveBluedartSettlements_result:
22678 
  """
22679 
  Attributes:
22680 
   - ex
22681 
  """
22682 
 
22683 
  thrift_spec = (
22684 
    None, # 0
22685 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22686 
  )
22687 
 
22688 
  def __init__(self, ex=None,):
22689 
    self.ex = ex
22690 
 
22691 
  def read(self, iprot):
22692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22694 
      return
22695 
    iprot.readStructBegin()
22696 
    while True:
22697 
      (fname, ftype, fid) = iprot.readFieldBegin()
22698 
      if ftype == TType.STOP:
22699 
        break
22700 
      if fid == 1:
22701 
        if ftype == TType.STRUCT:
22702 
          self.ex = TransactionServiceException()
22703 
          self.ex.read(iprot)
22704 
        else:
22705 
          iprot.skip(ftype)
22706 
      else:
22707 
        iprot.skip(ftype)
22708 
      iprot.readFieldEnd()
22709 
    iprot.readStructEnd()
22710 
 
22711 
  def write(self, oprot):
22712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22714 
      return
22715 
    oprot.writeStructBegin('saveBluedartSettlements_result')
22716 
    if self.ex is not None:
22717 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22718 
      self.ex.write(oprot)
22719 
      oprot.writeFieldEnd()
22720 
    oprot.writeFieldStop()
22721 
    oprot.writeStructEnd()
22722 
 
22723 
  def validate(self):
22724 
    return
22725 
 
22726 
 
22727 
  def __repr__(self):
22728 
    L = ['%s=%r' % (key, value)
22729 
      for key, value in self.__dict__.iteritems()]
22730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22731 
 
22732 
  def __eq__(self, other):
22733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22734 
 
22735 
  def __ne__(self, other):
22736 
    return not (self == other)
22737 
 
22738 
class savePaymentSettlements_args:
22739 
  """
22740 
  Attributes:
22741 
   - settlementDate
22742 
   - paymentGatewayId
4905 varun.gupt 22743 
   - referenceId
4600 varun.gupt 22744 
   - serviceTax
22745 
   - otherCharges
22746 
   - netCollection
22747 
  """
22748 
 
22749 
  thrift_spec = (
22750 
    None, # 0
22751 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
22752 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 22753 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 22754 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
22755 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
22756 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
22757 
  )
22758 
 
4905 varun.gupt 22759 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 22760 
    self.settlementDate = settlementDate
22761 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 22762 
    self.referenceId = referenceId
4600 varun.gupt 22763 
    self.serviceTax = serviceTax
22764 
    self.otherCharges = otherCharges
22765 
    self.netCollection = netCollection
22766 
 
22767 
  def read(self, iprot):
22768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22770 
      return
22771 
    iprot.readStructBegin()
22772 
    while True:
22773 
      (fname, ftype, fid) = iprot.readFieldBegin()
22774 
      if ftype == TType.STOP:
22775 
        break
22776 
      if fid == 1:
22777 
        if ftype == TType.I64:
22778 
          self.settlementDate = iprot.readI64();
22779 
        else:
22780 
          iprot.skip(ftype)
22781 
      elif fid == 2:
22782 
        if ftype == TType.I64:
22783 
          self.paymentGatewayId = iprot.readI64();
22784 
        else:
22785 
          iprot.skip(ftype)
22786 
      elif fid == 3:
22787 
        if ftype == TType.I64:
4905 varun.gupt 22788 
          self.referenceId = iprot.readI64();
4600 varun.gupt 22789 
        else:
22790 
          iprot.skip(ftype)
22791 
      elif fid == 4:
22792 
        if ftype == TType.DOUBLE:
22793 
          self.serviceTax = iprot.readDouble();
22794 
        else:
22795 
          iprot.skip(ftype)
22796 
      elif fid == 5:
22797 
        if ftype == TType.DOUBLE:
22798 
          self.otherCharges = iprot.readDouble();
22799 
        else:
22800 
          iprot.skip(ftype)
22801 
      elif fid == 6:
22802 
        if ftype == TType.DOUBLE:
22803 
          self.netCollection = iprot.readDouble();
22804 
        else:
22805 
          iprot.skip(ftype)
22806 
      else:
22807 
        iprot.skip(ftype)
22808 
      iprot.readFieldEnd()
22809 
    iprot.readStructEnd()
22810 
 
22811 
  def write(self, oprot):
22812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22814 
      return
22815 
    oprot.writeStructBegin('savePaymentSettlements_args')
22816 
    if self.settlementDate is not None:
22817 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
22818 
      oprot.writeI64(self.settlementDate)
22819 
      oprot.writeFieldEnd()
22820 
    if self.paymentGatewayId is not None:
22821 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
22822 
      oprot.writeI64(self.paymentGatewayId)
22823 
      oprot.writeFieldEnd()
4905 varun.gupt 22824 
    if self.referenceId is not None:
22825 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
22826 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 22827 
      oprot.writeFieldEnd()
22828 
    if self.serviceTax is not None:
22829 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
22830 
      oprot.writeDouble(self.serviceTax)
22831 
      oprot.writeFieldEnd()
22832 
    if self.otherCharges is not None:
22833 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
22834 
      oprot.writeDouble(self.otherCharges)
22835 
      oprot.writeFieldEnd()
22836 
    if self.netCollection is not None:
22837 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
22838 
      oprot.writeDouble(self.netCollection)
22839 
      oprot.writeFieldEnd()
22840 
    oprot.writeFieldStop()
22841 
    oprot.writeStructEnd()
22842 
 
22843 
  def validate(self):
22844 
    return
22845 
 
22846 
 
22847 
  def __repr__(self):
22848 
    L = ['%s=%r' % (key, value)
22849 
      for key, value in self.__dict__.iteritems()]
22850 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22851 
 
22852 
  def __eq__(self, other):
22853 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22854 
 
22855 
  def __ne__(self, other):
22856 
    return not (self == other)
22857 
 
22858 
class savePaymentSettlements_result:
22859 
  """
22860 
  Attributes:
22861 
   - ex
22862 
  """
22863 
 
22864 
  thrift_spec = (
22865 
    None, # 0
22866 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22867 
  )
22868 
 
22869 
  def __init__(self, ex=None,):
22870 
    self.ex = ex
22871 
 
22872 
  def read(self, iprot):
22873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22875 
      return
22876 
    iprot.readStructBegin()
22877 
    while True:
22878 
      (fname, ftype, fid) = iprot.readFieldBegin()
22879 
      if ftype == TType.STOP:
22880 
        break
22881 
      if fid == 1:
22882 
        if ftype == TType.STRUCT:
22883 
          self.ex = TransactionServiceException()
22884 
          self.ex.read(iprot)
22885 
        else:
22886 
          iprot.skip(ftype)
22887 
      else:
22888 
        iprot.skip(ftype)
22889 
      iprot.readFieldEnd()
22890 
    iprot.readStructEnd()
22891 
 
22892 
  def write(self, oprot):
22893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22895 
      return
22896 
    oprot.writeStructBegin('savePaymentSettlements_result')
22897 
    if self.ex is not None:
22898 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22899 
      self.ex.write(oprot)
22900 
      oprot.writeFieldEnd()
22901 
    oprot.writeFieldStop()
22902 
    oprot.writeStructEnd()
22903 
 
22904 
  def validate(self):
22905 
    return
22906 
 
22907 
 
22908 
  def __repr__(self):
22909 
    L = ['%s=%r' % (key, value)
22910 
      for key, value in self.__dict__.iteritems()]
22911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22912 
 
22913 
  def __eq__(self, other):
22914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22915 
 
22916 
  def __ne__(self, other):
22917 
    return not (self == other)
22918 
 
22919 
class saveEBSSettlementSummary_args:
22920 
  """
22921 
  Attributes:
22922 
   - settlementId
22923 
   - settlementDate
22924 
   - transactionDateFrom
22925 
   - transactionDateTo
22926 
   - amount
22927 
  """
22928 
 
22929 
  thrift_spec = (
22930 
    None, # 0
22931 
    (1, TType.I64, 'settlementId', None, None, ), # 1
22932 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
22933 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
22934 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
22935 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
22936 
  )
22937 
 
22938 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
22939 
    self.settlementId = settlementId
22940 
    self.settlementDate = settlementDate
22941 
    self.transactionDateFrom = transactionDateFrom
22942 
    self.transactionDateTo = transactionDateTo
22943 
    self.amount = amount
22944 
 
22945 
  def read(self, iprot):
22946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22948 
      return
22949 
    iprot.readStructBegin()
22950 
    while True:
22951 
      (fname, ftype, fid) = iprot.readFieldBegin()
22952 
      if ftype == TType.STOP:
22953 
        break
22954 
      if fid == 1:
22955 
        if ftype == TType.I64:
22956 
          self.settlementId = iprot.readI64();
22957 
        else:
22958 
          iprot.skip(ftype)
22959 
      elif fid == 2:
22960 
        if ftype == TType.I64:
22961 
          self.settlementDate = iprot.readI64();
22962 
        else:
22963 
          iprot.skip(ftype)
22964 
      elif fid == 3:
22965 
        if ftype == TType.I64:
22966 
          self.transactionDateFrom = iprot.readI64();
22967 
        else:
22968 
          iprot.skip(ftype)
22969 
      elif fid == 4:
22970 
        if ftype == TType.I64:
22971 
          self.transactionDateTo = iprot.readI64();
22972 
        else:
22973 
          iprot.skip(ftype)
22974 
      elif fid == 5:
22975 
        if ftype == TType.DOUBLE:
22976 
          self.amount = iprot.readDouble();
22977 
        else:
22978 
          iprot.skip(ftype)
22979 
      else:
22980 
        iprot.skip(ftype)
22981 
      iprot.readFieldEnd()
22982 
    iprot.readStructEnd()
22983 
 
22984 
  def write(self, oprot):
22985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22987 
      return
22988 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
22989 
    if self.settlementId is not None:
22990 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
22991 
      oprot.writeI64(self.settlementId)
22992 
      oprot.writeFieldEnd()
22993 
    if self.settlementDate is not None:
22994 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
22995 
      oprot.writeI64(self.settlementDate)
22996 
      oprot.writeFieldEnd()
22997 
    if self.transactionDateFrom is not None:
22998 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
22999 
      oprot.writeI64(self.transactionDateFrom)
23000 
      oprot.writeFieldEnd()
23001 
    if self.transactionDateTo is not None:
23002 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
23003 
      oprot.writeI64(self.transactionDateTo)
23004 
      oprot.writeFieldEnd()
23005 
    if self.amount is not None:
23006 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
23007 
      oprot.writeDouble(self.amount)
23008 
      oprot.writeFieldEnd()
23009 
    oprot.writeFieldStop()
23010 
    oprot.writeStructEnd()
23011 
 
23012 
  def validate(self):
23013 
    return
23014 
 
23015 
 
23016 
  def __repr__(self):
23017 
    L = ['%s=%r' % (key, value)
23018 
      for key, value in self.__dict__.iteritems()]
23019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23020 
 
23021 
  def __eq__(self, other):
23022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23023 
 
23024 
  def __ne__(self, other):
23025 
    return not (self == other)
23026 
 
23027 
class saveEBSSettlementSummary_result:
23028 
  """
23029 
  Attributes:
23030 
   - ex
23031 
  """
23032 
 
23033 
  thrift_spec = (
23034 
    None, # 0
23035 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23036 
  )
23037 
 
23038 
  def __init__(self, ex=None,):
23039 
    self.ex = ex
23040 
 
23041 
  def read(self, iprot):
23042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23044 
      return
23045 
    iprot.readStructBegin()
23046 
    while True:
23047 
      (fname, ftype, fid) = iprot.readFieldBegin()
23048 
      if ftype == TType.STOP:
23049 
        break
23050 
      if fid == 1:
23051 
        if ftype == TType.STRUCT:
23052 
          self.ex = TransactionServiceException()
23053 
          self.ex.read(iprot)
23054 
        else:
23055 
          iprot.skip(ftype)
23056 
      else:
23057 
        iprot.skip(ftype)
23058 
      iprot.readFieldEnd()
23059 
    iprot.readStructEnd()
23060 
 
23061 
  def write(self, oprot):
23062 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23063 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23064 
      return
23065 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
23066 
    if self.ex is not None:
23067 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23068 
      self.ex.write(oprot)
23069 
      oprot.writeFieldEnd()
23070 
    oprot.writeFieldStop()
23071 
    oprot.writeStructEnd()
23072 
 
23073 
  def validate(self):
23074 
    return
23075 
 
23076 
 
23077 
  def __repr__(self):
23078 
    L = ['%s=%r' % (key, value)
23079 
      for key, value in self.__dict__.iteritems()]
23080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23081 
 
23082 
  def __eq__(self, other):
23083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23084 
 
23085 
  def __ne__(self, other):
23086 
    return not (self == other)
23087 
 
5386 phani.kuma 23088 
class getSettlementForPrepaid_args:
4600 varun.gupt 23089 
  """
23090 
  Attributes:
5189 varun.gupt 23091 
   - referenceId
23092 
   - isRefund
4600 varun.gupt 23093 
  """
23094 
 
23095 
  thrift_spec = (
23096 
    None, # 0
5189 varun.gupt 23097 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 23098 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 23099 
  )
23100 
 
5386 phani.kuma 23101 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 23102 
    self.referenceId = referenceId
23103 
    self.isRefund = isRefund
4600 varun.gupt 23104 
 
23105 
  def read(self, iprot):
23106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23108 
      return
23109 
    iprot.readStructBegin()
23110 
    while True:
23111 
      (fname, ftype, fid) = iprot.readFieldBegin()
23112 
      if ftype == TType.STOP:
23113 
        break
23114 
      if fid == 1:
23115 
        if ftype == TType.I64:
5189 varun.gupt 23116 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23117 
        else:
23118 
          iprot.skip(ftype)
5189 varun.gupt 23119 
      elif fid == 2:
23120 
        if ftype == TType.BOOL:
23121 
          self.isRefund = iprot.readBool();
23122 
        else:
23123 
          iprot.skip(ftype)
4600 varun.gupt 23124 
      else:
23125 
        iprot.skip(ftype)
23126 
      iprot.readFieldEnd()
23127 
    iprot.readStructEnd()
23128 
 
23129 
  def write(self, oprot):
23130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23132 
      return
5386 phani.kuma 23133 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 23134 
    if self.referenceId is not None:
23135 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
23136 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23137 
      oprot.writeFieldEnd()
5386 phani.kuma 23138 
    if self.isRefund is not None:
23139 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
23140 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 23141 
      oprot.writeFieldEnd()
5386 phani.kuma 23142 
    oprot.writeFieldStop()
23143 
    oprot.writeStructEnd()
23144 
 
23145 
  def validate(self):
23146 
    return
23147 
 
23148 
 
23149 
  def __repr__(self):
23150 
    L = ['%s=%r' % (key, value)
23151 
      for key, value in self.__dict__.iteritems()]
23152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23153 
 
23154 
  def __eq__(self, other):
23155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23156 
 
23157 
  def __ne__(self, other):
23158 
    return not (self == other)
23159 
 
23160 
class getSettlementForPrepaid_result:
23161 
  """
23162 
  Attributes:
23163 
   - success
23164 
   - ex
23165 
  """
23166 
 
23167 
  thrift_spec = (
23168 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23169 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23170 
  )
23171 
 
23172 
  def __init__(self, success=None, ex=None,):
23173 
    self.success = success
23174 
    self.ex = ex
23175 
 
23176 
  def read(self, iprot):
23177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23179 
      return
23180 
    iprot.readStructBegin()
23181 
    while True:
23182 
      (fname, ftype, fid) = iprot.readFieldBegin()
23183 
      if ftype == TType.STOP:
23184 
        break
23185 
      if fid == 0:
23186 
        if ftype == TType.STRUCT:
23187 
          self.success = PaymentSettlement()
23188 
          self.success.read(iprot)
23189 
        else:
23190 
          iprot.skip(ftype)
23191 
      elif fid == 1:
23192 
        if ftype == TType.STRUCT:
23193 
          self.ex = TransactionServiceException()
23194 
          self.ex.read(iprot)
23195 
        else:
23196 
          iprot.skip(ftype)
23197 
      else:
23198 
        iprot.skip(ftype)
23199 
      iprot.readFieldEnd()
23200 
    iprot.readStructEnd()
23201 
 
23202 
  def write(self, oprot):
23203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23205 
      return
23206 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
23207 
    if self.success is not None:
23208 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23209 
      self.success.write(oprot)
23210 
      oprot.writeFieldEnd()
23211 
    if self.ex is not None:
23212 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23213 
      self.ex.write(oprot)
23214 
      oprot.writeFieldEnd()
23215 
    oprot.writeFieldStop()
23216 
    oprot.writeStructEnd()
23217 
 
23218 
  def validate(self):
23219 
    return
23220 
 
23221 
 
23222 
  def __repr__(self):
23223 
    L = ['%s=%r' % (key, value)
23224 
      for key, value in self.__dict__.iteritems()]
23225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23226 
 
23227 
  def __eq__(self, other):
23228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23229 
 
23230 
  def __ne__(self, other):
23231 
    return not (self == other)
23232 
 
23233 
class getSettlementForCod_args:
23234 
  """
23235 
  Attributes:
23236 
   - orderId
23237 
   - isRefund
23238 
  """
23239 
 
23240 
  thrift_spec = (
23241 
    None, # 0
23242 
    (1, TType.I64, 'orderId', None, None, ), # 1
23243 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
23244 
  )
23245 
 
23246 
  def __init__(self, orderId=None, isRefund=None,):
23247 
    self.orderId = orderId
23248 
    self.isRefund = isRefund
23249 
 
23250 
  def read(self, iprot):
23251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23253 
      return
23254 
    iprot.readStructBegin()
23255 
    while True:
23256 
      (fname, ftype, fid) = iprot.readFieldBegin()
23257 
      if ftype == TType.STOP:
23258 
        break
23259 
      if fid == 1:
23260 
        if ftype == TType.I64:
23261 
          self.orderId = iprot.readI64();
23262 
        else:
23263 
          iprot.skip(ftype)
23264 
      elif fid == 2:
23265 
        if ftype == TType.BOOL:
23266 
          self.isRefund = iprot.readBool();
23267 
        else:
23268 
          iprot.skip(ftype)
23269 
      else:
23270 
        iprot.skip(ftype)
23271 
      iprot.readFieldEnd()
23272 
    iprot.readStructEnd()
23273 
 
23274 
  def write(self, oprot):
23275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23277 
      return
23278 
    oprot.writeStructBegin('getSettlementForCod_args')
23279 
    if self.orderId is not None:
23280 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23281 
      oprot.writeI64(self.orderId)
23282 
      oprot.writeFieldEnd()
5189 varun.gupt 23283 
    if self.isRefund is not None:
5386 phani.kuma 23284 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23285 
      oprot.writeBool(self.isRefund)
23286 
      oprot.writeFieldEnd()
4600 varun.gupt 23287 
    oprot.writeFieldStop()
23288 
    oprot.writeStructEnd()
23289 
 
23290 
  def validate(self):
23291 
    return
23292 
 
23293 
 
23294 
  def __repr__(self):
23295 
    L = ['%s=%r' % (key, value)
23296 
      for key, value in self.__dict__.iteritems()]
23297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23298 
 
23299 
  def __eq__(self, other):
23300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23301 
 
23302 
  def __ne__(self, other):
23303 
    return not (self == other)
23304 
 
5386 phani.kuma 23305 
class getSettlementForCod_result:
4600 varun.gupt 23306 
  """
23307 
  Attributes:
23308 
   - success
23309 
   - ex
23310 
  """
23311 
 
23312 
  thrift_spec = (
23313 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23314 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23315 
  )
23316 
 
23317 
  def __init__(self, success=None, ex=None,):
23318 
    self.success = success
23319 
    self.ex = ex
23320 
 
23321 
  def read(self, iprot):
23322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23324 
      return
23325 
    iprot.readStructBegin()
23326 
    while True:
23327 
      (fname, ftype, fid) = iprot.readFieldBegin()
23328 
      if ftype == TType.STOP:
23329 
        break
23330 
      if fid == 0:
23331 
        if ftype == TType.STRUCT:
23332 
          self.success = PaymentSettlement()
23333 
          self.success.read(iprot)
23334 
        else:
23335 
          iprot.skip(ftype)
23336 
      elif fid == 1:
23337 
        if ftype == TType.STRUCT:
23338 
          self.ex = TransactionServiceException()
23339 
          self.ex.read(iprot)
23340 
        else:
23341 
          iprot.skip(ftype)
23342 
      else:
23343 
        iprot.skip(ftype)
23344 
      iprot.readFieldEnd()
23345 
    iprot.readStructEnd()
23346 
 
23347 
  def write(self, oprot):
23348 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23349 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23350 
      return
5386 phani.kuma 23351 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 23352 
    if self.success is not None:
23353 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23354 
      self.success.write(oprot)
23355 
      oprot.writeFieldEnd()
23356 
    if self.ex is not None:
23357 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23358 
      self.ex.write(oprot)
23359 
      oprot.writeFieldEnd()
23360 
    oprot.writeFieldStop()
23361 
    oprot.writeStructEnd()
23362 
 
23363 
  def validate(self):
23364 
    return
23365 
 
23366 
 
23367 
  def __repr__(self):
23368 
    L = ['%s=%r' % (key, value)
23369 
      for key, value in self.__dict__.iteritems()]
23370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23371 
 
23372 
  def __eq__(self, other):
23373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23374 
 
23375 
  def __ne__(self, other):
23376 
    return not (self == other)
23377 
 
23378 
class getEBSSettlementSummaries_args:
23379 
 
23380 
  thrift_spec = (
23381 
  )
23382 
 
23383 
  def read(self, iprot):
23384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23386 
      return
23387 
    iprot.readStructBegin()
23388 
    while True:
23389 
      (fname, ftype, fid) = iprot.readFieldBegin()
23390 
      if ftype == TType.STOP:
23391 
        break
23392 
      else:
23393 
        iprot.skip(ftype)
23394 
      iprot.readFieldEnd()
23395 
    iprot.readStructEnd()
23396 
 
23397 
  def write(self, oprot):
23398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23400 
      return
23401 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
23402 
    oprot.writeFieldStop()
23403 
    oprot.writeStructEnd()
23404 
 
23405 
  def validate(self):
23406 
    return
23407 
 
23408 
 
23409 
  def __repr__(self):
23410 
    L = ['%s=%r' % (key, value)
23411 
      for key, value in self.__dict__.iteritems()]
23412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23413 
 
23414 
  def __eq__(self, other):
23415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23416 
 
23417 
  def __ne__(self, other):
23418 
    return not (self == other)
23419 
 
23420 
class getEBSSettlementSummaries_result:
23421 
  """
23422 
  Attributes:
23423 
   - success
23424 
   - ex
23425 
  """
23426 
 
23427 
  thrift_spec = (
23428 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23429 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23430 
  )
23431 
 
23432 
  def __init__(self, success=None, ex=None,):
23433 
    self.success = success
23434 
    self.ex = ex
23435 
 
23436 
  def read(self, iprot):
23437 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23438 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23439 
      return
23440 
    iprot.readStructBegin()
23441 
    while True:
23442 
      (fname, ftype, fid) = iprot.readFieldBegin()
23443 
      if ftype == TType.STOP:
23444 
        break
23445 
      if fid == 0:
23446 
        if ftype == TType.MAP:
23447 
          self.success = {}
6188 rajveer 23448 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
23449 
          for _i558 in xrange(_size554):
23450 
            _key559 = iprot.readI64();
23451 
            _val560 = iprot.readString();
23452 
            self.success[_key559] = _val560
4600 varun.gupt 23453 
          iprot.readMapEnd()
23454 
        else:
23455 
          iprot.skip(ftype)
23456 
      elif fid == 1:
23457 
        if ftype == TType.STRUCT:
23458 
          self.ex = TransactionServiceException()
23459 
          self.ex.read(iprot)
23460 
        else:
23461 
          iprot.skip(ftype)
23462 
      else:
23463 
        iprot.skip(ftype)
23464 
      iprot.readFieldEnd()
23465 
    iprot.readStructEnd()
23466 
 
23467 
  def write(self, oprot):
23468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23470 
      return
23471 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
23472 
    if self.success is not None:
23473 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23474 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 23475 
      for kiter561,viter562 in self.success.items():
23476 
        oprot.writeI64(kiter561)
23477 
        oprot.writeString(viter562)
4600 varun.gupt 23478 
      oprot.writeMapEnd()
23479 
      oprot.writeFieldEnd()
23480 
    if self.ex is not None:
23481 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23482 
      self.ex.write(oprot)
23483 
      oprot.writeFieldEnd()
23484 
    oprot.writeFieldStop()
23485 
    oprot.writeStructEnd()
23486 
 
23487 
  def validate(self):
23488 
    return
23489 
 
23490 
 
23491 
  def __repr__(self):
23492 
    L = ['%s=%r' % (key, value)
23493 
      for key, value in self.__dict__.iteritems()]
23494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23495 
 
23496 
  def __eq__(self, other):
23497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23498 
 
23499 
  def __ne__(self, other):
23500 
    return not (self == other)
23501 
 
23502 
class markEBSSettlementUploaded_args:
23503 
  """
23504 
  Attributes:
23505 
   - settlementId
23506 
  """
23507 
 
23508 
  thrift_spec = (
23509 
    None, # 0
23510 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23511 
  )
23512 
 
23513 
  def __init__(self, settlementId=None,):
23514 
    self.settlementId = settlementId
23515 
 
23516 
  def read(self, iprot):
23517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23519 
      return
23520 
    iprot.readStructBegin()
23521 
    while True:
23522 
      (fname, ftype, fid) = iprot.readFieldBegin()
23523 
      if ftype == TType.STOP:
23524 
        break
23525 
      if fid == 1:
23526 
        if ftype == TType.I64:
23527 
          self.settlementId = iprot.readI64();
23528 
        else:
23529 
          iprot.skip(ftype)
23530 
      else:
23531 
        iprot.skip(ftype)
23532 
      iprot.readFieldEnd()
23533 
    iprot.readStructEnd()
23534 
 
23535 
  def write(self, oprot):
23536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23538 
      return
23539 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
23540 
    if self.settlementId is not None:
23541 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23542 
      oprot.writeI64(self.settlementId)
23543 
      oprot.writeFieldEnd()
23544 
    oprot.writeFieldStop()
23545 
    oprot.writeStructEnd()
23546 
 
23547 
  def validate(self):
23548 
    return
23549 
 
23550 
 
23551 
  def __repr__(self):
23552 
    L = ['%s=%r' % (key, value)
23553 
      for key, value in self.__dict__.iteritems()]
23554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23555 
 
23556 
  def __eq__(self, other):
23557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23558 
 
23559 
  def __ne__(self, other):
23560 
    return not (self == other)
23561 
 
23562 
class markEBSSettlementUploaded_result:
23563 
  """
23564 
  Attributes:
23565 
   - ex
23566 
  """
23567 
 
23568 
  thrift_spec = (
23569 
    None, # 0
23570 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23571 
  )
23572 
 
23573 
  def __init__(self, ex=None,):
23574 
    self.ex = ex
23575 
 
23576 
  def read(self, iprot):
23577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23579 
      return
23580 
    iprot.readStructBegin()
23581 
    while True:
23582 
      (fname, ftype, fid) = iprot.readFieldBegin()
23583 
      if ftype == TType.STOP:
23584 
        break
23585 
      if fid == 1:
23586 
        if ftype == TType.STRUCT:
23587 
          self.ex = TransactionServiceException()
23588 
          self.ex.read(iprot)
23589 
        else:
23590 
          iprot.skip(ftype)
23591 
      else:
23592 
        iprot.skip(ftype)
23593 
      iprot.readFieldEnd()
23594 
    iprot.readStructEnd()
23595 
 
23596 
  def write(self, oprot):
23597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23599 
      return
23600 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
23601 
    if self.ex is not None:
23602 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23603 
      self.ex.write(oprot)
23604 
      oprot.writeFieldEnd()
23605 
    oprot.writeFieldStop()
23606 
    oprot.writeStructEnd()
23607 
 
23608 
  def validate(self):
23609 
    return
23610 
 
23611 
 
23612 
  def __repr__(self):
23613 
    L = ['%s=%r' % (key, value)
23614 
      for key, value in self.__dict__.iteritems()]
23615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23616 
 
23617 
  def __eq__(self, other):
23618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23619 
 
23620 
  def __ne__(self, other):
23621 
    return not (self == other)
23622 
 
23623 
class getEBSSettlementDate_args:
23624 
  """
23625 
  Attributes:
23626 
   - settlementId
23627 
  """
23628 
 
23629 
  thrift_spec = (
23630 
    None, # 0
23631 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23632 
  )
23633 
 
23634 
  def __init__(self, settlementId=None,):
23635 
    self.settlementId = settlementId
23636 
 
23637 
  def read(self, iprot):
23638 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23639 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23640 
      return
23641 
    iprot.readStructBegin()
23642 
    while True:
23643 
      (fname, ftype, fid) = iprot.readFieldBegin()
23644 
      if ftype == TType.STOP:
23645 
        break
23646 
      if fid == 1:
23647 
        if ftype == TType.I64:
23648 
          self.settlementId = iprot.readI64();
23649 
        else:
23650 
          iprot.skip(ftype)
23651 
      else:
23652 
        iprot.skip(ftype)
23653 
      iprot.readFieldEnd()
23654 
    iprot.readStructEnd()
23655 
 
23656 
  def write(self, oprot):
23657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23659 
      return
23660 
    oprot.writeStructBegin('getEBSSettlementDate_args')
23661 
    if self.settlementId is not None:
23662 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23663 
      oprot.writeI64(self.settlementId)
23664 
      oprot.writeFieldEnd()
23665 
    oprot.writeFieldStop()
23666 
    oprot.writeStructEnd()
23667 
 
23668 
  def validate(self):
23669 
    return
23670 
 
23671 
 
23672 
  def __repr__(self):
23673 
    L = ['%s=%r' % (key, value)
23674 
      for key, value in self.__dict__.iteritems()]
23675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23676 
 
23677 
  def __eq__(self, other):
23678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23679 
 
23680 
  def __ne__(self, other):
23681 
    return not (self == other)
23682 
 
23683 
class getEBSSettlementDate_result:
23684 
  """
23685 
  Attributes:
23686 
   - success
23687 
   - ex
23688 
  """
23689 
 
23690 
  thrift_spec = (
23691 
    (0, TType.I64, 'success', None, None, ), # 0
23692 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23693 
  )
23694 
 
23695 
  def __init__(self, success=None, ex=None,):
23696 
    self.success = success
23697 
    self.ex = ex
23698 
 
23699 
  def read(self, iprot):
23700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23702 
      return
23703 
    iprot.readStructBegin()
23704 
    while True:
23705 
      (fname, ftype, fid) = iprot.readFieldBegin()
23706 
      if ftype == TType.STOP:
23707 
        break
23708 
      if fid == 0:
23709 
        if ftype == TType.I64:
23710 
          self.success = iprot.readI64();
23711 
        else:
23712 
          iprot.skip(ftype)
23713 
      elif fid == 1:
23714 
        if ftype == TType.STRUCT:
23715 
          self.ex = TransactionServiceException()
23716 
          self.ex.read(iprot)
23717 
        else:
23718 
          iprot.skip(ftype)
23719 
      else:
23720 
        iprot.skip(ftype)
23721 
      iprot.readFieldEnd()
23722 
    iprot.readStructEnd()
23723 
 
23724 
  def write(self, oprot):
23725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23727 
      return
23728 
    oprot.writeStructBegin('getEBSSettlementDate_result')
23729 
    if self.success is not None:
23730 
      oprot.writeFieldBegin('success', TType.I64, 0)
23731 
      oprot.writeI64(self.success)
23732 
      oprot.writeFieldEnd()
23733 
    if self.ex is not None:
23734 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23735 
      self.ex.write(oprot)
23736 
      oprot.writeFieldEnd()
23737 
    oprot.writeFieldStop()
23738 
    oprot.writeStructEnd()
23739 
 
23740 
  def validate(self):
23741 
    return
23742 
 
23743 
 
23744 
  def __repr__(self):
23745 
    L = ['%s=%r' % (key, value)
23746 
      for key, value in self.__dict__.iteritems()]
23747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23748 
 
23749 
  def __eq__(self, other):
23750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23751 
 
23752 
  def __ne__(self, other):
23753 
    return not (self == other)
4715 varun.gupt 23754 
 
23755 
class getSettlementsByDate_args:
23756 
  """
23757 
  Attributes:
23758 
   - settlementDateFrom
23759 
   - settlementDateTo
23760 
   - isRefund
23761 
  """
23762 
 
23763 
  thrift_spec = (
23764 
    None, # 0
23765 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
23766 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
23767 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
23768 
  )
23769 
 
23770 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
23771 
    self.settlementDateFrom = settlementDateFrom
23772 
    self.settlementDateTo = settlementDateTo
23773 
    self.isRefund = isRefund
23774 
 
23775 
  def read(self, iprot):
23776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23778 
      return
23779 
    iprot.readStructBegin()
23780 
    while True:
23781 
      (fname, ftype, fid) = iprot.readFieldBegin()
23782 
      if ftype == TType.STOP:
23783 
        break
23784 
      if fid == 1:
23785 
        if ftype == TType.I64:
23786 
          self.settlementDateFrom = iprot.readI64();
23787 
        else:
23788 
          iprot.skip(ftype)
23789 
      elif fid == 2:
23790 
        if ftype == TType.I64:
23791 
          self.settlementDateTo = iprot.readI64();
23792 
        else:
23793 
          iprot.skip(ftype)
23794 
      elif fid == 3:
23795 
        if ftype == TType.BOOL:
23796 
          self.isRefund = iprot.readBool();
23797 
        else:
23798 
          iprot.skip(ftype)
23799 
      else:
23800 
        iprot.skip(ftype)
23801 
      iprot.readFieldEnd()
23802 
    iprot.readStructEnd()
23803 
 
23804 
  def write(self, oprot):
23805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23807 
      return
23808 
    oprot.writeStructBegin('getSettlementsByDate_args')
23809 
    if self.settlementDateFrom is not None:
23810 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
23811 
      oprot.writeI64(self.settlementDateFrom)
23812 
      oprot.writeFieldEnd()
23813 
    if self.settlementDateTo is not None:
23814 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
23815 
      oprot.writeI64(self.settlementDateTo)
23816 
      oprot.writeFieldEnd()
23817 
    if self.isRefund is not None:
23818 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
23819 
      oprot.writeBool(self.isRefund)
23820 
      oprot.writeFieldEnd()
23821 
    oprot.writeFieldStop()
23822 
    oprot.writeStructEnd()
23823 
 
23824 
  def validate(self):
23825 
    return
23826 
 
23827 
 
23828 
  def __repr__(self):
23829 
    L = ['%s=%r' % (key, value)
23830 
      for key, value in self.__dict__.iteritems()]
23831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23832 
 
23833 
  def __eq__(self, other):
23834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23835 
 
23836 
  def __ne__(self, other):
23837 
    return not (self == other)
23838 
 
23839 
class getSettlementsByDate_result:
23840 
  """
23841 
  Attributes:
23842 
   - success
23843 
   - ex
23844 
  """
23845 
 
23846 
  thrift_spec = (
23847 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
23848 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23849 
  )
23850 
 
23851 
  def __init__(self, success=None, ex=None,):
23852 
    self.success = success
23853 
    self.ex = ex
23854 
 
23855 
  def read(self, iprot):
23856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23858 
      return
23859 
    iprot.readStructBegin()
23860 
    while True:
23861 
      (fname, ftype, fid) = iprot.readFieldBegin()
23862 
      if ftype == TType.STOP:
23863 
        break
23864 
      if fid == 0:
23865 
        if ftype == TType.LIST:
23866 
          self.success = []
6188 rajveer 23867 
          (_etype566, _size563) = iprot.readListBegin()
23868 
          for _i567 in xrange(_size563):
23869 
            _elem568 = PaymentSettlement()
23870 
            _elem568.read(iprot)
23871 
            self.success.append(_elem568)
4715 varun.gupt 23872 
          iprot.readListEnd()
23873 
        else:
23874 
          iprot.skip(ftype)
23875 
      elif fid == 1:
23876 
        if ftype == TType.STRUCT:
23877 
          self.ex = TransactionServiceException()
23878 
          self.ex.read(iprot)
23879 
        else:
23880 
          iprot.skip(ftype)
23881 
      else:
23882 
        iprot.skip(ftype)
23883 
      iprot.readFieldEnd()
23884 
    iprot.readStructEnd()
23885 
 
23886 
  def write(self, oprot):
23887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23889 
      return
23890 
    oprot.writeStructBegin('getSettlementsByDate_result')
23891 
    if self.success is not None:
23892 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23893 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23894 
      for iter569 in self.success:
23895 
        iter569.write(oprot)
4715 varun.gupt 23896 
      oprot.writeListEnd()
23897 
      oprot.writeFieldEnd()
23898 
    if self.ex is not None:
23899 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23900 
      self.ex.write(oprot)
23901 
      oprot.writeFieldEnd()
23902 
    oprot.writeFieldStop()
23903 
    oprot.writeStructEnd()
23904 
 
23905 
  def validate(self):
23906 
    return
23907 
 
23908 
 
23909 
  def __repr__(self):
23910 
    L = ['%s=%r' % (key, value)
23911 
      for key, value in self.__dict__.iteritems()]
23912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23913 
 
23914 
  def __eq__(self, other):
23915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23916 
 
23917 
  def __ne__(self, other):
23918 
    return not (self == other)
23919 
 
23920 
class getReshippedOrderIds_args:
23921 
  """
23922 
  Attributes:
23923 
   - orderIds
23924 
  """
23925 
 
23926 
  thrift_spec = (
23927 
    None, # 0
23928 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
23929 
  )
23930 
 
23931 
  def __init__(self, orderIds=None,):
23932 
    self.orderIds = orderIds
23933 
 
23934 
  def read(self, iprot):
23935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23937 
      return
23938 
    iprot.readStructBegin()
23939 
    while True:
23940 
      (fname, ftype, fid) = iprot.readFieldBegin()
23941 
      if ftype == TType.STOP:
23942 
        break
23943 
      if fid == 1:
23944 
        if ftype == TType.LIST:
23945 
          self.orderIds = []
6188 rajveer 23946 
          (_etype573, _size570) = iprot.readListBegin()
23947 
          for _i574 in xrange(_size570):
23948 
            _elem575 = iprot.readI64();
23949 
            self.orderIds.append(_elem575)
4715 varun.gupt 23950 
          iprot.readListEnd()
23951 
        else:
23952 
          iprot.skip(ftype)
23953 
      else:
23954 
        iprot.skip(ftype)
23955 
      iprot.readFieldEnd()
23956 
    iprot.readStructEnd()
23957 
 
23958 
  def write(self, oprot):
23959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23961 
      return
23962 
    oprot.writeStructBegin('getReshippedOrderIds_args')
23963 
    if self.orderIds is not None:
23964 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
23965 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 23966 
      for iter576 in self.orderIds:
23967 
        oprot.writeI64(iter576)
4715 varun.gupt 23968 
      oprot.writeListEnd()
23969 
      oprot.writeFieldEnd()
23970 
    oprot.writeFieldStop()
23971 
    oprot.writeStructEnd()
23972 
 
23973 
  def validate(self):
23974 
    return
23975 
 
23976 
 
23977 
  def __repr__(self):
23978 
    L = ['%s=%r' % (key, value)
23979 
      for key, value in self.__dict__.iteritems()]
23980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23981 
 
23982 
  def __eq__(self, other):
23983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23984 
 
23985 
  def __ne__(self, other):
23986 
    return not (self == other)
23987 
 
23988 
class getReshippedOrderIds_result:
23989 
  """
23990 
  Attributes:
23991 
   - success
23992 
   - ex
23993 
  """
23994 
 
23995 
  thrift_spec = (
23996 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
23997 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23998 
  )
23999 
 
24000 
  def __init__(self, success=None, ex=None,):
24001 
    self.success = success
24002 
    self.ex = ex
24003 
 
24004 
  def read(self, iprot):
24005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24007 
      return
24008 
    iprot.readStructBegin()
24009 
    while True:
24010 
      (fname, ftype, fid) = iprot.readFieldBegin()
24011 
      if ftype == TType.STOP:
24012 
        break
24013 
      if fid == 0:
24014 
        if ftype == TType.LIST:
24015 
          self.success = []
6188 rajveer 24016 
          (_etype580, _size577) = iprot.readListBegin()
24017 
          for _i581 in xrange(_size577):
24018 
            _elem582 = iprot.readI64();
24019 
            self.success.append(_elem582)
4715 varun.gupt 24020 
          iprot.readListEnd()
24021 
        else:
24022 
          iprot.skip(ftype)
24023 
      elif fid == 1:
24024 
        if ftype == TType.STRUCT:
24025 
          self.ex = TransactionServiceException()
24026 
          self.ex.read(iprot)
24027 
        else:
24028 
          iprot.skip(ftype)
24029 
      else:
24030 
        iprot.skip(ftype)
24031 
      iprot.readFieldEnd()
24032 
    iprot.readStructEnd()
24033 
 
24034 
  def write(self, oprot):
24035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24037 
      return
24038 
    oprot.writeStructBegin('getReshippedOrderIds_result')
24039 
    if self.success is not None:
24040 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24041 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24042 
      for iter583 in self.success:
24043 
        oprot.writeI64(iter583)
4715 varun.gupt 24044 
      oprot.writeListEnd()
24045 
      oprot.writeFieldEnd()
24046 
    if self.ex is not None:
24047 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24048 
      self.ex.write(oprot)
24049 
      oprot.writeFieldEnd()
24050 
    oprot.writeFieldStop()
24051 
    oprot.writeStructEnd()
24052 
 
24053 
  def validate(self):
24054 
    return
24055 
 
24056 
 
24057 
  def __repr__(self):
24058 
    L = ['%s=%r' % (key, value)
24059 
      for key, value in self.__dict__.iteritems()]
24060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24061 
 
24062 
  def __eq__(self, other):
24063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24064 
 
24065 
  def __ne__(self, other):
24066 
    return not (self == other)
4757 mandeep.dh 24067 
 
5481 phani.kuma 24068 
class getBilledOrders_args:
4875 varun.gupt 24069 
  """
24070 
  Attributes:
24071 
   - vendorId
5481 phani.kuma 24072 
   - onlyVendorNotPaid
24073 
   - billingDateFrom
24074 
   - billingDateTo
4875 varun.gupt 24075 
  """
24076 
 
24077 
  thrift_spec = (
24078 
    None, # 0
24079 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 24080 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
24081 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
24082 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 24083 
  )
24084 
 
5481 phani.kuma 24085 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 24086 
    self.vendorId = vendorId
5481 phani.kuma 24087 
    self.onlyVendorNotPaid = onlyVendorNotPaid
24088 
    self.billingDateFrom = billingDateFrom
24089 
    self.billingDateTo = billingDateTo
4875 varun.gupt 24090 
 
24091 
  def read(self, iprot):
24092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24094 
      return
24095 
    iprot.readStructBegin()
24096 
    while True:
24097 
      (fname, ftype, fid) = iprot.readFieldBegin()
24098 
      if ftype == TType.STOP:
24099 
        break
24100 
      if fid == 1:
24101 
        if ftype == TType.I64:
24102 
          self.vendorId = iprot.readI64();
24103 
        else:
24104 
          iprot.skip(ftype)
5481 phani.kuma 24105 
      elif fid == 2:
24106 
        if ftype == TType.BOOL:
24107 
          self.onlyVendorNotPaid = iprot.readBool();
24108 
        else:
24109 
          iprot.skip(ftype)
24110 
      elif fid == 3:
24111 
        if ftype == TType.I64:
24112 
          self.billingDateFrom = iprot.readI64();
24113 
        else:
24114 
          iprot.skip(ftype)
24115 
      elif fid == 4:
24116 
        if ftype == TType.I64:
24117 
          self.billingDateTo = iprot.readI64();
24118 
        else:
24119 
          iprot.skip(ftype)
4875 varun.gupt 24120 
      else:
24121 
        iprot.skip(ftype)
24122 
      iprot.readFieldEnd()
24123 
    iprot.readStructEnd()
24124 
 
24125 
  def write(self, oprot):
24126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24128 
      return
5481 phani.kuma 24129 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 24130 
    if self.vendorId is not None:
24131 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
24132 
      oprot.writeI64(self.vendorId)
24133 
      oprot.writeFieldEnd()
5481 phani.kuma 24134 
    if self.onlyVendorNotPaid is not None:
24135 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
24136 
      oprot.writeBool(self.onlyVendorNotPaid)
24137 
      oprot.writeFieldEnd()
24138 
    if self.billingDateFrom is not None:
24139 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
24140 
      oprot.writeI64(self.billingDateFrom)
24141 
      oprot.writeFieldEnd()
24142 
    if self.billingDateTo is not None:
24143 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
24144 
      oprot.writeI64(self.billingDateTo)
24145 
      oprot.writeFieldEnd()
4875 varun.gupt 24146 
    oprot.writeFieldStop()
24147 
    oprot.writeStructEnd()
24148 
 
24149 
  def validate(self):
24150 
    return
24151 
 
24152 
 
24153 
  def __repr__(self):
24154 
    L = ['%s=%r' % (key, value)
24155 
      for key, value in self.__dict__.iteritems()]
24156 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24157 
 
24158 
  def __eq__(self, other):
24159 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24160 
 
24161 
  def __ne__(self, other):
24162 
    return not (self == other)
24163 
 
5481 phani.kuma 24164 
class getBilledOrders_result:
4875 varun.gupt 24165 
  """
24166 
  Attributes:
24167 
   - success
24168 
   - ex
24169 
  """
24170 
 
24171 
  thrift_spec = (
24172 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24173 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24174 
  )
24175 
 
24176 
  def __init__(self, success=None, ex=None,):
24177 
    self.success = success
24178 
    self.ex = ex
24179 
 
24180 
  def read(self, iprot):
24181 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24182 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24183 
      return
24184 
    iprot.readStructBegin()
24185 
    while True:
24186 
      (fname, ftype, fid) = iprot.readFieldBegin()
24187 
      if ftype == TType.STOP:
24188 
        break
24189 
      if fid == 0:
24190 
        if ftype == TType.LIST:
24191 
          self.success = []
6188 rajveer 24192 
          (_etype587, _size584) = iprot.readListBegin()
24193 
          for _i588 in xrange(_size584):
24194 
            _elem589 = Order()
24195 
            _elem589.read(iprot)
24196 
            self.success.append(_elem589)
4875 varun.gupt 24197 
          iprot.readListEnd()
24198 
        else:
24199 
          iprot.skip(ftype)
24200 
      elif fid == 1:
24201 
        if ftype == TType.STRUCT:
24202 
          self.ex = TransactionServiceException()
24203 
          self.ex.read(iprot)
24204 
        else:
24205 
          iprot.skip(ftype)
24206 
      else:
24207 
        iprot.skip(ftype)
24208 
      iprot.readFieldEnd()
24209 
    iprot.readStructEnd()
24210 
 
24211 
  def write(self, oprot):
24212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24214 
      return
5481 phani.kuma 24215 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 24216 
    if self.success is not None:
24217 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24218 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24219 
      for iter590 in self.success:
24220 
        iter590.write(oprot)
4875 varun.gupt 24221 
      oprot.writeListEnd()
24222 
      oprot.writeFieldEnd()
24223 
    if self.ex is not None:
24224 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24225 
      self.ex.write(oprot)
24226 
      oprot.writeFieldEnd()
24227 
    oprot.writeFieldStop()
24228 
    oprot.writeStructEnd()
24229 
 
24230 
  def validate(self):
24231 
    return
24232 
 
24233 
 
24234 
  def __repr__(self):
24235 
    L = ['%s=%r' % (key, value)
24236 
      for key, value in self.__dict__.iteritems()]
24237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24238 
 
24239 
  def __eq__(self, other):
24240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24241 
 
24242 
  def __ne__(self, other):
24243 
    return not (self == other)
5031 varun.gupt 24244 
 
24245 
class getStatusDistributionOfOrders_args:
24246 
  """
24247 
  Attributes:
24248 
   - startDate
24249 
   - endDate
24250 
  """
24251 
 
24252 
  thrift_spec = (
24253 
    None, # 0
24254 
    (1, TType.I64, 'startDate', None, None, ), # 1
24255 
    (2, TType.I64, 'endDate', None, None, ), # 2
24256 
  )
24257 
 
24258 
  def __init__(self, startDate=None, endDate=None,):
24259 
    self.startDate = startDate
24260 
    self.endDate = endDate
24261 
 
24262 
  def read(self, iprot):
24263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24265 
      return
24266 
    iprot.readStructBegin()
24267 
    while True:
24268 
      (fname, ftype, fid) = iprot.readFieldBegin()
24269 
      if ftype == TType.STOP:
24270 
        break
24271 
      if fid == 1:
24272 
        if ftype == TType.I64:
24273 
          self.startDate = iprot.readI64();
24274 
        else:
24275 
          iprot.skip(ftype)
24276 
      elif fid == 2:
24277 
        if ftype == TType.I64:
24278 
          self.endDate = iprot.readI64();
24279 
        else:
24280 
          iprot.skip(ftype)
24281 
      else:
24282 
        iprot.skip(ftype)
24283 
      iprot.readFieldEnd()
24284 
    iprot.readStructEnd()
24285 
 
24286 
  def write(self, oprot):
24287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24289 
      return
24290 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24291 
    if self.startDate is not None:
24292 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24293 
      oprot.writeI64(self.startDate)
24294 
      oprot.writeFieldEnd()
24295 
    if self.endDate is not None:
24296 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24297 
      oprot.writeI64(self.endDate)
24298 
      oprot.writeFieldEnd()
24299 
    oprot.writeFieldStop()
24300 
    oprot.writeStructEnd()
24301 
 
24302 
  def validate(self):
24303 
    return
24304 
 
24305 
 
24306 
  def __repr__(self):
24307 
    L = ['%s=%r' % (key, value)
24308 
      for key, value in self.__dict__.iteritems()]
24309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24310 
 
24311 
  def __eq__(self, other):
24312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24313 
 
24314 
  def __ne__(self, other):
24315 
    return not (self == other)
24316 
 
24317 
class getStatusDistributionOfOrders_result:
24318 
  """
24319 
  Attributes:
24320 
   - success
24321 
   - ex
24322 
  """
24323 
 
24324 
  thrift_spec = (
24325 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
24326 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24327 
  )
24328 
 
24329 
  def __init__(self, success=None, ex=None,):
24330 
    self.success = success
24331 
    self.ex = ex
24332 
 
24333 
  def read(self, iprot):
24334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24336 
      return
24337 
    iprot.readStructBegin()
24338 
    while True:
24339 
      (fname, ftype, fid) = iprot.readFieldBegin()
24340 
      if ftype == TType.STOP:
24341 
        break
24342 
      if fid == 0:
24343 
        if ftype == TType.MAP:
24344 
          self.success = {}
6188 rajveer 24345 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
24346 
          for _i595 in xrange(_size591):
24347 
            _key596 = iprot.readI64();
24348 
            _val597 = iprot.readI64();
24349 
            self.success[_key596] = _val597
5031 varun.gupt 24350 
          iprot.readMapEnd()
24351 
        else:
24352 
          iprot.skip(ftype)
24353 
      elif fid == 1:
24354 
        if ftype == TType.STRUCT:
24355 
          self.ex = TransactionServiceException()
24356 
          self.ex.read(iprot)
24357 
        else:
24358 
          iprot.skip(ftype)
24359 
      else:
24360 
        iprot.skip(ftype)
24361 
      iprot.readFieldEnd()
24362 
    iprot.readStructEnd()
24363 
 
24364 
  def write(self, oprot):
24365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24367 
      return
24368 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
24369 
    if self.success is not None:
24370 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24371 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 24372 
      for kiter598,viter599 in self.success.items():
24373 
        oprot.writeI64(kiter598)
24374 
        oprot.writeI64(viter599)
5031 varun.gupt 24375 
      oprot.writeMapEnd()
24376 
      oprot.writeFieldEnd()
24377 
    if self.ex is not None:
24378 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24379 
      self.ex.write(oprot)
24380 
      oprot.writeFieldEnd()
24381 
    oprot.writeFieldStop()
24382 
    oprot.writeStructEnd()
24383 
 
24384 
  def validate(self):
24385 
    return
24386 
 
24387 
 
24388 
  def __repr__(self):
24389 
    L = ['%s=%r' % (key, value)
24390 
      for key, value in self.__dict__.iteritems()]
24391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24392 
 
24393 
  def __eq__(self, other):
24394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24395 
 
24396 
  def __ne__(self, other):
24397 
    return not (self == other)
5067 varun.gupt 24398 
 
24399 
class getOrderIdsForStatus_args:
24400 
  """
24401 
  Attributes:
24402 
   - status
24403 
   - startDatetime
24404 
   - endDatetime
24405 
  """
24406 
 
24407 
  thrift_spec = (
24408 
    None, # 0
24409 
    (1, TType.I64, 'status', None, None, ), # 1
24410 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
24411 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
24412 
  )
24413 
 
24414 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
24415 
    self.status = status
24416 
    self.startDatetime = startDatetime
24417 
    self.endDatetime = endDatetime
24418 
 
24419 
  def read(self, iprot):
24420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24422 
      return
24423 
    iprot.readStructBegin()
24424 
    while True:
24425 
      (fname, ftype, fid) = iprot.readFieldBegin()
24426 
      if ftype == TType.STOP:
24427 
        break
24428 
      if fid == 1:
24429 
        if ftype == TType.I64:
24430 
          self.status = iprot.readI64();
24431 
        else:
24432 
          iprot.skip(ftype)
24433 
      elif fid == 2:
24434 
        if ftype == TType.I64:
24435 
          self.startDatetime = iprot.readI64();
24436 
        else:
24437 
          iprot.skip(ftype)
24438 
      elif fid == 3:
24439 
        if ftype == TType.I64:
24440 
          self.endDatetime = iprot.readI64();
24441 
        else:
24442 
          iprot.skip(ftype)
24443 
      else:
24444 
        iprot.skip(ftype)
24445 
      iprot.readFieldEnd()
24446 
    iprot.readStructEnd()
24447 
 
24448 
  def write(self, oprot):
24449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24451 
      return
24452 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
24453 
    if self.status is not None:
24454 
      oprot.writeFieldBegin('status', TType.I64, 1)
24455 
      oprot.writeI64(self.status)
24456 
      oprot.writeFieldEnd()
24457 
    if self.startDatetime is not None:
24458 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
24459 
      oprot.writeI64(self.startDatetime)
24460 
      oprot.writeFieldEnd()
24461 
    if self.endDatetime is not None:
24462 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
24463 
      oprot.writeI64(self.endDatetime)
24464 
      oprot.writeFieldEnd()
24465 
    oprot.writeFieldStop()
24466 
    oprot.writeStructEnd()
24467 
 
24468 
  def validate(self):
24469 
    return
24470 
 
24471 
 
24472 
  def __repr__(self):
24473 
    L = ['%s=%r' % (key, value)
24474 
      for key, value in self.__dict__.iteritems()]
24475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24476 
 
24477 
  def __eq__(self, other):
24478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24479 
 
24480 
  def __ne__(self, other):
24481 
    return not (self == other)
24482 
 
24483 
class getOrderIdsForStatus_result:
24484 
  """
24485 
  Attributes:
24486 
   - success
24487 
   - ex
24488 
  """
24489 
 
24490 
  thrift_spec = (
24491 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24492 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24493 
  )
24494 
 
24495 
  def __init__(self, success=None, ex=None,):
24496 
    self.success = success
24497 
    self.ex = ex
24498 
 
24499 
  def read(self, iprot):
24500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24502 
      return
24503 
    iprot.readStructBegin()
24504 
    while True:
24505 
      (fname, ftype, fid) = iprot.readFieldBegin()
24506 
      if ftype == TType.STOP:
24507 
        break
24508 
      if fid == 0:
24509 
        if ftype == TType.LIST:
24510 
          self.success = []
6188 rajveer 24511 
          (_etype603, _size600) = iprot.readListBegin()
24512 
          for _i604 in xrange(_size600):
24513 
            _elem605 = iprot.readI64();
24514 
            self.success.append(_elem605)
5067 varun.gupt 24515 
          iprot.readListEnd()
24516 
        else:
24517 
          iprot.skip(ftype)
24518 
      elif fid == 1:
24519 
        if ftype == TType.STRUCT:
24520 
          self.ex = TransactionServiceException()
24521 
          self.ex.read(iprot)
24522 
        else:
24523 
          iprot.skip(ftype)
24524 
      else:
24525 
        iprot.skip(ftype)
24526 
      iprot.readFieldEnd()
24527 
    iprot.readStructEnd()
24528 
 
24529 
  def write(self, oprot):
24530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24532 
      return
24533 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
24534 
    if self.success is not None:
24535 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24536 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24537 
      for iter606 in self.success:
24538 
        oprot.writeI64(iter606)
5067 varun.gupt 24539 
      oprot.writeListEnd()
24540 
      oprot.writeFieldEnd()
24541 
    if self.ex is not None:
24542 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24543 
      self.ex.write(oprot)
24544 
      oprot.writeFieldEnd()
24545 
    oprot.writeFieldStop()
24546 
    oprot.writeStructEnd()
24547 
 
24548 
  def validate(self):
24549 
    return
24550 
 
24551 
 
24552 
  def __repr__(self):
24553 
    L = ['%s=%r' % (key, value)
24554 
      for key, value in self.__dict__.iteritems()]
24555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24556 
 
24557 
  def __eq__(self, other):
24558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24559 
 
24560 
  def __ne__(self, other):
24561 
    return not (self == other)
5099 varun.gupt 24562 
 
5348 anupam.sin 24563 
class updateCODAgent_args:
24564 
  """
24565 
  Attributes:
24566 
   - agent
24567 
   - orderId
24568 
  """
24569 
 
24570 
  thrift_spec = (
24571 
    None, # 0
24572 
    (1, TType.STRING, 'agent', None, None, ), # 1
24573 
    (2, TType.I64, 'orderId', None, None, ), # 2
24574 
  )
24575 
 
24576 
  def __init__(self, agent=None, orderId=None,):
24577 
    self.agent = agent
24578 
    self.orderId = orderId
24579 
 
24580 
  def read(self, iprot):
24581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24583 
      return
24584 
    iprot.readStructBegin()
24585 
    while True:
24586 
      (fname, ftype, fid) = iprot.readFieldBegin()
24587 
      if ftype == TType.STOP:
24588 
        break
24589 
      if fid == 1:
24590 
        if ftype == TType.STRING:
24591 
          self.agent = iprot.readString();
24592 
        else:
24593 
          iprot.skip(ftype)
24594 
      elif fid == 2:
24595 
        if ftype == TType.I64:
24596 
          self.orderId = iprot.readI64();
24597 
        else:
24598 
          iprot.skip(ftype)
24599 
      else:
24600 
        iprot.skip(ftype)
24601 
      iprot.readFieldEnd()
24602 
    iprot.readStructEnd()
24603 
 
24604 
  def write(self, oprot):
24605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24607 
      return
24608 
    oprot.writeStructBegin('updateCODAgent_args')
24609 
    if self.agent is not None:
24610 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
24611 
      oprot.writeString(self.agent)
24612 
      oprot.writeFieldEnd()
24613 
    if self.orderId is not None:
24614 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
24615 
      oprot.writeI64(self.orderId)
24616 
      oprot.writeFieldEnd()
24617 
    oprot.writeFieldStop()
24618 
    oprot.writeStructEnd()
24619 
 
24620 
  def validate(self):
24621 
    return
24622 
 
24623 
 
24624 
  def __repr__(self):
24625 
    L = ['%s=%r' % (key, value)
24626 
      for key, value in self.__dict__.iteritems()]
24627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24628 
 
24629 
  def __eq__(self, other):
24630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24631 
 
24632 
  def __ne__(self, other):
24633 
    return not (self == other)
24634 
 
24635 
class updateCODAgent_result:
24636 
  """
24637 
  Attributes:
24638 
   - ex
24639 
  """
24640 
 
24641 
  thrift_spec = (
24642 
    None, # 0
24643 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24644 
  )
24645 
 
24646 
  def __init__(self, ex=None,):
24647 
    self.ex = ex
24648 
 
24649 
  def read(self, iprot):
24650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24652 
      return
24653 
    iprot.readStructBegin()
24654 
    while True:
24655 
      (fname, ftype, fid) = iprot.readFieldBegin()
24656 
      if ftype == TType.STOP:
24657 
        break
24658 
      if fid == 1:
24659 
        if ftype == TType.STRUCT:
24660 
          self.ex = TransactionServiceException()
24661 
          self.ex.read(iprot)
24662 
        else:
24663 
          iprot.skip(ftype)
24664 
      else:
24665 
        iprot.skip(ftype)
24666 
      iprot.readFieldEnd()
24667 
    iprot.readStructEnd()
24668 
 
24669 
  def write(self, oprot):
24670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24672 
      return
24673 
    oprot.writeStructBegin('updateCODAgent_result')
24674 
    if self.ex is not None:
24675 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24676 
      self.ex.write(oprot)
24677 
      oprot.writeFieldEnd()
24678 
    oprot.writeFieldStop()
24679 
    oprot.writeStructEnd()
24680 
 
24681 
  def validate(self):
24682 
    return
24683 
 
24684 
 
24685 
  def __repr__(self):
24686 
    L = ['%s=%r' % (key, value)
24687 
      for key, value in self.__dict__.iteritems()]
24688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24689 
 
24690 
  def __eq__(self, other):
24691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24692 
 
24693 
  def __ne__(self, other):
24694 
    return not (self == other)
24695 
 
5099 varun.gupt 24696 
class updateOrderAsPaidToVendor_args:
24697 
  """
24698 
  Attributes:
24699 
   - orderId
24700 
  """
24701 
 
24702 
  thrift_spec = (
24703 
    None, # 0
24704 
    (1, TType.I64, 'orderId', None, None, ), # 1
24705 
  )
24706 
 
24707 
  def __init__(self, orderId=None,):
24708 
    self.orderId = orderId
24709 
 
24710 
  def read(self, iprot):
24711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24713 
      return
24714 
    iprot.readStructBegin()
24715 
    while True:
24716 
      (fname, ftype, fid) = iprot.readFieldBegin()
24717 
      if ftype == TType.STOP:
24718 
        break
24719 
      if fid == 1:
24720 
        if ftype == TType.I64:
24721 
          self.orderId = iprot.readI64();
24722 
        else:
24723 
          iprot.skip(ftype)
24724 
      else:
24725 
        iprot.skip(ftype)
24726 
      iprot.readFieldEnd()
24727 
    iprot.readStructEnd()
24728 
 
24729 
  def write(self, oprot):
24730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24732 
      return
24733 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
24734 
    if self.orderId is not None:
24735 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24736 
      oprot.writeI64(self.orderId)
24737 
      oprot.writeFieldEnd()
24738 
    oprot.writeFieldStop()
24739 
    oprot.writeStructEnd()
24740 
 
24741 
  def validate(self):
24742 
    return
24743 
 
24744 
 
24745 
  def __repr__(self):
24746 
    L = ['%s=%r' % (key, value)
24747 
      for key, value in self.__dict__.iteritems()]
24748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24749 
 
24750 
  def __eq__(self, other):
24751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24752 
 
24753 
  def __ne__(self, other):
24754 
    return not (self == other)
24755 
 
24756 
class updateOrderAsPaidToVendor_result:
24757 
  """
24758 
  Attributes:
24759 
   - ex
24760 
  """
24761 
 
24762 
  thrift_spec = (
24763 
    None, # 0
24764 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24765 
  )
24766 
 
24767 
  def __init__(self, ex=None,):
24768 
    self.ex = ex
24769 
 
24770 
  def read(self, iprot):
24771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24773 
      return
24774 
    iprot.readStructBegin()
24775 
    while True:
24776 
      (fname, ftype, fid) = iprot.readFieldBegin()
24777 
      if ftype == TType.STOP:
24778 
        break
24779 
      if fid == 1:
24780 
        if ftype == TType.STRUCT:
24781 
          self.ex = TransactionServiceException()
24782 
          self.ex.read(iprot)
24783 
        else:
24784 
          iprot.skip(ftype)
24785 
      else:
24786 
        iprot.skip(ftype)
24787 
      iprot.readFieldEnd()
24788 
    iprot.readStructEnd()
24789 
 
24790 
  def write(self, oprot):
24791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24793 
      return
24794 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
24795 
    if self.ex is not None:
24796 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24797 
      self.ex.write(oprot)
24798 
      oprot.writeFieldEnd()
24799 
    oprot.writeFieldStop()
24800 
    oprot.writeStructEnd()
24801 
 
24802 
  def validate(self):
24803 
    return
24804 
 
24805 
 
24806 
  def __repr__(self):
24807 
    L = ['%s=%r' % (key, value)
24808 
      for key, value in self.__dict__.iteritems()]
24809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24810 
 
24811 
  def __eq__(self, other):
24812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24813 
 
24814 
  def __ne__(self, other):
24815 
    return not (self == other)
5208 varun.gupt 24816 
 
5386 phani.kuma 24817 
class updateOrderOnlyAsPaidToVendor_args:
24818 
  """
24819 
  Attributes:
24820 
   - orderId
24821 
  """
24822 
 
24823 
  thrift_spec = (
24824 
    None, # 0
24825 
    (1, TType.I64, 'orderId', None, None, ), # 1
24826 
  )
24827 
 
24828 
  def __init__(self, orderId=None,):
24829 
    self.orderId = orderId
24830 
 
24831 
  def read(self, iprot):
24832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24834 
      return
24835 
    iprot.readStructBegin()
24836 
    while True:
24837 
      (fname, ftype, fid) = iprot.readFieldBegin()
24838 
      if ftype == TType.STOP:
24839 
        break
24840 
      if fid == 1:
24841 
        if ftype == TType.I64:
24842 
          self.orderId = iprot.readI64();
24843 
        else:
24844 
          iprot.skip(ftype)
24845 
      else:
24846 
        iprot.skip(ftype)
24847 
      iprot.readFieldEnd()
24848 
    iprot.readStructEnd()
24849 
 
24850 
  def write(self, oprot):
24851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24853 
      return
24854 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
24855 
    if self.orderId is not None:
24856 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24857 
      oprot.writeI64(self.orderId)
24858 
      oprot.writeFieldEnd()
24859 
    oprot.writeFieldStop()
24860 
    oprot.writeStructEnd()
24861 
 
24862 
  def validate(self):
24863 
    return
24864 
 
24865 
 
24866 
  def __repr__(self):
24867 
    L = ['%s=%r' % (key, value)
24868 
      for key, value in self.__dict__.iteritems()]
24869 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24870 
 
24871 
  def __eq__(self, other):
24872 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24873 
 
24874 
  def __ne__(self, other):
24875 
    return not (self == other)
24876 
 
24877 
class updateOrderOnlyAsPaidToVendor_result:
24878 
  """
24879 
  Attributes:
24880 
   - ex
24881 
  """
24882 
 
24883 
  thrift_spec = (
24884 
    None, # 0
24885 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24886 
  )
24887 
 
24888 
  def __init__(self, ex=None,):
24889 
    self.ex = ex
24890 
 
24891 
  def read(self, iprot):
24892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24894 
      return
24895 
    iprot.readStructBegin()
24896 
    while True:
24897 
      (fname, ftype, fid) = iprot.readFieldBegin()
24898 
      if ftype == TType.STOP:
24899 
        break
24900 
      if fid == 1:
24901 
        if ftype == TType.STRUCT:
24902 
          self.ex = TransactionServiceException()
24903 
          self.ex.read(iprot)
24904 
        else:
24905 
          iprot.skip(ftype)
24906 
      else:
24907 
        iprot.skip(ftype)
24908 
      iprot.readFieldEnd()
24909 
    iprot.readStructEnd()
24910 
 
24911 
  def write(self, oprot):
24912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24914 
      return
24915 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
24916 
    if self.ex is not None:
24917 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24918 
      self.ex.write(oprot)
24919 
      oprot.writeFieldEnd()
24920 
    oprot.writeFieldStop()
24921 
    oprot.writeStructEnd()
24922 
 
24923 
  def validate(self):
24924 
    return
24925 
 
24926 
 
24927 
  def __repr__(self):
24928 
    L = ['%s=%r' % (key, value)
24929 
      for key, value in self.__dict__.iteritems()]
24930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24931 
 
24932 
  def __eq__(self, other):
24933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24934 
 
24935 
  def __ne__(self, other):
24936 
    return not (self == other)
24937 
 
5208 varun.gupt 24938 
class getRefundedOrdersMarkedPaid_args:
24939 
 
24940 
  thrift_spec = (
24941 
  )
24942 
 
24943 
  def read(self, iprot):
24944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24946 
      return
24947 
    iprot.readStructBegin()
24948 
    while True:
24949 
      (fname, ftype, fid) = iprot.readFieldBegin()
24950 
      if ftype == TType.STOP:
24951 
        break
24952 
      else:
24953 
        iprot.skip(ftype)
24954 
      iprot.readFieldEnd()
24955 
    iprot.readStructEnd()
24956 
 
24957 
  def write(self, oprot):
24958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24960 
      return
24961 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
24962 
    oprot.writeFieldStop()
24963 
    oprot.writeStructEnd()
24964 
 
24965 
  def validate(self):
24966 
    return
24967 
 
24968 
 
24969 
  def __repr__(self):
24970 
    L = ['%s=%r' % (key, value)
24971 
      for key, value in self.__dict__.iteritems()]
24972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24973 
 
24974 
  def __eq__(self, other):
24975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24976 
 
24977 
  def __ne__(self, other):
24978 
    return not (self == other)
24979 
 
24980 
class getRefundedOrdersMarkedPaid_result:
24981 
  """
24982 
  Attributes:
24983 
   - success
24984 
   - ex
24985 
  """
24986 
 
24987 
  thrift_spec = (
24988 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24989 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24990 
  )
24991 
 
24992 
  def __init__(self, success=None, ex=None,):
24993 
    self.success = success
24994 
    self.ex = ex
24995 
 
24996 
  def read(self, iprot):
24997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24999 
      return
25000 
    iprot.readStructBegin()
25001 
    while True:
25002 
      (fname, ftype, fid) = iprot.readFieldBegin()
25003 
      if ftype == TType.STOP:
25004 
        break
25005 
      if fid == 0:
25006 
        if ftype == TType.LIST:
25007 
          self.success = []
6188 rajveer 25008 
          (_etype610, _size607) = iprot.readListBegin()
25009 
          for _i611 in xrange(_size607):
25010 
            _elem612 = Order()
25011 
            _elem612.read(iprot)
25012 
            self.success.append(_elem612)
5208 varun.gupt 25013 
          iprot.readListEnd()
25014 
        else:
25015 
          iprot.skip(ftype)
25016 
      elif fid == 1:
25017 
        if ftype == TType.STRUCT:
25018 
          self.ex = TransactionServiceException()
25019 
          self.ex.read(iprot)
25020 
        else:
25021 
          iprot.skip(ftype)
25022 
      else:
25023 
        iprot.skip(ftype)
25024 
      iprot.readFieldEnd()
25025 
    iprot.readStructEnd()
25026 
 
25027 
  def write(self, oprot):
25028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25030 
      return
25031 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
25032 
    if self.success is not None:
25033 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25034 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25035 
      for iter613 in self.success:
25036 
        iter613.write(oprot)
5208 varun.gupt 25037 
      oprot.writeListEnd()
25038 
      oprot.writeFieldEnd()
25039 
    if self.ex is not None:
25040 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25041 
      self.ex.write(oprot)
25042 
      oprot.writeFieldEnd()
25043 
    oprot.writeFieldStop()
25044 
    oprot.writeStructEnd()
25045 
 
25046 
  def validate(self):
25047 
    return
25048 
 
25049 
 
25050 
  def __repr__(self):
25051 
    L = ['%s=%r' % (key, value)
25052 
      for key, value in self.__dict__.iteritems()]
25053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25054 
 
25055 
  def __eq__(self, other):
25056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25057 
 
25058 
  def __ne__(self, other):
25059 
    return not (self == other)
5447 anupam.sin 25060 
 
25061 
class getAllVerificationAgents_args:
25062 
  """
25063 
  Attributes:
25064 
   - minOrderId
25065 
   - maxOrderId
25066 
  """
25067 
 
25068 
  thrift_spec = (
25069 
    None, # 0
25070 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
25071 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
25072 
  )
25073 
 
25074 
  def __init__(self, minOrderId=None, maxOrderId=None,):
25075 
    self.minOrderId = minOrderId
25076 
    self.maxOrderId = maxOrderId
25077 
 
25078 
  def read(self, iprot):
25079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25081 
      return
25082 
    iprot.readStructBegin()
25083 
    while True:
25084 
      (fname, ftype, fid) = iprot.readFieldBegin()
25085 
      if ftype == TType.STOP:
25086 
        break
25087 
      if fid == 1:
25088 
        if ftype == TType.I64:
25089 
          self.minOrderId = iprot.readI64();
25090 
        else:
25091 
          iprot.skip(ftype)
25092 
      elif fid == 2:
25093 
        if ftype == TType.I64:
25094 
          self.maxOrderId = iprot.readI64();
25095 
        else:
25096 
          iprot.skip(ftype)
25097 
      else:
25098 
        iprot.skip(ftype)
25099 
      iprot.readFieldEnd()
25100 
    iprot.readStructEnd()
25101 
 
25102 
  def write(self, oprot):
25103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25105 
      return
25106 
    oprot.writeStructBegin('getAllVerificationAgents_args')
25107 
    if self.minOrderId is not None:
25108 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
25109 
      oprot.writeI64(self.minOrderId)
25110 
      oprot.writeFieldEnd()
25111 
    if self.maxOrderId is not None:
25112 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
25113 
      oprot.writeI64(self.maxOrderId)
25114 
      oprot.writeFieldEnd()
25115 
    oprot.writeFieldStop()
25116 
    oprot.writeStructEnd()
25117 
 
25118 
  def validate(self):
25119 
    return
25120 
 
25121 
 
25122 
  def __repr__(self):
25123 
    L = ['%s=%r' % (key, value)
25124 
      for key, value in self.__dict__.iteritems()]
25125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25126 
 
25127 
  def __eq__(self, other):
25128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25129 
 
25130 
  def __ne__(self, other):
25131 
    return not (self == other)
25132 
 
25133 
class getAllVerificationAgents_result:
25134 
  """
25135 
  Attributes:
25136 
   - success
25137 
  """
25138 
 
25139 
  thrift_spec = (
25140 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
25141 
  )
25142 
 
25143 
  def __init__(self, success=None,):
25144 
    self.success = success
25145 
 
25146 
  def read(self, iprot):
25147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25149 
      return
25150 
    iprot.readStructBegin()
25151 
    while True:
25152 
      (fname, ftype, fid) = iprot.readFieldBegin()
25153 
      if ftype == TType.STOP:
25154 
        break
25155 
      if fid == 0:
25156 
        if ftype == TType.LIST:
25157 
          self.success = []
6188 rajveer 25158 
          (_etype617, _size614) = iprot.readListBegin()
25159 
          for _i618 in xrange(_size614):
25160 
            _elem619 = CODVerificationAgent()
25161 
            _elem619.read(iprot)
25162 
            self.success.append(_elem619)
5447 anupam.sin 25163 
          iprot.readListEnd()
25164 
        else:
25165 
          iprot.skip(ftype)
25166 
      else:
25167 
        iprot.skip(ftype)
25168 
      iprot.readFieldEnd()
25169 
    iprot.readStructEnd()
25170 
 
25171 
  def write(self, oprot):
25172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25174 
      return
25175 
    oprot.writeStructBegin('getAllVerificationAgents_result')
25176 
    if self.success is not None:
25177 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25178 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25179 
      for iter620 in self.success:
25180 
        iter620.write(oprot)
5447 anupam.sin 25181 
      oprot.writeListEnd()
25182 
      oprot.writeFieldEnd()
25183 
    oprot.writeFieldStop()
25184 
    oprot.writeStructEnd()
25185 
 
25186 
  def validate(self):
25187 
    return
25188 
 
25189 
 
25190 
  def __repr__(self):
25191 
    L = ['%s=%r' % (key, value)
25192 
      for key, value in self.__dict__.iteritems()]
25193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25194 
 
25195 
  def __eq__(self, other):
25196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25197 
 
25198 
  def __ne__(self, other):
25199 
    return not (self == other)
5527 anupam.sin 25200 
 
25201 
class getAllAttributesForOrderId_args:
25202 
  """
25203 
  Attributes:
25204 
   - orderId
25205 
  """
25206 
 
25207 
  thrift_spec = (
25208 
    None, # 0
25209 
    (1, TType.I64, 'orderId', None, None, ), # 1
25210 
  )
25211 
 
25212 
  def __init__(self, orderId=None,):
25213 
    self.orderId = orderId
25214 
 
25215 
  def read(self, iprot):
25216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25218 
      return
25219 
    iprot.readStructBegin()
25220 
    while True:
25221 
      (fname, ftype, fid) = iprot.readFieldBegin()
25222 
      if ftype == TType.STOP:
25223 
        break
25224 
      if fid == 1:
25225 
        if ftype == TType.I64:
25226 
          self.orderId = iprot.readI64();
25227 
        else:
25228 
          iprot.skip(ftype)
25229 
      else:
25230 
        iprot.skip(ftype)
25231 
      iprot.readFieldEnd()
25232 
    iprot.readStructEnd()
25233 
 
25234 
  def write(self, oprot):
25235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25237 
      return
25238 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
25239 
    if self.orderId is not None:
25240 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25241 
      oprot.writeI64(self.orderId)
25242 
      oprot.writeFieldEnd()
25243 
    oprot.writeFieldStop()
25244 
    oprot.writeStructEnd()
25245 
 
25246 
  def validate(self):
25247 
    return
25248 
 
25249 
 
25250 
  def __repr__(self):
25251 
    L = ['%s=%r' % (key, value)
25252 
      for key, value in self.__dict__.iteritems()]
25253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25254 
 
25255 
  def __eq__(self, other):
25256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25257 
 
25258 
  def __ne__(self, other):
25259 
    return not (self == other)
25260 
 
25261 
class getAllAttributesForOrderId_result:
25262 
  """
25263 
  Attributes:
25264 
   - success
25265 
  """
25266 
 
25267 
  thrift_spec = (
25268 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25269 
  )
25270 
 
25271 
  def __init__(self, success=None,):
25272 
    self.success = success
25273 
 
25274 
  def read(self, iprot):
25275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25277 
      return
25278 
    iprot.readStructBegin()
25279 
    while True:
25280 
      (fname, ftype, fid) = iprot.readFieldBegin()
25281 
      if ftype == TType.STOP:
25282 
        break
25283 
      if fid == 0:
25284 
        if ftype == TType.LIST:
25285 
          self.success = []
6188 rajveer 25286 
          (_etype624, _size621) = iprot.readListBegin()
25287 
          for _i625 in xrange(_size621):
25288 
            _elem626 = Attribute()
25289 
            _elem626.read(iprot)
25290 
            self.success.append(_elem626)
5527 anupam.sin 25291 
          iprot.readListEnd()
25292 
        else:
25293 
          iprot.skip(ftype)
25294 
      else:
25295 
        iprot.skip(ftype)
25296 
      iprot.readFieldEnd()
25297 
    iprot.readStructEnd()
25298 
 
25299 
  def write(self, oprot):
25300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25302 
      return
25303 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
25304 
    if self.success is not None:
25305 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25306 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25307 
      for iter627 in self.success:
25308 
        iter627.write(oprot)
5527 anupam.sin 25309 
      oprot.writeListEnd()
25310 
      oprot.writeFieldEnd()
25311 
    oprot.writeFieldStop()
25312 
    oprot.writeStructEnd()
25313 
 
25314 
  def validate(self):
25315 
    return
25316 
 
25317 
 
25318 
  def __repr__(self):
25319 
    L = ['%s=%r' % (key, value)
25320 
      for key, value in self.__dict__.iteritems()]
25321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25322 
 
25323 
  def __eq__(self, other):
25324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25325 
 
25326 
  def __ne__(self, other):
25327 
    return not (self == other)
25328 
 
5676 rajveer 25329 
class setOrderAttributes_args:
25330 
  """
25331 
  Attributes:
25332 
   - orderId
25333 
   - attributes
25334 
  """
25335 
 
25336 
  thrift_spec = None
25337 
  def __init__(self, orderId=None, attributes=None,):
25338 
    self.orderId = orderId
25339 
    self.attributes = attributes
25340 
 
25341 
  def read(self, iprot):
25342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25344 
      return
25345 
    iprot.readStructBegin()
25346 
    while True:
25347 
      (fname, ftype, fid) = iprot.readFieldBegin()
25348 
      if ftype == TType.STOP:
25349 
        break
25350 
      if fid == 1:
25351 
        if ftype == TType.I64:
25352 
          self.orderId = iprot.readI64();
25353 
        else:
25354 
          iprot.skip(ftype)
25355 
      elif fid == -1:
25356 
        if ftype == TType.LIST:
25357 
          self.attributes = []
6188 rajveer 25358 
          (_etype631, _size628) = iprot.readListBegin()
25359 
          for _i632 in xrange(_size628):
25360 
            _elem633 = Attribute()
25361 
            _elem633.read(iprot)
25362 
            self.attributes.append(_elem633)
5676 rajveer 25363 
          iprot.readListEnd()
25364 
        else:
25365 
          iprot.skip(ftype)
25366 
      else:
25367 
        iprot.skip(ftype)
25368 
      iprot.readFieldEnd()
25369 
    iprot.readStructEnd()
25370 
 
25371 
  def write(self, oprot):
25372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25374 
      return
25375 
    oprot.writeStructBegin('setOrderAttributes_args')
25376 
    if self.attributes is not None:
25377 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
25378 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 25379 
      for iter634 in self.attributes:
25380 
        iter634.write(oprot)
5676 rajveer 25381 
      oprot.writeListEnd()
25382 
      oprot.writeFieldEnd()
25383 
    if self.orderId is not None:
25384 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25385 
      oprot.writeI64(self.orderId)
25386 
      oprot.writeFieldEnd()
25387 
    oprot.writeFieldStop()
25388 
    oprot.writeStructEnd()
25389 
 
25390 
  def validate(self):
25391 
    return
25392 
 
25393 
 
25394 
  def __repr__(self):
25395 
    L = ['%s=%r' % (key, value)
25396 
      for key, value in self.__dict__.iteritems()]
25397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25398 
 
25399 
  def __eq__(self, other):
25400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25401 
 
25402 
  def __ne__(self, other):
25403 
    return not (self == other)
25404 
 
25405 
class setOrderAttributes_result:
25406 
 
25407 
  thrift_spec = (
25408 
  )
25409 
 
25410 
  def read(self, iprot):
25411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25413 
      return
25414 
    iprot.readStructBegin()
25415 
    while True:
25416 
      (fname, ftype, fid) = iprot.readFieldBegin()
25417 
      if ftype == TType.STOP:
25418 
        break
25419 
      else:
25420 
        iprot.skip(ftype)
25421 
      iprot.readFieldEnd()
25422 
    iprot.readStructEnd()
25423 
 
25424 
  def write(self, oprot):
25425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25427 
      return
25428 
    oprot.writeStructBegin('setOrderAttributes_result')
25429 
    oprot.writeFieldStop()
25430 
    oprot.writeStructEnd()
25431 
 
25432 
  def validate(self):
25433 
    return
25434 
 
25435 
 
25436 
  def __repr__(self):
25437 
    L = ['%s=%r' % (key, value)
25438 
      for key, value in self.__dict__.iteritems()]
25439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25440 
 
25441 
  def __eq__(self, other):
25442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25443 
 
25444 
  def __ne__(self, other):
25445 
    return not (self == other)
25446 
 
5527 anupam.sin 25447 
class setOrderAttributeForTransaction_args:
25448 
  """
25449 
  Attributes:
25450 
   - transactionId
25451 
   - attribute
25452 
  """
25453 
 
25454 
  thrift_spec = None
25455 
  def __init__(self, transactionId=None, attribute=None,):
25456 
    self.transactionId = transactionId
25457 
    self.attribute = attribute
25458 
 
25459 
  def read(self, iprot):
25460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25462 
      return
25463 
    iprot.readStructBegin()
25464 
    while True:
25465 
      (fname, ftype, fid) = iprot.readFieldBegin()
25466 
      if ftype == TType.STOP:
25467 
        break
25468 
      if fid == 1:
25469 
        if ftype == TType.I64:
25470 
          self.transactionId = iprot.readI64();
25471 
        else:
25472 
          iprot.skip(ftype)
25473 
      elif fid == -1:
25474 
        if ftype == TType.STRUCT:
25475 
          self.attribute = Attribute()
25476 
          self.attribute.read(iprot)
25477 
        else:
25478 
          iprot.skip(ftype)
25479 
      else:
25480 
        iprot.skip(ftype)
25481 
      iprot.readFieldEnd()
25482 
    iprot.readStructEnd()
25483 
 
25484 
  def write(self, oprot):
25485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25487 
      return
25488 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
25489 
    if self.attribute is not None:
25490 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
25491 
      self.attribute.write(oprot)
25492 
      oprot.writeFieldEnd()
25493 
    if self.transactionId is not None:
25494 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
25495 
      oprot.writeI64(self.transactionId)
25496 
      oprot.writeFieldEnd()
25497 
    oprot.writeFieldStop()
25498 
    oprot.writeStructEnd()
25499 
 
25500 
  def validate(self):
25501 
    return
25502 
 
25503 
 
25504 
  def __repr__(self):
25505 
    L = ['%s=%r' % (key, value)
25506 
      for key, value in self.__dict__.iteritems()]
25507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25508 
 
25509 
  def __eq__(self, other):
25510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25511 
 
25512 
  def __ne__(self, other):
25513 
    return not (self == other)
25514 
 
25515 
class setOrderAttributeForTransaction_result:
25516 
 
25517 
  thrift_spec = (
25518 
  )
25519 
 
25520 
  def read(self, iprot):
25521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25523 
      return
25524 
    iprot.readStructBegin()
25525 
    while True:
25526 
      (fname, ftype, fid) = iprot.readFieldBegin()
25527 
      if ftype == TType.STOP:
25528 
        break
25529 
      else:
25530 
        iprot.skip(ftype)
25531 
      iprot.readFieldEnd()
25532 
    iprot.readStructEnd()
25533 
 
25534 
  def write(self, oprot):
25535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25537 
      return
25538 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
25539 
    oprot.writeFieldStop()
25540 
    oprot.writeStructEnd()
25541 
 
25542 
  def validate(self):
25543 
    return
25544 
 
25545 
 
25546 
  def __repr__(self):
25547 
    L = ['%s=%r' % (key, value)
25548 
      for key, value in self.__dict__.iteritems()]
25549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25550 
 
25551 
  def __eq__(self, other):
25552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25553 
 
25554 
  def __ne__(self, other):
25555 
    return not (self == other)
5553 rajveer 25556 
 
25557 
class getReceivePendingOrders_args:
25558 
  """
25559 
  Attributes:
25560 
   - storeId
25561 
  """
25562 
 
25563 
  thrift_spec = (
25564 
    None, # 0
25565 
    (1, TType.I64, 'storeId', None, None, ), # 1
25566 
  )
25567 
 
25568 
  def __init__(self, storeId=None,):
25569 
    self.storeId = storeId
25570 
 
25571 
  def read(self, iprot):
25572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25574 
      return
25575 
    iprot.readStructBegin()
25576 
    while True:
25577 
      (fname, ftype, fid) = iprot.readFieldBegin()
25578 
      if ftype == TType.STOP:
25579 
        break
25580 
      if fid == 1:
25581 
        if ftype == TType.I64:
25582 
          self.storeId = iprot.readI64();
25583 
        else:
25584 
          iprot.skip(ftype)
25585 
      else:
25586 
        iprot.skip(ftype)
25587 
      iprot.readFieldEnd()
25588 
    iprot.readStructEnd()
25589 
 
25590 
  def write(self, oprot):
25591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25593 
      return
25594 
    oprot.writeStructBegin('getReceivePendingOrders_args')
25595 
    if self.storeId is not None:
25596 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25597 
      oprot.writeI64(self.storeId)
25598 
      oprot.writeFieldEnd()
25599 
    oprot.writeFieldStop()
25600 
    oprot.writeStructEnd()
25601 
 
25602 
  def validate(self):
25603 
    return
25604 
 
25605 
 
25606 
  def __repr__(self):
25607 
    L = ['%s=%r' % (key, value)
25608 
      for key, value in self.__dict__.iteritems()]
25609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25610 
 
25611 
  def __eq__(self, other):
25612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25613 
 
25614 
  def __ne__(self, other):
25615 
    return not (self == other)
25616 
 
25617 
class getReceivePendingOrders_result:
25618 
  """
25619 
  Attributes:
25620 
   - success
25621 
  """
25622 
 
25623 
  thrift_spec = (
25624 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25625 
  )
25626 
 
25627 
  def __init__(self, success=None,):
25628 
    self.success = success
25629 
 
25630 
  def read(self, iprot):
25631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25633 
      return
25634 
    iprot.readStructBegin()
25635 
    while True:
25636 
      (fname, ftype, fid) = iprot.readFieldBegin()
25637 
      if ftype == TType.STOP:
25638 
        break
25639 
      if fid == 0:
25640 
        if ftype == TType.LIST:
25641 
          self.success = []
6188 rajveer 25642 
          (_etype638, _size635) = iprot.readListBegin()
25643 
          for _i639 in xrange(_size635):
25644 
            _elem640 = Order()
25645 
            _elem640.read(iprot)
25646 
            self.success.append(_elem640)
5553 rajveer 25647 
          iprot.readListEnd()
25648 
        else:
25649 
          iprot.skip(ftype)
25650 
      else:
25651 
        iprot.skip(ftype)
25652 
      iprot.readFieldEnd()
25653 
    iprot.readStructEnd()
25654 
 
25655 
  def write(self, oprot):
25656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25658 
      return
25659 
    oprot.writeStructBegin('getReceivePendingOrders_result')
25660 
    if self.success is not None:
25661 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25662 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25663 
      for iter641 in self.success:
25664 
        iter641.write(oprot)
5553 rajveer 25665 
      oprot.writeListEnd()
25666 
      oprot.writeFieldEnd()
25667 
    oprot.writeFieldStop()
25668 
    oprot.writeStructEnd()
25669 
 
25670 
  def validate(self):
25671 
    return
25672 
 
25673 
 
25674 
  def __repr__(self):
25675 
    L = ['%s=%r' % (key, value)
25676 
      for key, value in self.__dict__.iteritems()]
25677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25678 
 
25679 
  def __eq__(self, other):
25680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25681 
 
25682 
  def __ne__(self, other):
25683 
    return not (self == other)
25684 
 
25685 
class getReceivedAtStoreOrders_args:
25686 
  """
25687 
  Attributes:
25688 
   - storeId
25689 
  """
25690 
 
25691 
  thrift_spec = (
25692 
    None, # 0
25693 
    (1, TType.I64, 'storeId', None, None, ), # 1
25694 
  )
25695 
 
25696 
  def __init__(self, storeId=None,):
25697 
    self.storeId = storeId
25698 
 
25699 
  def read(self, iprot):
25700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25702 
      return
25703 
    iprot.readStructBegin()
25704 
    while True:
25705 
      (fname, ftype, fid) = iprot.readFieldBegin()
25706 
      if ftype == TType.STOP:
25707 
        break
25708 
      if fid == 1:
25709 
        if ftype == TType.I64:
25710 
          self.storeId = iprot.readI64();
25711 
        else:
25712 
          iprot.skip(ftype)
25713 
      else:
25714 
        iprot.skip(ftype)
25715 
      iprot.readFieldEnd()
25716 
    iprot.readStructEnd()
25717 
 
25718 
  def write(self, oprot):
25719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25721 
      return
25722 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
25723 
    if self.storeId is not None:
25724 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25725 
      oprot.writeI64(self.storeId)
25726 
      oprot.writeFieldEnd()
25727 
    oprot.writeFieldStop()
25728 
    oprot.writeStructEnd()
25729 
 
25730 
  def validate(self):
25731 
    return
25732 
 
25733 
 
25734 
  def __repr__(self):
25735 
    L = ['%s=%r' % (key, value)
25736 
      for key, value in self.__dict__.iteritems()]
25737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25738 
 
25739 
  def __eq__(self, other):
25740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25741 
 
25742 
  def __ne__(self, other):
25743 
    return not (self == other)
25744 
 
25745 
class getReceivedAtStoreOrders_result:
25746 
  """
25747 
  Attributes:
25748 
   - success
25749 
  """
25750 
 
25751 
  thrift_spec = (
25752 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25753 
  )
25754 
 
25755 
  def __init__(self, success=None,):
25756 
    self.success = success
25757 
 
25758 
  def read(self, iprot):
25759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25761 
      return
25762 
    iprot.readStructBegin()
25763 
    while True:
25764 
      (fname, ftype, fid) = iprot.readFieldBegin()
25765 
      if ftype == TType.STOP:
25766 
        break
25767 
      if fid == 0:
25768 
        if ftype == TType.LIST:
25769 
          self.success = []
6188 rajveer 25770 
          (_etype645, _size642) = iprot.readListBegin()
25771 
          for _i646 in xrange(_size642):
25772 
            _elem647 = Order()
25773 
            _elem647.read(iprot)
25774 
            self.success.append(_elem647)
5553 rajveer 25775 
          iprot.readListEnd()
25776 
        else:
25777 
          iprot.skip(ftype)
25778 
      else:
25779 
        iprot.skip(ftype)
25780 
      iprot.readFieldEnd()
25781 
    iprot.readStructEnd()
25782 
 
25783 
  def write(self, oprot):
25784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25786 
      return
25787 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
25788 
    if self.success is not None:
25789 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25790 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25791 
      for iter648 in self.success:
25792 
        iter648.write(oprot)
5553 rajveer 25793 
      oprot.writeListEnd()
25794 
      oprot.writeFieldEnd()
25795 
    oprot.writeFieldStop()
25796 
    oprot.writeStructEnd()
25797 
 
25798 
  def validate(self):
25799 
    return
25800 
 
25801 
 
25802 
  def __repr__(self):
25803 
    L = ['%s=%r' % (key, value)
25804 
      for key, value in self.__dict__.iteritems()]
25805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25806 
 
25807 
  def __eq__(self, other):
25808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25809 
 
25810 
  def __ne__(self, other):
25811 
    return not (self == other)
5593 mandeep.dh 25812 
 
5713 rajveer 25813 
class getOrdersCollectionAtStore_args:
25814 
  """
25815 
  Attributes:
25816 
   - storeId
25817 
   - fromDate
25818 
   - toDate
25819 
   - onlyCod
25820 
  """
25821 
 
25822 
  thrift_spec = (
25823 
    None, # 0
25824 
    (1, TType.I64, 'storeId', None, None, ), # 1
25825 
    (2, TType.I64, 'fromDate', None, None, ), # 2
25826 
    (3, TType.I64, 'toDate', None, None, ), # 3
25827 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
25828 
  )
25829 
 
25830 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
25831 
    self.storeId = storeId
25832 
    self.fromDate = fromDate
25833 
    self.toDate = toDate
25834 
    self.onlyCod = onlyCod
25835 
 
25836 
  def read(self, iprot):
25837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25839 
      return
25840 
    iprot.readStructBegin()
25841 
    while True:
25842 
      (fname, ftype, fid) = iprot.readFieldBegin()
25843 
      if ftype == TType.STOP:
25844 
        break
25845 
      if fid == 1:
25846 
        if ftype == TType.I64:
25847 
          self.storeId = iprot.readI64();
25848 
        else:
25849 
          iprot.skip(ftype)
25850 
      elif fid == 2:
25851 
        if ftype == TType.I64:
25852 
          self.fromDate = iprot.readI64();
25853 
        else:
25854 
          iprot.skip(ftype)
25855 
      elif fid == 3:
25856 
        if ftype == TType.I64:
25857 
          self.toDate = iprot.readI64();
25858 
        else:
25859 
          iprot.skip(ftype)
25860 
      elif fid == 4:
25861 
        if ftype == TType.BOOL:
25862 
          self.onlyCod = iprot.readBool();
25863 
        else:
25864 
          iprot.skip(ftype)
25865 
      else:
25866 
        iprot.skip(ftype)
25867 
      iprot.readFieldEnd()
25868 
    iprot.readStructEnd()
25869 
 
25870 
  def write(self, oprot):
25871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25873 
      return
25874 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
25875 
    if self.storeId is not None:
25876 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25877 
      oprot.writeI64(self.storeId)
25878 
      oprot.writeFieldEnd()
25879 
    if self.fromDate is not None:
25880 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
25881 
      oprot.writeI64(self.fromDate)
25882 
      oprot.writeFieldEnd()
25883 
    if self.toDate is not None:
25884 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
25885 
      oprot.writeI64(self.toDate)
25886 
      oprot.writeFieldEnd()
25887 
    if self.onlyCod is not None:
25888 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
25889 
      oprot.writeBool(self.onlyCod)
25890 
      oprot.writeFieldEnd()
25891 
    oprot.writeFieldStop()
25892 
    oprot.writeStructEnd()
25893 
 
25894 
  def validate(self):
25895 
    return
25896 
 
25897 
 
25898 
  def __repr__(self):
25899 
    L = ['%s=%r' % (key, value)
25900 
      for key, value in self.__dict__.iteritems()]
25901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25902 
 
25903 
  def __eq__(self, other):
25904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25905 
 
25906 
  def __ne__(self, other):
25907 
    return not (self == other)
25908 
 
25909 
class getOrdersCollectionAtStore_result:
25910 
  """
25911 
  Attributes:
25912 
   - success
25913 
  """
25914 
 
25915 
  thrift_spec = (
25916 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25917 
  )
25918 
 
25919 
  def __init__(self, success=None,):
25920 
    self.success = success
25921 
 
25922 
  def read(self, iprot):
25923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25925 
      return
25926 
    iprot.readStructBegin()
25927 
    while True:
25928 
      (fname, ftype, fid) = iprot.readFieldBegin()
25929 
      if ftype == TType.STOP:
25930 
        break
25931 
      if fid == 0:
25932 
        if ftype == TType.LIST:
25933 
          self.success = []
6188 rajveer 25934 
          (_etype652, _size649) = iprot.readListBegin()
25935 
          for _i653 in xrange(_size649):
25936 
            _elem654 = Order()
25937 
            _elem654.read(iprot)
25938 
            self.success.append(_elem654)
5713 rajveer 25939 
          iprot.readListEnd()
25940 
        else:
25941 
          iprot.skip(ftype)
25942 
      else:
25943 
        iprot.skip(ftype)
25944 
      iprot.readFieldEnd()
25945 
    iprot.readStructEnd()
25946 
 
25947 
  def write(self, oprot):
25948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25950 
      return
25951 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
25952 
    if self.success is not None:
25953 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25954 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25955 
      for iter655 in self.success:
25956 
        iter655.write(oprot)
5713 rajveer 25957 
      oprot.writeListEnd()
25958 
      oprot.writeFieldEnd()
25959 
    oprot.writeFieldStop()
25960 
    oprot.writeStructEnd()
25961 
 
25962 
  def validate(self):
25963 
    return
25964 
 
25965 
 
25966 
  def __repr__(self):
25967 
    L = ['%s=%r' % (key, value)
25968 
      for key, value in self.__dict__.iteritems()]
25969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25970 
 
25971 
  def __eq__(self, other):
25972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25973 
 
25974 
  def __ne__(self, other):
25975 
    return not (self == other)
25976 
 
5833 rajveer 25977 
class getOrderAttributeValue_args:
25978 
  """
25979 
  Attributes:
25980 
   - orderId
25981 
   - attributeName
25982 
  """
25983 
 
25984 
  thrift_spec = None
25985 
  def __init__(self, orderId=None, attributeName=None,):
25986 
    self.orderId = orderId
25987 
    self.attributeName = attributeName
25988 
 
25989 
  def read(self, iprot):
25990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25992 
      return
25993 
    iprot.readStructBegin()
25994 
    while True:
25995 
      (fname, ftype, fid) = iprot.readFieldBegin()
25996 
      if ftype == TType.STOP:
25997 
        break
25998 
      if fid == 1:
25999 
        if ftype == TType.I64:
26000 
          self.orderId = iprot.readI64();
26001 
        else:
26002 
          iprot.skip(ftype)
26003 
      elif fid == -1:
26004 
        if ftype == TType.STRING:
26005 
          self.attributeName = iprot.readString();
26006 
        else:
26007 
          iprot.skip(ftype)
26008 
      else:
26009 
        iprot.skip(ftype)
26010 
      iprot.readFieldEnd()
26011 
    iprot.readStructEnd()
26012 
 
26013 
  def write(self, oprot):
26014 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26015 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26016 
      return
26017 
    oprot.writeStructBegin('getOrderAttributeValue_args')
26018 
    if self.attributeName is not None:
26019 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
26020 
      oprot.writeString(self.attributeName)
26021 
      oprot.writeFieldEnd()
26022 
    if self.orderId is not None:
26023 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26024 
      oprot.writeI64(self.orderId)
26025 
      oprot.writeFieldEnd()
26026 
    oprot.writeFieldStop()
26027 
    oprot.writeStructEnd()
26028 
 
26029 
  def validate(self):
26030 
    return
26031 
 
26032 
 
26033 
  def __repr__(self):
26034 
    L = ['%s=%r' % (key, value)
26035 
      for key, value in self.__dict__.iteritems()]
26036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26037 
 
26038 
  def __eq__(self, other):
26039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26040 
 
26041 
  def __ne__(self, other):
26042 
    return not (self == other)
26043 
 
26044 
class getOrderAttributeValue_result:
26045 
  """
26046 
  Attributes:
26047 
   - success
26048 
  """
26049 
 
26050 
  thrift_spec = (
26051 
    (0, TType.STRING, 'success', None, None, ), # 0
26052 
  )
26053 
 
26054 
  def __init__(self, success=None,):
26055 
    self.success = success
26056 
 
26057 
  def read(self, iprot):
26058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26060 
      return
26061 
    iprot.readStructBegin()
26062 
    while True:
26063 
      (fname, ftype, fid) = iprot.readFieldBegin()
26064 
      if ftype == TType.STOP:
26065 
        break
26066 
      if fid == 0:
26067 
        if ftype == TType.STRING:
26068 
          self.success = iprot.readString();
26069 
        else:
26070 
          iprot.skip(ftype)
26071 
      else:
26072 
        iprot.skip(ftype)
26073 
      iprot.readFieldEnd()
26074 
    iprot.readStructEnd()
26075 
 
26076 
  def write(self, oprot):
26077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26079 
      return
26080 
    oprot.writeStructBegin('getOrderAttributeValue_result')
26081 
    if self.success is not None:
26082 
      oprot.writeFieldBegin('success', TType.STRING, 0)
26083 
      oprot.writeString(self.success)
26084 
      oprot.writeFieldEnd()
26085 
    oprot.writeFieldStop()
26086 
    oprot.writeStructEnd()
26087 
 
26088 
  def validate(self):
26089 
    return
26090 
 
26091 
 
26092 
  def __repr__(self):
26093 
    L = ['%s=%r' % (key, value)
26094 
      for key, value in self.__dict__.iteritems()]
26095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26096 
 
26097 
  def __eq__(self, other):
26098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26099 
 
26100 
  def __ne__(self, other):
26101 
    return not (self == other)
26102 
 
6019 rajveer 26103 
class changeJacketNumber_args:
26104 
  """
26105 
  Attributes:
26106 
   - orderId
26107 
   - jacketNumber
26108 
  """
26109 
 
26110 
  thrift_spec = (
26111 
    None, # 0
26112 
    (1, TType.I64, 'orderId', None, None, ), # 1
26113 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
26114 
  )
26115 
 
26116 
  def __init__(self, orderId=None, jacketNumber=None,):
26117 
    self.orderId = orderId
26118 
    self.jacketNumber = jacketNumber
26119 
 
26120 
  def read(self, iprot):
26121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26123 
      return
26124 
    iprot.readStructBegin()
26125 
    while True:
26126 
      (fname, ftype, fid) = iprot.readFieldBegin()
26127 
      if ftype == TType.STOP:
26128 
        break
26129 
      if fid == 1:
26130 
        if ftype == TType.I64:
26131 
          self.orderId = iprot.readI64();
26132 
        else:
26133 
          iprot.skip(ftype)
26134 
      elif fid == 2:
26135 
        if ftype == TType.I64:
26136 
          self.jacketNumber = iprot.readI64();
26137 
        else:
26138 
          iprot.skip(ftype)
26139 
      else:
26140 
        iprot.skip(ftype)
26141 
      iprot.readFieldEnd()
26142 
    iprot.readStructEnd()
26143 
 
26144 
  def write(self, oprot):
26145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26147 
      return
26148 
    oprot.writeStructBegin('changeJacketNumber_args')
26149 
    if self.orderId is not None:
26150 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26151 
      oprot.writeI64(self.orderId)
26152 
      oprot.writeFieldEnd()
26153 
    if self.jacketNumber is not None:
26154 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
26155 
      oprot.writeI64(self.jacketNumber)
26156 
      oprot.writeFieldEnd()
26157 
    oprot.writeFieldStop()
26158 
    oprot.writeStructEnd()
26159 
 
26160 
  def validate(self):
26161 
    return
26162 
 
26163 
 
26164 
  def __repr__(self):
26165 
    L = ['%s=%r' % (key, value)
26166 
      for key, value in self.__dict__.iteritems()]
26167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26168 
 
26169 
  def __eq__(self, other):
26170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26171 
 
26172 
  def __ne__(self, other):
26173 
    return not (self == other)
26174 
 
26175 
class changeJacketNumber_result:
26176 
  """
26177 
  Attributes:
26178 
   - success
26179 
  """
26180 
 
26181 
  thrift_spec = (
26182 
    (0, TType.BOOL, 'success', None, None, ), # 0
26183 
  )
26184 
 
26185 
  def __init__(self, success=None,):
26186 
    self.success = success
26187 
 
26188 
  def read(self, iprot):
26189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26191 
      return
26192 
    iprot.readStructBegin()
26193 
    while True:
26194 
      (fname, ftype, fid) = iprot.readFieldBegin()
26195 
      if ftype == TType.STOP:
26196 
        break
26197 
      if fid == 0:
26198 
        if ftype == TType.BOOL:
26199 
          self.success = iprot.readBool();
26200 
        else:
26201 
          iprot.skip(ftype)
26202 
      else:
26203 
        iprot.skip(ftype)
26204 
      iprot.readFieldEnd()
26205 
    iprot.readStructEnd()
26206 
 
26207 
  def write(self, oprot):
26208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26210 
      return
26211 
    oprot.writeStructBegin('changeJacketNumber_result')
26212 
    if self.success is not None:
26213 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26214 
      oprot.writeBool(self.success)
26215 
      oprot.writeFieldEnd()
26216 
    oprot.writeFieldStop()
26217 
    oprot.writeStructEnd()
26218 
 
26219 
  def validate(self):
26220 
    return
26221 
 
26222 
 
26223 
  def __repr__(self):
26224 
    L = ['%s=%r' % (key, value)
26225 
      for key, value in self.__dict__.iteritems()]
26226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26227 
 
26228 
  def __eq__(self, other):
26229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26230 
 
26231 
  def __ne__(self, other):
26232 
    return not (self == other)
26233 
 
26234 
class markOrderAsRtoInTransit_args:
26235 
  """
26236 
  Attributes:
26237 
   - orderId
26238 
  """
26239 
 
26240 
  thrift_spec = (
26241 
    None, # 0
26242 
    (1, TType.I64, 'orderId', None, None, ), # 1
26243 
  )
26244 
 
26245 
  def __init__(self, orderId=None,):
26246 
    self.orderId = orderId
26247 
 
26248 
  def read(self, iprot):
26249 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26250 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26251 
      return
26252 
    iprot.readStructBegin()
26253 
    while True:
26254 
      (fname, ftype, fid) = iprot.readFieldBegin()
26255 
      if ftype == TType.STOP:
26256 
        break
26257 
      if fid == 1:
26258 
        if ftype == TType.I64:
26259 
          self.orderId = iprot.readI64();
26260 
        else:
26261 
          iprot.skip(ftype)
26262 
      else:
26263 
        iprot.skip(ftype)
26264 
      iprot.readFieldEnd()
26265 
    iprot.readStructEnd()
26266 
 
26267 
  def write(self, oprot):
26268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26270 
      return
26271 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26272 
    if self.orderId is not None:
26273 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26274 
      oprot.writeI64(self.orderId)
26275 
      oprot.writeFieldEnd()
26276 
    oprot.writeFieldStop()
26277 
    oprot.writeStructEnd()
26278 
 
26279 
  def validate(self):
26280 
    return
26281 
 
26282 
 
26283 
  def __repr__(self):
26284 
    L = ['%s=%r' % (key, value)
26285 
      for key, value in self.__dict__.iteritems()]
26286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26287 
 
26288 
  def __eq__(self, other):
26289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26290 
 
26291 
  def __ne__(self, other):
26292 
    return not (self == other)
26293 
 
26294 
class markOrderAsRtoInTransit_result:
26295 
  """
26296 
  Attributes:
26297 
   - success
26298 
  """
26299 
 
26300 
  thrift_spec = (
26301 
    (0, TType.BOOL, 'success', None, None, ), # 0
26302 
  )
26303 
 
26304 
  def __init__(self, success=None,):
26305 
    self.success = success
26306 
 
26307 
  def read(self, iprot):
26308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26310 
      return
26311 
    iprot.readStructBegin()
26312 
    while True:
26313 
      (fname, ftype, fid) = iprot.readFieldBegin()
26314 
      if ftype == TType.STOP:
26315 
        break
26316 
      if fid == 0:
26317 
        if ftype == TType.BOOL:
26318 
          self.success = iprot.readBool();
26319 
        else:
26320 
          iprot.skip(ftype)
26321 
      else:
26322 
        iprot.skip(ftype)
26323 
      iprot.readFieldEnd()
26324 
    iprot.readStructEnd()
26325 
 
26326 
  def write(self, oprot):
26327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26329 
      return
26330 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
26331 
    if self.success is not None:
26332 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26333 
      oprot.writeBool(self.success)
26334 
      oprot.writeFieldEnd()
26335 
    oprot.writeFieldStop()
26336 
    oprot.writeStructEnd()
26337 
 
26338 
  def validate(self):
26339 
    return
26340 
 
26341 
 
26342 
  def __repr__(self):
26343 
    L = ['%s=%r' % (key, value)
26344 
      for key, value in self.__dict__.iteritems()]
26345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26346 
 
26347 
  def __eq__(self, other):
26348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26349 
 
26350 
  def __ne__(self, other):
26351 
    return not (self == other)
26352 
 
5593 mandeep.dh 26353 
class acceptOrderForItem_args:
26354 
  """
26355 
  Attributes:
26356 
   - itemId
26357 
   - quantity
26358 
   - fulfilmentWarehouseId
26359 
   - billingWarehouseId
26360 
  """
26361 
 
26362 
  thrift_spec = (
26363 
    None, # 0
26364 
    (1, TType.I64, 'itemId', None, None, ), # 1
26365 
    (2, TType.I64, 'quantity', None, None, ), # 2
26366 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
26367 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
26368 
  )
26369 
 
26370 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
26371 
    self.itemId = itemId
26372 
    self.quantity = quantity
26373 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
26374 
    self.billingWarehouseId = billingWarehouseId
26375 
 
26376 
  def read(self, iprot):
26377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26379 
      return
26380 
    iprot.readStructBegin()
26381 
    while True:
26382 
      (fname, ftype, fid) = iprot.readFieldBegin()
26383 
      if ftype == TType.STOP:
26384 
        break
26385 
      if fid == 1:
26386 
        if ftype == TType.I64:
26387 
          self.itemId = iprot.readI64();
26388 
        else:
26389 
          iprot.skip(ftype)
26390 
      elif fid == 2:
26391 
        if ftype == TType.I64:
26392 
          self.quantity = iprot.readI64();
26393 
        else:
26394 
          iprot.skip(ftype)
26395 
      elif fid == 3:
26396 
        if ftype == TType.I64:
26397 
          self.fulfilmentWarehouseId = iprot.readI64();
26398 
        else:
26399 
          iprot.skip(ftype)
26400 
      elif fid == 4:
26401 
        if ftype == TType.I64:
26402 
          self.billingWarehouseId = iprot.readI64();
26403 
        else:
26404 
          iprot.skip(ftype)
26405 
      else:
26406 
        iprot.skip(ftype)
26407 
      iprot.readFieldEnd()
26408 
    iprot.readStructEnd()
26409 
 
26410 
  def write(self, oprot):
26411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26413 
      return
26414 
    oprot.writeStructBegin('acceptOrderForItem_args')
26415 
    if self.itemId is not None:
26416 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26417 
      oprot.writeI64(self.itemId)
26418 
      oprot.writeFieldEnd()
26419 
    if self.quantity is not None:
26420 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
26421 
      oprot.writeI64(self.quantity)
26422 
      oprot.writeFieldEnd()
26423 
    if self.fulfilmentWarehouseId is not None:
26424 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26425 
      oprot.writeI64(self.fulfilmentWarehouseId)
26426 
      oprot.writeFieldEnd()
26427 
    if self.billingWarehouseId is not None:
26428 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26429 
      oprot.writeI64(self.billingWarehouseId)
26430 
      oprot.writeFieldEnd()
26431 
    oprot.writeFieldStop()
26432 
    oprot.writeStructEnd()
26433 
 
26434 
  def validate(self):
26435 
    return
26436 
 
26437 
 
26438 
  def __repr__(self):
26439 
    L = ['%s=%r' % (key, value)
26440 
      for key, value in self.__dict__.iteritems()]
26441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26442 
 
26443 
  def __eq__(self, other):
26444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26445 
 
26446 
  def __ne__(self, other):
26447 
    return not (self == other)
26448 
 
26449 
class acceptOrderForItem_result:
26450 
 
26451 
  thrift_spec = (
26452 
  )
26453 
 
26454 
  def read(self, iprot):
26455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26457 
      return
26458 
    iprot.readStructBegin()
26459 
    while True:
26460 
      (fname, ftype, fid) = iprot.readFieldBegin()
26461 
      if ftype == TType.STOP:
26462 
        break
26463 
      else:
26464 
        iprot.skip(ftype)
26465 
      iprot.readFieldEnd()
26466 
    iprot.readStructEnd()
26467 
 
26468 
  def write(self, oprot):
26469 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26470 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26471 
      return
26472 
    oprot.writeStructBegin('acceptOrderForItem_result')
26473 
    oprot.writeFieldStop()
26474 
    oprot.writeStructEnd()
26475 
 
26476 
  def validate(self):
26477 
    return
26478 
 
26479 
 
26480 
  def __repr__(self):
26481 
    L = ['%s=%r' % (key, value)
26482 
      for key, value in self.__dict__.iteritems()]
26483 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26484 
 
26485 
  def __eq__(self, other):
26486 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26487 
 
26488 
  def __ne__(self, other):
26489 
    return not (self == other)
6000 mandeep.dh 26490 
 
26491 
class createRechargeOrder_args:
26492 
  """
26493 
  Attributes:
26494 
   - rechargeOrder
26495 
  """
26496 
 
26497 
  thrift_spec = (
26498 
    None, # 0
26499 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
26500 
  )
26501 
 
26502 
  def __init__(self, rechargeOrder=None,):
26503 
    self.rechargeOrder = rechargeOrder
26504 
 
26505 
  def read(self, iprot):
26506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26508 
      return
26509 
    iprot.readStructBegin()
26510 
    while True:
26511 
      (fname, ftype, fid) = iprot.readFieldBegin()
26512 
      if ftype == TType.STOP:
26513 
        break
26514 
      if fid == 1:
26515 
        if ftype == TType.STRUCT:
26516 
          self.rechargeOrder = RechargeOrder()
26517 
          self.rechargeOrder.read(iprot)
26518 
        else:
26519 
          iprot.skip(ftype)
26520 
      else:
26521 
        iprot.skip(ftype)
26522 
      iprot.readFieldEnd()
26523 
    iprot.readStructEnd()
26524 
 
26525 
  def write(self, oprot):
26526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26528 
      return
26529 
    oprot.writeStructBegin('createRechargeOrder_args')
26530 
    if self.rechargeOrder is not None:
26531 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
26532 
      self.rechargeOrder.write(oprot)
26533 
      oprot.writeFieldEnd()
26534 
    oprot.writeFieldStop()
26535 
    oprot.writeStructEnd()
26536 
 
26537 
  def validate(self):
26538 
    return
26539 
 
26540 
 
26541 
  def __repr__(self):
26542 
    L = ['%s=%r' % (key, value)
26543 
      for key, value in self.__dict__.iteritems()]
26544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26545 
 
26546 
  def __eq__(self, other):
26547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26548 
 
26549 
  def __ne__(self, other):
26550 
    return not (self == other)
26551 
 
26552 
class createRechargeOrder_result:
26553 
  """
26554 
  Attributes:
26555 
   - success
26556 
   - ex
26557 
  """
26558 
 
26559 
  thrift_spec = (
26560 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26561 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26562 
  )
26563 
 
26564 
  def __init__(self, success=None, ex=None,):
26565 
    self.success = success
26566 
    self.ex = ex
26567 
 
26568 
  def read(self, iprot):
26569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26571 
      return
26572 
    iprot.readStructBegin()
26573 
    while True:
26574 
      (fname, ftype, fid) = iprot.readFieldBegin()
26575 
      if ftype == TType.STOP:
26576 
        break
26577 
      if fid == 0:
26578 
        if ftype == TType.STRUCT:
26579 
          self.success = RechargeOrder()
26580 
          self.success.read(iprot)
26581 
        else:
26582 
          iprot.skip(ftype)
26583 
      elif fid == 1:
26584 
        if ftype == TType.STRUCT:
26585 
          self.ex = TransactionServiceException()
26586 
          self.ex.read(iprot)
26587 
        else:
26588 
          iprot.skip(ftype)
26589 
      else:
26590 
        iprot.skip(ftype)
26591 
      iprot.readFieldEnd()
26592 
    iprot.readStructEnd()
26593 
 
26594 
  def write(self, oprot):
26595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26597 
      return
26598 
    oprot.writeStructBegin('createRechargeOrder_result')
26599 
    if self.success is not None:
26600 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26601 
      self.success.write(oprot)
26602 
      oprot.writeFieldEnd()
26603 
    if self.ex is not None:
26604 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26605 
      self.ex.write(oprot)
26606 
      oprot.writeFieldEnd()
26607 
    oprot.writeFieldStop()
26608 
    oprot.writeStructEnd()
26609 
 
26610 
  def validate(self):
26611 
    return
26612 
 
26613 
 
26614 
  def __repr__(self):
26615 
    L = ['%s=%r' % (key, value)
26616 
      for key, value in self.__dict__.iteritems()]
26617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26618 
 
26619 
  def __eq__(self, other):
26620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26621 
 
26622 
  def __ne__(self, other):
26623 
    return not (self == other)
26624 
 
6031 rajveer 26625 
class getRechargeOrder_args:
26626 
  """
26627 
  Attributes:
26628 
   - rechargeRrderId
26629 
  """
26630 
 
26631 
  thrift_spec = (
26632 
    None, # 0
26633 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
26634 
  )
26635 
 
26636 
  def __init__(self, rechargeRrderId=None,):
26637 
    self.rechargeRrderId = rechargeRrderId
26638 
 
26639 
  def read(self, iprot):
26640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26642 
      return
26643 
    iprot.readStructBegin()
26644 
    while True:
26645 
      (fname, ftype, fid) = iprot.readFieldBegin()
26646 
      if ftype == TType.STOP:
26647 
        break
26648 
      if fid == 1:
26649 
        if ftype == TType.I64:
26650 
          self.rechargeRrderId = iprot.readI64();
26651 
        else:
26652 
          iprot.skip(ftype)
26653 
      else:
26654 
        iprot.skip(ftype)
26655 
      iprot.readFieldEnd()
26656 
    iprot.readStructEnd()
26657 
 
26658 
  def write(self, oprot):
26659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26661 
      return
26662 
    oprot.writeStructBegin('getRechargeOrder_args')
26663 
    if self.rechargeRrderId is not None:
26664 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
26665 
      oprot.writeI64(self.rechargeRrderId)
26666 
      oprot.writeFieldEnd()
26667 
    oprot.writeFieldStop()
26668 
    oprot.writeStructEnd()
26669 
 
26670 
  def validate(self):
26671 
    return
26672 
 
26673 
 
26674 
  def __repr__(self):
26675 
    L = ['%s=%r' % (key, value)
26676 
      for key, value in self.__dict__.iteritems()]
26677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26678 
 
26679 
  def __eq__(self, other):
26680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26681 
 
26682 
  def __ne__(self, other):
26683 
    return not (self == other)
26684 
 
26685 
class getRechargeOrder_result:
26686 
  """
26687 
  Attributes:
26688 
   - success
26689 
   - ex
26690 
  """
26691 
 
26692 
  thrift_spec = (
26693 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26694 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26695 
  )
26696 
 
26697 
  def __init__(self, success=None, ex=None,):
26698 
    self.success = success
26699 
    self.ex = ex
26700 
 
26701 
  def read(self, iprot):
26702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26704 
      return
26705 
    iprot.readStructBegin()
26706 
    while True:
26707 
      (fname, ftype, fid) = iprot.readFieldBegin()
26708 
      if ftype == TType.STOP:
26709 
        break
26710 
      if fid == 0:
26711 
        if ftype == TType.STRUCT:
26712 
          self.success = RechargeOrder()
26713 
          self.success.read(iprot)
26714 
        else:
26715 
          iprot.skip(ftype)
26716 
      elif fid == 1:
26717 
        if ftype == TType.STRUCT:
26718 
          self.ex = TransactionServiceException()
26719 
          self.ex.read(iprot)
26720 
        else:
26721 
          iprot.skip(ftype)
26722 
      else:
26723 
        iprot.skip(ftype)
26724 
      iprot.readFieldEnd()
26725 
    iprot.readStructEnd()
26726 
 
26727 
  def write(self, oprot):
26728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26730 
      return
26731 
    oprot.writeStructBegin('getRechargeOrder_result')
26732 
    if self.success is not None:
26733 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26734 
      self.success.write(oprot)
26735 
      oprot.writeFieldEnd()
26736 
    if self.ex is not None:
26737 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26738 
      self.ex.write(oprot)
26739 
      oprot.writeFieldEnd()
26740 
    oprot.writeFieldStop()
26741 
    oprot.writeStructEnd()
26742 
 
26743 
  def validate(self):
26744 
    return
26745 
 
26746 
 
26747 
  def __repr__(self):
26748 
    L = ['%s=%r' % (key, value)
26749 
      for key, value in self.__dict__.iteritems()]
26750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26751 
 
26752 
  def __eq__(self, other):
26753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26754 
 
26755 
  def __ne__(self, other):
26756 
    return not (self == other)
26757 
 
26758 
class getRechargeOrders_args:
26759 
  """
26760 
  Attributes:
26761 
   - userId
26762 
  """
26763 
 
26764 
  thrift_spec = (
26765 
    None, # 0
26766 
    (1, TType.I64, 'userId', None, None, ), # 1
26767 
  )
26768 
 
26769 
  def __init__(self, userId=None,):
26770 
    self.userId = userId
26771 
 
26772 
  def read(self, iprot):
26773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26775 
      return
26776 
    iprot.readStructBegin()
26777 
    while True:
26778 
      (fname, ftype, fid) = iprot.readFieldBegin()
26779 
      if ftype == TType.STOP:
26780 
        break
26781 
      if fid == 1:
26782 
        if ftype == TType.I64:
26783 
          self.userId = iprot.readI64();
26784 
        else:
26785 
          iprot.skip(ftype)
26786 
      else:
26787 
        iprot.skip(ftype)
26788 
      iprot.readFieldEnd()
26789 
    iprot.readStructEnd()
26790 
 
26791 
  def write(self, oprot):
26792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26794 
      return
26795 
    oprot.writeStructBegin('getRechargeOrders_args')
26796 
    if self.userId is not None:
26797 
      oprot.writeFieldBegin('userId', TType.I64, 1)
26798 
      oprot.writeI64(self.userId)
26799 
      oprot.writeFieldEnd()
26800 
    oprot.writeFieldStop()
26801 
    oprot.writeStructEnd()
26802 
 
26803 
  def validate(self):
26804 
    return
26805 
 
26806 
 
26807 
  def __repr__(self):
26808 
    L = ['%s=%r' % (key, value)
26809 
      for key, value in self.__dict__.iteritems()]
26810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26811 
 
26812 
  def __eq__(self, other):
26813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26814 
 
26815 
  def __ne__(self, other):
26816 
    return not (self == other)
26817 
 
26818 
class getRechargeOrders_result:
26819 
  """
26820 
  Attributes:
26821 
   - success
26822 
  """
26823 
 
26824 
  thrift_spec = (
26825 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
26826 
  )
26827 
 
26828 
  def __init__(self, success=None,):
26829 
    self.success = success
26830 
 
26831 
  def read(self, iprot):
26832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26834 
      return
26835 
    iprot.readStructBegin()
26836 
    while True:
26837 
      (fname, ftype, fid) = iprot.readFieldBegin()
26838 
      if ftype == TType.STOP:
26839 
        break
26840 
      if fid == 0:
26841 
        if ftype == TType.LIST:
26842 
          self.success = []
6188 rajveer 26843 
          (_etype659, _size656) = iprot.readListBegin()
26844 
          for _i660 in xrange(_size656):
26845 
            _elem661 = RechargeOrder()
26846 
            _elem661.read(iprot)
26847 
            self.success.append(_elem661)
6031 rajveer 26848 
          iprot.readListEnd()
26849 
        else:
26850 
          iprot.skip(ftype)
26851 
      else:
26852 
        iprot.skip(ftype)
26853 
      iprot.readFieldEnd()
26854 
    iprot.readStructEnd()
26855 
 
26856 
  def write(self, oprot):
26857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26859 
      return
26860 
    oprot.writeStructBegin('getRechargeOrders_result')
26861 
    if self.success is not None:
26862 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26863 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26864 
      for iter662 in self.success:
26865 
        iter662.write(oprot)
6031 rajveer 26866 
      oprot.writeListEnd()
26867 
      oprot.writeFieldEnd()
26868 
    oprot.writeFieldStop()
26869 
    oprot.writeStructEnd()
26870 
 
26871 
  def validate(self):
26872 
    return
26873 
 
26874 
 
26875 
  def __repr__(self):
26876 
    L = ['%s=%r' % (key, value)
26877 
      for key, value in self.__dict__.iteritems()]
26878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26879 
 
26880 
  def __eq__(self, other):
26881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26882 
 
26883 
  def __ne__(self, other):
26884 
    return not (self == other)
26885 
 
6000 mandeep.dh 26886 
class updateRechargeOrderStatus_args:
26887 
  """
26888 
  Attributes:
26889 
   - rechargeOrderId
26890 
   - rechargeOrderStatus
26891 
  """
26892 
 
26893 
  thrift_spec = (
26894 
    None, # 0
26895 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
26896 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
26897 
  )
26898 
 
26899 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
26900 
    self.rechargeOrderId = rechargeOrderId
26901 
    self.rechargeOrderStatus = rechargeOrderStatus
26902 
 
26903 
  def read(self, iprot):
26904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26906 
      return
26907 
    iprot.readStructBegin()
26908 
    while True:
26909 
      (fname, ftype, fid) = iprot.readFieldBegin()
26910 
      if ftype == TType.STOP:
26911 
        break
26912 
      if fid == 1:
26913 
        if ftype == TType.I64:
26914 
          self.rechargeOrderId = iprot.readI64();
26915 
        else:
26916 
          iprot.skip(ftype)
26917 
      elif fid == 2:
26918 
        if ftype == TType.I32:
26919 
          self.rechargeOrderStatus = iprot.readI32();
26920 
        else:
26921 
          iprot.skip(ftype)
26922 
      else:
26923 
        iprot.skip(ftype)
26924 
      iprot.readFieldEnd()
26925 
    iprot.readStructEnd()
26926 
 
26927 
  def write(self, oprot):
26928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26930 
      return
26931 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
26932 
    if self.rechargeOrderId is not None:
26933 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
26934 
      oprot.writeI64(self.rechargeOrderId)
26935 
      oprot.writeFieldEnd()
26936 
    if self.rechargeOrderStatus is not None:
26937 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
26938 
      oprot.writeI32(self.rechargeOrderStatus)
26939 
      oprot.writeFieldEnd()
26940 
    oprot.writeFieldStop()
26941 
    oprot.writeStructEnd()
26942 
 
26943 
  def validate(self):
26944 
    return
26945 
 
26946 
 
26947 
  def __repr__(self):
26948 
    L = ['%s=%r' % (key, value)
26949 
      for key, value in self.__dict__.iteritems()]
26950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26951 
 
26952 
  def __eq__(self, other):
26953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26954 
 
26955 
  def __ne__(self, other):
26956 
    return not (self == other)
26957 
 
26958 
class updateRechargeOrderStatus_result:
26959 
  """
26960 
  Attributes:
6031 rajveer 26961 
   - success
6000 mandeep.dh 26962 
   - ex
26963 
  """
26964 
 
26965 
  thrift_spec = (
6031 rajveer 26966 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 26967 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26968 
  )
26969 
 
6031 rajveer 26970 
  def __init__(self, success=None, ex=None,):
26971 
    self.success = success
6000 mandeep.dh 26972 
    self.ex = ex
26973 
 
26974 
  def read(self, iprot):
26975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26977 
      return
26978 
    iprot.readStructBegin()
26979 
    while True:
26980 
      (fname, ftype, fid) = iprot.readFieldBegin()
26981 
      if ftype == TType.STOP:
26982 
        break
6031 rajveer 26983 
      if fid == 0:
26984 
        if ftype == TType.BOOL:
26985 
          self.success = iprot.readBool();
26986 
        else:
26987 
          iprot.skip(ftype)
26988 
      elif fid == 1:
6000 mandeep.dh 26989 
        if ftype == TType.STRUCT:
26990 
          self.ex = TransactionServiceException()
26991 
          self.ex.read(iprot)
26992 
        else:
26993 
          iprot.skip(ftype)
26994 
      else:
26995 
        iprot.skip(ftype)
26996 
      iprot.readFieldEnd()
26997 
    iprot.readStructEnd()
26998 
 
26999 
  def write(self, oprot):
27000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27002 
      return
27003 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 27004 
    if self.success is not None:
27005 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27006 
      oprot.writeBool(self.success)
27007 
      oprot.writeFieldEnd()
6000 mandeep.dh 27008 
    if self.ex is not None:
27009 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27010 
      self.ex.write(oprot)
27011 
      oprot.writeFieldEnd()
27012 
    oprot.writeFieldStop()
27013 
    oprot.writeStructEnd()
27014 
 
27015 
  def validate(self):
27016 
    return
27017 
 
27018 
 
27019 
  def __repr__(self):
27020 
    L = ['%s=%r' % (key, value)
27021 
      for key, value in self.__dict__.iteritems()]
27022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27023 
 
27024 
  def __eq__(self, other):
27025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27026 
 
27027 
  def __ne__(self, other):
27028 
    return not (self == other)
27029 
 
27030 
class activateRechargeTxn_args:
27031 
  """
27032 
  Attributes:
6031 rajveer 27033 
   - rechargeOrderId
6000 mandeep.dh 27034 
  """
27035 
 
27036 
  thrift_spec = (
27037 
    None, # 0
6031 rajveer 27038 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 27039 
  )
27040 
 
6031 rajveer 27041 
  def __init__(self, rechargeOrderId=None,):
27042 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 27043 
 
27044 
  def read(self, iprot):
27045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27047 
      return
27048 
    iprot.readStructBegin()
27049 
    while True:
27050 
      (fname, ftype, fid) = iprot.readFieldBegin()
27051 
      if ftype == TType.STOP:
27052 
        break
27053 
      if fid == 1:
6031 rajveer 27054 
        if ftype == TType.I64:
27055 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 27056 
        else:
27057 
          iprot.skip(ftype)
27058 
      else:
27059 
        iprot.skip(ftype)
27060 
      iprot.readFieldEnd()
27061 
    iprot.readStructEnd()
27062 
 
27063 
  def write(self, oprot):
27064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27066 
      return
27067 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 27068 
    if self.rechargeOrderId is not None:
27069 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27070 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 27071 
      oprot.writeFieldEnd()
27072 
    oprot.writeFieldStop()
27073 
    oprot.writeStructEnd()
27074 
 
27075 
  def validate(self):
27076 
    return
27077 
 
27078 
 
27079 
  def __repr__(self):
27080 
    L = ['%s=%r' % (key, value)
27081 
      for key, value in self.__dict__.iteritems()]
27082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27083 
 
27084 
  def __eq__(self, other):
27085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27086 
 
27087 
  def __ne__(self, other):
27088 
    return not (self == other)
27089 
 
27090 
class activateRechargeTxn_result:
27091 
  """
27092 
  Attributes:
27093 
   - success
27094 
   - ex
27095 
  """
27096 
 
27097 
  thrift_spec = (
6031 rajveer 27098 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27099 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27100 
  )
27101 
 
27102 
  def __init__(self, success=None, ex=None,):
27103 
    self.success = success
27104 
    self.ex = ex
27105 
 
27106 
  def read(self, iprot):
27107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27109 
      return
27110 
    iprot.readStructBegin()
27111 
    while True:
27112 
      (fname, ftype, fid) = iprot.readFieldBegin()
27113 
      if ftype == TType.STOP:
27114 
        break
27115 
      if fid == 0:
6031 rajveer 27116 
        if ftype == TType.BOOL:
27117 
          self.success = iprot.readBool();
6000 mandeep.dh 27118 
        else:
27119 
          iprot.skip(ftype)
27120 
      elif fid == 1:
27121 
        if ftype == TType.STRUCT:
27122 
          self.ex = TransactionServiceException()
27123 
          self.ex.read(iprot)
27124 
        else:
27125 
          iprot.skip(ftype)
27126 
      else:
27127 
        iprot.skip(ftype)
27128 
      iprot.readFieldEnd()
27129 
    iprot.readStructEnd()
27130 
 
27131 
  def write(self, oprot):
27132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27134 
      return
27135 
    oprot.writeStructBegin('activateRechargeTxn_result')
27136 
    if self.success is not None:
6031 rajveer 27137 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27138 
      oprot.writeBool(self.success)
6000 mandeep.dh 27139 
      oprot.writeFieldEnd()
27140 
    if self.ex is not None:
27141 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27142 
      self.ex.write(oprot)
27143 
      oprot.writeFieldEnd()
27144 
    oprot.writeFieldStop()
27145 
    oprot.writeStructEnd()
27146 
 
27147 
  def validate(self):
27148 
    return
27149 
 
27150 
 
27151 
  def __repr__(self):
27152 
    L = ['%s=%r' % (key, value)
27153 
      for key, value in self.__dict__.iteritems()]
27154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27155 
 
27156 
  def __eq__(self, other):
27157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27158 
 
27159 
  def __ne__(self, other):
27160 
    return not (self == other)
27161 
 
6031 rajveer 27162 
class getUserWallet_args:
6000 mandeep.dh 27163 
  """
27164 
  Attributes:
6031 rajveer 27165 
   - userId
6000 mandeep.dh 27166 
  """
27167 
 
27168 
  thrift_spec = (
27169 
    None, # 0
6031 rajveer 27170 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27171 
  )
27172 
 
6031 rajveer 27173 
  def __init__(self, userId=None,):
27174 
    self.userId = userId
6000 mandeep.dh 27175 
 
27176 
  def read(self, iprot):
27177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27179 
      return
27180 
    iprot.readStructBegin()
27181 
    while True:
27182 
      (fname, ftype, fid) = iprot.readFieldBegin()
27183 
      if ftype == TType.STOP:
27184 
        break
27185 
      if fid == 1:
27186 
        if ftype == TType.I64:
6031 rajveer 27187 
          self.userId = iprot.readI64();
6000 mandeep.dh 27188 
        else:
27189 
          iprot.skip(ftype)
27190 
      else:
27191 
        iprot.skip(ftype)
27192 
      iprot.readFieldEnd()
27193 
    iprot.readStructEnd()
27194 
 
27195 
  def write(self, oprot):
27196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27198 
      return
6031 rajveer 27199 
    oprot.writeStructBegin('getUserWallet_args')
27200 
    if self.userId is not None:
27201 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27202 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27203 
      oprot.writeFieldEnd()
27204 
    oprot.writeFieldStop()
27205 
    oprot.writeStructEnd()
27206 
 
27207 
  def validate(self):
27208 
    return
27209 
 
27210 
 
27211 
  def __repr__(self):
27212 
    L = ['%s=%r' % (key, value)
27213 
      for key, value in self.__dict__.iteritems()]
27214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27215 
 
27216 
  def __eq__(self, other):
27217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27218 
 
27219 
  def __ne__(self, other):
27220 
    return not (self == other)
27221 
 
6031 rajveer 27222 
class getUserWallet_result:
6000 mandeep.dh 27223 
  """
27224 
  Attributes:
27225 
   - success
27226 
  """
27227 
 
27228 
  thrift_spec = (
6031 rajveer 27229 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 27230 
  )
27231 
 
27232 
  def __init__(self, success=None,):
27233 
    self.success = success
27234 
 
27235 
  def read(self, iprot):
27236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27238 
      return
27239 
    iprot.readStructBegin()
27240 
    while True:
27241 
      (fname, ftype, fid) = iprot.readFieldBegin()
27242 
      if ftype == TType.STOP:
27243 
        break
27244 
      if fid == 0:
6031 rajveer 27245 
        if ftype == TType.STRUCT:
27246 
          self.success = UserWallet()
27247 
          self.success.read(iprot)
6000 mandeep.dh 27248 
        else:
27249 
          iprot.skip(ftype)
27250 
      else:
27251 
        iprot.skip(ftype)
27252 
      iprot.readFieldEnd()
27253 
    iprot.readStructEnd()
27254 
 
27255 
  def write(self, oprot):
27256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27258 
      return
6031 rajveer 27259 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27260 
    if self.success is not None:
6031 rajveer 27261 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27262 
      self.success.write(oprot)
6000 mandeep.dh 27263 
      oprot.writeFieldEnd()
27264 
    oprot.writeFieldStop()
27265 
    oprot.writeStructEnd()
27266 
 
27267 
  def validate(self):
27268 
    return
27269 
 
27270 
 
27271 
  def __repr__(self):
27272 
    L = ['%s=%r' % (key, value)
27273 
      for key, value in self.__dict__.iteritems()]
27274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27275 
 
27276 
  def __eq__(self, other):
27277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27278 
 
27279 
  def __ne__(self, other):
27280 
    return not (self == other)
27281 
 
6031 rajveer 27282 
class getUserWalletHistory_args:
6000 mandeep.dh 27283 
  """
27284 
  Attributes:
6031 rajveer 27285 
   - userId
6000 mandeep.dh 27286 
  """
27287 
 
27288 
  thrift_spec = (
27289 
    None, # 0
6031 rajveer 27290 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27291 
  )
27292 
 
6031 rajveer 27293 
  def __init__(self, userId=None,):
27294 
    self.userId = userId
6000 mandeep.dh 27295 
 
27296 
  def read(self, iprot):
27297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27299 
      return
27300 
    iprot.readStructBegin()
27301 
    while True:
27302 
      (fname, ftype, fid) = iprot.readFieldBegin()
27303 
      if ftype == TType.STOP:
27304 
        break
27305 
      if fid == 1:
27306 
        if ftype == TType.I64:
6031 rajveer 27307 
          self.userId = iprot.readI64();
6000 mandeep.dh 27308 
        else:
27309 
          iprot.skip(ftype)
27310 
      else:
27311 
        iprot.skip(ftype)
27312 
      iprot.readFieldEnd()
27313 
    iprot.readStructEnd()
27314 
 
27315 
  def write(self, oprot):
27316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27318 
      return
6031 rajveer 27319 
    oprot.writeStructBegin('getUserWalletHistory_args')
27320 
    if self.userId is not None:
27321 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27322 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27323 
      oprot.writeFieldEnd()
27324 
    oprot.writeFieldStop()
27325 
    oprot.writeStructEnd()
27326 
 
27327 
  def validate(self):
27328 
    return
27329 
 
27330 
 
27331 
  def __repr__(self):
27332 
    L = ['%s=%r' % (key, value)
27333 
      for key, value in self.__dict__.iteritems()]
27334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27335 
 
27336 
  def __eq__(self, other):
27337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27338 
 
27339 
  def __ne__(self, other):
27340 
    return not (self == other)
27341 
 
6031 rajveer 27342 
class getUserWalletHistory_result:
6000 mandeep.dh 27343 
  """
27344 
  Attributes:
27345 
   - success
27346 
  """
27347 
 
27348 
  thrift_spec = (
6031 rajveer 27349 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 27350 
  )
27351 
 
27352 
  def __init__(self, success=None,):
27353 
    self.success = success
27354 
 
27355 
  def read(self, iprot):
27356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27358 
      return
27359 
    iprot.readStructBegin()
27360 
    while True:
27361 
      (fname, ftype, fid) = iprot.readFieldBegin()
27362 
      if ftype == TType.STOP:
27363 
        break
27364 
      if fid == 0:
27365 
        if ftype == TType.LIST:
27366 
          self.success = []
6188 rajveer 27367 
          (_etype666, _size663) = iprot.readListBegin()
27368 
          for _i667 in xrange(_size663):
27369 
            _elem668 = UserWalletHistory()
27370 
            _elem668.read(iprot)
27371 
            self.success.append(_elem668)
6000 mandeep.dh 27372 
          iprot.readListEnd()
27373 
        else:
27374 
          iprot.skip(ftype)
27375 
      else:
27376 
        iprot.skip(ftype)
27377 
      iprot.readFieldEnd()
27378 
    iprot.readStructEnd()
27379 
 
27380 
  def write(self, oprot):
27381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27383 
      return
6031 rajveer 27384 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 27385 
    if self.success is not None:
27386 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27387 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27388 
      for iter669 in self.success:
27389 
        iter669.write(oprot)
6000 mandeep.dh 27390 
      oprot.writeListEnd()
27391 
      oprot.writeFieldEnd()
27392 
    oprot.writeFieldStop()
27393 
    oprot.writeStructEnd()
27394 
 
27395 
  def validate(self):
27396 
    return
27397 
 
27398 
 
27399 
  def __repr__(self):
27400 
    L = ['%s=%r' % (key, value)
27401 
      for key, value in self.__dict__.iteritems()]
27402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27403 
 
27404 
  def __eq__(self, other):
27405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27406 
 
27407 
  def __ne__(self, other):
27408 
    return not (self == other)
6048 rajveer 27409 
 
6050 anupam.sin 27410 
class getRechargeOrdersForTransaction_args:
27411 
  """
27412 
  Attributes:
27413 
   - txnId
27414 
  """
27415 
 
27416 
  thrift_spec = (
27417 
    None, # 0
27418 
    (1, TType.I64, 'txnId', None, None, ), # 1
27419 
  )
27420 
 
27421 
  def __init__(self, txnId=None,):
27422 
    self.txnId = txnId
27423 
 
27424 
  def read(self, iprot):
27425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27427 
      return
27428 
    iprot.readStructBegin()
27429 
    while True:
27430 
      (fname, ftype, fid) = iprot.readFieldBegin()
27431 
      if ftype == TType.STOP:
27432 
        break
27433 
      if fid == 1:
27434 
        if ftype == TType.I64:
27435 
          self.txnId = iprot.readI64();
27436 
        else:
27437 
          iprot.skip(ftype)
27438 
      else:
27439 
        iprot.skip(ftype)
27440 
      iprot.readFieldEnd()
27441 
    iprot.readStructEnd()
27442 
 
27443 
  def write(self, oprot):
27444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27446 
      return
27447 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
27448 
    if self.txnId is not None:
27449 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
27450 
      oprot.writeI64(self.txnId)
27451 
      oprot.writeFieldEnd()
27452 
    oprot.writeFieldStop()
27453 
    oprot.writeStructEnd()
27454 
 
27455 
  def validate(self):
27456 
    return
27457 
 
27458 
 
27459 
  def __repr__(self):
27460 
    L = ['%s=%r' % (key, value)
27461 
      for key, value in self.__dict__.iteritems()]
27462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27463 
 
27464 
  def __eq__(self, other):
27465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27466 
 
27467 
  def __ne__(self, other):
27468 
    return not (self == other)
27469 
 
27470 
class getRechargeOrdersForTransaction_result:
27471 
  """
27472 
  Attributes:
27473 
   - success
27474 
   - ex
27475 
  """
27476 
 
27477 
  thrift_spec = (
27478 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27479 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27480 
  )
27481 
 
27482 
  def __init__(self, success=None, ex=None,):
27483 
    self.success = success
27484 
    self.ex = ex
27485 
 
27486 
  def read(self, iprot):
27487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27489 
      return
27490 
    iprot.readStructBegin()
27491 
    while True:
27492 
      (fname, ftype, fid) = iprot.readFieldBegin()
27493 
      if ftype == TType.STOP:
27494 
        break
27495 
      if fid == 0:
27496 
        if ftype == TType.STRUCT:
27497 
          self.success = RechargeOrder()
27498 
          self.success.read(iprot)
27499 
        else:
27500 
          iprot.skip(ftype)
27501 
      elif fid == 1:
27502 
        if ftype == TType.STRUCT:
27503 
          self.ex = TransactionServiceException()
27504 
          self.ex.read(iprot)
27505 
        else:
27506 
          iprot.skip(ftype)
27507 
      else:
27508 
        iprot.skip(ftype)
27509 
      iprot.readFieldEnd()
27510 
    iprot.readStructEnd()
27511 
 
27512 
  def write(self, oprot):
27513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27515 
      return
27516 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
27517 
    if self.success is not None:
27518 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27519 
      self.success.write(oprot)
27520 
      oprot.writeFieldEnd()
27521 
    if self.ex is not None:
27522 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27523 
      self.ex.write(oprot)
27524 
      oprot.writeFieldEnd()
27525 
    oprot.writeFieldStop()
27526 
    oprot.writeStructEnd()
27527 
 
27528 
  def validate(self):
27529 
    return
27530 
 
27531 
 
27532 
  def __repr__(self):
27533 
    L = ['%s=%r' % (key, value)
27534 
      for key, value in self.__dict__.iteritems()]
27535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27536 
 
27537 
  def __eq__(self, other):
27538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27539 
 
27540 
  def __ne__(self, other):
27541 
    return not (self == other)
27542 
 
6048 rajveer 27543 
class getServiceProviders_args:
27544 
  """
27545 
  Attributes:
27546 
   - rechargeType
6206 rajveer 27547 
   - onlyActive
6048 rajveer 27548 
  """
27549 
 
27550 
  thrift_spec = (
27551 
    None, # 0
27552 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 27553 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 27554 
  )
27555 
 
6206 rajveer 27556 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 27557 
    self.rechargeType = rechargeType
6206 rajveer 27558 
    self.onlyActive = onlyActive
6048 rajveer 27559 
 
27560 
  def read(self, iprot):
27561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27563 
      return
27564 
    iprot.readStructBegin()
27565 
    while True:
27566 
      (fname, ftype, fid) = iprot.readFieldBegin()
27567 
      if ftype == TType.STOP:
27568 
        break
27569 
      if fid == 1:
27570 
        if ftype == TType.I32:
27571 
          self.rechargeType = iprot.readI32();
27572 
        else:
27573 
          iprot.skip(ftype)
6206 rajveer 27574 
      elif fid == 2:
27575 
        if ftype == TType.BOOL:
27576 
          self.onlyActive = iprot.readBool();
27577 
        else:
27578 
          iprot.skip(ftype)
6048 rajveer 27579 
      else:
27580 
        iprot.skip(ftype)
27581 
      iprot.readFieldEnd()
27582 
    iprot.readStructEnd()
27583 
 
27584 
  def write(self, oprot):
27585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27587 
      return
27588 
    oprot.writeStructBegin('getServiceProviders_args')
27589 
    if self.rechargeType is not None:
27590 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27591 
      oprot.writeI32(self.rechargeType)
27592 
      oprot.writeFieldEnd()
6206 rajveer 27593 
    if self.onlyActive is not None:
27594 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
27595 
      oprot.writeBool(self.onlyActive)
27596 
      oprot.writeFieldEnd()
6048 rajveer 27597 
    oprot.writeFieldStop()
27598 
    oprot.writeStructEnd()
27599 
 
27600 
  def validate(self):
27601 
    return
27602 
 
27603 
 
27604 
  def __repr__(self):
27605 
    L = ['%s=%r' % (key, value)
27606 
      for key, value in self.__dict__.iteritems()]
27607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27608 
 
27609 
  def __eq__(self, other):
27610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27611 
 
27612 
  def __ne__(self, other):
27613 
    return not (self == other)
27614 
 
27615 
class getServiceProviders_result:
27616 
  """
27617 
  Attributes:
27618 
   - success
27619 
  """
27620 
 
27621 
  thrift_spec = (
27622 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
27623 
  )
27624 
 
27625 
  def __init__(self, success=None,):
27626 
    self.success = success
27627 
 
27628 
  def read(self, iprot):
27629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27631 
      return
27632 
    iprot.readStructBegin()
27633 
    while True:
27634 
      (fname, ftype, fid) = iprot.readFieldBegin()
27635 
      if ftype == TType.STOP:
27636 
        break
27637 
      if fid == 0:
27638 
        if ftype == TType.MAP:
27639 
          self.success = {}
6188 rajveer 27640 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
27641 
          for _i674 in xrange(_size670):
27642 
            _key675 = iprot.readI64();
27643 
            _val676 = iprot.readString();
27644 
            self.success[_key675] = _val676
6048 rajveer 27645 
          iprot.readMapEnd()
27646 
        else:
27647 
          iprot.skip(ftype)
27648 
      else:
27649 
        iprot.skip(ftype)
27650 
      iprot.readFieldEnd()
27651 
    iprot.readStructEnd()
27652 
 
27653 
  def write(self, oprot):
27654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27656 
      return
27657 
    oprot.writeStructBegin('getServiceProviders_result')
27658 
    if self.success is not None:
27659 
      oprot.writeFieldBegin('success', TType.MAP, 0)
27660 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 27661 
      for kiter677,viter678 in self.success.items():
27662 
        oprot.writeI64(kiter677)
27663 
        oprot.writeString(viter678)
6048 rajveer 27664 
      oprot.writeMapEnd()
27665 
      oprot.writeFieldEnd()
27666 
    oprot.writeFieldStop()
27667 
    oprot.writeStructEnd()
27668 
 
27669 
  def validate(self):
27670 
    return
27671 
 
27672 
 
27673 
  def __repr__(self):
27674 
    L = ['%s=%r' % (key, value)
27675 
      for key, value in self.__dict__.iteritems()]
27676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27677 
 
27678 
  def __eq__(self, other):
27679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27680 
 
27681 
  def __ne__(self, other):
27682 
    return not (self == other)
27683 
 
27684 
class getServiceProviderForDevice_args:
27685 
  """
27686 
  Attributes:
6049 rajveer 27687 
   - rechargeType
6048 rajveer 27688 
   - deviceNumber
27689 
  """
27690 
 
27691 
  thrift_spec = (
27692 
    None, # 0
6049 rajveer 27693 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27694 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 27695 
  )
27696 
 
6049 rajveer 27697 
  def __init__(self, rechargeType=None, deviceNumber=None,):
27698 
    self.rechargeType = rechargeType
6048 rajveer 27699 
    self.deviceNumber = deviceNumber
27700 
 
27701 
  def read(self, iprot):
27702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27704 
      return
27705 
    iprot.readStructBegin()
27706 
    while True:
27707 
      (fname, ftype, fid) = iprot.readFieldBegin()
27708 
      if ftype == TType.STOP:
27709 
        break
27710 
      if fid == 1:
6049 rajveer 27711 
        if ftype == TType.I32:
27712 
          self.rechargeType = iprot.readI32();
27713 
        else:
27714 
          iprot.skip(ftype)
27715 
      elif fid == 2:
6048 rajveer 27716 
        if ftype == TType.STRING:
27717 
          self.deviceNumber = iprot.readString();
27718 
        else:
27719 
          iprot.skip(ftype)
27720 
      else:
27721 
        iprot.skip(ftype)
27722 
      iprot.readFieldEnd()
27723 
    iprot.readStructEnd()
27724 
 
27725 
  def write(self, oprot):
27726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27728 
      return
27729 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 27730 
    if self.rechargeType is not None:
27731 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27732 
      oprot.writeI32(self.rechargeType)
27733 
      oprot.writeFieldEnd()
6048 rajveer 27734 
    if self.deviceNumber is not None:
6049 rajveer 27735 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 27736 
      oprot.writeString(self.deviceNumber)
27737 
      oprot.writeFieldEnd()
27738 
    oprot.writeFieldStop()
27739 
    oprot.writeStructEnd()
27740 
 
27741 
  def validate(self):
27742 
    return
27743 
 
27744 
 
27745 
  def __repr__(self):
27746 
    L = ['%s=%r' % (key, value)
27747 
      for key, value in self.__dict__.iteritems()]
27748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27749 
 
27750 
  def __eq__(self, other):
27751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27752 
 
27753 
  def __ne__(self, other):
27754 
    return not (self == other)
27755 
 
27756 
class getServiceProviderForDevice_result:
27757 
  """
27758 
  Attributes:
27759 
   - success
27760 
  """
27761 
 
27762 
  thrift_spec = (
6289 anupam.sin 27763 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 27764 
  )
27765 
 
27766 
  def __init__(self, success=None,):
27767 
    self.success = success
27768 
 
27769 
  def read(self, iprot):
27770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27772 
      return
27773 
    iprot.readStructBegin()
27774 
    while True:
27775 
      (fname, ftype, fid) = iprot.readFieldBegin()
27776 
      if ftype == TType.STOP:
27777 
        break
27778 
      if fid == 0:
6289 anupam.sin 27779 
        if ftype == TType.STRUCT:
27780 
          self.success = DeviceNumberInfo()
27781 
          self.success.read(iprot)
6048 rajveer 27782 
        else:
27783 
          iprot.skip(ftype)
27784 
      else:
27785 
        iprot.skip(ftype)
27786 
      iprot.readFieldEnd()
27787 
    iprot.readStructEnd()
27788 
 
27789 
  def write(self, oprot):
27790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27792 
      return
27793 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
27794 
    if self.success is not None:
6289 anupam.sin 27795 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27796 
      self.success.write(oprot)
6048 rajveer 27797 
      oprot.writeFieldEnd()
27798 
    oprot.writeFieldStop()
27799 
    oprot.writeStructEnd()
27800 
 
27801 
  def validate(self):
27802 
    return
27803 
 
27804 
 
27805 
  def __repr__(self):
27806 
    L = ['%s=%r' % (key, value)
27807 
      for key, value in self.__dict__.iteritems()]
27808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27809 
 
27810 
  def __eq__(self, other):
27811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27812 
 
27813 
  def __ne__(self, other):
27814 
    return not (self == other)
6094 rajveer 27815 
 
6269 rajveer 27816 
class validateRecharge_args:
27817 
  """
27818 
  Attributes:
27819 
   - rechargeType
27820 
   - deviceNumber
6307 anupam.sin 27821 
   - userSelectedProviderId
6269 rajveer 27822 
  """
27823 
 
27824 
  thrift_spec = (
27825 
    None, # 0
27826 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27827 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 27828 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6269 rajveer 27829 
  )
27830 
 
6336 anupam.sin 27831 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None,):
6269 rajveer 27832 
    self.rechargeType = rechargeType
27833 
    self.deviceNumber = deviceNumber
6307 anupam.sin 27834 
    self.userSelectedProviderId = userSelectedProviderId
6269 rajveer 27835 
 
27836 
  def read(self, iprot):
27837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27839 
      return
27840 
    iprot.readStructBegin()
27841 
    while True:
27842 
      (fname, ftype, fid) = iprot.readFieldBegin()
27843 
      if ftype == TType.STOP:
27844 
        break
27845 
      if fid == 1:
27846 
        if ftype == TType.I32:
27847 
          self.rechargeType = iprot.readI32();
27848 
        else:
27849 
          iprot.skip(ftype)
27850 
      elif fid == 2:
27851 
        if ftype == TType.STRING:
27852 
          self.deviceNumber = iprot.readString();
27853 
        else:
27854 
          iprot.skip(ftype)
6307 anupam.sin 27855 
      elif fid == 3:
27856 
        if ftype == TType.I64:
27857 
          self.userSelectedProviderId = iprot.readI64();
27858 
        else:
27859 
          iprot.skip(ftype)
6269 rajveer 27860 
      else:
27861 
        iprot.skip(ftype)
27862 
      iprot.readFieldEnd()
27863 
    iprot.readStructEnd()
27864 
 
27865 
  def write(self, oprot):
27866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27868 
      return
27869 
    oprot.writeStructBegin('validateRecharge_args')
27870 
    if self.rechargeType is not None:
27871 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27872 
      oprot.writeI32(self.rechargeType)
27873 
      oprot.writeFieldEnd()
27874 
    if self.deviceNumber is not None:
27875 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
27876 
      oprot.writeString(self.deviceNumber)
27877 
      oprot.writeFieldEnd()
6307 anupam.sin 27878 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 27879 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 27880 
      oprot.writeI64(self.userSelectedProviderId)
27881 
      oprot.writeFieldEnd()
6269 rajveer 27882 
    oprot.writeFieldStop()
27883 
    oprot.writeStructEnd()
27884 
 
27885 
  def validate(self):
27886 
    return
27887 
 
27888 
 
27889 
  def __repr__(self):
27890 
    L = ['%s=%r' % (key, value)
27891 
      for key, value in self.__dict__.iteritems()]
27892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27893 
 
27894 
  def __eq__(self, other):
27895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27896 
 
27897 
  def __ne__(self, other):
27898 
    return not (self == other)
27899 
 
27900 
class validateRecharge_result:
27901 
  """
27902 
  Attributes:
27903 
   - success
27904 
  """
27905 
 
27906 
  thrift_spec = (
27907 
    (0, TType.STRING, 'success', None, None, ), # 0
27908 
  )
27909 
 
27910 
  def __init__(self, success=None,):
27911 
    self.success = success
27912 
 
27913 
  def read(self, iprot):
27914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27916 
      return
27917 
    iprot.readStructBegin()
27918 
    while True:
27919 
      (fname, ftype, fid) = iprot.readFieldBegin()
27920 
      if ftype == TType.STOP:
27921 
        break
27922 
      if fid == 0:
27923 
        if ftype == TType.STRING:
27924 
          self.success = iprot.readString();
27925 
        else:
27926 
          iprot.skip(ftype)
27927 
      else:
27928 
        iprot.skip(ftype)
27929 
      iprot.readFieldEnd()
27930 
    iprot.readStructEnd()
27931 
 
27932 
  def write(self, oprot):
27933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27935 
      return
27936 
    oprot.writeStructBegin('validateRecharge_result')
27937 
    if self.success is not None:
27938 
      oprot.writeFieldBegin('success', TType.STRING, 0)
27939 
      oprot.writeString(self.success)
27940 
      oprot.writeFieldEnd()
27941 
    oprot.writeFieldStop()
27942 
    oprot.writeStructEnd()
27943 
 
27944 
  def validate(self):
27945 
    return
27946 
 
27947 
 
27948 
  def __repr__(self):
27949 
    L = ['%s=%r' % (key, value)
27950 
      for key, value in self.__dict__.iteritems()]
27951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27952 
 
27953 
  def __eq__(self, other):
27954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27955 
 
27956 
  def __ne__(self, other):
27957 
    return not (self == other)
27958 
 
6094 rajveer 27959 
class getRechargeOrdersForDevice_args:
27960 
  """
27961 
  Attributes:
27962 
   - deviceNumber
27963 
  """
27964 
 
27965 
  thrift_spec = (
27966 
    None, # 0
27967 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
27968 
  )
27969 
 
27970 
  def __init__(self, deviceNumber=None,):
27971 
    self.deviceNumber = deviceNumber
27972 
 
27973 
  def read(self, iprot):
27974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27976 
      return
27977 
    iprot.readStructBegin()
27978 
    while True:
27979 
      (fname, ftype, fid) = iprot.readFieldBegin()
27980 
      if ftype == TType.STOP:
27981 
        break
27982 
      if fid == 1:
27983 
        if ftype == TType.STRING:
27984 
          self.deviceNumber = iprot.readString();
27985 
        else:
27986 
          iprot.skip(ftype)
27987 
      else:
27988 
        iprot.skip(ftype)
27989 
      iprot.readFieldEnd()
27990 
    iprot.readStructEnd()
27991 
 
27992 
  def write(self, oprot):
27993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27995 
      return
27996 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
27997 
    if self.deviceNumber is not None:
27998 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
27999 
      oprot.writeString(self.deviceNumber)
28000 
      oprot.writeFieldEnd()
28001 
    oprot.writeFieldStop()
28002 
    oprot.writeStructEnd()
28003 
 
28004 
  def validate(self):
28005 
    return
28006 
 
28007 
 
28008 
  def __repr__(self):
28009 
    L = ['%s=%r' % (key, value)
28010 
      for key, value in self.__dict__.iteritems()]
28011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28012 
 
28013 
  def __eq__(self, other):
28014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28015 
 
28016 
  def __ne__(self, other):
28017 
    return not (self == other)
28018 
 
28019 
class getRechargeOrdersForDevice_result:
28020 
  """
28021 
  Attributes:
28022 
   - success
28023 
  """
28024 
 
28025 
  thrift_spec = (
28026 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28027 
  )
28028 
 
28029 
  def __init__(self, success=None,):
28030 
    self.success = success
28031 
 
28032 
  def read(self, iprot):
28033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28035 
      return
28036 
    iprot.readStructBegin()
28037 
    while True:
28038 
      (fname, ftype, fid) = iprot.readFieldBegin()
28039 
      if ftype == TType.STOP:
28040 
        break
28041 
      if fid == 0:
28042 
        if ftype == TType.LIST:
28043 
          self.success = []
6188 rajveer 28044 
          (_etype682, _size679) = iprot.readListBegin()
28045 
          for _i683 in xrange(_size679):
28046 
            _elem684 = RechargeOrder()
28047 
            _elem684.read(iprot)
28048 
            self.success.append(_elem684)
6094 rajveer 28049 
          iprot.readListEnd()
28050 
        else:
28051 
          iprot.skip(ftype)
28052 
      else:
28053 
        iprot.skip(ftype)
28054 
      iprot.readFieldEnd()
28055 
    iprot.readStructEnd()
28056 
 
28057 
  def write(self, oprot):
28058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28060 
      return
28061 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
28062 
    if self.success is not None:
28063 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28064 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28065 
      for iter685 in self.success:
28066 
        iter685.write(oprot)
6094 rajveer 28067 
      oprot.writeListEnd()
28068 
      oprot.writeFieldEnd()
28069 
    oprot.writeFieldStop()
28070 
    oprot.writeStructEnd()
28071 
 
28072 
  def validate(self):
28073 
    return
28074 
 
28075 
 
28076 
  def __repr__(self):
28077 
    L = ['%s=%r' % (key, value)
28078 
      for key, value in self.__dict__.iteritems()]
28079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28080 
 
28081 
  def __eq__(self, other):
28082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28083 
 
28084 
  def __ne__(self, other):
28085 
    return not (self == other)
28086 
 
28087 
class addAmountToWallet_args:
28088 
  """
28089 
  Attributes:
28090 
   - userId
28091 
   - orderId
28092 
   - amount
28093 
  """
28094 
 
28095 
  thrift_spec = (
28096 
    None, # 0
28097 
    (1, TType.I64, 'userId', None, None, ), # 1
28098 
    (2, TType.I64, 'orderId', None, None, ), # 2
28099 
    (3, TType.I64, 'amount', None, None, ), # 3
28100 
  )
28101 
 
28102 
  def __init__(self, userId=None, orderId=None, amount=None,):
28103 
    self.userId = userId
28104 
    self.orderId = orderId
28105 
    self.amount = amount
28106 
 
28107 
  def read(self, iprot):
28108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28110 
      return
28111 
    iprot.readStructBegin()
28112 
    while True:
28113 
      (fname, ftype, fid) = iprot.readFieldBegin()
28114 
      if ftype == TType.STOP:
28115 
        break
28116 
      if fid == 1:
28117 
        if ftype == TType.I64:
28118 
          self.userId = iprot.readI64();
28119 
        else:
28120 
          iprot.skip(ftype)
28121 
      elif fid == 2:
28122 
        if ftype == TType.I64:
28123 
          self.orderId = iprot.readI64();
28124 
        else:
28125 
          iprot.skip(ftype)
28126 
      elif fid == 3:
28127 
        if ftype == TType.I64:
28128 
          self.amount = iprot.readI64();
28129 
        else:
28130 
          iprot.skip(ftype)
28131 
      else:
28132 
        iprot.skip(ftype)
28133 
      iprot.readFieldEnd()
28134 
    iprot.readStructEnd()
28135 
 
28136 
  def write(self, oprot):
28137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28139 
      return
28140 
    oprot.writeStructBegin('addAmountToWallet_args')
28141 
    if self.userId is not None:
28142 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28143 
      oprot.writeI64(self.userId)
28144 
      oprot.writeFieldEnd()
28145 
    if self.orderId is not None:
28146 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
28147 
      oprot.writeI64(self.orderId)
28148 
      oprot.writeFieldEnd()
28149 
    if self.amount is not None:
28150 
      oprot.writeFieldBegin('amount', TType.I64, 3)
28151 
      oprot.writeI64(self.amount)
28152 
      oprot.writeFieldEnd()
28153 
    oprot.writeFieldStop()
28154 
    oprot.writeStructEnd()
28155 
 
28156 
  def validate(self):
28157 
    return
28158 
 
28159 
 
28160 
  def __repr__(self):
28161 
    L = ['%s=%r' % (key, value)
28162 
      for key, value in self.__dict__.iteritems()]
28163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28164 
 
28165 
  def __eq__(self, other):
28166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28167 
 
28168 
  def __ne__(self, other):
28169 
    return not (self == other)
28170 
 
28171 
class addAmountToWallet_result:
28172 
 
28173 
  thrift_spec = (
28174 
  )
28175 
 
28176 
  def read(self, iprot):
28177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28179 
      return
28180 
    iprot.readStructBegin()
28181 
    while True:
28182 
      (fname, ftype, fid) = iprot.readFieldBegin()
28183 
      if ftype == TType.STOP:
28184 
        break
28185 
      else:
28186 
        iprot.skip(ftype)
28187 
      iprot.readFieldEnd()
28188 
    iprot.readStructEnd()
28189 
 
28190 
  def write(self, oprot):
28191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28193 
      return
28194 
    oprot.writeStructBegin('addAmountToWallet_result')
28195 
    oprot.writeFieldStop()
28196 
    oprot.writeStructEnd()
28197 
 
28198 
  def validate(self):
28199 
    return
28200 
 
28201 
 
28202 
  def __repr__(self):
28203 
    L = ['%s=%r' % (key, value)
28204 
      for key, value in self.__dict__.iteritems()]
28205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28206 
 
28207 
  def __eq__(self, other):
28208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28209 
 
28210 
  def __ne__(self, other):
28211 
    return not (self == other)
6154 rajveer 28212 
 
6188 rajveer 28213 
class getRechargeStatistics_args:
28214 
 
28215 
  thrift_spec = (
28216 
  )
28217 
 
28218 
  def read(self, iprot):
28219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28221 
      return
28222 
    iprot.readStructBegin()
28223 
    while True:
28224 
      (fname, ftype, fid) = iprot.readFieldBegin()
28225 
      if ftype == TType.STOP:
28226 
        break
28227 
      else:
28228 
        iprot.skip(ftype)
28229 
      iprot.readFieldEnd()
28230 
    iprot.readStructEnd()
28231 
 
28232 
  def write(self, oprot):
28233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28235 
      return
28236 
    oprot.writeStructBegin('getRechargeStatistics_args')
28237 
    oprot.writeFieldStop()
28238 
    oprot.writeStructEnd()
28239 
 
28240 
  def validate(self):
28241 
    return
28242 
 
28243 
 
28244 
  def __repr__(self):
28245 
    L = ['%s=%r' % (key, value)
28246 
      for key, value in self.__dict__.iteritems()]
28247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28248 
 
28249 
  def __eq__(self, other):
28250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28251 
 
28252 
  def __ne__(self, other):
28253 
    return not (self == other)
28254 
 
28255 
class getRechargeStatistics_result:
28256 
  """
28257 
  Attributes:
28258 
   - success
28259 
  """
28260 
 
28261 
  thrift_spec = (
28262 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
28263 
  )
28264 
 
28265 
  def __init__(self, success=None,):
28266 
    self.success = success
28267 
 
28268 
  def read(self, iprot):
28269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28271 
      return
28272 
    iprot.readStructBegin()
28273 
    while True:
28274 
      (fname, ftype, fid) = iprot.readFieldBegin()
28275 
      if ftype == TType.STOP:
28276 
        break
28277 
      if fid == 0:
28278 
        if ftype == TType.STRUCT:
28279 
          self.success = RechargeStatistics()
28280 
          self.success.read(iprot)
28281 
        else:
28282 
          iprot.skip(ftype)
28283 
      else:
28284 
        iprot.skip(ftype)
28285 
      iprot.readFieldEnd()
28286 
    iprot.readStructEnd()
28287 
 
28288 
  def write(self, oprot):
28289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28291 
      return
28292 
    oprot.writeStructBegin('getRechargeStatistics_result')
28293 
    if self.success is not None:
28294 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28295 
      self.success.write(oprot)
28296 
      oprot.writeFieldEnd()
28297 
    oprot.writeFieldStop()
28298 
    oprot.writeStructEnd()
28299 
 
28300 
  def validate(self):
28301 
    return
28302 
 
28303 
 
28304 
  def __repr__(self):
28305 
    L = ['%s=%r' % (key, value)
28306 
      for key, value in self.__dict__.iteritems()]
28307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28308 
 
28309 
  def __eq__(self, other):
28310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28311 
 
28312 
  def __ne__(self, other):
28313 
    return not (self == other)
28314 
 
6154 rajveer 28315 
class getRechargeOrdersForStatus_args:
28316 
  """
28317 
  Attributes:
28318 
   - status
28319 
  """
28320 
 
28321 
  thrift_spec = (
28322 
    None, # 0
28323 
    (1, TType.I64, 'status', None, None, ), # 1
28324 
  )
28325 
 
28326 
  def __init__(self, status=None,):
28327 
    self.status = status
28328 
 
28329 
  def read(self, iprot):
28330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28332 
      return
28333 
    iprot.readStructBegin()
28334 
    while True:
28335 
      (fname, ftype, fid) = iprot.readFieldBegin()
28336 
      if ftype == TType.STOP:
28337 
        break
28338 
      if fid == 1:
28339 
        if ftype == TType.I64:
28340 
          self.status = iprot.readI64();
28341 
        else:
28342 
          iprot.skip(ftype)
28343 
      else:
28344 
        iprot.skip(ftype)
28345 
      iprot.readFieldEnd()
28346 
    iprot.readStructEnd()
28347 
 
28348 
  def write(self, oprot):
28349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28351 
      return
28352 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
28353 
    if self.status is not None:
28354 
      oprot.writeFieldBegin('status', TType.I64, 1)
28355 
      oprot.writeI64(self.status)
28356 
      oprot.writeFieldEnd()
28357 
    oprot.writeFieldStop()
28358 
    oprot.writeStructEnd()
28359 
 
28360 
  def validate(self):
28361 
    return
28362 
 
28363 
 
28364 
  def __repr__(self):
28365 
    L = ['%s=%r' % (key, value)
28366 
      for key, value in self.__dict__.iteritems()]
28367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28368 
 
28369 
  def __eq__(self, other):
28370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28371 
 
28372 
  def __ne__(self, other):
28373 
    return not (self == other)
28374 
 
28375 
class getRechargeOrdersForStatus_result:
28376 
  """
28377 
  Attributes:
28378 
   - success
28379 
  """
28380 
 
28381 
  thrift_spec = (
28382 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28383 
  )
28384 
 
28385 
  def __init__(self, success=None,):
28386 
    self.success = success
28387 
 
28388 
  def read(self, iprot):
28389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28391 
      return
28392 
    iprot.readStructBegin()
28393 
    while True:
28394 
      (fname, ftype, fid) = iprot.readFieldBegin()
28395 
      if ftype == TType.STOP:
28396 
        break
28397 
      if fid == 0:
28398 
        if ftype == TType.LIST:
28399 
          self.success = []
6188 rajveer 28400 
          (_etype689, _size686) = iprot.readListBegin()
28401 
          for _i690 in xrange(_size686):
28402 
            _elem691 = RechargeOrder()
28403 
            _elem691.read(iprot)
28404 
            self.success.append(_elem691)
6154 rajveer 28405 
          iprot.readListEnd()
28406 
        else:
28407 
          iprot.skip(ftype)
28408 
      else:
28409 
        iprot.skip(ftype)
28410 
      iprot.readFieldEnd()
28411 
    iprot.readStructEnd()
28412 
 
28413 
  def write(self, oprot):
28414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28416 
      return
28417 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
28418 
    if self.success is not None:
28419 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28420 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28421 
      for iter692 in self.success:
28422 
        iter692.write(oprot)
6154 rajveer 28423 
      oprot.writeListEnd()
28424 
      oprot.writeFieldEnd()
28425 
    oprot.writeFieldStop()
28426 
    oprot.writeStructEnd()
28427 
 
28428 
  def validate(self):
28429 
    return
28430 
 
28431 
 
28432 
  def __repr__(self):
28433 
    L = ['%s=%r' % (key, value)
28434 
      for key, value in self.__dict__.iteritems()]
28435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28436 
 
28437 
  def __eq__(self, other):
28438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28439 
 
28440 
  def __ne__(self, other):
28441 
    return not (self == other)
6159 rajveer 28442 
 
28443 
class getPlansForOperator_args:
28444 
  """
28445 
  Attributes:
28446 
   - operatorId
28447 
  """
28448 
 
28449 
  thrift_spec = (
28450 
    None, # 0
28451 
    (1, TType.I64, 'operatorId', None, None, ), # 1
28452 
  )
28453 
 
28454 
  def __init__(self, operatorId=None,):
28455 
    self.operatorId = operatorId
28456 
 
28457 
  def read(self, iprot):
28458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28460 
      return
28461 
    iprot.readStructBegin()
28462 
    while True:
28463 
      (fname, ftype, fid) = iprot.readFieldBegin()
28464 
      if ftype == TType.STOP:
28465 
        break
28466 
      if fid == 1:
28467 
        if ftype == TType.I64:
28468 
          self.operatorId = iprot.readI64();
28469 
        else:
28470 
          iprot.skip(ftype)
28471 
      else:
28472 
        iprot.skip(ftype)
28473 
      iprot.readFieldEnd()
28474 
    iprot.readStructEnd()
28475 
 
28476 
  def write(self, oprot):
28477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28479 
      return
28480 
    oprot.writeStructBegin('getPlansForOperator_args')
28481 
    if self.operatorId is not None:
28482 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28483 
      oprot.writeI64(self.operatorId)
28484 
      oprot.writeFieldEnd()
28485 
    oprot.writeFieldStop()
28486 
    oprot.writeStructEnd()
28487 
 
28488 
  def validate(self):
28489 
    return
28490 
 
28491 
 
28492 
  def __repr__(self):
28493 
    L = ['%s=%r' % (key, value)
28494 
      for key, value in self.__dict__.iteritems()]
28495 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28496 
 
28497 
  def __eq__(self, other):
28498 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28499 
 
28500 
  def __ne__(self, other):
28501 
    return not (self == other)
28502 
 
28503 
class getPlansForOperator_result:
28504 
  """
28505 
  Attributes:
28506 
   - success
28507 
  """
28508 
 
28509 
  thrift_spec = (
28510 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
28511 
  )
28512 
 
28513 
  def __init__(self, success=None,):
28514 
    self.success = success
28515 
 
28516 
  def read(self, iprot):
28517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28519 
      return
28520 
    iprot.readStructBegin()
28521 
    while True:
28522 
      (fname, ftype, fid) = iprot.readFieldBegin()
28523 
      if ftype == TType.STOP:
28524 
        break
28525 
      if fid == 0:
28526 
        if ftype == TType.LIST:
28527 
          self.success = []
6188 rajveer 28528 
          (_etype696, _size693) = iprot.readListBegin()
28529 
          for _i697 in xrange(_size693):
28530 
            _elem698 = RechargePlan()
28531 
            _elem698.read(iprot)
28532 
            self.success.append(_elem698)
6159 rajveer 28533 
          iprot.readListEnd()
28534 
        else:
28535 
          iprot.skip(ftype)
28536 
      else:
28537 
        iprot.skip(ftype)
28538 
      iprot.readFieldEnd()
28539 
    iprot.readStructEnd()
28540 
 
28541 
  def write(self, oprot):
28542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28544 
      return
28545 
    oprot.writeStructBegin('getPlansForOperator_result')
28546 
    if self.success is not None:
28547 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28548 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28549 
      for iter699 in self.success:
28550 
        iter699.write(oprot)
6159 rajveer 28551 
      oprot.writeListEnd()
28552 
      oprot.writeFieldEnd()
28553 
    oprot.writeFieldStop()
28554 
    oprot.writeStructEnd()
28555 
 
28556 
  def validate(self):
28557 
    return
28558 
 
28559 
 
28560 
  def __repr__(self):
28561 
    L = ['%s=%r' % (key, value)
28562 
      for key, value in self.__dict__.iteritems()]
28563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28564 
 
28565 
  def __eq__(self, other):
28566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28567 
 
28568 
  def __ne__(self, other):
28569 
    return not (self == other)
6289 anupam.sin 28570 
 
28571 
class getRechargeDenominations_args:
28572 
  """
28573 
  Attributes:
28574 
   - operatorId
6307 anupam.sin 28575 
   - circleCode
6289 anupam.sin 28576 
   - denominationType
28577 
  """
28578 
 
28579 
  thrift_spec = (
28580 
    None, # 0
28581 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 28582 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 28583 
    (3, TType.I32, 'denominationType', None, None, ), # 3
28584 
  )
28585 
 
6307 anupam.sin 28586 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 28587 
    self.operatorId = operatorId
6307 anupam.sin 28588 
    self.circleCode = circleCode
6289 anupam.sin 28589 
    self.denominationType = denominationType
28590 
 
28591 
  def read(self, iprot):
28592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28594 
      return
28595 
    iprot.readStructBegin()
28596 
    while True:
28597 
      (fname, ftype, fid) = iprot.readFieldBegin()
28598 
      if ftype == TType.STOP:
28599 
        break
28600 
      if fid == 1:
28601 
        if ftype == TType.I64:
28602 
          self.operatorId = iprot.readI64();
28603 
        else:
28604 
          iprot.skip(ftype)
28605 
      elif fid == 2:
28606 
        if ftype == TType.STRING:
6307 anupam.sin 28607 
          self.circleCode = iprot.readString();
6289 anupam.sin 28608 
        else:
28609 
          iprot.skip(ftype)
28610 
      elif fid == 3:
28611 
        if ftype == TType.I32:
28612 
          self.denominationType = iprot.readI32();
28613 
        else:
28614 
          iprot.skip(ftype)
28615 
      else:
28616 
        iprot.skip(ftype)
28617 
      iprot.readFieldEnd()
28618 
    iprot.readStructEnd()
28619 
 
28620 
  def write(self, oprot):
28621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28623 
      return
28624 
    oprot.writeStructBegin('getRechargeDenominations_args')
28625 
    if self.operatorId is not None:
28626 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28627 
      oprot.writeI64(self.operatorId)
28628 
      oprot.writeFieldEnd()
6307 anupam.sin 28629 
    if self.circleCode is not None:
28630 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
28631 
      oprot.writeString(self.circleCode)
6289 anupam.sin 28632 
      oprot.writeFieldEnd()
28633 
    if self.denominationType is not None:
28634 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
28635 
      oprot.writeI32(self.denominationType)
28636 
      oprot.writeFieldEnd()
28637 
    oprot.writeFieldStop()
28638 
    oprot.writeStructEnd()
28639 
 
28640 
  def validate(self):
28641 
    return
28642 
 
28643 
 
28644 
  def __repr__(self):
28645 
    L = ['%s=%r' % (key, value)
28646 
      for key, value in self.__dict__.iteritems()]
28647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28648 
 
28649 
  def __eq__(self, other):
28650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28651 
 
28652 
  def __ne__(self, other):
28653 
    return not (self == other)
28654 
 
28655 
class getRechargeDenominations_result:
28656 
  """
28657 
  Attributes:
28658 
   - success
28659 
   - ex
28660 
  """
28661 
 
28662 
  thrift_spec = (
28663 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
28664 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28665 
  )
28666 
 
28667 
  def __init__(self, success=None, ex=None,):
28668 
    self.success = success
28669 
    self.ex = ex
28670 
 
28671 
  def read(self, iprot):
28672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28674 
      return
28675 
    iprot.readStructBegin()
28676 
    while True:
28677 
      (fname, ftype, fid) = iprot.readFieldBegin()
28678 
      if ftype == TType.STOP:
28679 
        break
28680 
      if fid == 0:
28681 
        if ftype == TType.LIST:
28682 
          self.success = []
28683 
          (_etype703, _size700) = iprot.readListBegin()
28684 
          for _i704 in xrange(_size700):
28685 
            _elem705 = RechargeDenomination()
28686 
            _elem705.read(iprot)
28687 
            self.success.append(_elem705)
28688 
          iprot.readListEnd()
28689 
        else:
28690 
          iprot.skip(ftype)
28691 
      elif fid == 1:
28692 
        if ftype == TType.STRUCT:
28693 
          self.ex = TransactionServiceException()
28694 
          self.ex.read(iprot)
28695 
        else:
28696 
          iprot.skip(ftype)
28697 
      else:
28698 
        iprot.skip(ftype)
28699 
      iprot.readFieldEnd()
28700 
    iprot.readStructEnd()
28701 
 
28702 
  def write(self, oprot):
28703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28705 
      return
28706 
    oprot.writeStructBegin('getRechargeDenominations_result')
28707 
    if self.success is not None:
28708 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28709 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28710 
      for iter706 in self.success:
28711 
        iter706.write(oprot)
28712 
      oprot.writeListEnd()
28713 
      oprot.writeFieldEnd()
28714 
    if self.ex is not None:
28715 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28716 
      self.ex.write(oprot)
28717 
      oprot.writeFieldEnd()
28718 
    oprot.writeFieldStop()
28719 
    oprot.writeStructEnd()
28720 
 
28721 
  def validate(self):
28722 
    return
28723 
 
28724 
 
28725 
  def __repr__(self):
28726 
    L = ['%s=%r' % (key, value)
28727 
      for key, value in self.__dict__.iteritems()]
28728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28729 
 
28730 
  def __eq__(self, other):
28731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28732 
 
28733 
  def __ne__(self, other):
28734 
    return not (self == other)