Subversion Repositories SmartDukaan

Rev

Rev 7172 | Rev 7263 | 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 
 
7190 amar.kumar 336 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, 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
7190 amar.kumar 350 
     - freebieWarehouseId
4283 anupam.sin 351 
     - billed_by
352 
     - jacketNumber
3064 chandransh 353 
     - billingType
5110 mandeep.dh 354 
     - fulfilmentWarehouseId
4763 rajveer 355 
     - authorize
3064 chandransh 356 
    """
357 
    pass
358 
 
6756 amar.kumar 359 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 360 
    """
361 
    Add the invoice number to the order.
362 
 
363 
    Parameters:
364 
     - orderId
365 
     - invoiceNumber
4763 rajveer 366 
     - color
6756 amar.kumar 367 
     - serialNumber
368 
     - itemNumber
4579 rajveer 369 
    """
370 
    pass
371 
 
4910 phani.kuma 372 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 373 
    """
374 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 375 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 376 
 
377 
    Parameters:
378 
     - warehouseId
379 
     - providerId
380 
     - cod
4910 phani.kuma 381 
     - orderIds
4410 rajveer 382 
    """
383 
    pass
384 
 
5713 rajveer 385 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 386 
    """
387 
    Parameters:
388 
     - providerId
389 
     - orderIds
5713 rajveer 390 
     - awbs
5676 rajveer 391 
    """
392 
    pass
393 
 
4910 phani.kuma 394 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 395 
    """
4910 phani.kuma 396 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
397 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 398 
 
3064 chandransh 399 
    Parameters:
759 chandransh 400 
     - providerId
4910 phani.kuma 401 
     - pickupDetails
759 chandransh 402 
    """
403 
    pass
404 
 
4910 phani.kuma 405 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 406 
    """
407 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 408 
 
1113 chandransh 409 
    Parameters:
410 
     - providerId
411 
    """
412 
    pass
413 
 
1132 chandransh 414 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
415 
    """
416 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
417 
    the name of the receiver.
418 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 419 
 
1132 chandransh 420 
    Parameters:
421 
     - providerId
422 
     - deliveredOrders
423 
    """
424 
    pass
425 
 
4910 phani.kuma 426 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 427 
    """
4910 phani.kuma 428 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 429 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 430 
 
1135 chandransh 431 
    Parameters:
432 
     - providerId
433 
     - returnedOrders
434 
    """
435 
    pass
436 
 
4910 phani.kuma 437 
  def getRTOrders(self, providerId):
438 
    """
439 
    Returns a list of orders that were returned by courier.
440 
 
441 
    Parameters:
442 
     - providerId
443 
    """
444 
    pass
445 
 
1246 chandransh 446 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
447 
    """
448 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 449 
 
1246 chandransh 450 
    Parameters:
451 
     - providerId
452 
     - undeliveredOrders
453 
    """
454 
    pass
455 
 
4910 phani.kuma 456 
  def getNonDeliveredOrdersbyCourier(self, providerId):
457 
    """
458 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
459 
 
460 
    Parameters:
461 
     - providerId
462 
    """
463 
    pass
464 
 
465 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
466 
    """
467 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
468 
 
469 
    Parameters:
470 
     - providerId
471 
     - local_connected_orders
472 
    """
473 
    pass
474 
 
475 
  def getOrdersNotLocalConnected(self, providerId):
476 
    """
477 
    Returns a list of orders that were picked up or shipped but pending local connection.
478 
 
479 
    Parameters:
480 
     - providerId
481 
    """
482 
    pass
483 
 
484 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
485 
    """
486 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
487 
 
488 
    Parameters:
489 
     - providerId
490 
     - destination_city_reached_orders
491 
    """
492 
    pass
493 
 
494 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
495 
    """
496 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
497 
 
498 
    Parameters:
499 
     - providerId
500 
     - first_atdl_orders
501 
    """
502 
    pass
503 
 
1408 ankur.sing 504 
  def getUndeliveredOrders(self, providerId, warehouseId):
505 
    """
506 
    Returns the list of orders whose delivery time has passed but have not been
507 
    delivered yet for the given provider and warehouse. To get a complete list of
508 
    undelivered orders, pass them as -1.
509 
    Returns an empty list if no such orders exist.
3431 rajveer 510 
 
1408 ankur.sing 511 
    Parameters:
512 
     - providerId
513 
     - warehouseId
514 
    """
515 
    pass
516 
 
4783 phani.kuma 517 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
518 
    """
519 
    Returns the list of orders whose expected delivery date has passed but have not been
520 
    delivered yet.
521 
    Returns an empty list if no such orders exist.
522 
    """
523 
    pass
524 
 
2536 chandransh 525 
  def toggleDOAFlag(self, orderId):
526 
    """
527 
    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.
528 
    Returns the final flag status.
529 
    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 530 
 
2536 chandransh 531 
    Parameters:
532 
     - orderId
533 
    """
534 
    pass
1886 ankur.sing 535 
 
4712 rajveer 536 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
537 
    """
538 
    Parameters:
539 
     - orderId
540 
     - deliveryTimestamp
541 
     - receiver
542 
    """
543 
    pass
544 
 
5553 rajveer 545 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
546 
    """
547 
    Parameters:
548 
     - orderId
549 
     - deliveryTimestamp
550 
    """
551 
    pass
552 
 
4454 rajveer 553 
  def markOrderDoaRequestReceived(self, orderId):
554 
    """
555 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
556 
 
557 
    Parameters:
558 
     - orderId
559 
    """
560 
    pass
561 
 
562 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
563 
    """
564 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
565 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
566 
 
567 
    Parameters:
568 
     - orderId
569 
     - isAuthorized
570 
    """
571 
    pass
572 
 
4488 rajveer 573 
  def markOrderReturnRequestReceived(self, orderId):
574 
    """
575 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
576 
 
577 
    Parameters:
578 
     - orderId
579 
    """
580 
    pass
581 
 
582 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
583 
    """
584 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
585 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
586 
 
587 
    Parameters:
588 
     - orderId
589 
     - isAuthorized
590 
    """
591 
    pass
592 
 
4579 rajveer 593 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 594 
    """
595 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 596 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
597 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 598 
    For any other status, it returns false.
599 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 600 
 
2536 chandransh 601 
    Parameters:
602 
     - orderId
4579 rajveer 603 
     - providerId
2536 chandransh 604 
    """
605 
    pass
606 
 
4602 rajveer 607 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 608 
    """
4452 rajveer 609 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 610 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
611 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
612 
    	3. Returns true
2591 chandransh 613 
    If the order is in any other status, it returns false.
2536 chandransh 614 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 615 
 
2536 chandransh 616 
    Parameters:
617 
     - orderId
618 
     - pickupNumber
4602 rajveer 619 
     - providerId
2536 chandransh 620 
    """
621 
    pass
622 
 
2764 chandransh 623 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
624 
    """
625 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 626 
 
2764 chandransh 627 
    Parameters:
628 
     - providerId
629 
     - pickupDetails
630 
    """
631 
    pass
632 
 
4910 phani.kuma 633 
  def getDoasNotPickedUp(self, providerId):
634 
    """
635 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
636 
 
637 
    Parameters:
638 
     - providerId
639 
    """
640 
    pass
641 
 
4741 phani.kuma 642 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
643 
    """
644 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
645 
 
646 
    Parameters:
647 
     - providerId
648 
     - pickupDetails
649 
    """
650 
    pass
651 
 
4910 phani.kuma 652 
  def getReturnOrdersNotPickedUp(self, providerId):
653 
    """
654 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
655 
 
656 
    Parameters:
657 
     - providerId
658 
    """
659 
    pass
660 
 
4479 rajveer 661 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 662 
    """
4452 rajveer 663 
    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 664 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 665 
    If the order is in any other state, it returns false.
666 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 667 
 
2591 chandransh 668 
    Parameters:
669 
     - orderId
4479 rajveer 670 
     - receiveCondition
2591 chandransh 671 
    """
672 
    pass
2536 chandransh 673 
 
2591 chandransh 674 
  def validateDoa(self, orderId, isValid):
675 
    """
4452 rajveer 676 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 677 
    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 678 
    If the order is in any other state, it returns false.
679 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 680 
 
2591 chandransh 681 
    Parameters:
682 
     - orderId
683 
     - isValid
684 
    """
685 
    pass
686 
 
4495 rajveer 687 
  def validateReturnProduct(self, orderId, isUsable):
688 
    """
689 
    Parameters:
690 
     - orderId
691 
     - isUsable
692 
    """
693 
    pass
694 
 
2616 chandransh 695 
  def reshipOrder(self, orderId):
696 
    """
4484 rajveer 697 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 698 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 699 
    	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 700 
 
701 
    If the order is in DOA_CERT_VALID state, it does the following:
702 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
703 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 704 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 705 
 
2616 chandransh 706 
    Returns the id of the newly created order.
3431 rajveer 707 
 
2616 chandransh 708 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 709 
 
2616 chandransh 710 
    Parameters:
711 
     - orderId
712 
    """
713 
    pass
2591 chandransh 714 
 
3226 chandransh 715 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 716 
    """
4484 rajveer 717 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 718 
    	1. Creates a refund request for batch processing.
719 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 720 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 721 
 
2616 chandransh 722 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
723 
    	1. Creates a refund request for batch processing.
3226 chandransh 724 
    	2. Cancels the reservation of the item in the warehouse.
725 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 726 
 
3226 chandransh 727 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
728 
    	1. Cancels the reservation of the item in the warehouse.
729 
    	2. Marks the current order as CANCELED.
730 
 
731 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
732 
 
2616 chandransh 733 
    Returns True if it is successful, False otherwise.
3431 rajveer 734 
 
2616 chandransh 735 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 736 
 
2616 chandransh 737 
    Parameters:
738 
     - orderId
3226 chandransh 739 
     - refundedBy
740 
     - reason
2616 chandransh 741 
    """
742 
    pass
743 
 
2690 chandransh 744 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
745 
    """
746 
    Get all return orders created between the from and to dates for the given warehouse.
747 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 748 
 
2690 chandransh 749 
    Parameters:
750 
     - warehouseId
751 
     - fromDate
752 
     - toDate
753 
    """
754 
    pass
2616 chandransh 755 
 
5481 phani.kuma 756 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
757 
    """
758 
    Get all return orders created between the from and to dates.
759 
 
760 
    Parameters:
761 
     - onlyNotProcessed
762 
     - fromDate
763 
     - toDate
764 
    """
765 
    pass
766 
 
2700 chandransh 767 
  def getReturnOrder(self, id):
768 
    """
769 
    Returns the ReturnOrder corresponding to the given id.
770 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 771 
 
2700 chandransh 772 
    Parameters:
773 
     - id
774 
    """
775 
    pass
776 
 
2690 chandransh 777 
  def processReturn(self, returnOrderId):
778 
    """
779 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 780 
 
2690 chandransh 781 
    Parameters:
782 
     - returnOrderId
783 
    """
784 
    pass
785 
 
3451 chandransh 786 
  def updateWeight(self, orderId, weight):
787 
    """
788 
    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 789 
 
3451 chandransh 790 
    Parameters:
791 
     - orderId
792 
     - weight
793 
    """
794 
    pass
795 
 
3469 chandransh 796 
  def changeItem(self, orderId, itemId):
797 
    """
798 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
799 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 800 
 
3469 chandransh 801 
    Parameters:
802 
     - orderId
803 
     - itemId
804 
    """
805 
    pass
806 
 
807 
  def shiftToWarehouse(self, orderId, warehouseId):
808 
    """
809 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
810 
 
811 
    Parameters:
812 
     - orderId
813 
     - warehouseId
814 
    """
815 
    pass
816 
 
4647 rajveer 817 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 818 
    """
819 
    Adds the given delay reason to the given order.
3986 chandransh 820 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 821 
    Raises an exception if no order with the given id can be found.
3469 chandransh 822 
 
3553 chandransh 823 
    Parameters:
824 
     - orderId
825 
     - delayReason
3986 chandransh 826 
     - furtherDelay
4647 rajveer 827 
     - delayReasonText
3553 chandransh 828 
    """
829 
    pass
830 
 
3956 chandransh 831 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
832 
    """
833 
    Marks the COD orders with given AWB nos. as having been processed.
834 
    Updates the captured amount for the corresponding payment.
3553 chandransh 835 
 
3956 chandransh 836 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
837 
    1. There is no order corresponding to an AWB number.
838 
    2. The captured amount for a payment exceeds the total payment.
839 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
840 
 
841 
    Parameters:
842 
     - collectedAmountMap
843 
     - xferBy
844 
     - xferTxnId
845 
     - xferDate
846 
    """
847 
    pass
848 
 
4008 mandeep.dh 849 
  def getTransactionsRequiringExtraProcessing(self, category):
850 
    """
4065 mandeep.dh 851 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 852 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 853 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 854 
 
4008 mandeep.dh 855 
    Parameters:
856 
     - category
857 
    """
858 
    pass
859 
 
860 
  def markTransactionAsProcessed(self, transactionId, category):
861 
    """
862 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 863 
    It essentially deletes the transaction id record for a particular
864 
    processing type category (if present) from DB.
865 
    This is currently used by CRM application.
4008 mandeep.dh 866 
 
867 
    Parameters:
868 
     - transactionId
869 
     - category
870 
    """
871 
    pass
872 
 
4018 chandransh 873 
  def getItemWiseRiskyOrdersCount(self, ):
874 
    """
875 
    Returns a map containing the number of risky orders keyed by item id. A risky order
876 
    is defined as one whose shipping date is about to expire.
877 
    """
878 
    pass
4008 mandeep.dh 879 
 
4295 varun.gupt 880 
  def getOrdersForItemIds(self, itemIds):
881 
    """
882 
    Returns a list of all orders which have items with given id
883 
 
884 
    Parameters:
885 
     - itemIds
886 
    """
887 
    pass
888 
 
4247 rajveer 889 
  def markOrderCancellationRequestReceived(self, orderId):
890 
    """
891 
    Mark order as cancellation request received. If customer sends request of cancellation of
892 
    a particular order, this method will be called. It will just change status of the order
893 
    depending on its current status. It also records the previous status, so that we can move
894 
    back to that status if cancellation request is denied.
4018 chandransh 895 
 
4247 rajveer 896 
    Parameters:
897 
     - orderId
898 
    """
899 
    pass
900 
 
901 
  def markOrderCancellationRequestConfirmed(self, orderId):
902 
    """
903 
    If we decide to to cancel order, CRM will call this method to move the status of order to
904 
    cancellation request confirmed. After this OM will be able to cancel the order.
905 
 
906 
    Parameters:
907 
     - orderId
908 
    """
909 
    pass
910 
 
911 
  def markOrderCancellationRequestDenied(self, orderId):
912 
    """
913 
    If we decide to not to cancel order, we will move the order ro previous status.
914 
 
915 
    Parameters:
916 
     - orderId
917 
    """
918 
    pass
919 
 
4258 rajveer 920 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 921 
    """
4258 rajveer 922 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
923 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 924 
 
925 
    Parameters:
4258 rajveer 926 
     - transactionId
4247 rajveer 927 
    """
928 
    pass
929 
 
4259 anupam.sin 930 
  def refundTransaction(self, transactionId, refundedBy, reason):
931 
    """
932 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
933 
    need to be cancelled
4247 rajveer 934 
 
4259 anupam.sin 935 
    Parameters:
936 
     - transactionId
937 
     - refundedBy
938 
     - reason
939 
    """
940 
    pass
941 
 
4324 mandeep.dh 942 
  def updateShipmentAddress(self, orderId, addressId):
943 
    """
944 
    Updates shipment address of an order. Delivery and shipping date estimates
945 
    etc. are also updated here.
946 
 
947 
    Throws TransactionServiceException in case address change is not
948 
    possible due to certain reasons such as new pincode in address is
949 
    not serviceable etc.
950 
 
951 
    Parameters:
952 
     - orderId
953 
     - addressId
954 
    """
955 
    pass
956 
 
4285 rajveer 957 
  def acceptOrdersForItemId(self, itemId, inventory):
958 
    """
959 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
960 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 961 
 
4285 rajveer 962 
    Parameters:
963 
     - itemId
964 
     - inventory
965 
    """
966 
    pass
967 
 
4369 rajveer 968 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 969 
    """
970 
    Parameters:
971 
     - vendorId
972 
     - itemId
973 
     - quantity
974 
     - estimate
4369 rajveer 975 
     - isReminder
4303 rajveer 976 
    """
977 
    pass
4285 rajveer 978 
 
4369 rajveer 979 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 980 
    """
981 
    Parameters:
982 
     - vendorId
983 
     - itemId
984 
     - quantity
985 
     - estimate
4369 rajveer 986 
     - isReminder
4303 rajveer 987 
    """
988 
    pass
989 
 
4369 rajveer 990 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 991 
    """
992 
    Parameters:
993 
     - vendorId
994 
     - itemId
995 
     - quantity
996 
     - estimate
4369 rajveer 997 
     - isReminder
4303 rajveer 998 
    """
999 
    pass
1000 
 
4369 rajveer 1001 
  def markOrdersAsTimeout(self, vendorId):
1002 
    """
1003 
    Parameters:
1004 
     - vendorId
1005 
    """
1006 
    pass
4303 rajveer 1007 
 
4662 rajveer 1008 
  def markOrderAsLostInTransit(self, orderId):
1009 
    """
1010 
    Mark order as LOST_IN_TRANSIT
1011 
 
1012 
    Parameters:
1013 
     - orderId
1014 
    """
1015 
    pass
1016 
 
4386 anupam.sin 1017 
  def getOrderForAwb(self, awb):
1018 
    """
1019 
    Returns the order corresponding to an AWB number
4369 rajveer 1020 
 
4386 anupam.sin 1021 
    Parameters:
1022 
     - awb
1023 
    """
1024 
    pass
1025 
 
4910 phani.kuma 1026 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1027 
    """
4910 phani.kuma 1028 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1029 
 
4506 phani.kuma 1030 
    Parameters:
1031 
     - logistics_provider_id
4910 phani.kuma 1032 
     - order_status_list
4506 phani.kuma 1033 
    """
1034 
    pass
1035 
 
4600 varun.gupt 1036 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1037 
    """
1038 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1039 
 
4600 varun.gupt 1040 
    Parameters:
1041 
     - vendorId
1042 
     - billingDateFrom
1043 
     - billingDateTo
1044 
    """
1045 
    pass
1046 
 
4607 rajveer 1047 
  def getSlippedSippingDateOrders(self, ):
1048 
    pass
1049 
 
4709 rajveer 1050 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1051 
    """
1052 
    Parameters:
1053 
     - cancelDateFrom
1054 
     - cancelDateTo
1055 
    """
1056 
    pass
1057 
 
4600 varun.gupt 1058 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1059 
    """
1060 
    Parameters:
1061 
     - mapAWBAndAmount
1062 
    """
1063 
    pass
1064 
 
4905 varun.gupt 1065 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1066 
    """
1067 
    Parameters:
1068 
     - settlementDate
1069 
     - paymentGatewayId
4905 varun.gupt 1070 
     - referenceId
4600 varun.gupt 1071 
     - serviceTax
1072 
     - otherCharges
1073 
     - netCollection
1074 
    """
1075 
    pass
1076 
 
1077 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1078 
    """
1079 
    Parameters:
1080 
     - settlementId
1081 
     - settlementDate
1082 
     - transactionDateFrom
1083 
     - transactionDateTo
1084 
     - amount
1085 
    """
1086 
    pass
1087 
 
5386 phani.kuma 1088 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1089 
    """
1090 
    Parameters:
5189 varun.gupt 1091 
     - referenceId
1092 
     - isRefund
4600 varun.gupt 1093 
    """
1094 
    pass
1095 
 
5386 phani.kuma 1096 
  def getSettlementForCod(self, orderId, isRefund):
1097 
    """
1098 
    Parameters:
1099 
     - orderId
1100 
     - isRefund
1101 
    """
1102 
    pass
1103 
 
4600 varun.gupt 1104 
  def getEBSSettlementSummaries(self, ):
1105 
    pass
1106 
 
1107 
  def markEBSSettlementUploaded(self, settlementId):
1108 
    """
1109 
    Parameters:
1110 
     - settlementId
1111 
    """
1112 
    pass
1113 
 
1114 
  def getEBSSettlementDate(self, settlementId):
1115 
    """
1116 
    Parameters:
1117 
     - settlementId
1118 
    """
1119 
    pass
1120 
 
4715 varun.gupt 1121 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1122 
    """
1123 
    Parameters:
1124 
     - settlementDateFrom
1125 
     - settlementDateTo
1126 
     - isRefund
1127 
    """
1128 
    pass
4600 varun.gupt 1129 
 
4715 varun.gupt 1130 
  def getReshippedOrderIds(self, orderIds):
1131 
    """
1132 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1133 
 
1134 
    Parameters:
1135 
     - orderIds
1136 
    """
1137 
    pass
1138 
 
5481 phani.kuma 1139 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1140 
    """
1141 
    Parameters:
1142 
     - vendorId
5481 phani.kuma 1143 
     - onlyVendorNotPaid
1144 
     - billingDateFrom
1145 
     - billingDateTo
4875 varun.gupt 1146 
    """
1147 
    pass
4757 mandeep.dh 1148 
 
5031 varun.gupt 1149 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1150 
    """
1151 
    Parameters:
1152 
     - startDate
1153 
     - endDate
1154 
    """
1155 
    pass
4875 varun.gupt 1156 
 
5067 varun.gupt 1157 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1158 
    """
1159 
    Parameters:
1160 
     - status
1161 
     - startDatetime
1162 
     - endDatetime
1163 
    """
1164 
    pass
5031 varun.gupt 1165 
 
5348 anupam.sin 1166 
  def updateCODAgent(self, agent, orderId):
1167 
    """
1168 
    Updates the agent who handled the COD verification call
1169 
 
1170 
    Parameters:
1171 
     - agent
1172 
     - orderId
1173 
    """
1174 
    pass
1175 
 
5099 varun.gupt 1176 
  def updateOrderAsPaidToVendor(self, orderId):
1177 
    """
1178 
    Parameters:
1179 
     - orderId
1180 
    """
1181 
    pass
5067 varun.gupt 1182 
 
5386 phani.kuma 1183 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1184 
    """
1185 
    Parameters:
1186 
     - orderId
1187 
    """
1188 
    pass
1189 
 
5208 varun.gupt 1190 
  def getRefundedOrdersMarkedPaid(self, ):
1191 
    pass
5099 varun.gupt 1192 
 
5447 anupam.sin 1193 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1194 
    """
1195 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1196 
 
5447 anupam.sin 1197 
 
1198 
    Parameters:
1199 
     - minOrderId
1200 
     - maxOrderId
1201 
    """
1202 
    pass
1203 
 
5527 anupam.sin 1204 
  def getAllAttributesForOrderId(self, orderId):
1205 
    """
1206 
    gets all attributes for a given orderId
5447 anupam.sin 1207 
 
5527 anupam.sin 1208 
    Parameters:
1209 
     - orderId
1210 
    """
1211 
    pass
1212 
 
5676 rajveer 1213 
  def setOrderAttributes(self, orderId, attributes):
1214 
    """
1215 
    sets attributes for an order
1216 
 
1217 
    Parameters:
1218 
     - orderId
1219 
     - attributes
1220 
    """
1221 
    pass
1222 
 
5527 anupam.sin 1223 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1224 
    """
1225 
    sets attributes for all orders in a transaction
1226 
 
1227 
    Parameters:
1228 
     - transactionId
1229 
     - attribute
1230 
    """
1231 
    pass
1232 
 
5553 rajveer 1233 
  def getReceivePendingOrders(self, storeId):
1234 
    """
1235 
    Parameters:
1236 
     - storeId
1237 
    """
1238 
    pass
5527 anupam.sin 1239 
 
5553 rajveer 1240 
  def getReceivedAtStoreOrders(self, storeId):
1241 
    """
1242 
    Parameters:
1243 
     - storeId
1244 
    """
1245 
    pass
1246 
 
5713 rajveer 1247 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
1248 
    """
1249 
    Parameters:
1250 
     - storeId
1251 
     - fromDate
1252 
     - toDate
1253 
     - onlyCod
1254 
    """
1255 
    pass
1256 
 
5833 rajveer 1257 
  def getOrderAttributeValue(self, orderId, attributeName):
1258 
    """
1259 
    Parameters:
1260 
     - orderId
1261 
     - attributeName
1262 
    """
1263 
    pass
1264 
 
6019 rajveer 1265 
  def changeJacketNumber(self, orderId, jacketNumber):
1266 
    """
1267 
    Parameters:
1268 
     - orderId
1269 
     - jacketNumber
1270 
    """
1271 
    pass
1272 
 
1273 
  def markOrderAsRtoInTransit(self, orderId):
1274 
    """
1275 
    Parameters:
1276 
     - orderId
1277 
    """
1278 
    pass
1279 
 
5593 mandeep.dh 1280 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1281 
    """
1282 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1283 
    invoked while scanning IN of items.
5553 rajveer 1284 
 
5593 mandeep.dh 1285 
    Parameters:
1286 
     - itemId
1287 
     - quantity
1288 
     - fulfilmentWarehouseId
1289 
     - billingWarehouseId
1290 
    """
1291 
    pass
1292 
 
6000 mandeep.dh 1293 
  def createRechargeOrder(self, rechargeOrder):
1294 
    """
1295 
    Parameters:
1296 
     - rechargeOrder
1297 
    """
1298 
    pass
5593 mandeep.dh 1299 
 
6031 rajveer 1300 
  def getRechargeOrder(self, rechargeRrderId):
1301 
    """
1302 
    Parameters:
1303 
     - rechargeRrderId
1304 
    """
1305 
    pass
1306 
 
1307 
  def getRechargeOrders(self, userId):
1308 
    """
1309 
    Parameters:
1310 
     - userId
1311 
    """
1312 
    pass
1313 
 
6000 mandeep.dh 1314 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
1315 
    """
1316 
    Parameters:
1317 
     - rechargeOrderId
1318 
     - rechargeOrderStatus
1319 
    """
1320 
    pass
1321 
 
6031 rajveer 1322 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 1323 
    """
1324 
    Parameters:
6031 rajveer 1325 
     - rechargeOrderId
6000 mandeep.dh 1326 
    """
1327 
    pass
1328 
 
6031 rajveer 1329 
  def getUserWallet(self, userId):
6000 mandeep.dh 1330 
    """
1331 
    Parameters:
6031 rajveer 1332 
     - userId
6000 mandeep.dh 1333 
    """
1334 
    pass
1335 
 
6031 rajveer 1336 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 1337 
    """
1338 
    Parameters:
6031 rajveer 1339 
     - userId
6000 mandeep.dh 1340 
    """
1341 
    pass
1342 
 
6050 anupam.sin 1343 
  def getRechargeOrdersForTransaction(self, txnId):
1344 
    """
1345 
    Returns a recharge order for a given transactionId
1346 
 
1347 
    Parameters:
1348 
     - txnId
1349 
    """
1350 
    pass
1351 
 
6206 rajveer 1352 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 1353 
    """
1354 
    Parameters:
1355 
     - rechargeType
6206 rajveer 1356 
     - onlyActive
6048 rajveer 1357 
    """
1358 
    pass
6000 mandeep.dh 1359 
 
6049 rajveer 1360 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 1361 
    """
1362 
    Parameters:
6049 rajveer 1363 
     - rechargeType
6048 rajveer 1364 
     - deviceNumber
1365 
    """
1366 
    pass
1367 
 
6591 anupam.sin 1368 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 1369 
    """
1370 
    Parameters:
1371 
     - rechargeType
1372 
     - deviceNumber
6307 anupam.sin 1373 
     - userSelectedProviderId
6591 anupam.sin 1374 
     - clientAddress
6269 rajveer 1375 
    """
1376 
    pass
1377 
 
6094 rajveer 1378 
  def getRechargeOrdersForDevice(self, deviceNumber):
1379 
    """
1380 
    Parameters:
1381 
     - deviceNumber
1382 
    """
1383 
    pass
6048 rajveer 1384 
 
6094 rajveer 1385 
  def addAmountToWallet(self, userId, orderId, amount):
1386 
    """
1387 
    Parameters:
1388 
     - userId
1389 
     - orderId
1390 
     - amount
1391 
    """
1392 
    pass
1393 
 
6188 rajveer 1394 
  def getRechargeStatistics(self, ):
1395 
    pass
1396 
 
6154 rajveer 1397 
  def getRechargeOrdersForStatus(self, status):
1398 
    """
1399 
    Parameters:
1400 
     - status
1401 
    """
1402 
    pass
6094 rajveer 1403 
 
6159 rajveer 1404 
  def getPlansForOperator(self, operatorId):
1405 
    """
1406 
    Parameters:
1407 
     - operatorId
1408 
    """
1409 
    pass
6154 rajveer 1410 
 
6307 anupam.sin 1411 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 1412 
    """
1413 
    Returns denominations for a given operator and circle
6159 rajveer 1414 
 
6289 anupam.sin 1415 
    Parameters:
1416 
     - operatorId
6307 anupam.sin 1417 
     - circleCode
6289 anupam.sin 1418 
     - denominationType
1419 
    """
1420 
    pass
1421 
 
6371 rajveer 1422 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
1423 
    """
1424 
    Parameters:
1425 
     - operatorId
1426 
     - circleId
1427 
     - isAvailable
1428 
    """
1429 
    pass
6289 anupam.sin 1430 
 
6389 rajveer 1431 
  def getAvailableEmiSchemes(self, ):
1432 
    pass
6371 rajveer 1433 
 
6389 rajveer 1434 
  def getMiscCharges(self, transactionId):
1435 
    """
1436 
    Parameters:
1437 
     - transactionId
1438 
    """
1439 
    pass
1440 
 
6507 anupam.sin 1441 
  def refundRechargeOrder(self, rechargeOrderId):
1442 
    """
1443 
    Parameters:
1444 
     - rechargeOrderId
1445 
    """
1446 
    pass
6389 rajveer 1447 
 
6821 amar.kumar 1448 
  def getPhysicalOrders(self, fromDate, toDate):
1449 
    """
1450 
    Parameters:
1451 
     - fromDate
1452 
     - toDate
1453 
    """
1454 
    pass
6507 anupam.sin 1455 
 
6906 rajveer 1456 
  def getDocument(self, docType, docSource):
1457 
    """
1458 
    Parameters:
1459 
     - docType
1460 
     - docSource
1461 
    """
1462 
    pass
6821 amar.kumar 1463 
 
6985 anupam.sin 1464 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
1465 
    """
1466 
    Parameters:
1467 
     - orderId
1468 
     - line1
1469 
     - line2
1470 
     - city
1471 
     - state
1472 
     - pin
1473 
    """
1474 
    pass
6906 rajveer 1475 
 
7075 rajveer 1476 
  def retrieveInvoice(self, orderId, userId):
6988 rajveer 1477 
    """
1478 
    Parameters:
1479 
     - orderId
7075 rajveer 1480 
     - userId
6988 rajveer 1481 
    """
1482 
    pass
6985 anupam.sin 1483 
 
7026 rajveer 1484 
  def receiveUpdatesForRedExpress(self, awbNumber):
1485 
    """
1486 
    Parameters:
1487 
     - awbNumber
1488 
    """
1489 
    pass
6988 rajveer 1490 
 
7073 anupam.sin 1491 
  def createRechargeTransaction(self, thriftRechargeTransaction):
1492 
    """
1493 
    Parameters:
1494 
     - thriftRechargeTransaction
1495 
    """
1496 
    pass
7026 rajveer 1497 
 
7085 rajveer 1498 
  def getRechargeTransactions(self, storeId):
1499 
    """
1500 
    Parameters:
1501 
     - storeId
1502 
    """
1503 
    pass
1504 
 
7151 amit.gupta 1505 
  def getRechargeTrans(self, storeId, startDate, endDate, status):
1506 
    """
1507 
    Parameters:
1508 
     - storeId
1509 
     - startDate
1510 
     - endDate
1511 
     - status
1512 
    """
1513 
    pass
1514 
 
7080 anupam.sin 1515 
  def getRechargeTransaction(self, rechargeId):
1516 
    """
1517 
    Parameters:
1518 
     - rechargeId
1519 
    """
1520 
    pass
7073 anupam.sin 1521 
 
7080 anupam.sin 1522 
  def getFRCs(self, circleId, operatorId):
1523 
    """
1524 
    Parameters:
1525 
     - circleId
1526 
     - operatorId
1527 
    """
1528 
    pass
1529 
 
7096 anupam.sin 1530 
  def getHotspotStore(self, id, hotspotid):
1531 
    """
1532 
    Parameters:
1533 
     - id
1534 
     - hotspotid
1535 
    """
1536 
    pass
7080 anupam.sin 1537 
 
7096 anupam.sin 1538 
  def getTelecomCircle(self, id, code):
1539 
    """
1540 
    Parameters:
1541 
     - id
1542 
     - code
1543 
    """
1544 
    pass
1545 
 
7109 anupam.sin 1546 
  def retrieveHotspotRechargeInvoice(self, rechargeId):
1547 
    """
1548 
    Parameters:
1549 
     - rechargeId
1550 
    """
1551 
    pass
7096 anupam.sin 1552 
 
7190 amar.kumar 1553 
  def splitFreebieOrder(self, orderId, splitReason, shippingDate):
1554 
    """
1555 
    Parameters:
1556 
     - orderId
1557 
     - splitReason
1558 
     - shippingDate
1559 
    """
1560 
    pass
1561 
 
7172 anupam.sin 1562 
  def getRechargeTransactionsByNumber(self, number, storeId):
7169 anupam.sin 1563 
    """
1564 
    Parameters:
1565 
     - number
7172 anupam.sin 1566 
     - storeId
7169 anupam.sin 1567 
    """
1568 
    pass
7109 anupam.sin 1569 
 
7169 anupam.sin 1570 
  def updateHotspotStorePassword(self, storeId, password):
1571 
    """
1572 
    Parameters:
1573 
     - storeId
1574 
     - password
1575 
    """
1576 
    pass
1577 
 
1578 
 
3376 rajveer 1579 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1580 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1581 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1582 
 
1583 
  def createTransaction(self, transaction):
1584 
    """
1585 
    Parameters:
1586 
     - transaction
1587 
    """
1588 
    self.send_createTransaction(transaction)
132 ashish 1589 
    return self.recv_createTransaction()
94 ashish 1590 
 
1591 
  def send_createTransaction(self, transaction):
1592 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1593 
    args = createTransaction_args()
1594 
    args.transaction = transaction
1595 
    args.write(self._oprot)
1596 
    self._oprot.writeMessageEnd()
1597 
    self._oprot.trans.flush()
1598 
 
1599 
  def recv_createTransaction(self, ):
1600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1601 
    if mtype == TMessageType.EXCEPTION:
1602 
      x = TApplicationException()
1603 
      x.read(self._iprot)
1604 
      self._iprot.readMessageEnd()
1605 
      raise x
1606 
    result = createTransaction_result()
1607 
    result.read(self._iprot)
1608 
    self._iprot.readMessageEnd()
3431 rajveer 1609 
    if result.success is not None:
132 ashish 1610 
      return result.success
3431 rajveer 1611 
    if result.ex is not None:
94 ashish 1612 
      raise result.ex
132 ashish 1613 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1614 
 
1615 
  def getTransaction(self, id):
1616 
    """
1617 
    Parameters:
1618 
     - id
1619 
    """
1620 
    self.send_getTransaction(id)
1621 
    return self.recv_getTransaction()
1622 
 
1623 
  def send_getTransaction(self, id):
1624 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1625 
    args = getTransaction_args()
1626 
    args.id = id
1627 
    args.write(self._oprot)
1628 
    self._oprot.writeMessageEnd()
1629 
    self._oprot.trans.flush()
1630 
 
1631 
  def recv_getTransaction(self, ):
1632 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1633 
    if mtype == TMessageType.EXCEPTION:
1634 
      x = TApplicationException()
1635 
      x.read(self._iprot)
1636 
      self._iprot.readMessageEnd()
1637 
      raise x
1638 
    result = getTransaction_result()
1639 
    result.read(self._iprot)
1640 
    self._iprot.readMessageEnd()
3431 rajveer 1641 
    if result.success is not None:
94 ashish 1642 
      return result.success
3431 rajveer 1643 
    if result.ex is not None:
94 ashish 1644 
      raise result.ex
1645 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1646 
 
1647 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1648 
    """
1649 
    Parameters:
1650 
     - customerId
1651 
     - from_date
1652 
     - to_date
1653 
     - status
1654 
    """
1655 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1656 
    return self.recv_getTransactionsForCustomer()
1657 
 
1658 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1659 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1660 
    args = getTransactionsForCustomer_args()
1661 
    args.customerId = customerId
1662 
    args.from_date = from_date
1663 
    args.to_date = to_date
1664 
    args.status = status
1665 
    args.write(self._oprot)
1666 
    self._oprot.writeMessageEnd()
1667 
    self._oprot.trans.flush()
1668 
 
1669 
  def recv_getTransactionsForCustomer(self, ):
1670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1671 
    if mtype == TMessageType.EXCEPTION:
1672 
      x = TApplicationException()
1673 
      x.read(self._iprot)
1674 
      self._iprot.readMessageEnd()
1675 
      raise x
1676 
    result = getTransactionsForCustomer_result()
1677 
    result.read(self._iprot)
1678 
    self._iprot.readMessageEnd()
3431 rajveer 1679 
    if result.success is not None:
94 ashish 1680 
      return result.success
3431 rajveer 1681 
    if result.ex is not None:
94 ashish 1682 
      raise result.ex
1683 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1684 
 
132 ashish 1685 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1686 
    """
1687 
    Parameters:
1688 
     - shoppingCartId
1689 
    """
1690 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1691 
    return self.recv_getTransactionsForShoppingCartId()
1692 
 
1693 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1694 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1695 
    args = getTransactionsForShoppingCartId_args()
1696 
    args.shoppingCartId = shoppingCartId
1697 
    args.write(self._oprot)
1698 
    self._oprot.writeMessageEnd()
1699 
    self._oprot.trans.flush()
1700 
 
1701 
  def recv_getTransactionsForShoppingCartId(self, ):
1702 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1703 
    if mtype == TMessageType.EXCEPTION:
1704 
      x = TApplicationException()
1705 
      x.read(self._iprot)
1706 
      self._iprot.readMessageEnd()
1707 
      raise x
1708 
    result = getTransactionsForShoppingCartId_result()
1709 
    result.read(self._iprot)
1710 
    self._iprot.readMessageEnd()
3431 rajveer 1711 
    if result.success is not None:
132 ashish 1712 
      return result.success
3431 rajveer 1713 
    if result.ex is not None:
132 ashish 1714 
      raise result.ex
1715 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1716 
 
94 ashish 1717 
  def getTransactionStatus(self, transactionId):
1718 
    """
1719 
    Parameters:
1720 
     - transactionId
1721 
    """
1722 
    self.send_getTransactionStatus(transactionId)
1723 
    return self.recv_getTransactionStatus()
1724 
 
1725 
  def send_getTransactionStatus(self, transactionId):
1726 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1727 
    args = getTransactionStatus_args()
1728 
    args.transactionId = transactionId
1729 
    args.write(self._oprot)
1730 
    self._oprot.writeMessageEnd()
1731 
    self._oprot.trans.flush()
1732 
 
1733 
  def recv_getTransactionStatus(self, ):
1734 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1735 
    if mtype == TMessageType.EXCEPTION:
1736 
      x = TApplicationException()
1737 
      x.read(self._iprot)
1738 
      self._iprot.readMessageEnd()
1739 
      raise x
1740 
    result = getTransactionStatus_result()
1741 
    result.read(self._iprot)
1742 
    self._iprot.readMessageEnd()
3431 rajveer 1743 
    if result.success is not None:
94 ashish 1744 
      return result.success
3431 rajveer 1745 
    if result.ex is not None:
94 ashish 1746 
      raise result.ex
1747 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1748 
 
5527 anupam.sin 1749 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1750 
    """
1751 
    Parameters:
1752 
     - transactionId
1753 
     - status
1754 
     - description
5527 anupam.sin 1755 
     - pickUp
1756 
     - orderType
94 ashish 1757 
    """
5527 anupam.sin 1758 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1759 
    return self.recv_changeTransactionStatus()
1760 
 
5527 anupam.sin 1761 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1762 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1763 
    args = changeTransactionStatus_args()
1764 
    args.transactionId = transactionId
1765 
    args.status = status
1766 
    args.description = description
5527 anupam.sin 1767 
    args.pickUp = pickUp
1768 
    args.orderType = orderType
94 ashish 1769 
    args.write(self._oprot)
1770 
    self._oprot.writeMessageEnd()
1771 
    self._oprot.trans.flush()
1772 
 
1773 
  def recv_changeTransactionStatus(self, ):
1774 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1775 
    if mtype == TMessageType.EXCEPTION:
1776 
      x = TApplicationException()
1777 
      x.read(self._iprot)
1778 
      self._iprot.readMessageEnd()
1779 
      raise x
1780 
    result = changeTransactionStatus_result()
1781 
    result.read(self._iprot)
1782 
    self._iprot.readMessageEnd()
3431 rajveer 1783 
    if result.success is not None:
94 ashish 1784 
      return result.success
3431 rajveer 1785 
    if result.ex is not None:
94 ashish 1786 
      raise result.ex
1787 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1788 
 
1398 varun.gupt 1789 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1790 
    """
1791 
    Parameters:
1792 
     - transactionId
1793 
    """
1398 varun.gupt 1794 
    self.send_enqueueTransactionInfoEmail(transactionId)
1795 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1796 
 
1398 varun.gupt 1797 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1798 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1799 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1800 
    args.transactionId = transactionId
1801 
    args.write(self._oprot)
1802 
    self._oprot.writeMessageEnd()
1803 
    self._oprot.trans.flush()
1804 
 
1398 varun.gupt 1805 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1806 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1807 
    if mtype == TMessageType.EXCEPTION:
1808 
      x = TApplicationException()
1809 
      x.read(self._iprot)
1810 
      self._iprot.readMessageEnd()
1811 
      raise x
1398 varun.gupt 1812 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1813 
    result.read(self._iprot)
1814 
    self._iprot.readMessageEnd()
3431 rajveer 1815 
    if result.success is not None:
1382 varun.gupt 1816 
      return result.success
3431 rajveer 1817 
    if result.ex is not None:
1382 varun.gupt 1818 
      raise result.ex
1398 varun.gupt 1819 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1820 
 
4801 anupam.sin 1821 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1822 
    """
1823 
    Parameters:
4801 anupam.sin 1824 
     - statuses
483 rajveer 1825 
     - from_date
1826 
     - to_date
1827 
     - warehouse_id
94 ashish 1828 
    """
4801 anupam.sin 1829 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1830 
    return self.recv_getAllOrders()
94 ashish 1831 
 
4801 anupam.sin 1832 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1833 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1834 
    args = getAllOrders_args()
4801 anupam.sin 1835 
    args.statuses = statuses
483 rajveer 1836 
    args.from_date = from_date
1837 
    args.to_date = to_date
1838 
    args.warehouse_id = warehouse_id
94 ashish 1839 
    args.write(self._oprot)
1840 
    self._oprot.writeMessageEnd()
1841 
    self._oprot.trans.flush()
1842 
 
483 rajveer 1843 
  def recv_getAllOrders(self, ):
94 ashish 1844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1845 
    if mtype == TMessageType.EXCEPTION:
1846 
      x = TApplicationException()
1847 
      x.read(self._iprot)
1848 
      self._iprot.readMessageEnd()
1849 
      raise x
483 rajveer 1850 
    result = getAllOrders_result()
94 ashish 1851 
    result.read(self._iprot)
1852 
    self._iprot.readMessageEnd()
3431 rajveer 1853 
    if result.success is not None:
94 ashish 1854 
      return result.success
3431 rajveer 1855 
    if result.ex is not None:
94 ashish 1856 
      raise result.ex
483 rajveer 1857 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1858 
 
4133 chandransh 1859 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1860 
    """
1861 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1862 
    Pass the status as null and the limit as 0 to ignore them.
1863 
 
1864 
    Parameters:
1865 
     - statuses
1866 
     - offset
1867 
     - limit
1868 
     - warehouse_id
1869 
    """
1870 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1871 
    return self.recv_getOrdersInBatch()
1872 
 
1873 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1874 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1875 
    args = getOrdersInBatch_args()
1876 
    args.statuses = statuses
1877 
    args.offset = offset
1878 
    args.limit = limit
1879 
    args.warehouse_id = warehouse_id
1880 
    args.write(self._oprot)
1881 
    self._oprot.writeMessageEnd()
1882 
    self._oprot.trans.flush()
1883 
 
1884 
  def recv_getOrdersInBatch(self, ):
1885 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1886 
    if mtype == TMessageType.EXCEPTION:
1887 
      x = TApplicationException()
1888 
      x.read(self._iprot)
1889 
      self._iprot.readMessageEnd()
1890 
      raise x
1891 
    result = getOrdersInBatch_result()
1892 
    result.read(self._iprot)
1893 
    self._iprot.readMessageEnd()
1894 
    if result.success is not None:
1895 
      return result.success
1896 
    if result.ex is not None:
1897 
      raise result.ex
1898 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1899 
 
1900 
  def getOrderCount(self, statuses, warehouseId):
1901 
    """
1902 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1903 
 
1904 
    Parameters:
1905 
     - statuses
1906 
     - warehouseId
1907 
    """
1908 
    self.send_getOrderCount(statuses, warehouseId)
1909 
    return self.recv_getOrderCount()
1910 
 
1911 
  def send_getOrderCount(self, statuses, warehouseId):
1912 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1913 
    args = getOrderCount_args()
1914 
    args.statuses = statuses
1915 
    args.warehouseId = warehouseId
1916 
    args.write(self._oprot)
1917 
    self._oprot.writeMessageEnd()
1918 
    self._oprot.trans.flush()
1919 
 
1920 
  def recv_getOrderCount(self, ):
1921 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1922 
    if mtype == TMessageType.EXCEPTION:
1923 
      x = TApplicationException()
1924 
      x.read(self._iprot)
1925 
      self._iprot.readMessageEnd()
1926 
      raise x
1927 
    result = getOrderCount_result()
1928 
    result.read(self._iprot)
1929 
    self._iprot.readMessageEnd()
1930 
    if result.success is not None:
1931 
      return result.success
1932 
    if result.ex is not None:
1933 
      raise result.ex
1934 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1935 
 
999 varun.gupt 1936 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1937 
    """
1132 chandransh 1938 
    Returns orders within a range of their billing dates
3431 rajveer 1939 
 
999 varun.gupt 1940 
    Parameters:
1941 
     - status
1942 
     - start_billing_date
1943 
     - end_billing_date
1944 
     - warehouse_id
1945 
    """
1946 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1947 
    return self.recv_getOrdersByBillingDate()
1948 
 
1949 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1950 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1951 
    args = getOrdersByBillingDate_args()
1952 
    args.status = status
1953 
    args.start_billing_date = start_billing_date
1954 
    args.end_billing_date = end_billing_date
1955 
    args.warehouse_id = warehouse_id
1956 
    args.write(self._oprot)
1957 
    self._oprot.writeMessageEnd()
1958 
    self._oprot.trans.flush()
1959 
 
1960 
  def recv_getOrdersByBillingDate(self, ):
1961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1962 
    if mtype == TMessageType.EXCEPTION:
1963 
      x = TApplicationException()
1964 
      x.read(self._iprot)
1965 
      self._iprot.readMessageEnd()
1966 
      raise x
1967 
    result = getOrdersByBillingDate_result()
1968 
    result.read(self._iprot)
1969 
    self._iprot.readMessageEnd()
3431 rajveer 1970 
    if result.success is not None:
999 varun.gupt 1971 
      return result.success
3431 rajveer 1972 
    if result.ex is not None:
999 varun.gupt 1973 
      raise result.ex
1974 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1975 
 
3451 chandransh 1976 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1977 
    """
1978 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1979 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1980 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1981 
 
3427 chandransh 1982 
    Parameters:
1983 
     - fromShippingDate
1984 
     - toShippingDate
1985 
     - providerId
1986 
     - warehouseId
3451 chandransh 1987 
     - cod
3427 chandransh 1988 
    """
3451 chandransh 1989 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1990 
    return self.recv_getOrdersByShippingDate()
1991 
 
3451 chandransh 1992 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1993 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1994 
    args = getOrdersByShippingDate_args()
1995 
    args.fromShippingDate = fromShippingDate
1996 
    args.toShippingDate = toShippingDate
1997 
    args.providerId = providerId
1998 
    args.warehouseId = warehouseId
3451 chandransh 1999 
    args.cod = cod
3427 chandransh 2000 
    args.write(self._oprot)
2001 
    self._oprot.writeMessageEnd()
2002 
    self._oprot.trans.flush()
2003 
 
2004 
  def recv_getOrdersByShippingDate(self, ):
2005 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2006 
    if mtype == TMessageType.EXCEPTION:
2007 
      x = TApplicationException()
2008 
      x.read(self._iprot)
2009 
      self._iprot.readMessageEnd()
2010 
      raise x
2011 
    result = getOrdersByShippingDate_result()
2012 
    result.read(self._iprot)
2013 
    self._iprot.readMessageEnd()
3431 rajveer 2014 
    if result.success is not None:
3427 chandransh 2015 
      return result.success
3431 rajveer 2016 
    if result.ex is not None:
3427 chandransh 2017 
      raise result.ex
2018 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
2019 
 
1382 varun.gupt 2020 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
2021 
    """
2022 
    Returns order ids for orders which can be returned
3431 rajveer 2023 
 
1382 varun.gupt 2024 
    Parameters:
2025 
     - customer_id
2026 
     - limit
2027 
    """
2028 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
2029 
    return self.recv_getReturnableOrdersForCustomer()
2030 
 
2031 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
2032 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
2033 
    args = getReturnableOrdersForCustomer_args()
2034 
    args.customer_id = customer_id
2035 
    args.limit = limit
2036 
    args.write(self._oprot)
2037 
    self._oprot.writeMessageEnd()
2038 
    self._oprot.trans.flush()
2039 
 
2040 
  def recv_getReturnableOrdersForCustomer(self, ):
2041 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2042 
    if mtype == TMessageType.EXCEPTION:
2043 
      x = TApplicationException()
2044 
      x.read(self._iprot)
2045 
      self._iprot.readMessageEnd()
2046 
      raise x
2047 
    result = getReturnableOrdersForCustomer_result()
2048 
    result.read(self._iprot)
2049 
    self._iprot.readMessageEnd()
3431 rajveer 2050 
    if result.success is not None:
1382 varun.gupt 2051 
      return result.success
3431 rajveer 2052 
    if result.ex is not None:
1382 varun.gupt 2053 
      raise result.ex
2054 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
2055 
 
2056 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
2057 
    """
2058 
    Returns order ids for orders which can be cancelled
3431 rajveer 2059 
 
1382 varun.gupt 2060 
    Parameters:
2061 
     - customer_id
2062 
     - limit
2063 
    """
2064 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
2065 
    return self.recv_getCancellableOrdersForCustomer()
2066 
 
2067 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
2068 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
2069 
    args = getCancellableOrdersForCustomer_args()
2070 
    args.customer_id = customer_id
2071 
    args.limit = limit
2072 
    args.write(self._oprot)
2073 
    self._oprot.writeMessageEnd()
2074 
    self._oprot.trans.flush()
2075 
 
2076 
  def recv_getCancellableOrdersForCustomer(self, ):
2077 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2078 
    if mtype == TMessageType.EXCEPTION:
2079 
      x = TApplicationException()
2080 
      x.read(self._iprot)
2081 
      self._iprot.readMessageEnd()
2082 
      raise x
2083 
    result = getCancellableOrdersForCustomer_result()
2084 
    result.read(self._iprot)
2085 
    self._iprot.readMessageEnd()
3431 rajveer 2086 
    if result.success is not None:
1382 varun.gupt 2087 
      return result.success
3431 rajveer 2088 
    if result.ex is not None:
1382 varun.gupt 2089 
      raise result.ex
2090 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
2091 
 
483 rajveer 2092 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 2093 
    """
2094 
    Parameters:
483 rajveer 2095 
     - orderId
2096 
     - status
2097 
     - description
94 ashish 2098 
    """
483 rajveer 2099 
    self.send_changeOrderStatus(orderId, status, description)
2100 
    return self.recv_changeOrderStatus()
94 ashish 2101 
 
483 rajveer 2102 
  def send_changeOrderStatus(self, orderId, status, description):
2103 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
2104 
    args = changeOrderStatus_args()
2105 
    args.orderId = orderId
2106 
    args.status = status
2107 
    args.description = description
94 ashish 2108 
    args.write(self._oprot)
2109 
    self._oprot.writeMessageEnd()
2110 
    self._oprot.trans.flush()
2111 
 
483 rajveer 2112 
  def recv_changeOrderStatus(self, ):
94 ashish 2113 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2114 
    if mtype == TMessageType.EXCEPTION:
2115 
      x = TApplicationException()
2116 
      x.read(self._iprot)
2117 
      self._iprot.readMessageEnd()
2118 
      raise x
483 rajveer 2119 
    result = changeOrderStatus_result()
94 ashish 2120 
    result.read(self._iprot)
2121 
    self._iprot.readMessageEnd()
3431 rajveer 2122 
    if result.success is not None:
94 ashish 2123 
      return result.success
3431 rajveer 2124 
    if result.ex is not None:
94 ashish 2125 
      raise result.ex
483 rajveer 2126 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 2127 
 
1528 ankur.sing 2128 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 2129 
    """
1528 ankur.sing 2130 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
2131 
    only user who owns the transaction can view its order details.
3431 rajveer 2132 
 
94 ashish 2133 
    Parameters:
2134 
     - transactionId
1528 ankur.sing 2135 
     - customerId
94 ashish 2136 
    """
1528 ankur.sing 2137 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2138 
    return self.recv_getOrdersForTransaction()
94 ashish 2139 
 
1528 ankur.sing 2140 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2141 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2142 
    args = getOrdersForTransaction_args()
94 ashish 2143 
    args.transactionId = transactionId
1528 ankur.sing 2144 
    args.customerId = customerId
94 ashish 2145 
    args.write(self._oprot)
2146 
    self._oprot.writeMessageEnd()
2147 
    self._oprot.trans.flush()
2148 
 
483 rajveer 2149 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2150 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2151 
    if mtype == TMessageType.EXCEPTION:
2152 
      x = TApplicationException()
2153 
      x.read(self._iprot)
2154 
      self._iprot.readMessageEnd()
2155 
      raise x
483 rajveer 2156 
    result = getOrdersForTransaction_result()
94 ashish 2157 
    result.read(self._iprot)
2158 
    self._iprot.readMessageEnd()
3431 rajveer 2159 
    if result.success is not None:
94 ashish 2160 
      return result.success
3431 rajveer 2161 
    if result.ex is not None:
94 ashish 2162 
      raise result.ex
483 rajveer 2163 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2164 
 
3014 chandransh 2165 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2166 
    """
3014 chandransh 2167 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2168 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2169 
 
94 ashish 2170 
    Parameters:
483 rajveer 2171 
     - customerId
2172 
     - from_date
2173 
     - to_date
3014 chandransh 2174 
     - statuses
94 ashish 2175 
    """
3014 chandransh 2176 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2177 
    return self.recv_getOrdersForCustomer()
94 ashish 2178 
 
3014 chandransh 2179 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2180 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2181 
    args = getOrdersForCustomer_args()
2182 
    args.customerId = customerId
2183 
    args.from_date = from_date
2184 
    args.to_date = to_date
3014 chandransh 2185 
    args.statuses = statuses
94 ashish 2186 
    args.write(self._oprot)
2187 
    self._oprot.writeMessageEnd()
2188 
    self._oprot.trans.flush()
2189 
 
483 rajveer 2190 
  def recv_getOrdersForCustomer(self, ):
94 ashish 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
483 rajveer 2197 
    result = getOrdersForCustomer_result()
94 ashish 2198 
    result.read(self._iprot)
2199 
    self._iprot.readMessageEnd()
3431 rajveer 2200 
    if result.success is not None:
94 ashish 2201 
      return result.success
3431 rajveer 2202 
    if result.ex is not None:
94 ashish 2203 
      raise result.ex
483 rajveer 2204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2205 
 
483 rajveer 2206 
  def createOrder(self, order):
94 ashish 2207 
    """
2208 
    Parameters:
483 rajveer 2209 
     - order
94 ashish 2210 
    """
483 rajveer 2211 
    self.send_createOrder(order)
2212 
    return self.recv_createOrder()
94 ashish 2213 
 
483 rajveer 2214 
  def send_createOrder(self, order):
2215 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2216 
    args = createOrder_args()
2217 
    args.order = order
94 ashish 2218 
    args.write(self._oprot)
2219 
    self._oprot.writeMessageEnd()
2220 
    self._oprot.trans.flush()
2221 
 
483 rajveer 2222 
  def recv_createOrder(self, ):
94 ashish 2223 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2224 
    if mtype == TMessageType.EXCEPTION:
2225 
      x = TApplicationException()
2226 
      x.read(self._iprot)
2227 
      self._iprot.readMessageEnd()
2228 
      raise x
483 rajveer 2229 
    result = createOrder_result()
94 ashish 2230 
    result.read(self._iprot)
2231 
    self._iprot.readMessageEnd()
3431 rajveer 2232 
    if result.success is not None:
94 ashish 2233 
      return result.success
3431 rajveer 2234 
    if result.ex is not None:
94 ashish 2235 
      raise result.ex
483 rajveer 2236 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2237 
 
483 rajveer 2238 
  def getOrder(self, id):
94 ashish 2239 
    """
2240 
    Parameters:
483 rajveer 2241 
     - id
94 ashish 2242 
    """
483 rajveer 2243 
    self.send_getOrder(id)
2244 
    return self.recv_getOrder()
94 ashish 2245 
 
483 rajveer 2246 
  def send_getOrder(self, id):
2247 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2248 
    args = getOrder_args()
2249 
    args.id = id
94 ashish 2250 
    args.write(self._oprot)
2251 
    self._oprot.writeMessageEnd()
2252 
    self._oprot.trans.flush()
2253 
 
483 rajveer 2254 
  def recv_getOrder(self, ):
94 ashish 2255 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2256 
    if mtype == TMessageType.EXCEPTION:
2257 
      x = TApplicationException()
2258 
      x.read(self._iprot)
2259 
      self._iprot.readMessageEnd()
2260 
      raise x
483 rajveer 2261 
    result = getOrder_result()
94 ashish 2262 
    result.read(self._iprot)
2263 
    self._iprot.readMessageEnd()
3431 rajveer 2264 
    if result.success is not None:
94 ashish 2265 
      return result.success
3431 rajveer 2266 
    if result.ex is not None:
94 ashish 2267 
      raise result.ex
483 rajveer 2268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2269 
 
483 rajveer 2270 
  def getLineItemsForOrder(self, orderId):
94 ashish 2271 
    """
2272 
    Parameters:
483 rajveer 2273 
     - orderId
94 ashish 2274 
    """
483 rajveer 2275 
    self.send_getLineItemsForOrder(orderId)
2276 
    return self.recv_getLineItemsForOrder()
94 ashish 2277 
 
483 rajveer 2278 
  def send_getLineItemsForOrder(self, orderId):
2279 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2280 
    args = getLineItemsForOrder_args()
2281 
    args.orderId = orderId
94 ashish 2282 
    args.write(self._oprot)
2283 
    self._oprot.writeMessageEnd()
2284 
    self._oprot.trans.flush()
2285 
 
483 rajveer 2286 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2287 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2288 
    if mtype == TMessageType.EXCEPTION:
2289 
      x = TApplicationException()
2290 
      x.read(self._iprot)
2291 
      self._iprot.readMessageEnd()
2292 
      raise x
483 rajveer 2293 
    result = getLineItemsForOrder_result()
94 ashish 2294 
    result.read(self._iprot)
2295 
    self._iprot.readMessageEnd()
3431 rajveer 2296 
    if result.success is not None:
94 ashish 2297 
      return result.success
3431 rajveer 2298 
    if result.ex is not None:
94 ashish 2299 
      raise result.ex
483 rajveer 2300 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2301 
 
4999 phani.kuma 2302 
  def getOrderList(self, order_ids):
2303 
    """
2304 
    Parameters:
2305 
     - order_ids
2306 
    """
2307 
    self.send_getOrderList(order_ids)
2308 
    return self.recv_getOrderList()
2309 
 
2310 
  def send_getOrderList(self, order_ids):
2311 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2312 
    args = getOrderList_args()
2313 
    args.order_ids = order_ids
2314 
    args.write(self._oprot)
2315 
    self._oprot.writeMessageEnd()
2316 
    self._oprot.trans.flush()
2317 
 
2318 
  def recv_getOrderList(self, ):
2319 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2320 
    if mtype == TMessageType.EXCEPTION:
2321 
      x = TApplicationException()
2322 
      x.read(self._iprot)
2323 
      self._iprot.readMessageEnd()
2324 
      raise x
2325 
    result = getOrderList_result()
2326 
    result.read(self._iprot)
2327 
    self._iprot.readMessageEnd()
2328 
    if result.success is not None:
2329 
      return result.success
2330 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2331 
 
5386 phani.kuma 2332 
  def getOrderListForVendor(self, order_ids, vendorId):
2333 
    """
2334 
    Parameters:
2335 
     - order_ids
2336 
     - vendorId
2337 
    """
2338 
    self.send_getOrderListForVendor(order_ids, vendorId)
2339 
    return self.recv_getOrderListForVendor()
2340 
 
2341 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2342 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2343 
    args = getOrderListForVendor_args()
2344 
    args.order_ids = order_ids
2345 
    args.vendorId = vendorId
2346 
    args.write(self._oprot)
2347 
    self._oprot.writeMessageEnd()
2348 
    self._oprot.trans.flush()
2349 
 
2350 
  def recv_getOrderListForVendor(self, ):
2351 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2352 
    if mtype == TMessageType.EXCEPTION:
2353 
      x = TApplicationException()
2354 
      x.read(self._iprot)
2355 
      self._iprot.readMessageEnd()
2356 
      raise x
2357 
    result = getOrderListForVendor_result()
2358 
    result.read(self._iprot)
2359 
    self._iprot.readMessageEnd()
2360 
    if result.success is not None:
2361 
      return result.success
2362 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2363 
 
1528 ankur.sing 2364 
  def getOrderForCustomer(self, orderId, customerId):
2365 
    """
2366 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2367 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2368 
 
1528 ankur.sing 2369 
    Parameters:
2370 
     - orderId
2371 
     - customerId
2372 
    """
2373 
    self.send_getOrderForCustomer(orderId, customerId)
2374 
    return self.recv_getOrderForCustomer()
2375 
 
2376 
  def send_getOrderForCustomer(self, orderId, customerId):
2377 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2378 
    args = getOrderForCustomer_args()
2379 
    args.orderId = orderId
2380 
    args.customerId = customerId
2381 
    args.write(self._oprot)
2382 
    self._oprot.writeMessageEnd()
2383 
    self._oprot.trans.flush()
2384 
 
2385 
  def recv_getOrderForCustomer(self, ):
2386 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2387 
    if mtype == TMessageType.EXCEPTION:
2388 
      x = TApplicationException()
2389 
      x.read(self._iprot)
2390 
      self._iprot.readMessageEnd()
2391 
      raise x
2392 
    result = getOrderForCustomer_result()
2393 
    result.read(self._iprot)
2394 
    self._iprot.readMessageEnd()
3431 rajveer 2395 
    if result.success is not None:
1528 ankur.sing 2396 
      return result.success
3431 rajveer 2397 
    if result.ex is not None:
1528 ankur.sing 2398 
      raise result.ex
2399 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2400 
 
4444 rajveer 2401 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2402 
    """
2403 
    Parameters:
4394 rajveer 2404 
     - type
4444 rajveer 2405 
     - warehouseId
4394 rajveer 2406 
     - status
2407 
     - timestamp
3064 chandransh 2408 
    """
4444 rajveer 2409 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2410 
    return self.recv_getAlerts()
2411 
 
4444 rajveer 2412 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2413 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2414 
    args = getAlerts_args()
4394 rajveer 2415 
    args.type = type
4444 rajveer 2416 
    args.warehouseId = warehouseId
4394 rajveer 2417 
    args.status = status
2418 
    args.timestamp = timestamp
3064 chandransh 2419 
    args.write(self._oprot)
2420 
    self._oprot.writeMessageEnd()
2421 
    self._oprot.trans.flush()
2422 
 
2423 
  def recv_getAlerts(self, ):
2424 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2425 
    if mtype == TMessageType.EXCEPTION:
2426 
      x = TApplicationException()
2427 
      x.read(self._iprot)
2428 
      self._iprot.readMessageEnd()
2429 
      raise x
2430 
    result = getAlerts_result()
2431 
    result.read(self._iprot)
2432 
    self._iprot.readMessageEnd()
3431 rajveer 2433 
    if result.success is not None:
3064 chandransh 2434 
      return result.success
2435 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2436 
 
4444 rajveer 2437 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2438 
    """
2439 
    Parameters:
2440 
     - type
4444 rajveer 2441 
     - warehouseId
4394 rajveer 2442 
     - description
3064 chandransh 2443 
    """
4444 rajveer 2444 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2445 
    self.recv_addAlert()
3064 chandransh 2446 
 
4444 rajveer 2447 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2448 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2449 
    args = addAlert_args()
3064 chandransh 2450 
    args.type = type
4444 rajveer 2451 
    args.warehouseId = warehouseId
4394 rajveer 2452 
    args.description = description
3064 chandransh 2453 
    args.write(self._oprot)
2454 
    self._oprot.writeMessageEnd()
2455 
    self._oprot.trans.flush()
2456 
 
4394 rajveer 2457 
  def recv_addAlert(self, ):
3064 chandransh 2458 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2459 
    if mtype == TMessageType.EXCEPTION:
2460 
      x = TApplicationException()
2461 
      x.read(self._iprot)
2462 
      self._iprot.readMessageEnd()
2463 
      raise x
4394 rajveer 2464 
    result = addAlert_result()
3064 chandransh 2465 
    result.read(self._iprot)
2466 
    self._iprot.readMessageEnd()
2467 
    return
2468 
 
4444 rajveer 2469 
  def markAlertsAsSeen(self, warehouseId):
2470 
    """
2471 
    Parameters:
2472 
     - warehouseId
2473 
    """
2474 
    self.send_markAlertsAsSeen(warehouseId)
2475 
    self.recv_markAlertsAsSeen()
2476 
 
2477 
  def send_markAlertsAsSeen(self, warehouseId):
2478 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2479 
    args = markAlertsAsSeen_args()
2480 
    args.warehouseId = warehouseId
2481 
    args.write(self._oprot)
2482 
    self._oprot.writeMessageEnd()
2483 
    self._oprot.trans.flush()
2484 
 
2485 
  def recv_markAlertsAsSeen(self, ):
2486 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2487 
    if mtype == TMessageType.EXCEPTION:
2488 
      x = TApplicationException()
2489 
      x.read(self._iprot)
2490 
      self._iprot.readMessageEnd()
2491 
      raise x
2492 
    result = markAlertsAsSeen_result()
2493 
    result.read(self._iprot)
2494 
    self._iprot.readMessageEnd()
2495 
    return
2496 
 
3064 chandransh 2497 
  def getValidOrderCount(self, ):
2498 
    """
2499 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2500 
    """
2501 
    self.send_getValidOrderCount()
2502 
    return self.recv_getValidOrderCount()
2503 
 
2504 
  def send_getValidOrderCount(self, ):
2505 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2506 
    args = getValidOrderCount_args()
2507 
    args.write(self._oprot)
2508 
    self._oprot.writeMessageEnd()
2509 
    self._oprot.trans.flush()
2510 
 
2511 
  def recv_getValidOrderCount(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 = getValidOrderCount_result()
2519 
    result.read(self._iprot)
2520 
    self._iprot.readMessageEnd()
3431 rajveer 2521 
    if result.success is not None:
3064 chandransh 2522 
      return result.success
2523 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2524 
 
2525 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2526 
    """
2527 
    Returns the number of distinct customers who have done successful transactions
2528 
    """
2529 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2530 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2531 
 
2532 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2533 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2534 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2535 
    args.write(self._oprot)
2536 
    self._oprot.writeMessageEnd()
2537 
    self._oprot.trans.flush()
2538 
 
2539 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2540 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2541 
    if mtype == TMessageType.EXCEPTION:
2542 
      x = TApplicationException()
2543 
      x.read(self._iprot)
2544 
      self._iprot.readMessageEnd()
2545 
      raise x
2546 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2547 
    result.read(self._iprot)
2548 
    self._iprot.readMessageEnd()
3431 rajveer 2549 
    if result.success is not None:
3064 chandransh 2550 
      return result.success
2551 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2552 
 
2553 
  def getValidOrdersAmountRange(self, ):
2554 
    """
2555 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2556 
    List contains two values, first minimum amount and second maximum amount.
2557 
    """
2558 
    self.send_getValidOrdersAmountRange()
2559 
    return self.recv_getValidOrdersAmountRange()
2560 
 
2561 
  def send_getValidOrdersAmountRange(self, ):
2562 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2563 
    args = getValidOrdersAmountRange_args()
2564 
    args.write(self._oprot)
2565 
    self._oprot.writeMessageEnd()
2566 
    self._oprot.trans.flush()
2567 
 
2568 
  def recv_getValidOrdersAmountRange(self, ):
2569 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2570 
    if mtype == TMessageType.EXCEPTION:
2571 
      x = TApplicationException()
2572 
      x.read(self._iprot)
2573 
      self._iprot.readMessageEnd()
2574 
      raise x
2575 
    result = getValidOrdersAmountRange_result()
2576 
    result.read(self._iprot)
2577 
    self._iprot.readMessageEnd()
3431 rajveer 2578 
    if result.success is not None:
3064 chandransh 2579 
      return result.success
2580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2581 
 
5874 rajveer 2582 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2583 
    """
2584 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2585 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2586 
 
3064 chandransh 2587 
    Parameters:
2588 
     - limit
5874 rajveer 2589 
     - onlyStore
3064 chandransh 2590 
    """
5874 rajveer 2591 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2592 
    return self.recv_getValidOrders()
2593 
 
5874 rajveer 2594 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2595 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2596 
    args = getValidOrders_args()
2597 
    args.limit = limit
5874 rajveer 2598 
    args.onlyStore = onlyStore
3064 chandransh 2599 
    args.write(self._oprot)
2600 
    self._oprot.writeMessageEnd()
2601 
    self._oprot.trans.flush()
2602 
 
2603 
  def recv_getValidOrders(self, ):
2604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2605 
    if mtype == TMessageType.EXCEPTION:
2606 
      x = TApplicationException()
2607 
      x.read(self._iprot)
2608 
      self._iprot.readMessageEnd()
2609 
      raise x
2610 
    result = getValidOrders_result()
2611 
    result.read(self._iprot)
2612 
    self._iprot.readMessageEnd()
3431 rajveer 2613 
    if result.success is not None:
3064 chandransh 2614 
      return result.success
2615 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2616 
 
1220 chandransh 2617 
  def batchOrders(self, warehouseId):
2618 
    """
2619 
    Create a batch of all the pending orders for the given warehouse.
2620 
    The returned list is orderd by created_timestamp.
2621 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2622 
 
1220 chandransh 2623 
    Parameters:
2624 
     - warehouseId
2625 
    """
2626 
    self.send_batchOrders(warehouseId)
2627 
    return self.recv_batchOrders()
2628 
 
2629 
  def send_batchOrders(self, warehouseId):
2630 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2631 
    args = batchOrders_args()
2632 
    args.warehouseId = warehouseId
2633 
    args.write(self._oprot)
2634 
    self._oprot.writeMessageEnd()
2635 
    self._oprot.trans.flush()
2636 
 
2637 
  def recv_batchOrders(self, ):
2638 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2639 
    if mtype == TMessageType.EXCEPTION:
2640 
      x = TApplicationException()
2641 
      x.read(self._iprot)
2642 
      self._iprot.readMessageEnd()
2643 
      raise x
2644 
    result = batchOrders_result()
2645 
    result.read(self._iprot)
2646 
    self._iprot.readMessageEnd()
3431 rajveer 2647 
    if result.success is not None:
1220 chandransh 2648 
      return result.success
3431 rajveer 2649 
    if result.ex is not None:
1220 chandransh 2650 
      raise result.ex
2651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2652 
 
1208 chandransh 2653 
  def markOrderAsOutOfStock(self, orderId):
2654 
    """
2655 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2656 
 
1208 chandransh 2657 
    Parameters:
2658 
     - orderId
2659 
    """
2660 
    self.send_markOrderAsOutOfStock(orderId)
2661 
    return self.recv_markOrderAsOutOfStock()
2662 
 
2663 
  def send_markOrderAsOutOfStock(self, orderId):
2664 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2665 
    args = markOrderAsOutOfStock_args()
2666 
    args.orderId = orderId
2667 
    args.write(self._oprot)
2668 
    self._oprot.writeMessageEnd()
2669 
    self._oprot.trans.flush()
2670 
 
2671 
  def recv_markOrderAsOutOfStock(self, ):
2672 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2673 
    if mtype == TMessageType.EXCEPTION:
2674 
      x = TApplicationException()
2675 
      x.read(self._iprot)
2676 
      self._iprot.readMessageEnd()
2677 
      raise x
2678 
    result = markOrderAsOutOfStock_result()
2679 
    result.read(self._iprot)
2680 
    self._iprot.readMessageEnd()
3431 rajveer 2681 
    if result.success is not None:
1208 chandransh 2682 
      return result.success
3431 rajveer 2683 
    if result.ex is not None:
1208 chandransh 2684 
      raise result.ex
2685 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2686 
 
3064 chandransh 2687 
  def verifyOrder(self, orderId):
759 chandransh 2688 
    """
3064 chandransh 2689 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2690 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2691 
    used for all other orders as well.
2692 
    Throws an exception if no such order exists.
3431 rajveer 2693 
 
759 chandransh 2694 
    Parameters:
3064 chandransh 2695 
     - orderId
759 chandransh 2696 
    """
3064 chandransh 2697 
    self.send_verifyOrder(orderId)
2698 
    return self.recv_verifyOrder()
759 chandransh 2699 
 
3064 chandransh 2700 
  def send_verifyOrder(self, orderId):
2701 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2702 
    args = verifyOrder_args()
2703 
    args.orderId = orderId
759 chandransh 2704 
    args.write(self._oprot)
2705 
    self._oprot.writeMessageEnd()
2706 
    self._oprot.trans.flush()
2707 
 
3064 chandransh 2708 
  def recv_verifyOrder(self, ):
759 chandransh 2709 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2710 
    if mtype == TMessageType.EXCEPTION:
2711 
      x = TApplicationException()
2712 
      x.read(self._iprot)
2713 
      self._iprot.readMessageEnd()
2714 
      raise x
3064 chandransh 2715 
    result = verifyOrder_result()
759 chandransh 2716 
    result.read(self._iprot)
2717 
    self._iprot.readMessageEnd()
3431 rajveer 2718 
    if result.success is not None:
759 chandransh 2719 
      return result.success
3431 rajveer 2720 
    if result.ex is not None:
759 chandransh 2721 
      raise result.ex
3064 chandransh 2722 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2723 
 
3064 chandransh 2724 
  def acceptOrder(self, orderId):
1113 chandransh 2725 
    """
3064 chandransh 2726 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2727 
    given order is not a COD order, it also captures the payment if the same has
2728 
    not been captured.
2729 
    Throws an exception if no such order exists.
3431 rajveer 2730 
 
1113 chandransh 2731 
    Parameters:
3064 chandransh 2732 
     - orderId
1113 chandransh 2733 
    """
3064 chandransh 2734 
    self.send_acceptOrder(orderId)
2735 
    return self.recv_acceptOrder()
1113 chandransh 2736 
 
3064 chandransh 2737 
  def send_acceptOrder(self, orderId):
2738 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2739 
    args = acceptOrder_args()
2740 
    args.orderId = orderId
1113 chandransh 2741 
    args.write(self._oprot)
2742 
    self._oprot.writeMessageEnd()
2743 
    self._oprot.trans.flush()
2744 
 
3064 chandransh 2745 
  def recv_acceptOrder(self, ):
1113 chandransh 2746 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2747 
    if mtype == TMessageType.EXCEPTION:
2748 
      x = TApplicationException()
2749 
      x.read(self._iprot)
2750 
      self._iprot.readMessageEnd()
2751 
      raise x
3064 chandransh 2752 
    result = acceptOrder_result()
1113 chandransh 2753 
    result.read(self._iprot)
2754 
    self._iprot.readMessageEnd()
3431 rajveer 2755 
    if result.success is not None:
1113 chandransh 2756 
      return result.success
3431 rajveer 2757 
    if result.ex is not None:
1113 chandransh 2758 
      raise result.ex
3064 chandransh 2759 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2760 
 
7190 amar.kumar 2761 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2762 
    """
3064 chandransh 2763 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2764 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2765 
    the IMEI no. if a -1 is supplied.
2766 
    Also, it generates an invoice number for the order, marks the order as
2767 
    BILLED and sets the billing timestamp.
2768 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2769 
 
1135 chandransh 2770 
    Parameters:
3064 chandransh 2771 
     - orderId
2772 
     - invoice_number
4658 mandeep.dh 2773 
     - serialNumber
4283 anupam.sin 2774 
     - itemNumber
7190 amar.kumar 2775 
     - freebieWarehouseId
3064 chandransh 2776 
     - billed_by
4264 rajveer 2777 
     - jacketNumber
4283 anupam.sin 2778 
     - billingType
5110 mandeep.dh 2779 
     - fulfilmentWarehouseId
4763 rajveer 2780 
     - authorize
1135 chandransh 2781 
    """
7190 amar.kumar 2782 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2783 
    return self.recv_addBillingDetails()
1135 chandransh 2784 
 
7190 amar.kumar 2785 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2786 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2787 
    args = addBillingDetails_args()
2788 
    args.orderId = orderId
2789 
    args.invoice_number = invoice_number
4658 mandeep.dh 2790 
    args.serialNumber = serialNumber
4283 anupam.sin 2791 
    args.itemNumber = itemNumber
7190 amar.kumar 2792 
    args.freebieWarehouseId = freebieWarehouseId
3064 chandransh 2793 
    args.billed_by = billed_by
4264 rajveer 2794 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2795 
    args.billingType = billingType
5110 mandeep.dh 2796 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2797 
    args.authorize = authorize
1135 chandransh 2798 
    args.write(self._oprot)
2799 
    self._oprot.writeMessageEnd()
2800 
    self._oprot.trans.flush()
2801 
 
3064 chandransh 2802 
  def recv_addBillingDetails(self, ):
1135 chandransh 2803 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2804 
    if mtype == TMessageType.EXCEPTION:
2805 
      x = TApplicationException()
2806 
      x.read(self._iprot)
2807 
      self._iprot.readMessageEnd()
2808 
      raise x
3064 chandransh 2809 
    result = addBillingDetails_result()
1135 chandransh 2810 
    result.read(self._iprot)
2811 
    self._iprot.readMessageEnd()
3431 rajveer 2812 
    if result.success is not None:
3064 chandransh 2813 
      return result.success
3431 rajveer 2814 
    if result.ex is not None:
1135 chandransh 2815 
      raise result.ex
3064 chandransh 2816 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2817 
 
6756 amar.kumar 2818 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2819 
    """
2820 
    Add the invoice number to the order.
2821 
 
2822 
    Parameters:
2823 
     - orderId
2824 
     - invoiceNumber
4763 rajveer 2825 
     - color
6756 amar.kumar 2826 
     - serialNumber
2827 
     - itemNumber
4579 rajveer 2828 
    """
6756 amar.kumar 2829 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color, serialNumber, itemNumber)
4579 rajveer 2830 
    self.recv_addInvoiceNumber()
2831 
 
6756 amar.kumar 2832 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2833 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2834 
    args = addInvoiceNumber_args()
2835 
    args.orderId = orderId
2836 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2837 
    args.color = color
6756 amar.kumar 2838 
    args.serialNumber = serialNumber
2839 
    args.itemNumber = itemNumber
4579 rajveer 2840 
    args.write(self._oprot)
2841 
    self._oprot.writeMessageEnd()
2842 
    self._oprot.trans.flush()
2843 
 
2844 
  def recv_addInvoiceNumber(self, ):
2845 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2846 
    if mtype == TMessageType.EXCEPTION:
2847 
      x = TApplicationException()
2848 
      x.read(self._iprot)
2849 
      self._iprot.readMessageEnd()
2850 
      raise x
2851 
    result = addInvoiceNumber_result()
2852 
    result.read(self._iprot)
2853 
    self._iprot.readMessageEnd()
2854 
    if result.ex is not None:
2855 
      raise result.ex
2856 
    return
2857 
 
4910 phani.kuma 2858 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2859 
    """
3064 chandransh 2860 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2861 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2862 
 
1408 ankur.sing 2863 
    Parameters:
3064 chandransh 2864 
     - warehouseId
1408 ankur.sing 2865 
     - providerId
3064 chandransh 2866 
     - cod
4910 phani.kuma 2867 
     - orderIds
1408 ankur.sing 2868 
    """
4910 phani.kuma 2869 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2870 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2871 
 
4910 phani.kuma 2872 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2873 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2874 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2875 
    args.warehouseId = warehouseId
1408 ankur.sing 2876 
    args.providerId = providerId
3064 chandransh 2877 
    args.cod = cod
4910 phani.kuma 2878 
    args.orderIds = orderIds
1408 ankur.sing 2879 
    args.write(self._oprot)
2880 
    self._oprot.writeMessageEnd()
2881 
    self._oprot.trans.flush()
2882 
 
4910 phani.kuma 2883 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2884 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2885 
    if mtype == TMessageType.EXCEPTION:
2886 
      x = TApplicationException()
2887 
      x.read(self._iprot)
2888 
      self._iprot.readMessageEnd()
2889 
      raise x
4910 phani.kuma 2890 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2891 
    result.read(self._iprot)
2892 
    self._iprot.readMessageEnd()
3431 rajveer 2893 
    if result.success is not None:
1408 ankur.sing 2894 
      return result.success
3431 rajveer 2895 
    if result.ex is not None:
3064 chandransh 2896 
      raise result.ex
4910 phani.kuma 2897 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2898 
 
5713 rajveer 2899 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2900 
    """
2901 
    Parameters:
2902 
     - providerId
2903 
     - orderIds
5713 rajveer 2904 
     - awbs
5676 rajveer 2905 
    """
5713 rajveer 2906 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2907 
    return self.recv_markOrdersAsReturnedFromStore()
2908 
 
5713 rajveer 2909 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2910 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2911 
    args = markOrdersAsReturnedFromStore_args()
2912 
    args.providerId = providerId
2913 
    args.orderIds = orderIds
5713 rajveer 2914 
    args.awbs = awbs
5676 rajveer 2915 
    args.write(self._oprot)
2916 
    self._oprot.writeMessageEnd()
2917 
    self._oprot.trans.flush()
2918 
 
2919 
  def recv_markOrdersAsReturnedFromStore(self, ):
2920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2921 
    if mtype == TMessageType.EXCEPTION:
2922 
      x = TApplicationException()
2923 
      x.read(self._iprot)
2924 
      self._iprot.readMessageEnd()
2925 
      raise x
2926 
    result = markOrdersAsReturnedFromStore_result()
2927 
    result.read(self._iprot)
2928 
    self._iprot.readMessageEnd()
2929 
    if result.success is not None:
2930 
      return result.success
2931 
    if result.ex is not None:
2932 
      raise result.ex
2933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2934 
 
4910 phani.kuma 2935 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2936 
    """
4910 phani.kuma 2937 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2938 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2939 
 
2940 
    Parameters:
2941 
     - providerId
4910 phani.kuma 2942 
     - pickupDetails
4410 rajveer 2943 
    """
4910 phani.kuma 2944 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2945 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2946 
 
4910 phani.kuma 2947 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2948 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2949 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2950 
    args.providerId = providerId
4910 phani.kuma 2951 
    args.pickupDetails = pickupDetails
4410 rajveer 2952 
    args.write(self._oprot)
2953 
    self._oprot.writeMessageEnd()
2954 
    self._oprot.trans.flush()
2955 
 
4910 phani.kuma 2956 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2957 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2958 
    if mtype == TMessageType.EXCEPTION:
2959 
      x = TApplicationException()
2960 
      x.read(self._iprot)
2961 
      self._iprot.readMessageEnd()
2962 
      raise x
4910 phani.kuma 2963 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2964 
    result.read(self._iprot)
2965 
    self._iprot.readMessageEnd()
2966 
    if result.ex is not None:
2967 
      raise result.ex
4910 phani.kuma 2968 
    return
4410 rajveer 2969 
 
4910 phani.kuma 2970 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2971 
    """
3064 chandransh 2972 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2973 
 
94 ashish 2974 
    Parameters:
3064 chandransh 2975 
     - providerId
304 ashish 2976 
    """
4910 phani.kuma 2977 
    self.send_getOrdersNotPickedUp(providerId)
2978 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2979 
 
4910 phani.kuma 2980 
  def send_getOrdersNotPickedUp(self, providerId):
2981 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2982 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2983 
    args.providerId = providerId
304 ashish 2984 
    args.write(self._oprot)
2985 
    self._oprot.writeMessageEnd()
2986 
    self._oprot.trans.flush()
2987 
 
4910 phani.kuma 2988 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2990 
    if mtype == TMessageType.EXCEPTION:
2991 
      x = TApplicationException()
2992 
      x.read(self._iprot)
2993 
      self._iprot.readMessageEnd()
2994 
      raise x
4910 phani.kuma 2995 
    result = getOrdersNotPickedUp_result()
304 ashish 2996 
    result.read(self._iprot)
2997 
    self._iprot.readMessageEnd()
3431 rajveer 2998 
    if result.success is not None:
304 ashish 2999 
      return result.success
4910 phani.kuma 3000 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 3001 
 
3064 chandransh 3002 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 3003 
    """
3064 chandransh 3004 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
3005 
    the name of the receiver.
3006 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 3007 
 
304 ashish 3008 
    Parameters:
3064 chandransh 3009 
     - providerId
3010 
     - deliveredOrders
304 ashish 3011 
    """
3064 chandransh 3012 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
3013 
    self.recv_markOrdersAsDelivered()
304 ashish 3014 
 
3064 chandransh 3015 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
3016 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
3017 
    args = markOrdersAsDelivered_args()
3018 
    args.providerId = providerId
3019 
    args.deliveredOrders = deliveredOrders
304 ashish 3020 
    args.write(self._oprot)
3021 
    self._oprot.writeMessageEnd()
3022 
    self._oprot.trans.flush()
3023 
 
3064 chandransh 3024 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 3025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3026 
    if mtype == TMessageType.EXCEPTION:
3027 
      x = TApplicationException()
3028 
      x.read(self._iprot)
3029 
      self._iprot.readMessageEnd()
3030 
      raise x
3064 chandransh 3031 
    result = markOrdersAsDelivered_result()
304 ashish 3032 
    result.read(self._iprot)
3033 
    self._iprot.readMessageEnd()
3431 rajveer 3034 
    if result.ex is not None:
3064 chandransh 3035 
      raise result.ex
304 ashish 3036 
    return
3037 
 
4910 phani.kuma 3038 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 3039 
    """
4910 phani.kuma 3040 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 3041 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 3042 
 
3064 chandransh 3043 
    Parameters:
3044 
     - providerId
3045 
     - returnedOrders
1596 ankur.sing 3046 
    """
4910 phani.kuma 3047 
    self.send_markAsRTOrders(providerId, returnedOrders)
3048 
    self.recv_markAsRTOrders()
304 ashish 3049 
 
4910 phani.kuma 3050 
  def send_markAsRTOrders(self, providerId, returnedOrders):
3051 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
3052 
    args = markAsRTOrders_args()
3064 chandransh 3053 
    args.providerId = providerId
3054 
    args.returnedOrders = returnedOrders
1596 ankur.sing 3055 
    args.write(self._oprot)
3056 
    self._oprot.writeMessageEnd()
3057 
    self._oprot.trans.flush()
3058 
 
4910 phani.kuma 3059 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 3060 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3061 
    if mtype == TMessageType.EXCEPTION:
3062 
      x = TApplicationException()
3063 
      x.read(self._iprot)
3064 
      self._iprot.readMessageEnd()
3065 
      raise x
4910 phani.kuma 3066 
    result = markAsRTOrders_result()
1596 ankur.sing 3067 
    result.read(self._iprot)
3068 
    self._iprot.readMessageEnd()
3431 rajveer 3069 
    if result.ex is not None:
3064 chandransh 3070 
      raise result.ex
3071 
    return
1596 ankur.sing 3072 
 
4910 phani.kuma 3073 
  def getRTOrders(self, providerId):
3074 
    """
3075 
    Returns a list of orders that were returned by courier.
3076 
 
3077 
    Parameters:
3078 
     - providerId
3079 
    """
3080 
    self.send_getRTOrders(providerId)
3081 
    return self.recv_getRTOrders()
3082 
 
3083 
  def send_getRTOrders(self, providerId):
3084 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
3085 
    args = getRTOrders_args()
3086 
    args.providerId = providerId
3087 
    args.write(self._oprot)
3088 
    self._oprot.writeMessageEnd()
3089 
    self._oprot.trans.flush()
3090 
 
3091 
  def recv_getRTOrders(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 = getRTOrders_result()
3099 
    result.read(self._iprot)
3100 
    self._iprot.readMessageEnd()
3101 
    if result.success is not None:
3102 
      return result.success
3103 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
3104 
 
3064 chandransh 3105 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 3106 
    """
3064 chandransh 3107 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 3108 
 
3064 chandransh 3109 
    Parameters:
3110 
     - providerId
3111 
     - undeliveredOrders
1627 ankur.sing 3112 
    """
3064 chandransh 3113 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 3114 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 3115 
 
3064 chandransh 3116 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
3117 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
3118 
    args = updateNonDeliveryReason_args()
3119 
    args.providerId = providerId
3120 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 3121 
    args.write(self._oprot)
3122 
    self._oprot.writeMessageEnd()
3123 
    self._oprot.trans.flush()
3124 
 
3064 chandransh 3125 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 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
3064 chandransh 3132 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 3133 
    result.read(self._iprot)
3134 
    self._iprot.readMessageEnd()
4910 phani.kuma 3135 
    if result.ex is not None:
3136 
      raise result.ex
3137 
    return
3138 
 
3139 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3140 
    """
3141 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3142 
 
3143 
    Parameters:
3144 
     - providerId
3145 
    """
3146 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3147 
    return self.recv_getNonDeliveredOrdersbyCourier()
3148 
 
3149 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3150 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3151 
    args = getNonDeliveredOrdersbyCourier_args()
3152 
    args.providerId = providerId
3153 
    args.write(self._oprot)
3154 
    self._oprot.writeMessageEnd()
3155 
    self._oprot.trans.flush()
3156 
 
3157 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3158 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3159 
    if mtype == TMessageType.EXCEPTION:
3160 
      x = TApplicationException()
3161 
      x.read(self._iprot)
3162 
      self._iprot.readMessageEnd()
3163 
      raise x
3164 
    result = getNonDeliveredOrdersbyCourier_result()
3165 
    result.read(self._iprot)
3166 
    self._iprot.readMessageEnd()
4581 phani.kuma 3167 
    if result.success is not None:
3168 
      return result.success
4910 phani.kuma 3169 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3170 
 
3171 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3172 
    """
3173 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3174 
 
3175 
    Parameters:
3176 
     - providerId
3177 
     - local_connected_orders
3178 
    """
3179 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3180 
    self.recv_markOrdersAsLocalConnected()
3181 
 
3182 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3183 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3184 
    args = markOrdersAsLocalConnected_args()
3185 
    args.providerId = providerId
3186 
    args.local_connected_orders = local_connected_orders
3187 
    args.write(self._oprot)
3188 
    self._oprot.writeMessageEnd()
3189 
    self._oprot.trans.flush()
3190 
 
3191 
  def recv_markOrdersAsLocalConnected(self, ):
3192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3193 
    if mtype == TMessageType.EXCEPTION:
3194 
      x = TApplicationException()
3195 
      x.read(self._iprot)
3196 
      self._iprot.readMessageEnd()
3197 
      raise x
3198 
    result = markOrdersAsLocalConnected_result()
3199 
    result.read(self._iprot)
3200 
    self._iprot.readMessageEnd()
3431 rajveer 3201 
    if result.ex is not None:
3064 chandransh 3202 
      raise result.ex
4910 phani.kuma 3203 
    return
1627 ankur.sing 3204 
 
4910 phani.kuma 3205 
  def getOrdersNotLocalConnected(self, providerId):
3206 
    """
3207 
    Returns a list of orders that were picked up or shipped but pending local connection.
3208 
 
3209 
    Parameters:
3210 
     - providerId
3211 
    """
3212 
    self.send_getOrdersNotLocalConnected(providerId)
3213 
    return self.recv_getOrdersNotLocalConnected()
3214 
 
3215 
  def send_getOrdersNotLocalConnected(self, providerId):
3216 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3217 
    args = getOrdersNotLocalConnected_args()
3218 
    args.providerId = providerId
3219 
    args.write(self._oprot)
3220 
    self._oprot.writeMessageEnd()
3221 
    self._oprot.trans.flush()
3222 
 
3223 
  def recv_getOrdersNotLocalConnected(self, ):
3224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3225 
    if mtype == TMessageType.EXCEPTION:
3226 
      x = TApplicationException()
3227 
      x.read(self._iprot)
3228 
      self._iprot.readMessageEnd()
3229 
      raise x
3230 
    result = getOrdersNotLocalConnected_result()
3231 
    result.read(self._iprot)
3232 
    self._iprot.readMessageEnd()
3233 
    if result.success is not None:
3234 
      return result.success
3235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3236 
 
3237 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3238 
    """
3239 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3240 
 
3241 
    Parameters:
3242 
     - providerId
3243 
     - destination_city_reached_orders
3244 
    """
3245 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3246 
    self.recv_markOrdersAsDestinationCityReached()
3247 
 
3248 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3249 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3250 
    args = markOrdersAsDestinationCityReached_args()
3251 
    args.providerId = providerId
3252 
    args.destination_city_reached_orders = destination_city_reached_orders
3253 
    args.write(self._oprot)
3254 
    self._oprot.writeMessageEnd()
3255 
    self._oprot.trans.flush()
3256 
 
3257 
  def recv_markOrdersAsDestinationCityReached(self, ):
3258 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3259 
    if mtype == TMessageType.EXCEPTION:
3260 
      x = TApplicationException()
3261 
      x.read(self._iprot)
3262 
      self._iprot.readMessageEnd()
3263 
      raise x
3264 
    result = markOrdersAsDestinationCityReached_result()
3265 
    result.read(self._iprot)
3266 
    self._iprot.readMessageEnd()
3267 
    if result.ex is not None:
3268 
      raise result.ex
3269 
    return
3270 
 
3271 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3272 
    """
3273 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3274 
 
3275 
    Parameters:
3276 
     - providerId
3277 
     - first_atdl_orders
3278 
    """
3279 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3280 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3281 
 
3282 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3283 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3284 
    args = markOrdersAsFirstDeliveryAttempted_args()
3285 
    args.providerId = providerId
3286 
    args.first_atdl_orders = first_atdl_orders
3287 
    args.write(self._oprot)
3288 
    self._oprot.writeMessageEnd()
3289 
    self._oprot.trans.flush()
3290 
 
3291 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3292 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3293 
    if mtype == TMessageType.EXCEPTION:
3294 
      x = TApplicationException()
3295 
      x.read(self._iprot)
3296 
      self._iprot.readMessageEnd()
3297 
      raise x
3298 
    result = markOrdersAsFirstDeliveryAttempted_result()
3299 
    result.read(self._iprot)
3300 
    self._iprot.readMessageEnd()
3301 
    if result.ex is not None:
3302 
      raise result.ex
3303 
    return
3304 
 
3064 chandransh 3305 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3306 
    """
3064 chandransh 3307 
    Returns the list of orders whose delivery time has passed but have not been
3308 
    delivered yet for the given provider and warehouse. To get a complete list of
3309 
    undelivered orders, pass them as -1.
3310 
    Returns an empty list if no such orders exist.
3431 rajveer 3311 
 
1886 ankur.sing 3312 
    Parameters:
3064 chandransh 3313 
     - providerId
3314 
     - warehouseId
1886 ankur.sing 3315 
    """
3064 chandransh 3316 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3317 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3318 
 
3064 chandransh 3319 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3320 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3321 
    args = getUndeliveredOrders_args()
3322 
    args.providerId = providerId
3323 
    args.warehouseId = warehouseId
1886 ankur.sing 3324 
    args.write(self._oprot)
3325 
    self._oprot.writeMessageEnd()
3326 
    self._oprot.trans.flush()
3327 
 
3064 chandransh 3328 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3330 
    if mtype == TMessageType.EXCEPTION:
3331 
      x = TApplicationException()
3332 
      x.read(self._iprot)
3333 
      self._iprot.readMessageEnd()
3334 
      raise x
3064 chandransh 3335 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3336 
    result.read(self._iprot)
3337 
    self._iprot.readMessageEnd()
3431 rajveer 3338 
    if result.success is not None:
1886 ankur.sing 3339 
      return result.success
3064 chandransh 3340 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3341 
 
4783 phani.kuma 3342 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3343 
    """
3344 
    Returns the list of orders whose expected delivery date has passed but have not been
3345 
    delivered yet.
3346 
    Returns an empty list if no such orders exist.
3347 
    """
3348 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3349 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3350 
 
3351 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3352 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3353 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3354 
    args.write(self._oprot)
3355 
    self._oprot.writeMessageEnd()
3356 
    self._oprot.trans.flush()
3357 
 
3358 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3359 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3360 
    if mtype == TMessageType.EXCEPTION:
3361 
      x = TApplicationException()
3362 
      x.read(self._iprot)
3363 
      self._iprot.readMessageEnd()
3364 
      raise x
3365 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3366 
    result.read(self._iprot)
3367 
    self._iprot.readMessageEnd()
3368 
    if result.success is not None:
3369 
      return result.success
3370 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3371 
 
2536 chandransh 3372 
  def toggleDOAFlag(self, orderId):
3373 
    """
3374 
    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.
3375 
    Returns the final flag status.
3376 
    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 3377 
 
2536 chandransh 3378 
    Parameters:
3379 
     - orderId
3380 
    """
3381 
    self.send_toggleDOAFlag(orderId)
3382 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3383 
 
2536 chandransh 3384 
  def send_toggleDOAFlag(self, orderId):
3385 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3386 
    args = toggleDOAFlag_args()
3387 
    args.orderId = orderId
3388 
    args.write(self._oprot)
3389 
    self._oprot.writeMessageEnd()
3390 
    self._oprot.trans.flush()
3391 
 
3392 
  def recv_toggleDOAFlag(self, ):
3393 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3394 
    if mtype == TMessageType.EXCEPTION:
3395 
      x = TApplicationException()
3396 
      x.read(self._iprot)
3397 
      self._iprot.readMessageEnd()
3398 
      raise x
3399 
    result = toggleDOAFlag_result()
3400 
    result.read(self._iprot)
3401 
    self._iprot.readMessageEnd()
3431 rajveer 3402 
    if result.success is not None:
2536 chandransh 3403 
      return result.success
3431 rajveer 3404 
    if result.ex is not None:
2536 chandransh 3405 
      raise result.ex
3406 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3407 
 
4712 rajveer 3408 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3409 
    """
3410 
    Parameters:
3411 
     - orderId
3412 
     - deliveryTimestamp
3413 
     - receiver
3414 
    """
3415 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3416 
    self.recv_markOrderAsDelivered()
3417 
 
3418 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3419 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3420 
    args = markOrderAsDelivered_args()
3421 
    args.orderId = orderId
3422 
    args.deliveryTimestamp = deliveryTimestamp
3423 
    args.receiver = receiver
3424 
    args.write(self._oprot)
3425 
    self._oprot.writeMessageEnd()
3426 
    self._oprot.trans.flush()
3427 
 
3428 
  def recv_markOrderAsDelivered(self, ):
3429 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3430 
    if mtype == TMessageType.EXCEPTION:
3431 
      x = TApplicationException()
3432 
      x.read(self._iprot)
3433 
      self._iprot.readMessageEnd()
3434 
      raise x
3435 
    result = markOrderAsDelivered_result()
3436 
    result.read(self._iprot)
3437 
    self._iprot.readMessageEnd()
3438 
    if result.ex is not None:
3439 
      raise result.ex
3440 
    return
3441 
 
5553 rajveer 3442 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3443 
    """
3444 
    Parameters:
3445 
     - orderId
3446 
     - deliveryTimestamp
3447 
    """
3448 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3449 
    self.recv_markOrderAsReceivedAtStore()
3450 
 
3451 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3452 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3453 
    args = markOrderAsReceivedAtStore_args()
3454 
    args.orderId = orderId
3455 
    args.deliveryTimestamp = deliveryTimestamp
3456 
    args.write(self._oprot)
3457 
    self._oprot.writeMessageEnd()
3458 
    self._oprot.trans.flush()
3459 
 
3460 
  def recv_markOrderAsReceivedAtStore(self, ):
3461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3462 
    if mtype == TMessageType.EXCEPTION:
3463 
      x = TApplicationException()
3464 
      x.read(self._iprot)
3465 
      self._iprot.readMessageEnd()
3466 
      raise x
3467 
    result = markOrderAsReceivedAtStore_result()
3468 
    result.read(self._iprot)
3469 
    self._iprot.readMessageEnd()
3470 
    if result.ex is not None:
3471 
      raise result.ex
3472 
    return
3473 
 
4454 rajveer 3474 
  def markOrderDoaRequestReceived(self, orderId):
3475 
    """
3476 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3477 
 
3478 
    Parameters:
3479 
     - orderId
3480 
    """
3481 
    self.send_markOrderDoaRequestReceived(orderId)
3482 
    return self.recv_markOrderDoaRequestReceived()
3483 
 
3484 
  def send_markOrderDoaRequestReceived(self, orderId):
3485 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3486 
    args = markOrderDoaRequestReceived_args()
3487 
    args.orderId = orderId
3488 
    args.write(self._oprot)
3489 
    self._oprot.writeMessageEnd()
3490 
    self._oprot.trans.flush()
3491 
 
3492 
  def recv_markOrderDoaRequestReceived(self, ):
3493 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3494 
    if mtype == TMessageType.EXCEPTION:
3495 
      x = TApplicationException()
3496 
      x.read(self._iprot)
3497 
      self._iprot.readMessageEnd()
3498 
      raise x
3499 
    result = markOrderDoaRequestReceived_result()
3500 
    result.read(self._iprot)
3501 
    self._iprot.readMessageEnd()
3502 
    if result.success is not None:
3503 
      return result.success
3504 
    if result.ex is not None:
3505 
      raise result.ex
3506 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3507 
 
3508 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3509 
    """
3510 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3511 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3512 
 
3513 
    Parameters:
3514 
     - orderId
3515 
     - isAuthorized
3516 
    """
3517 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3518 
    return self.recv_markOrderDoaRequestAuthorized()
3519 
 
3520 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3521 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3522 
    args = markOrderDoaRequestAuthorized_args()
3523 
    args.orderId = orderId
3524 
    args.isAuthorized = isAuthorized
3525 
    args.write(self._oprot)
3526 
    self._oprot.writeMessageEnd()
3527 
    self._oprot.trans.flush()
3528 
 
3529 
  def recv_markOrderDoaRequestAuthorized(self, ):
3530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3531 
    if mtype == TMessageType.EXCEPTION:
3532 
      x = TApplicationException()
3533 
      x.read(self._iprot)
3534 
      self._iprot.readMessageEnd()
3535 
      raise x
3536 
    result = markOrderDoaRequestAuthorized_result()
3537 
    result.read(self._iprot)
3538 
    self._iprot.readMessageEnd()
3539 
    if result.success is not None:
3540 
      return result.success
3541 
    if result.ex is not None:
3542 
      raise result.ex
3543 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3544 
 
4488 rajveer 3545 
  def markOrderReturnRequestReceived(self, orderId):
3546 
    """
3547 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3548 
 
3549 
    Parameters:
3550 
     - orderId
3551 
    """
3552 
    self.send_markOrderReturnRequestReceived(orderId)
3553 
    return self.recv_markOrderReturnRequestReceived()
3554 
 
3555 
  def send_markOrderReturnRequestReceived(self, orderId):
3556 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3557 
    args = markOrderReturnRequestReceived_args()
3558 
    args.orderId = orderId
3559 
    args.write(self._oprot)
3560 
    self._oprot.writeMessageEnd()
3561 
    self._oprot.trans.flush()
3562 
 
3563 
  def recv_markOrderReturnRequestReceived(self, ):
3564 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3565 
    if mtype == TMessageType.EXCEPTION:
3566 
      x = TApplicationException()
3567 
      x.read(self._iprot)
3568 
      self._iprot.readMessageEnd()
3569 
      raise x
3570 
    result = markOrderReturnRequestReceived_result()
3571 
    result.read(self._iprot)
3572 
    self._iprot.readMessageEnd()
3573 
    if result.success is not None:
3574 
      return result.success
3575 
    if result.ex is not None:
3576 
      raise result.ex
3577 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3578 
 
3579 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3580 
    """
3581 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3582 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3583 
 
3584 
    Parameters:
3585 
     - orderId
3586 
     - isAuthorized
3587 
    """
3588 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3589 
    return self.recv_markOrderReturnRequestAuthorized()
3590 
 
3591 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3592 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3593 
    args = markOrderReturnRequestAuthorized_args()
3594 
    args.orderId = orderId
3595 
    args.isAuthorized = isAuthorized
3596 
    args.write(self._oprot)
3597 
    self._oprot.writeMessageEnd()
3598 
    self._oprot.trans.flush()
3599 
 
3600 
  def recv_markOrderReturnRequestAuthorized(self, ):
3601 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3602 
    if mtype == TMessageType.EXCEPTION:
3603 
      x = TApplicationException()
3604 
      x.read(self._iprot)
3605 
      self._iprot.readMessageEnd()
3606 
      raise x
3607 
    result = markOrderReturnRequestAuthorized_result()
3608 
    result.read(self._iprot)
3609 
    self._iprot.readMessageEnd()
3610 
    if result.success is not None:
3611 
      return result.success
3612 
    if result.ex is not None:
3613 
      raise result.ex
3614 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3615 
 
4579 rajveer 3616 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3617 
    """
3618 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3619 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3620 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3621 
    For any other status, it returns false.
3622 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3623 
 
2536 chandransh 3624 
    Parameters:
3625 
     - orderId
4579 rajveer 3626 
     - providerId
2536 chandransh 3627 
    """
4579 rajveer 3628 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3629 
    return self.recv_requestPickupNumber()
3630 
 
4579 rajveer 3631 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3632 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3633 
    args = requestPickupNumber_args()
3634 
    args.orderId = orderId
4579 rajveer 3635 
    args.providerId = providerId
2536 chandransh 3636 
    args.write(self._oprot)
3637 
    self._oprot.writeMessageEnd()
3638 
    self._oprot.trans.flush()
3639 
 
3640 
  def recv_requestPickupNumber(self, ):
3641 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3642 
    if mtype == TMessageType.EXCEPTION:
3643 
      x = TApplicationException()
3644 
      x.read(self._iprot)
3645 
      self._iprot.readMessageEnd()
3646 
      raise x
3647 
    result = requestPickupNumber_result()
3648 
    result.read(self._iprot)
3649 
    self._iprot.readMessageEnd()
3431 rajveer 3650 
    if result.success is not None:
2536 chandransh 3651 
      return result.success
3431 rajveer 3652 
    if result.ex is not None:
2536 chandransh 3653 
      raise result.ex
3654 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3655 
 
4602 rajveer 3656 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3657 
    """
4452 rajveer 3658 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3659 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3660 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3661 
    	3. Returns true
2591 chandransh 3662 
    If the order is in any other status, it returns false.
2536 chandransh 3663 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3664 
 
2536 chandransh 3665 
    Parameters:
3666 
     - orderId
3667 
     - pickupNumber
4602 rajveer 3668 
     - providerId
2536 chandransh 3669 
    """
4602 rajveer 3670 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3671 
    return self.recv_authorizePickup()
3672 
 
4602 rajveer 3673 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3674 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3675 
    args = authorizePickup_args()
3676 
    args.orderId = orderId
3677 
    args.pickupNumber = pickupNumber
4602 rajveer 3678 
    args.providerId = providerId
2536 chandransh 3679 
    args.write(self._oprot)
3680 
    self._oprot.writeMessageEnd()
3681 
    self._oprot.trans.flush()
3682 
 
3683 
  def recv_authorizePickup(self, ):
3684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3685 
    if mtype == TMessageType.EXCEPTION:
3686 
      x = TApplicationException()
3687 
      x.read(self._iprot)
3688 
      self._iprot.readMessageEnd()
3689 
      raise x
3690 
    result = authorizePickup_result()
3691 
    result.read(self._iprot)
3692 
    self._iprot.readMessageEnd()
3431 rajveer 3693 
    if result.success is not None:
2536 chandransh 3694 
      return result.success
3431 rajveer 3695 
    if result.ex is not None:
2536 chandransh 3696 
      raise result.ex
3697 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3698 
 
2764 chandransh 3699 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3700 
    """
3701 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3702 
 
2764 chandransh 3703 
    Parameters:
3704 
     - providerId
3705 
     - pickupDetails
3706 
    """
3707 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3708 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3709 
 
3710 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3711 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3712 
    args = markDoasAsPickedUp_args()
3713 
    args.providerId = providerId
3714 
    args.pickupDetails = pickupDetails
3715 
    args.write(self._oprot)
3716 
    self._oprot.writeMessageEnd()
3717 
    self._oprot.trans.flush()
3718 
 
3719 
  def recv_markDoasAsPickedUp(self, ):
3720 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3721 
    if mtype == TMessageType.EXCEPTION:
3722 
      x = TApplicationException()
3723 
      x.read(self._iprot)
3724 
      self._iprot.readMessageEnd()
3725 
      raise x
3726 
    result = markDoasAsPickedUp_result()
3727 
    result.read(self._iprot)
3728 
    self._iprot.readMessageEnd()
4910 phani.kuma 3729 
    return
3730 
 
3731 
  def getDoasNotPickedUp(self, providerId):
3732 
    """
3733 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3734 
 
3735 
    Parameters:
3736 
     - providerId
3737 
    """
3738 
    self.send_getDoasNotPickedUp(providerId)
3739 
    return self.recv_getDoasNotPickedUp()
3740 
 
3741 
  def send_getDoasNotPickedUp(self, providerId):
3742 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3743 
    args = getDoasNotPickedUp_args()
3744 
    args.providerId = providerId
3745 
    args.write(self._oprot)
3746 
    self._oprot.writeMessageEnd()
3747 
    self._oprot.trans.flush()
3748 
 
3749 
  def recv_getDoasNotPickedUp(self, ):
3750 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3751 
    if mtype == TMessageType.EXCEPTION:
3752 
      x = TApplicationException()
3753 
      x.read(self._iprot)
3754 
      self._iprot.readMessageEnd()
3755 
      raise x
3756 
    result = getDoasNotPickedUp_result()
3757 
    result.read(self._iprot)
3758 
    self._iprot.readMessageEnd()
3431 rajveer 3759 
    if result.success is not None:
2764 chandransh 3760 
      return result.success
4910 phani.kuma 3761 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3762 
 
4741 phani.kuma 3763 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3764 
    """
3765 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3766 
 
3767 
    Parameters:
3768 
     - providerId
3769 
     - pickupDetails
3770 
    """
3771 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3772 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3773 
 
3774 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3775 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3776 
    args = markReturnOrdersAsPickedUp_args()
3777 
    args.providerId = providerId
3778 
    args.pickupDetails = pickupDetails
3779 
    args.write(self._oprot)
3780 
    self._oprot.writeMessageEnd()
3781 
    self._oprot.trans.flush()
3782 
 
3783 
  def recv_markReturnOrdersAsPickedUp(self, ):
3784 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3785 
    if mtype == TMessageType.EXCEPTION:
3786 
      x = TApplicationException()
3787 
      x.read(self._iprot)
3788 
      self._iprot.readMessageEnd()
3789 
      raise x
3790 
    result = markReturnOrdersAsPickedUp_result()
3791 
    result.read(self._iprot)
3792 
    self._iprot.readMessageEnd()
4910 phani.kuma 3793 
    return
3794 
 
3795 
  def getReturnOrdersNotPickedUp(self, providerId):
3796 
    """
3797 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3798 
 
3799 
    Parameters:
3800 
     - providerId
3801 
    """
3802 
    self.send_getReturnOrdersNotPickedUp(providerId)
3803 
    return self.recv_getReturnOrdersNotPickedUp()
3804 
 
3805 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3806 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3807 
    args = getReturnOrdersNotPickedUp_args()
3808 
    args.providerId = providerId
3809 
    args.write(self._oprot)
3810 
    self._oprot.writeMessageEnd()
3811 
    self._oprot.trans.flush()
3812 
 
3813 
  def recv_getReturnOrdersNotPickedUp(self, ):
3814 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3815 
    if mtype == TMessageType.EXCEPTION:
3816 
      x = TApplicationException()
3817 
      x.read(self._iprot)
3818 
      self._iprot.readMessageEnd()
3819 
      raise x
3820 
    result = getReturnOrdersNotPickedUp_result()
3821 
    result.read(self._iprot)
3822 
    self._iprot.readMessageEnd()
4741 phani.kuma 3823 
    if result.success is not None:
3824 
      return result.success
4910 phani.kuma 3825 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3826 
 
4479 rajveer 3827 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3828 
    """
4452 rajveer 3829 
    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 3830 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3831 
    If the order is in any other state, it returns false.
3832 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3833 
 
2591 chandransh 3834 
    Parameters:
3835 
     - orderId
4479 rajveer 3836 
     - receiveCondition
2591 chandransh 3837 
    """
4479 rajveer 3838 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3839 
    return self.recv_receiveReturn()
2536 chandransh 3840 
 
4479 rajveer 3841 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3842 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3843 
    args = receiveReturn_args()
2591 chandransh 3844 
    args.orderId = orderId
4479 rajveer 3845 
    args.receiveCondition = receiveCondition
2591 chandransh 3846 
    args.write(self._oprot)
3847 
    self._oprot.writeMessageEnd()
3848 
    self._oprot.trans.flush()
3849 
 
2616 chandransh 3850 
  def recv_receiveReturn(self, ):
2591 chandransh 3851 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3852 
    if mtype == TMessageType.EXCEPTION:
3853 
      x = TApplicationException()
3854 
      x.read(self._iprot)
3855 
      self._iprot.readMessageEnd()
3856 
      raise x
2616 chandransh 3857 
    result = receiveReturn_result()
2591 chandransh 3858 
    result.read(self._iprot)
3859 
    self._iprot.readMessageEnd()
3431 rajveer 3860 
    if result.success is not None:
2591 chandransh 3861 
      return result.success
3431 rajveer 3862 
    if result.ex is not None:
2591 chandransh 3863 
      raise result.ex
2616 chandransh 3864 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3865 
 
3866 
  def validateDoa(self, orderId, isValid):
3867 
    """
4452 rajveer 3868 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3869 
    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 3870 
    If the order is in any other state, it returns false.
3871 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3872 
 
2591 chandransh 3873 
    Parameters:
3874 
     - orderId
3875 
     - isValid
3876 
    """
3877 
    self.send_validateDoa(orderId, isValid)
3878 
    return self.recv_validateDoa()
3879 
 
3880 
  def send_validateDoa(self, orderId, isValid):
3881 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3882 
    args = validateDoa_args()
3883 
    args.orderId = orderId
3884 
    args.isValid = isValid
3885 
    args.write(self._oprot)
3886 
    self._oprot.writeMessageEnd()
3887 
    self._oprot.trans.flush()
3888 
 
3889 
  def recv_validateDoa(self, ):
3890 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3891 
    if mtype == TMessageType.EXCEPTION:
3892 
      x = TApplicationException()
3893 
      x.read(self._iprot)
3894 
      self._iprot.readMessageEnd()
3895 
      raise x
3896 
    result = validateDoa_result()
3897 
    result.read(self._iprot)
3898 
    self._iprot.readMessageEnd()
3431 rajveer 3899 
    if result.success is not None:
2591 chandransh 3900 
      return result.success
3431 rajveer 3901 
    if result.ex is not None:
2591 chandransh 3902 
      raise result.ex
3903 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3904 
 
4495 rajveer 3905 
  def validateReturnProduct(self, orderId, isUsable):
3906 
    """
3907 
    Parameters:
3908 
     - orderId
3909 
     - isUsable
3910 
    """
3911 
    self.send_validateReturnProduct(orderId, isUsable)
3912 
    return self.recv_validateReturnProduct()
3913 
 
3914 
  def send_validateReturnProduct(self, orderId, isUsable):
3915 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3916 
    args = validateReturnProduct_args()
3917 
    args.orderId = orderId
3918 
    args.isUsable = isUsable
3919 
    args.write(self._oprot)
3920 
    self._oprot.writeMessageEnd()
3921 
    self._oprot.trans.flush()
3922 
 
3923 
  def recv_validateReturnProduct(self, ):
3924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3925 
    if mtype == TMessageType.EXCEPTION:
3926 
      x = TApplicationException()
3927 
      x.read(self._iprot)
3928 
      self._iprot.readMessageEnd()
3929 
      raise x
3930 
    result = validateReturnProduct_result()
3931 
    result.read(self._iprot)
3932 
    self._iprot.readMessageEnd()
3933 
    if result.success is not None:
3934 
      return result.success
3935 
    if result.ex is not None:
3936 
      raise result.ex
3937 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3938 
 
2616 chandransh 3939 
  def reshipOrder(self, orderId):
3940 
    """
4484 rajveer 3941 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3942 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3943 
    	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 3944 
 
3945 
    If the order is in DOA_CERT_VALID state, it does the following:
3946 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3947 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3948 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3949 
 
2616 chandransh 3950 
    Returns the id of the newly created order.
3431 rajveer 3951 
 
2616 chandransh 3952 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3953 
 
2616 chandransh 3954 
    Parameters:
3955 
     - orderId
3956 
    """
3957 
    self.send_reshipOrder(orderId)
3958 
    return self.recv_reshipOrder()
2591 chandransh 3959 
 
2616 chandransh 3960 
  def send_reshipOrder(self, orderId):
3961 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3962 
    args = reshipOrder_args()
3963 
    args.orderId = orderId
3964 
    args.write(self._oprot)
3965 
    self._oprot.writeMessageEnd()
3966 
    self._oprot.trans.flush()
3967 
 
3968 
  def recv_reshipOrder(self, ):
3969 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3970 
    if mtype == TMessageType.EXCEPTION:
3971 
      x = TApplicationException()
3972 
      x.read(self._iprot)
3973 
      self._iprot.readMessageEnd()
3974 
      raise x
3975 
    result = reshipOrder_result()
3976 
    result.read(self._iprot)
3977 
    self._iprot.readMessageEnd()
3431 rajveer 3978 
    if result.success is not None:
2616 chandransh 3979 
      return result.success
3431 rajveer 3980 
    if result.ex is not None:
2616 chandransh 3981 
      raise result.ex
3982 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3983 
 
3226 chandransh 3984 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3985 
    """
4484 rajveer 3986 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3987 
    	1. Creates a refund request for batch processing.
3988 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3989 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3990 
 
2616 chandransh 3991 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3992 
    	1. Creates a refund request for batch processing.
3226 chandransh 3993 
    	2. Cancels the reservation of the item in the warehouse.
3994 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3995 
 
3226 chandransh 3996 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3997 
    	1. Cancels the reservation of the item in the warehouse.
3998 
    	2. Marks the current order as CANCELED.
3999 
 
4000 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
4001 
 
2616 chandransh 4002 
    Returns True if it is successful, False otherwise.
3431 rajveer 4003 
 
2616 chandransh 4004 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 4005 
 
2616 chandransh 4006 
    Parameters:
4007 
     - orderId
3226 chandransh 4008 
     - refundedBy
4009 
     - reason
2616 chandransh 4010 
    """
3226 chandransh 4011 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 4012 
    return self.recv_refundOrder()
4013 
 
3226 chandransh 4014 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 4015 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
4016 
    args = refundOrder_args()
4017 
    args.orderId = orderId
3226 chandransh 4018 
    args.refundedBy = refundedBy
4019 
    args.reason = reason
2616 chandransh 4020 
    args.write(self._oprot)
4021 
    self._oprot.writeMessageEnd()
4022 
    self._oprot.trans.flush()
4023 
 
4024 
  def recv_refundOrder(self, ):
4025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4026 
    if mtype == TMessageType.EXCEPTION:
4027 
      x = TApplicationException()
4028 
      x.read(self._iprot)
4029 
      self._iprot.readMessageEnd()
4030 
      raise x
4031 
    result = refundOrder_result()
4032 
    result.read(self._iprot)
4033 
    self._iprot.readMessageEnd()
3431 rajveer 4034 
    if result.success is not None:
2616 chandransh 4035 
      return result.success
3431 rajveer 4036 
    if result.ex is not None:
2616 chandransh 4037 
      raise result.ex
4038 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
4039 
 
2690 chandransh 4040 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
4041 
    """
4042 
    Get all return orders created between the from and to dates for the given warehouse.
4043 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 4044 
 
2690 chandransh 4045 
    Parameters:
4046 
     - warehouseId
4047 
     - fromDate
4048 
     - toDate
4049 
    """
4050 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
4051 
    return self.recv_getReturnOrders()
2616 chandransh 4052 
 
2690 chandransh 4053 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
4054 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
4055 
    args = getReturnOrders_args()
4056 
    args.warehouseId = warehouseId
4057 
    args.fromDate = fromDate
4058 
    args.toDate = toDate
4059 
    args.write(self._oprot)
4060 
    self._oprot.writeMessageEnd()
4061 
    self._oprot.trans.flush()
4062 
 
4063 
  def recv_getReturnOrders(self, ):
4064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4065 
    if mtype == TMessageType.EXCEPTION:
4066 
      x = TApplicationException()
4067 
      x.read(self._iprot)
4068 
      self._iprot.readMessageEnd()
4069 
      raise x
4070 
    result = getReturnOrders_result()
4071 
    result.read(self._iprot)
4072 
    self._iprot.readMessageEnd()
3431 rajveer 4073 
    if result.success is not None:
2690 chandransh 4074 
      return result.success
4075 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
4076 
 
5481 phani.kuma 4077 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4078 
    """
4079 
    Get all return orders created between the from and to dates.
4080 
 
4081 
    Parameters:
4082 
     - onlyNotProcessed
4083 
     - fromDate
4084 
     - toDate
4085 
    """
4086 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
4087 
    return self.recv_getAllReturnOrders()
4088 
 
4089 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4090 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
4091 
    args = getAllReturnOrders_args()
4092 
    args.onlyNotProcessed = onlyNotProcessed
4093 
    args.fromDate = fromDate
4094 
    args.toDate = toDate
4095 
    args.write(self._oprot)
4096 
    self._oprot.writeMessageEnd()
4097 
    self._oprot.trans.flush()
4098 
 
4099 
  def recv_getAllReturnOrders(self, ):
4100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4101 
    if mtype == TMessageType.EXCEPTION:
4102 
      x = TApplicationException()
4103 
      x.read(self._iprot)
4104 
      self._iprot.readMessageEnd()
4105 
      raise x
4106 
    result = getAllReturnOrders_result()
4107 
    result.read(self._iprot)
4108 
    self._iprot.readMessageEnd()
4109 
    if result.success is not None:
4110 
      return result.success
4111 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
4112 
 
2700 chandransh 4113 
  def getReturnOrder(self, id):
4114 
    """
4115 
    Returns the ReturnOrder corresponding to the given id.
4116 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 4117 
 
2700 chandransh 4118 
    Parameters:
4119 
     - id
4120 
    """
4121 
    self.send_getReturnOrder(id)
4122 
    return self.recv_getReturnOrder()
4123 
 
4124 
  def send_getReturnOrder(self, id):
4125 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
4126 
    args = getReturnOrder_args()
4127 
    args.id = id
4128 
    args.write(self._oprot)
4129 
    self._oprot.writeMessageEnd()
4130 
    self._oprot.trans.flush()
4131 
 
4132 
  def recv_getReturnOrder(self, ):
4133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4134 
    if mtype == TMessageType.EXCEPTION:
4135 
      x = TApplicationException()
4136 
      x.read(self._iprot)
4137 
      self._iprot.readMessageEnd()
4138 
      raise x
4139 
    result = getReturnOrder_result()
4140 
    result.read(self._iprot)
4141 
    self._iprot.readMessageEnd()
3431 rajveer 4142 
    if result.success is not None:
2700 chandransh 4143 
      return result.success
3431 rajveer 4144 
    if result.ex is not None:
2700 chandransh 4145 
      raise result.ex
4146 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4147 
 
2690 chandransh 4148 
  def processReturn(self, returnOrderId):
4149 
    """
4150 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4151 
 
2690 chandransh 4152 
    Parameters:
4153 
     - returnOrderId
4154 
    """
4155 
    self.send_processReturn(returnOrderId)
4156 
    self.recv_processReturn()
4157 
 
4158 
  def send_processReturn(self, returnOrderId):
4159 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4160 
    args = processReturn_args()
4161 
    args.returnOrderId = returnOrderId
4162 
    args.write(self._oprot)
4163 
    self._oprot.writeMessageEnd()
4164 
    self._oprot.trans.flush()
4165 
 
4166 
  def recv_processReturn(self, ):
4167 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4168 
    if mtype == TMessageType.EXCEPTION:
4169 
      x = TApplicationException()
4170 
      x.read(self._iprot)
4171 
      self._iprot.readMessageEnd()
4172 
      raise x
4173 
    result = processReturn_result()
4174 
    result.read(self._iprot)
4175 
    self._iprot.readMessageEnd()
3431 rajveer 4176 
    if result.ex is not None:
2690 chandransh 4177 
      raise result.ex
4178 
    return
4179 
 
3451 chandransh 4180 
  def updateWeight(self, orderId, weight):
4181 
    """
4182 
    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 4183 
 
3451 chandransh 4184 
    Parameters:
4185 
     - orderId
4186 
     - weight
4187 
    """
4188 
    self.send_updateWeight(orderId, weight)
4189 
    return self.recv_updateWeight()
4190 
 
4191 
  def send_updateWeight(self, orderId, weight):
4192 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4193 
    args = updateWeight_args()
4194 
    args.orderId = orderId
4195 
    args.weight = weight
4196 
    args.write(self._oprot)
4197 
    self._oprot.writeMessageEnd()
4198 
    self._oprot.trans.flush()
4199 
 
4200 
  def recv_updateWeight(self, ):
4201 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4202 
    if mtype == TMessageType.EXCEPTION:
4203 
      x = TApplicationException()
4204 
      x.read(self._iprot)
4205 
      self._iprot.readMessageEnd()
4206 
      raise x
4207 
    result = updateWeight_result()
4208 
    result.read(self._iprot)
4209 
    self._iprot.readMessageEnd()
4210 
    if result.success is not None:
4211 
      return result.success
4212 
    if result.ex is not None:
4213 
      raise result.ex
4214 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4215 
 
3469 chandransh 4216 
  def changeItem(self, orderId, itemId):
4217 
    """
4218 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4219 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4220 
 
3469 chandransh 4221 
    Parameters:
4222 
     - orderId
4223 
     - itemId
4224 
    """
4225 
    self.send_changeItem(orderId, itemId)
4226 
    return self.recv_changeItem()
4227 
 
4228 
  def send_changeItem(self, orderId, itemId):
4229 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4230 
    args = changeItem_args()
4231 
    args.orderId = orderId
4232 
    args.itemId = itemId
4233 
    args.write(self._oprot)
4234 
    self._oprot.writeMessageEnd()
4235 
    self._oprot.trans.flush()
4236 
 
4237 
  def recv_changeItem(self, ):
4238 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4239 
    if mtype == TMessageType.EXCEPTION:
4240 
      x = TApplicationException()
4241 
      x.read(self._iprot)
4242 
      self._iprot.readMessageEnd()
4243 
      raise x
4244 
    result = changeItem_result()
4245 
    result.read(self._iprot)
4246 
    self._iprot.readMessageEnd()
4247 
    if result.success is not None:
4248 
      return result.success
4249 
    if result.ex is not None:
4250 
      raise result.ex
4251 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4252 
 
4253 
  def shiftToWarehouse(self, orderId, warehouseId):
4254 
    """
4255 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4256 
 
4257 
    Parameters:
4258 
     - orderId
4259 
     - warehouseId
4260 
    """
4261 
    self.send_shiftToWarehouse(orderId, warehouseId)
4262 
    return self.recv_shiftToWarehouse()
4263 
 
4264 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4265 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4266 
    args = shiftToWarehouse_args()
4267 
    args.orderId = orderId
4268 
    args.warehouseId = warehouseId
4269 
    args.write(self._oprot)
4270 
    self._oprot.writeMessageEnd()
4271 
    self._oprot.trans.flush()
4272 
 
4273 
  def recv_shiftToWarehouse(self, ):
4274 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4275 
    if mtype == TMessageType.EXCEPTION:
4276 
      x = TApplicationException()
4277 
      x.read(self._iprot)
4278 
      self._iprot.readMessageEnd()
4279 
      raise x
4280 
    result = shiftToWarehouse_result()
4281 
    result.read(self._iprot)
4282 
    self._iprot.readMessageEnd()
4283 
    if result.success is not None:
4284 
      return result.success
4285 
    if result.ex is not None:
4286 
      raise result.ex
4287 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4288 
 
4647 rajveer 4289 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4290 
    """
4291 
    Adds the given delay reason to the given order.
3986 chandransh 4292 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4293 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4294 
 
3553 chandransh 4295 
    Parameters:
4296 
     - orderId
4297 
     - delayReason
3986 chandransh 4298 
     - furtherDelay
4647 rajveer 4299 
     - delayReasonText
3553 chandransh 4300 
    """
4647 rajveer 4301 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4302 
    return self.recv_addDelayReason()
4303 
 
4647 rajveer 4304 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4305 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4306 
    args = addDelayReason_args()
4307 
    args.orderId = orderId
4308 
    args.delayReason = delayReason
3986 chandransh 4309 
    args.furtherDelay = furtherDelay
4647 rajveer 4310 
    args.delayReasonText = delayReasonText
3553 chandransh 4311 
    args.write(self._oprot)
4312 
    self._oprot.writeMessageEnd()
4313 
    self._oprot.trans.flush()
4314 
 
4315 
  def recv_addDelayReason(self, ):
4316 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4317 
    if mtype == TMessageType.EXCEPTION:
4318 
      x = TApplicationException()
4319 
      x.read(self._iprot)
4320 
      self._iprot.readMessageEnd()
4321 
      raise x
4322 
    result = addDelayReason_result()
4323 
    result.read(self._iprot)
4324 
    self._iprot.readMessageEnd()
4325 
    if result.success is not None:
4326 
      return result.success
4327 
    if result.ex is not None:
4328 
      raise result.ex
4329 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4330 
 
3956 chandransh 4331 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4332 
    """
4333 
    Marks the COD orders with given AWB nos. as having been processed.
4334 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4335 
 
3956 chandransh 4336 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4337 
    1. There is no order corresponding to an AWB number.
4338 
    2. The captured amount for a payment exceeds the total payment.
4339 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4340 
 
4341 
    Parameters:
4342 
     - collectedAmountMap
4343 
     - xferBy
4344 
     - xferTxnId
4345 
     - xferDate
4346 
    """
4347 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4348 
    return self.recv_reconcileCodCollection()
4349 
 
4350 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4351 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4352 
    args = reconcileCodCollection_args()
4353 
    args.collectedAmountMap = collectedAmountMap
4354 
    args.xferBy = xferBy
4355 
    args.xferTxnId = xferTxnId
4356 
    args.xferDate = xferDate
4357 
    args.write(self._oprot)
4358 
    self._oprot.writeMessageEnd()
4359 
    self._oprot.trans.flush()
4360 
 
4361 
  def recv_reconcileCodCollection(self, ):
4362 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4363 
    if mtype == TMessageType.EXCEPTION:
4364 
      x = TApplicationException()
4365 
      x.read(self._iprot)
4366 
      self._iprot.readMessageEnd()
4367 
      raise x
4368 
    result = reconcileCodCollection_result()
4369 
    result.read(self._iprot)
4370 
    self._iprot.readMessageEnd()
4371 
    if result.success is not None:
4372 
      return result.success
4373 
    if result.ex is not None:
4374 
      raise result.ex
4375 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4376 
 
4008 mandeep.dh 4377 
  def getTransactionsRequiringExtraProcessing(self, category):
4378 
    """
4065 mandeep.dh 4379 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4380 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4381 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4382 
 
4008 mandeep.dh 4383 
    Parameters:
4384 
     - category
4385 
    """
4386 
    self.send_getTransactionsRequiringExtraProcessing(category)
4387 
    return self.recv_getTransactionsRequiringExtraProcessing()
4388 
 
4389 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4390 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4391 
    args = getTransactionsRequiringExtraProcessing_args()
4392 
    args.category = category
4393 
    args.write(self._oprot)
4394 
    self._oprot.writeMessageEnd()
4395 
    self._oprot.trans.flush()
4396 
 
4397 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4398 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4399 
    if mtype == TMessageType.EXCEPTION:
4400 
      x = TApplicationException()
4401 
      x.read(self._iprot)
4402 
      self._iprot.readMessageEnd()
4403 
      raise x
4404 
    result = getTransactionsRequiringExtraProcessing_result()
4405 
    result.read(self._iprot)
4406 
    self._iprot.readMessageEnd()
4407 
    if result.success is not None:
4408 
      return result.success
4409 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4410 
 
4411 
  def markTransactionAsProcessed(self, transactionId, category):
4412 
    """
4413 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4414 
    It essentially deletes the transaction id record for a particular
4415 
    processing type category (if present) from DB.
4416 
    This is currently used by CRM application.
4008 mandeep.dh 4417 
 
4418 
    Parameters:
4419 
     - transactionId
4420 
     - category
4421 
    """
4422 
    self.send_markTransactionAsProcessed(transactionId, category)
4423 
    self.recv_markTransactionAsProcessed()
4424 
 
4425 
  def send_markTransactionAsProcessed(self, transactionId, category):
4426 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4427 
    args = markTransactionAsProcessed_args()
4428 
    args.transactionId = transactionId
4429 
    args.category = category
4430 
    args.write(self._oprot)
4431 
    self._oprot.writeMessageEnd()
4432 
    self._oprot.trans.flush()
4433 
 
4434 
  def recv_markTransactionAsProcessed(self, ):
4435 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4436 
    if mtype == TMessageType.EXCEPTION:
4437 
      x = TApplicationException()
4438 
      x.read(self._iprot)
4439 
      self._iprot.readMessageEnd()
4440 
      raise x
4441 
    result = markTransactionAsProcessed_result()
4442 
    result.read(self._iprot)
4443 
    self._iprot.readMessageEnd()
4444 
    return
4445 
 
4018 chandransh 4446 
  def getItemWiseRiskyOrdersCount(self, ):
4447 
    """
4448 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4449 
    is defined as one whose shipping date is about to expire.
4450 
    """
4451 
    self.send_getItemWiseRiskyOrdersCount()
4452 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4453 
 
4018 chandransh 4454 
  def send_getItemWiseRiskyOrdersCount(self, ):
4455 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4456 
    args = getItemWiseRiskyOrdersCount_args()
4457 
    args.write(self._oprot)
4458 
    self._oprot.writeMessageEnd()
4459 
    self._oprot.trans.flush()
4460 
 
4461 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4462 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4463 
    if mtype == TMessageType.EXCEPTION:
4464 
      x = TApplicationException()
4465 
      x.read(self._iprot)
4466 
      self._iprot.readMessageEnd()
4467 
      raise x
4468 
    result = getItemWiseRiskyOrdersCount_result()
4469 
    result.read(self._iprot)
4470 
    self._iprot.readMessageEnd()
4471 
    if result.success is not None:
4472 
      return result.success
4473 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4474 
 
4295 varun.gupt 4475 
  def getOrdersForItemIds(self, itemIds):
4476 
    """
4477 
    Returns a list of all orders which have items with given id
4478 
 
4479 
    Parameters:
4480 
     - itemIds
4481 
    """
4482 
    self.send_getOrdersForItemIds(itemIds)
4483 
    return self.recv_getOrdersForItemIds()
4484 
 
4485 
  def send_getOrdersForItemIds(self, itemIds):
4486 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4487 
    args = getOrdersForItemIds_args()
4488 
    args.itemIds = itemIds
4489 
    args.write(self._oprot)
4490 
    self._oprot.writeMessageEnd()
4491 
    self._oprot.trans.flush()
4492 
 
4493 
  def recv_getOrdersForItemIds(self, ):
4494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4495 
    if mtype == TMessageType.EXCEPTION:
4496 
      x = TApplicationException()
4497 
      x.read(self._iprot)
4498 
      self._iprot.readMessageEnd()
4499 
      raise x
4500 
    result = getOrdersForItemIds_result()
4501 
    result.read(self._iprot)
4502 
    self._iprot.readMessageEnd()
4503 
    if result.success is not None:
4504 
      return result.success
4505 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4506 
 
4247 rajveer 4507 
  def markOrderCancellationRequestReceived(self, orderId):
4508 
    """
4509 
    Mark order as cancellation request received. If customer sends request of cancellation of
4510 
    a particular order, this method will be called. It will just change status of the order
4511 
    depending on its current status. It also records the previous status, so that we can move
4512 
    back to that status if cancellation request is denied.
4018 chandransh 4513 
 
4247 rajveer 4514 
    Parameters:
4515 
     - orderId
4516 
    """
4517 
    self.send_markOrderCancellationRequestReceived(orderId)
4518 
    self.recv_markOrderCancellationRequestReceived()
4519 
 
4520 
  def send_markOrderCancellationRequestReceived(self, orderId):
4521 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4522 
    args = markOrderCancellationRequestReceived_args()
4523 
    args.orderId = orderId
4524 
    args.write(self._oprot)
4525 
    self._oprot.writeMessageEnd()
4526 
    self._oprot.trans.flush()
4527 
 
4528 
  def recv_markOrderCancellationRequestReceived(self, ):
4529 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4530 
    if mtype == TMessageType.EXCEPTION:
4531 
      x = TApplicationException()
4532 
      x.read(self._iprot)
4533 
      self._iprot.readMessageEnd()
4534 
      raise x
4535 
    result = markOrderCancellationRequestReceived_result()
4536 
    result.read(self._iprot)
4537 
    self._iprot.readMessageEnd()
4538 
    if result.ex is not None:
4539 
      raise result.ex
4540 
    return
4541 
 
4542 
  def markOrderCancellationRequestConfirmed(self, orderId):
4543 
    """
4544 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4545 
    cancellation request confirmed. After this OM will be able to cancel the order.
4546 
 
4547 
    Parameters:
4548 
     - orderId
4549 
    """
4550 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4551 
    self.recv_markOrderCancellationRequestConfirmed()
4552 
 
4553 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4554 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4555 
    args = markOrderCancellationRequestConfirmed_args()
4556 
    args.orderId = orderId
4557 
    args.write(self._oprot)
4558 
    self._oprot.writeMessageEnd()
4559 
    self._oprot.trans.flush()
4560 
 
4561 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4563 
    if mtype == TMessageType.EXCEPTION:
4564 
      x = TApplicationException()
4565 
      x.read(self._iprot)
4566 
      self._iprot.readMessageEnd()
4567 
      raise x
4568 
    result = markOrderCancellationRequestConfirmed_result()
4569 
    result.read(self._iprot)
4570 
    self._iprot.readMessageEnd()
4571 
    if result.ex is not None:
4572 
      raise result.ex
4573 
    return
4574 
 
4575 
  def markOrderCancellationRequestDenied(self, orderId):
4576 
    """
4577 
    If we decide to not to cancel order, we will move the order ro previous status.
4578 
 
4579 
    Parameters:
4580 
     - orderId
4581 
    """
4582 
    self.send_markOrderCancellationRequestDenied(orderId)
4583 
    self.recv_markOrderCancellationRequestDenied()
4584 
 
4585 
  def send_markOrderCancellationRequestDenied(self, orderId):
4586 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4587 
    args = markOrderCancellationRequestDenied_args()
4588 
    args.orderId = orderId
4589 
    args.write(self._oprot)
4590 
    self._oprot.writeMessageEnd()
4591 
    self._oprot.trans.flush()
4592 
 
4593 
  def recv_markOrderCancellationRequestDenied(self, ):
4594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4595 
    if mtype == TMessageType.EXCEPTION:
4596 
      x = TApplicationException()
4597 
      x.read(self._iprot)
4598 
      self._iprot.readMessageEnd()
4599 
      raise x
4600 
    result = markOrderCancellationRequestDenied_result()
4601 
    result.read(self._iprot)
4602 
    self._iprot.readMessageEnd()
4603 
    if result.ex is not None:
4604 
      raise result.ex
4605 
    return
4606 
 
4258 rajveer 4607 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4608 
    """
4258 rajveer 4609 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4610 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4611 
 
4612 
    Parameters:
4258 rajveer 4613 
     - transactionId
4247 rajveer 4614 
    """
4258 rajveer 4615 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4616 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4617 
 
4258 rajveer 4618 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4619 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4620 
    args = markTransactionAsPaymentFlagRemoved_args()
4621 
    args.transactionId = transactionId
4247 rajveer 4622 
    args.write(self._oprot)
4623 
    self._oprot.writeMessageEnd()
4624 
    self._oprot.trans.flush()
4625 
 
4258 rajveer 4626 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4628 
    if mtype == TMessageType.EXCEPTION:
4629 
      x = TApplicationException()
4630 
      x.read(self._iprot)
4631 
      self._iprot.readMessageEnd()
4632 
      raise x
4258 rajveer 4633 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4634 
    result.read(self._iprot)
4635 
    self._iprot.readMessageEnd()
4636 
    if result.ex is not None:
4637 
      raise result.ex
4638 
    return
4639 
 
4259 anupam.sin 4640 
  def refundTransaction(self, transactionId, refundedBy, reason):
4641 
    """
4642 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4643 
    need to be cancelled
4247 rajveer 4644 
 
4259 anupam.sin 4645 
    Parameters:
4646 
     - transactionId
4647 
     - refundedBy
4648 
     - reason
4649 
    """
4650 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4651 
    self.recv_refundTransaction()
4652 
 
4653 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4654 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4655 
    args = refundTransaction_args()
4656 
    args.transactionId = transactionId
4657 
    args.refundedBy = refundedBy
4658 
    args.reason = reason
4659 
    args.write(self._oprot)
4660 
    self._oprot.writeMessageEnd()
4661 
    self._oprot.trans.flush()
4662 
 
4663 
  def recv_refundTransaction(self, ):
4664 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4665 
    if mtype == TMessageType.EXCEPTION:
4666 
      x = TApplicationException()
4667 
      x.read(self._iprot)
4668 
      self._iprot.readMessageEnd()
4669 
      raise x
4670 
    result = refundTransaction_result()
4671 
    result.read(self._iprot)
4672 
    self._iprot.readMessageEnd()
4673 
    if result.ex is not None:
4674 
      raise result.ex
4675 
    return
4676 
 
4324 mandeep.dh 4677 
  def updateShipmentAddress(self, orderId, addressId):
4678 
    """
4679 
    Updates shipment address of an order. Delivery and shipping date estimates
4680 
    etc. are also updated here.
4681 
 
4682 
    Throws TransactionServiceException in case address change is not
4683 
    possible due to certain reasons such as new pincode in address is
4684 
    not serviceable etc.
4685 
 
4686 
    Parameters:
4687 
     - orderId
4688 
     - addressId
4689 
    """
4690 
    self.send_updateShipmentAddress(orderId, addressId)
4691 
    self.recv_updateShipmentAddress()
4692 
 
4693 
  def send_updateShipmentAddress(self, orderId, addressId):
4694 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4695 
    args = updateShipmentAddress_args()
4696 
    args.orderId = orderId
4697 
    args.addressId = addressId
4698 
    args.write(self._oprot)
4699 
    self._oprot.writeMessageEnd()
4700 
    self._oprot.trans.flush()
4701 
 
4702 
  def recv_updateShipmentAddress(self, ):
4703 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4704 
    if mtype == TMessageType.EXCEPTION:
4705 
      x = TApplicationException()
4706 
      x.read(self._iprot)
4707 
      self._iprot.readMessageEnd()
4708 
      raise x
4709 
    result = updateShipmentAddress_result()
4710 
    result.read(self._iprot)
4711 
    self._iprot.readMessageEnd()
4712 
    if result.ex is not None:
4713 
      raise result.ex
4714 
    return
4715 
 
4285 rajveer 4716 
  def acceptOrdersForItemId(self, itemId, inventory):
4717 
    """
4718 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4719 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4720 
 
4285 rajveer 4721 
    Parameters:
4722 
     - itemId
4723 
     - inventory
4724 
    """
4725 
    self.send_acceptOrdersForItemId(itemId, inventory)
4726 
    return self.recv_acceptOrdersForItemId()
4727 
 
4728 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4729 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4730 
    args = acceptOrdersForItemId_args()
4731 
    args.itemId = itemId
4732 
    args.inventory = inventory
4733 
    args.write(self._oprot)
4734 
    self._oprot.writeMessageEnd()
4735 
    self._oprot.trans.flush()
4736 
 
4737 
  def recv_acceptOrdersForItemId(self, ):
4738 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4739 
    if mtype == TMessageType.EXCEPTION:
4740 
      x = TApplicationException()
4741 
      x.read(self._iprot)
4742 
      self._iprot.readMessageEnd()
4743 
      raise x
4744 
    result = acceptOrdersForItemId_result()
4745 
    result.read(self._iprot)
4746 
    self._iprot.readMessageEnd()
4747 
    if result.success is not None:
4748 
      return result.success
4749 
    if result.ex is not None:
4750 
      raise result.ex
4751 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4752 
 
4369 rajveer 4753 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4754 
    """
4755 
    Parameters:
4756 
     - vendorId
4757 
     - itemId
4758 
     - quantity
4759 
     - estimate
4369 rajveer 4760 
     - isReminder
4303 rajveer 4761 
    """
4369 rajveer 4762 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4763 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4764 
 
4369 rajveer 4765 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4766 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4767 
    args = markOrdersAsPORaised_args()
4768 
    args.vendorId = vendorId
4769 
    args.itemId = itemId
4770 
    args.quantity = quantity
4771 
    args.estimate = estimate
4369 rajveer 4772 
    args.isReminder = isReminder
4303 rajveer 4773 
    args.write(self._oprot)
4774 
    self._oprot.writeMessageEnd()
4775 
    self._oprot.trans.flush()
4776 
 
4777 
  def recv_markOrdersAsPORaised(self, ):
4778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4779 
    if mtype == TMessageType.EXCEPTION:
4780 
      x = TApplicationException()
4781 
      x.read(self._iprot)
4782 
      self._iprot.readMessageEnd()
4783 
      raise x
4784 
    result = markOrdersAsPORaised_result()
4785 
    result.read(self._iprot)
4786 
    self._iprot.readMessageEnd()
4787 
    if result.ex is not None:
4788 
      raise result.ex
4789 
    return
4790 
 
4369 rajveer 4791 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4792 
    """
4793 
    Parameters:
4794 
     - vendorId
4795 
     - itemId
4796 
     - quantity
4797 
     - estimate
4369 rajveer 4798 
     - isReminder
4303 rajveer 4799 
    """
4369 rajveer 4800 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4801 
    self.recv_markOrdersAsReversalInitiated()
4802 
 
4369 rajveer 4803 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4804 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4805 
    args = markOrdersAsReversalInitiated_args()
4806 
    args.vendorId = vendorId
4807 
    args.itemId = itemId
4808 
    args.quantity = quantity
4809 
    args.estimate = estimate
4369 rajveer 4810 
    args.isReminder = isReminder
4303 rajveer 4811 
    args.write(self._oprot)
4812 
    self._oprot.writeMessageEnd()
4813 
    self._oprot.trans.flush()
4814 
 
4815 
  def recv_markOrdersAsReversalInitiated(self, ):
4816 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4817 
    if mtype == TMessageType.EXCEPTION:
4818 
      x = TApplicationException()
4819 
      x.read(self._iprot)
4820 
      self._iprot.readMessageEnd()
4821 
      raise x
4822 
    result = markOrdersAsReversalInitiated_result()
4823 
    result.read(self._iprot)
4824 
    self._iprot.readMessageEnd()
4825 
    if result.ex is not None:
4826 
      raise result.ex
4827 
    return
4828 
 
4369 rajveer 4829 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4830 
    """
4831 
    Parameters:
4832 
     - vendorId
4833 
     - itemId
4834 
     - quantity
4835 
     - estimate
4369 rajveer 4836 
     - isReminder
4303 rajveer 4837 
    """
4369 rajveer 4838 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4839 
    self.recv_markOrdersAsNotAvailabke()
4840 
 
4369 rajveer 4841 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4842 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4843 
    args = markOrdersAsNotAvailabke_args()
4844 
    args.vendorId = vendorId
4845 
    args.itemId = itemId
4846 
    args.quantity = quantity
4847 
    args.estimate = estimate
4369 rajveer 4848 
    args.isReminder = isReminder
4303 rajveer 4849 
    args.write(self._oprot)
4850 
    self._oprot.writeMessageEnd()
4851 
    self._oprot.trans.flush()
4852 
 
4853 
  def recv_markOrdersAsNotAvailabke(self, ):
4854 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4855 
    if mtype == TMessageType.EXCEPTION:
4856 
      x = TApplicationException()
4857 
      x.read(self._iprot)
4858 
      self._iprot.readMessageEnd()
4859 
      raise x
4860 
    result = markOrdersAsNotAvailabke_result()
4861 
    result.read(self._iprot)
4862 
    self._iprot.readMessageEnd()
4863 
    if result.ex is not None:
4864 
      raise result.ex
4865 
    return
4866 
 
4369 rajveer 4867 
  def markOrdersAsTimeout(self, vendorId):
4868 
    """
4869 
    Parameters:
4870 
     - vendorId
4871 
    """
4872 
    self.send_markOrdersAsTimeout(vendorId)
4873 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4874 
 
4369 rajveer 4875 
  def send_markOrdersAsTimeout(self, vendorId):
4876 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4877 
    args = markOrdersAsTimeout_args()
4878 
    args.vendorId = vendorId
4879 
    args.write(self._oprot)
4880 
    self._oprot.writeMessageEnd()
4881 
    self._oprot.trans.flush()
4882 
 
4883 
  def recv_markOrdersAsTimeout(self, ):
4884 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4885 
    if mtype == TMessageType.EXCEPTION:
4886 
      x = TApplicationException()
4887 
      x.read(self._iprot)
4888 
      self._iprot.readMessageEnd()
4889 
      raise x
4890 
    result = markOrdersAsTimeout_result()
4891 
    result.read(self._iprot)
4892 
    self._iprot.readMessageEnd()
4893 
    if result.success is not None:
4894 
      return result.success
4895 
    if result.ex is not None:
4896 
      raise result.ex
4897 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4898 
 
4662 rajveer 4899 
  def markOrderAsLostInTransit(self, orderId):
4900 
    """
4901 
    Mark order as LOST_IN_TRANSIT
4902 
 
4903 
    Parameters:
4904 
     - orderId
4905 
    """
4906 
    self.send_markOrderAsLostInTransit(orderId)
4907 
    return self.recv_markOrderAsLostInTransit()
4908 
 
4909 
  def send_markOrderAsLostInTransit(self, orderId):
4910 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4911 
    args = markOrderAsLostInTransit_args()
4912 
    args.orderId = orderId
4913 
    args.write(self._oprot)
4914 
    self._oprot.writeMessageEnd()
4915 
    self._oprot.trans.flush()
4916 
 
4917 
  def recv_markOrderAsLostInTransit(self, ):
4918 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4919 
    if mtype == TMessageType.EXCEPTION:
4920 
      x = TApplicationException()
4921 
      x.read(self._iprot)
4922 
      self._iprot.readMessageEnd()
4923 
      raise x
4924 
    result = markOrderAsLostInTransit_result()
4925 
    result.read(self._iprot)
4926 
    self._iprot.readMessageEnd()
4927 
    if result.success is not None:
4928 
      return result.success
4929 
    if result.ex is not None:
4930 
      raise result.ex
4931 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4932 
 
4386 anupam.sin 4933 
  def getOrderForAwb(self, awb):
4934 
    """
4935 
    Returns the order corresponding to an AWB number
4369 rajveer 4936 
 
4386 anupam.sin 4937 
    Parameters:
4938 
     - awb
4939 
    """
4940 
    self.send_getOrderForAwb(awb)
4941 
    return self.recv_getOrderForAwb()
4942 
 
4943 
  def send_getOrderForAwb(self, awb):
4944 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4945 
    args = getOrderForAwb_args()
4946 
    args.awb = awb
4947 
    args.write(self._oprot)
4948 
    self._oprot.writeMessageEnd()
4949 
    self._oprot.trans.flush()
4950 
 
4951 
  def recv_getOrderForAwb(self, ):
4952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4953 
    if mtype == TMessageType.EXCEPTION:
4954 
      x = TApplicationException()
4955 
      x.read(self._iprot)
4956 
      self._iprot.readMessageEnd()
4957 
      raise x
4958 
    result = getOrderForAwb_result()
4959 
    result.read(self._iprot)
4960 
    self._iprot.readMessageEnd()
4961 
    if result.success is not None:
4962 
      return result.success
4963 
    if result.ex is not None:
4964 
      raise result.ex
4965 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4966 
 
4910 phani.kuma 4967 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4968 
    """
4910 phani.kuma 4969 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4970 
 
4506 phani.kuma 4971 
    Parameters:
4972 
     - logistics_provider_id
4910 phani.kuma 4973 
     - order_status_list
4506 phani.kuma 4974 
    """
4910 phani.kuma 4975 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4976 
    return self.recv_getOrdersForProviderForStatus()
4977 
 
4910 phani.kuma 4978 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4979 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4980 
    args = getOrdersForProviderForStatus_args()
4981 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4982 
    args.order_status_list = order_status_list
4506 phani.kuma 4983 
    args.write(self._oprot)
4984 
    self._oprot.writeMessageEnd()
4985 
    self._oprot.trans.flush()
4986 
 
4987 
  def recv_getOrdersForProviderForStatus(self, ):
4988 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4989 
    if mtype == TMessageType.EXCEPTION:
4990 
      x = TApplicationException()
4991 
      x.read(self._iprot)
4992 
      self._iprot.readMessageEnd()
4993 
      raise x
4994 
    result = getOrdersForProviderForStatus_result()
4995 
    result.read(self._iprot)
4996 
    self._iprot.readMessageEnd()
4997 
    if result.success is not None:
4998 
      return result.success
4999 
    if result.ex is not None:
5000 
      raise result.ex
5001 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
5002 
 
4600 varun.gupt 5003 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
5004 
    """
5005 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 5006 
 
4600 varun.gupt 5007 
    Parameters:
5008 
     - vendorId
5009 
     - billingDateFrom
5010 
     - billingDateTo
5011 
    """
5012 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
5013 
    return self.recv_getBilledOrdersForVendor()
5014 
 
5015 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
5016 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
5017 
    args = getBilledOrdersForVendor_args()
5018 
    args.vendorId = vendorId
5019 
    args.billingDateFrom = billingDateFrom
5020 
    args.billingDateTo = billingDateTo
5021 
    args.write(self._oprot)
5022 
    self._oprot.writeMessageEnd()
5023 
    self._oprot.trans.flush()
5024 
 
5025 
  def recv_getBilledOrdersForVendor(self, ):
5026 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5027 
    if mtype == TMessageType.EXCEPTION:
5028 
      x = TApplicationException()
5029 
      x.read(self._iprot)
5030 
      self._iprot.readMessageEnd()
5031 
      raise x
5032 
    result = getBilledOrdersForVendor_result()
5033 
    result.read(self._iprot)
5034 
    self._iprot.readMessageEnd()
5035 
    if result.success is not None:
5036 
      return result.success
5037 
    if result.ex is not None:
5038 
      raise result.ex
5039 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
5040 
 
4607 rajveer 5041 
  def getSlippedSippingDateOrders(self, ):
5042 
    self.send_getSlippedSippingDateOrders()
5043 
    return self.recv_getSlippedSippingDateOrders()
5044 
 
5045 
  def send_getSlippedSippingDateOrders(self, ):
5046 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
5047 
    args = getSlippedSippingDateOrders_args()
5048 
    args.write(self._oprot)
5049 
    self._oprot.writeMessageEnd()
5050 
    self._oprot.trans.flush()
5051 
 
5052 
  def recv_getSlippedSippingDateOrders(self, ):
5053 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5054 
    if mtype == TMessageType.EXCEPTION:
5055 
      x = TApplicationException()
5056 
      x.read(self._iprot)
5057 
      self._iprot.readMessageEnd()
5058 
      raise x
5059 
    result = getSlippedSippingDateOrders_result()
5060 
    result.read(self._iprot)
5061 
    self._iprot.readMessageEnd()
5062 
    if result.success is not None:
5063 
      return result.success
5064 
    if result.ex is not None:
5065 
      raise result.ex
5066 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
5067 
 
4709 rajveer 5068 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5069 
    """
5070 
    Parameters:
5071 
     - cancelDateFrom
5072 
     - cancelDateTo
5073 
    """
5074 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
5075 
    return self.recv_getCancelledOrders()
5076 
 
5077 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5078 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
5079 
    args = getCancelledOrders_args()
5080 
    args.cancelDateFrom = cancelDateFrom
5081 
    args.cancelDateTo = cancelDateTo
5082 
    args.write(self._oprot)
5083 
    self._oprot.writeMessageEnd()
5084 
    self._oprot.trans.flush()
5085 
 
5086 
  def recv_getCancelledOrders(self, ):
5087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5088 
    if mtype == TMessageType.EXCEPTION:
5089 
      x = TApplicationException()
5090 
      x.read(self._iprot)
5091 
      self._iprot.readMessageEnd()
5092 
      raise x
5093 
    result = getCancelledOrders_result()
5094 
    result.read(self._iprot)
5095 
    self._iprot.readMessageEnd()
5096 
    if result.success is not None:
5097 
      return result.success
5098 
    if result.ex is not None:
5099 
      raise result.ex
5100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
5101 
 
4600 varun.gupt 5102 
  def saveBluedartSettlements(self, mapAWBAndAmount):
5103 
    """
5104 
    Parameters:
5105 
     - mapAWBAndAmount
5106 
    """
5107 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
5108 
    self.recv_saveBluedartSettlements()
5109 
 
5110 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
5111 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
5112 
    args = saveBluedartSettlements_args()
5113 
    args.mapAWBAndAmount = mapAWBAndAmount
5114 
    args.write(self._oprot)
5115 
    self._oprot.writeMessageEnd()
5116 
    self._oprot.trans.flush()
5117 
 
5118 
  def recv_saveBluedartSettlements(self, ):
5119 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5120 
    if mtype == TMessageType.EXCEPTION:
5121 
      x = TApplicationException()
5122 
      x.read(self._iprot)
5123 
      self._iprot.readMessageEnd()
5124 
      raise x
5125 
    result = saveBluedartSettlements_result()
5126 
    result.read(self._iprot)
5127 
    self._iprot.readMessageEnd()
5128 
    if result.ex is not None:
5129 
      raise result.ex
5130 
    return
5131 
 
4905 varun.gupt 5132 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5133 
    """
5134 
    Parameters:
5135 
     - settlementDate
5136 
     - paymentGatewayId
4905 varun.gupt 5137 
     - referenceId
4600 varun.gupt 5138 
     - serviceTax
5139 
     - otherCharges
5140 
     - netCollection
5141 
    """
4905 varun.gupt 5142 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5143 
    self.recv_savePaymentSettlements()
5144 
 
4905 varun.gupt 5145 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5146 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5147 
    args = savePaymentSettlements_args()
5148 
    args.settlementDate = settlementDate
5149 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5150 
    args.referenceId = referenceId
4600 varun.gupt 5151 
    args.serviceTax = serviceTax
5152 
    args.otherCharges = otherCharges
5153 
    args.netCollection = netCollection
5154 
    args.write(self._oprot)
5155 
    self._oprot.writeMessageEnd()
5156 
    self._oprot.trans.flush()
5157 
 
5158 
  def recv_savePaymentSettlements(self, ):
5159 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5160 
    if mtype == TMessageType.EXCEPTION:
5161 
      x = TApplicationException()
5162 
      x.read(self._iprot)
5163 
      self._iprot.readMessageEnd()
5164 
      raise x
5165 
    result = savePaymentSettlements_result()
5166 
    result.read(self._iprot)
5167 
    self._iprot.readMessageEnd()
5168 
    if result.ex is not None:
5169 
      raise result.ex
5170 
    return
5171 
 
5172 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5173 
    """
5174 
    Parameters:
5175 
     - settlementId
5176 
     - settlementDate
5177 
     - transactionDateFrom
5178 
     - transactionDateTo
5179 
     - amount
5180 
    """
5181 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5182 
    self.recv_saveEBSSettlementSummary()
5183 
 
5184 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5185 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5186 
    args = saveEBSSettlementSummary_args()
5187 
    args.settlementId = settlementId
5188 
    args.settlementDate = settlementDate
5189 
    args.transactionDateFrom = transactionDateFrom
5190 
    args.transactionDateTo = transactionDateTo
5191 
    args.amount = amount
5192 
    args.write(self._oprot)
5193 
    self._oprot.writeMessageEnd()
5194 
    self._oprot.trans.flush()
5195 
 
5196 
  def recv_saveEBSSettlementSummary(self, ):
5197 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5198 
    if mtype == TMessageType.EXCEPTION:
5199 
      x = TApplicationException()
5200 
      x.read(self._iprot)
5201 
      self._iprot.readMessageEnd()
5202 
      raise x
5203 
    result = saveEBSSettlementSummary_result()
5204 
    result.read(self._iprot)
5205 
    self._iprot.readMessageEnd()
5206 
    if result.ex is not None:
5207 
      raise result.ex
5208 
    return
5209 
 
5386 phani.kuma 5210 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5211 
    """
5212 
    Parameters:
5189 varun.gupt 5213 
     - referenceId
5214 
     - isRefund
4600 varun.gupt 5215 
    """
5386 phani.kuma 5216 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5217 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5218 
 
5386 phani.kuma 5219 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5220 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5221 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5222 
    args.referenceId = referenceId
5223 
    args.isRefund = isRefund
4600 varun.gupt 5224 
    args.write(self._oprot)
5225 
    self._oprot.writeMessageEnd()
5226 
    self._oprot.trans.flush()
5227 
 
5386 phani.kuma 5228 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5230 
    if mtype == TMessageType.EXCEPTION:
5231 
      x = TApplicationException()
5232 
      x.read(self._iprot)
5233 
      self._iprot.readMessageEnd()
5234 
      raise x
5386 phani.kuma 5235 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5236 
    result.read(self._iprot)
5237 
    self._iprot.readMessageEnd()
5238 
    if result.success is not None:
5239 
      return result.success
5240 
    if result.ex is not None:
5241 
      raise result.ex
5386 phani.kuma 5242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5243 
 
5386 phani.kuma 5244 
  def getSettlementForCod(self, orderId, isRefund):
5245 
    """
5246 
    Parameters:
5247 
     - orderId
5248 
     - isRefund
5249 
    """
5250 
    self.send_getSettlementForCod(orderId, isRefund)
5251 
    return self.recv_getSettlementForCod()
5252 
 
5253 
  def send_getSettlementForCod(self, orderId, isRefund):
5254 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5255 
    args = getSettlementForCod_args()
5256 
    args.orderId = orderId
5257 
    args.isRefund = isRefund
5258 
    args.write(self._oprot)
5259 
    self._oprot.writeMessageEnd()
5260 
    self._oprot.trans.flush()
5261 
 
5262 
  def recv_getSettlementForCod(self, ):
5263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5264 
    if mtype == TMessageType.EXCEPTION:
5265 
      x = TApplicationException()
5266 
      x.read(self._iprot)
5267 
      self._iprot.readMessageEnd()
5268 
      raise x
5269 
    result = getSettlementForCod_result()
5270 
    result.read(self._iprot)
5271 
    self._iprot.readMessageEnd()
5272 
    if result.success is not None:
5273 
      return result.success
5274 
    if result.ex is not None:
5275 
      raise result.ex
5276 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5277 
 
4600 varun.gupt 5278 
  def getEBSSettlementSummaries(self, ):
5279 
    self.send_getEBSSettlementSummaries()
5280 
    return self.recv_getEBSSettlementSummaries()
5281 
 
5282 
  def send_getEBSSettlementSummaries(self, ):
5283 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5284 
    args = getEBSSettlementSummaries_args()
5285 
    args.write(self._oprot)
5286 
    self._oprot.writeMessageEnd()
5287 
    self._oprot.trans.flush()
5288 
 
5289 
  def recv_getEBSSettlementSummaries(self, ):
5290 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5291 
    if mtype == TMessageType.EXCEPTION:
5292 
      x = TApplicationException()
5293 
      x.read(self._iprot)
5294 
      self._iprot.readMessageEnd()
5295 
      raise x
5296 
    result = getEBSSettlementSummaries_result()
5297 
    result.read(self._iprot)
5298 
    self._iprot.readMessageEnd()
5299 
    if result.success is not None:
5300 
      return result.success
5301 
    if result.ex is not None:
5302 
      raise result.ex
5303 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5304 
 
5305 
  def markEBSSettlementUploaded(self, settlementId):
5306 
    """
5307 
    Parameters:
5308 
     - settlementId
5309 
    """
5310 
    self.send_markEBSSettlementUploaded(settlementId)
5311 
    self.recv_markEBSSettlementUploaded()
5312 
 
5313 
  def send_markEBSSettlementUploaded(self, settlementId):
5314 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5315 
    args = markEBSSettlementUploaded_args()
5316 
    args.settlementId = settlementId
5317 
    args.write(self._oprot)
5318 
    self._oprot.writeMessageEnd()
5319 
    self._oprot.trans.flush()
5320 
 
5321 
  def recv_markEBSSettlementUploaded(self, ):
5322 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5323 
    if mtype == TMessageType.EXCEPTION:
5324 
      x = TApplicationException()
5325 
      x.read(self._iprot)
5326 
      self._iprot.readMessageEnd()
5327 
      raise x
5328 
    result = markEBSSettlementUploaded_result()
5329 
    result.read(self._iprot)
5330 
    self._iprot.readMessageEnd()
5331 
    if result.ex is not None:
5332 
      raise result.ex
5333 
    return
5334 
 
5335 
  def getEBSSettlementDate(self, settlementId):
5336 
    """
5337 
    Parameters:
5338 
     - settlementId
5339 
    """
5340 
    self.send_getEBSSettlementDate(settlementId)
5341 
    return self.recv_getEBSSettlementDate()
5342 
 
5343 
  def send_getEBSSettlementDate(self, settlementId):
5344 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5345 
    args = getEBSSettlementDate_args()
5346 
    args.settlementId = settlementId
5347 
    args.write(self._oprot)
5348 
    self._oprot.writeMessageEnd()
5349 
    self._oprot.trans.flush()
5350 
 
5351 
  def recv_getEBSSettlementDate(self, ):
5352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5353 
    if mtype == TMessageType.EXCEPTION:
5354 
      x = TApplicationException()
5355 
      x.read(self._iprot)
5356 
      self._iprot.readMessageEnd()
5357 
      raise x
5358 
    result = getEBSSettlementDate_result()
5359 
    result.read(self._iprot)
5360 
    self._iprot.readMessageEnd()
5361 
    if result.success is not None:
5362 
      return result.success
5363 
    if result.ex is not None:
5364 
      raise result.ex
5365 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5366 
 
4715 varun.gupt 5367 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5368 
    """
5369 
    Parameters:
5370 
     - settlementDateFrom
5371 
     - settlementDateTo
5372 
     - isRefund
5373 
    """
5374 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5375 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5376 
 
4715 varun.gupt 5377 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5378 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5379 
    args = getSettlementsByDate_args()
5380 
    args.settlementDateFrom = settlementDateFrom
5381 
    args.settlementDateTo = settlementDateTo
5382 
    args.isRefund = isRefund
5383 
    args.write(self._oprot)
5384 
    self._oprot.writeMessageEnd()
5385 
    self._oprot.trans.flush()
5386 
 
5387 
  def recv_getSettlementsByDate(self, ):
5388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5389 
    if mtype == TMessageType.EXCEPTION:
5390 
      x = TApplicationException()
5391 
      x.read(self._iprot)
5392 
      self._iprot.readMessageEnd()
5393 
      raise x
5394 
    result = getSettlementsByDate_result()
5395 
    result.read(self._iprot)
5396 
    self._iprot.readMessageEnd()
5397 
    if result.success is not None:
5398 
      return result.success
5399 
    if result.ex is not None:
5400 
      raise result.ex
5401 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5402 
 
5403 
  def getReshippedOrderIds(self, orderIds):
5404 
    """
5405 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5406 
 
5407 
    Parameters:
5408 
     - orderIds
5409 
    """
5410 
    self.send_getReshippedOrderIds(orderIds)
5411 
    return self.recv_getReshippedOrderIds()
5412 
 
5413 
  def send_getReshippedOrderIds(self, orderIds):
5414 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5415 
    args = getReshippedOrderIds_args()
5416 
    args.orderIds = orderIds
5417 
    args.write(self._oprot)
5418 
    self._oprot.writeMessageEnd()
5419 
    self._oprot.trans.flush()
5420 
 
5421 
  def recv_getReshippedOrderIds(self, ):
5422 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5423 
    if mtype == TMessageType.EXCEPTION:
5424 
      x = TApplicationException()
5425 
      x.read(self._iprot)
5426 
      self._iprot.readMessageEnd()
5427 
      raise x
5428 
    result = getReshippedOrderIds_result()
5429 
    result.read(self._iprot)
5430 
    self._iprot.readMessageEnd()
5431 
    if result.success is not None:
5432 
      return result.success
5433 
    if result.ex is not None:
5434 
      raise result.ex
5435 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5436 
 
5481 phani.kuma 5437 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5438 
    """
5439 
    Parameters:
5440 
     - vendorId
5481 phani.kuma 5441 
     - onlyVendorNotPaid
5442 
     - billingDateFrom
5443 
     - billingDateTo
4875 varun.gupt 5444 
    """
5481 phani.kuma 5445 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5446 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5447 
 
5481 phani.kuma 5448 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5449 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5450 
    args = getBilledOrders_args()
4875 varun.gupt 5451 
    args.vendorId = vendorId
5481 phani.kuma 5452 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5453 
    args.billingDateFrom = billingDateFrom
5454 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5455 
    args.write(self._oprot)
5456 
    self._oprot.writeMessageEnd()
5457 
    self._oprot.trans.flush()
5458 
 
5481 phani.kuma 5459 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 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
5481 phani.kuma 5466 
    result = getBilledOrders_result()
4875 varun.gupt 5467 
    result.read(self._iprot)
5468 
    self._iprot.readMessageEnd()
5469 
    if result.success is not None:
5470 
      return result.success
5471 
    if result.ex is not None:
5472 
      raise result.ex
5481 phani.kuma 5473 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5474 
 
5031 varun.gupt 5475 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5476 
    """
5477 
    Parameters:
5478 
     - startDate
5479 
     - endDate
5480 
    """
5481 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5482 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5483 
 
5031 varun.gupt 5484 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5485 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5486 
    args = getStatusDistributionOfOrders_args()
5487 
    args.startDate = startDate
5488 
    args.endDate = endDate
5489 
    args.write(self._oprot)
5490 
    self._oprot.writeMessageEnd()
5491 
    self._oprot.trans.flush()
5492 
 
5493 
  def recv_getStatusDistributionOfOrders(self, ):
5494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5495 
    if mtype == TMessageType.EXCEPTION:
5496 
      x = TApplicationException()
5497 
      x.read(self._iprot)
5498 
      self._iprot.readMessageEnd()
5499 
      raise x
5500 
    result = getStatusDistributionOfOrders_result()
5501 
    result.read(self._iprot)
5502 
    self._iprot.readMessageEnd()
5503 
    if result.success is not None:
5504 
      return result.success
5505 
    if result.ex is not None:
5506 
      raise result.ex
5507 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5508 
 
5067 varun.gupt 5509 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5510 
    """
5511 
    Parameters:
5512 
     - status
5513 
     - startDatetime
5514 
     - endDatetime
5515 
    """
5516 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5517 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5518 
 
5067 varun.gupt 5519 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5520 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5521 
    args = getOrderIdsForStatus_args()
5522 
    args.status = status
5523 
    args.startDatetime = startDatetime
5524 
    args.endDatetime = endDatetime
5525 
    args.write(self._oprot)
5526 
    self._oprot.writeMessageEnd()
5527 
    self._oprot.trans.flush()
5528 
 
5529 
  def recv_getOrderIdsForStatus(self, ):
5530 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5531 
    if mtype == TMessageType.EXCEPTION:
5532 
      x = TApplicationException()
5533 
      x.read(self._iprot)
5534 
      self._iprot.readMessageEnd()
5535 
      raise x
5536 
    result = getOrderIdsForStatus_result()
5537 
    result.read(self._iprot)
5538 
    self._iprot.readMessageEnd()
5539 
    if result.success is not None:
5540 
      return result.success
5541 
    if result.ex is not None:
5542 
      raise result.ex
5543 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5544 
 
5348 anupam.sin 5545 
  def updateCODAgent(self, agent, orderId):
5546 
    """
5547 
    Updates the agent who handled the COD verification call
5548 
 
5549 
    Parameters:
5550 
     - agent
5551 
     - orderId
5552 
    """
5553 
    self.send_updateCODAgent(agent, orderId)
5554 
    self.recv_updateCODAgent()
5555 
 
5556 
  def send_updateCODAgent(self, agent, orderId):
5557 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5558 
    args = updateCODAgent_args()
5559 
    args.agent = agent
5560 
    args.orderId = orderId
5561 
    args.write(self._oprot)
5562 
    self._oprot.writeMessageEnd()
5563 
    self._oprot.trans.flush()
5564 
 
5565 
  def recv_updateCODAgent(self, ):
5566 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5567 
    if mtype == TMessageType.EXCEPTION:
5568 
      x = TApplicationException()
5569 
      x.read(self._iprot)
5570 
      self._iprot.readMessageEnd()
5571 
      raise x
5572 
    result = updateCODAgent_result()
5573 
    result.read(self._iprot)
5574 
    self._iprot.readMessageEnd()
5575 
    if result.ex is not None:
5576 
      raise result.ex
5577 
    return
5578 
 
5099 varun.gupt 5579 
  def updateOrderAsPaidToVendor(self, orderId):
5580 
    """
5581 
    Parameters:
5582 
     - orderId
5583 
    """
5584 
    self.send_updateOrderAsPaidToVendor(orderId)
5585 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5586 
 
5099 varun.gupt 5587 
  def send_updateOrderAsPaidToVendor(self, orderId):
5588 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5589 
    args = updateOrderAsPaidToVendor_args()
5590 
    args.orderId = orderId
5591 
    args.write(self._oprot)
5592 
    self._oprot.writeMessageEnd()
5593 
    self._oprot.trans.flush()
5594 
 
5595 
  def recv_updateOrderAsPaidToVendor(self, ):
5596 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5597 
    if mtype == TMessageType.EXCEPTION:
5598 
      x = TApplicationException()
5599 
      x.read(self._iprot)
5600 
      self._iprot.readMessageEnd()
5601 
      raise x
5602 
    result = updateOrderAsPaidToVendor_result()
5603 
    result.read(self._iprot)
5604 
    self._iprot.readMessageEnd()
5605 
    if result.ex is not None:
5606 
      raise result.ex
5607 
    return
5608 
 
5386 phani.kuma 5609 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5610 
    """
5611 
    Parameters:
5612 
     - orderId
5613 
    """
5614 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5615 
    self.recv_updateOrderOnlyAsPaidToVendor()
5616 
 
5617 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5618 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5619 
    args = updateOrderOnlyAsPaidToVendor_args()
5620 
    args.orderId = orderId
5621 
    args.write(self._oprot)
5622 
    self._oprot.writeMessageEnd()
5623 
    self._oprot.trans.flush()
5624 
 
5625 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5627 
    if mtype == TMessageType.EXCEPTION:
5628 
      x = TApplicationException()
5629 
      x.read(self._iprot)
5630 
      self._iprot.readMessageEnd()
5631 
      raise x
5632 
    result = updateOrderOnlyAsPaidToVendor_result()
5633 
    result.read(self._iprot)
5634 
    self._iprot.readMessageEnd()
5635 
    if result.ex is not None:
5636 
      raise result.ex
5637 
    return
5638 
 
5208 varun.gupt 5639 
  def getRefundedOrdersMarkedPaid(self, ):
5640 
    self.send_getRefundedOrdersMarkedPaid()
5641 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5642 
 
5208 varun.gupt 5643 
  def send_getRefundedOrdersMarkedPaid(self, ):
5644 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5645 
    args = getRefundedOrdersMarkedPaid_args()
5646 
    args.write(self._oprot)
5647 
    self._oprot.writeMessageEnd()
5648 
    self._oprot.trans.flush()
5649 
 
5650 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5651 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5652 
    if mtype == TMessageType.EXCEPTION:
5653 
      x = TApplicationException()
5654 
      x.read(self._iprot)
5655 
      self._iprot.readMessageEnd()
5656 
      raise x
5657 
    result = getRefundedOrdersMarkedPaid_result()
5658 
    result.read(self._iprot)
5659 
    self._iprot.readMessageEnd()
5660 
    if result.success is not None:
5661 
      return result.success
5662 
    if result.ex is not None:
5663 
      raise result.ex
5664 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5665 
 
5447 anupam.sin 5666 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5667 
    """
5668 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5669 
 
5447 anupam.sin 5670 
 
5671 
    Parameters:
5672 
     - minOrderId
5673 
     - maxOrderId
5674 
    """
5675 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5676 
    return self.recv_getAllVerificationAgents()
5677 
 
5678 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5679 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5680 
    args = getAllVerificationAgents_args()
5681 
    args.minOrderId = minOrderId
5682 
    args.maxOrderId = maxOrderId
5683 
    args.write(self._oprot)
5684 
    self._oprot.writeMessageEnd()
5685 
    self._oprot.trans.flush()
5686 
 
5687 
  def recv_getAllVerificationAgents(self, ):
5688 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5689 
    if mtype == TMessageType.EXCEPTION:
5690 
      x = TApplicationException()
5691 
      x.read(self._iprot)
5692 
      self._iprot.readMessageEnd()
5693 
      raise x
5694 
    result = getAllVerificationAgents_result()
5695 
    result.read(self._iprot)
5696 
    self._iprot.readMessageEnd()
5697 
    if result.success is not None:
5698 
      return result.success
5699 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5700 
 
5527 anupam.sin 5701 
  def getAllAttributesForOrderId(self, orderId):
5702 
    """
5703 
    gets all attributes for a given orderId
5447 anupam.sin 5704 
 
5527 anupam.sin 5705 
    Parameters:
5706 
     - orderId
5707 
    """
5708 
    self.send_getAllAttributesForOrderId(orderId)
5709 
    return self.recv_getAllAttributesForOrderId()
5710 
 
5711 
  def send_getAllAttributesForOrderId(self, orderId):
5712 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5713 
    args = getAllAttributesForOrderId_args()
5714 
    args.orderId = orderId
5715 
    args.write(self._oprot)
5716 
    self._oprot.writeMessageEnd()
5717 
    self._oprot.trans.flush()
5718 
 
5719 
  def recv_getAllAttributesForOrderId(self, ):
5720 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5721 
    if mtype == TMessageType.EXCEPTION:
5722 
      x = TApplicationException()
5723 
      x.read(self._iprot)
5724 
      self._iprot.readMessageEnd()
5725 
      raise x
5726 
    result = getAllAttributesForOrderId_result()
5727 
    result.read(self._iprot)
5728 
    self._iprot.readMessageEnd()
5729 
    if result.success is not None:
5730 
      return result.success
5731 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5732 
 
5676 rajveer 5733 
  def setOrderAttributes(self, orderId, attributes):
5734 
    """
5735 
    sets attributes for an order
5736 
 
5737 
    Parameters:
5738 
     - orderId
5739 
     - attributes
5740 
    """
5741 
    self.send_setOrderAttributes(orderId, attributes)
5742 
    self.recv_setOrderAttributes()
5743 
 
5744 
  def send_setOrderAttributes(self, orderId, attributes):
5745 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5746 
    args = setOrderAttributes_args()
5747 
    args.orderId = orderId
5748 
    args.attributes = attributes
5749 
    args.write(self._oprot)
5750 
    self._oprot.writeMessageEnd()
5751 
    self._oprot.trans.flush()
5752 
 
5753 
  def recv_setOrderAttributes(self, ):
5754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5755 
    if mtype == TMessageType.EXCEPTION:
5756 
      x = TApplicationException()
5757 
      x.read(self._iprot)
5758 
      self._iprot.readMessageEnd()
5759 
      raise x
5760 
    result = setOrderAttributes_result()
5761 
    result.read(self._iprot)
5762 
    self._iprot.readMessageEnd()
5763 
    return
5764 
 
5527 anupam.sin 5765 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5766 
    """
5767 
    sets attributes for all orders in a transaction
5768 
 
5769 
    Parameters:
5770 
     - transactionId
5771 
     - attribute
5772 
    """
5773 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5774 
    self.recv_setOrderAttributeForTransaction()
5775 
 
5776 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5777 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5778 
    args = setOrderAttributeForTransaction_args()
5779 
    args.transactionId = transactionId
5780 
    args.attribute = attribute
5781 
    args.write(self._oprot)
5782 
    self._oprot.writeMessageEnd()
5783 
    self._oprot.trans.flush()
5784 
 
5785 
  def recv_setOrderAttributeForTransaction(self, ):
5786 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5787 
    if mtype == TMessageType.EXCEPTION:
5788 
      x = TApplicationException()
5789 
      x.read(self._iprot)
5790 
      self._iprot.readMessageEnd()
5791 
      raise x
5792 
    result = setOrderAttributeForTransaction_result()
5793 
    result.read(self._iprot)
5794 
    self._iprot.readMessageEnd()
5795 
    return
5796 
 
5553 rajveer 5797 
  def getReceivePendingOrders(self, storeId):
5798 
    """
5799 
    Parameters:
5800 
     - storeId
5801 
    """
5802 
    self.send_getReceivePendingOrders(storeId)
5803 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5804 
 
5553 rajveer 5805 
  def send_getReceivePendingOrders(self, storeId):
5806 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5807 
    args = getReceivePendingOrders_args()
5808 
    args.storeId = storeId
5809 
    args.write(self._oprot)
5810 
    self._oprot.writeMessageEnd()
5811 
    self._oprot.trans.flush()
5812 
 
5813 
  def recv_getReceivePendingOrders(self, ):
5814 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5815 
    if mtype == TMessageType.EXCEPTION:
5816 
      x = TApplicationException()
5817 
      x.read(self._iprot)
5818 
      self._iprot.readMessageEnd()
5819 
      raise x
5820 
    result = getReceivePendingOrders_result()
5821 
    result.read(self._iprot)
5822 
    self._iprot.readMessageEnd()
5823 
    if result.success is not None:
5824 
      return result.success
5825 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5826 
 
5827 
  def getReceivedAtStoreOrders(self, storeId):
5828 
    """
5829 
    Parameters:
5830 
     - storeId
5831 
    """
5832 
    self.send_getReceivedAtStoreOrders(storeId)
5833 
    return self.recv_getReceivedAtStoreOrders()
5834 
 
5835 
  def send_getReceivedAtStoreOrders(self, storeId):
5836 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5837 
    args = getReceivedAtStoreOrders_args()
5838 
    args.storeId = storeId
5839 
    args.write(self._oprot)
5840 
    self._oprot.writeMessageEnd()
5841 
    self._oprot.trans.flush()
5842 
 
5843 
  def recv_getReceivedAtStoreOrders(self, ):
5844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5845 
    if mtype == TMessageType.EXCEPTION:
5846 
      x = TApplicationException()
5847 
      x.read(self._iprot)
5848 
      self._iprot.readMessageEnd()
5849 
      raise x
5850 
    result = getReceivedAtStoreOrders_result()
5851 
    result.read(self._iprot)
5852 
    self._iprot.readMessageEnd()
5853 
    if result.success is not None:
5854 
      return result.success
5855 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5856 
 
5713 rajveer 5857 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5858 
    """
5859 
    Parameters:
5860 
     - storeId
5861 
     - fromDate
5862 
     - toDate
5863 
     - onlyCod
5864 
    """
5865 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5866 
    return self.recv_getOrdersCollectionAtStore()
5867 
 
5868 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5869 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5870 
    args = getOrdersCollectionAtStore_args()
5871 
    args.storeId = storeId
5872 
    args.fromDate = fromDate
5873 
    args.toDate = toDate
5874 
    args.onlyCod = onlyCod
5875 
    args.write(self._oprot)
5876 
    self._oprot.writeMessageEnd()
5877 
    self._oprot.trans.flush()
5878 
 
5879 
  def recv_getOrdersCollectionAtStore(self, ):
5880 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5881 
    if mtype == TMessageType.EXCEPTION:
5882 
      x = TApplicationException()
5883 
      x.read(self._iprot)
5884 
      self._iprot.readMessageEnd()
5885 
      raise x
5886 
    result = getOrdersCollectionAtStore_result()
5887 
    result.read(self._iprot)
5888 
    self._iprot.readMessageEnd()
5889 
    if result.success is not None:
5890 
      return result.success
5891 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5892 
 
5833 rajveer 5893 
  def getOrderAttributeValue(self, orderId, attributeName):
5894 
    """
5895 
    Parameters:
5896 
     - orderId
5897 
     - attributeName
5898 
    """
5899 
    self.send_getOrderAttributeValue(orderId, attributeName)
5900 
    return self.recv_getOrderAttributeValue()
5901 
 
5902 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5903 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5904 
    args = getOrderAttributeValue_args()
5905 
    args.orderId = orderId
5906 
    args.attributeName = attributeName
5907 
    args.write(self._oprot)
5908 
    self._oprot.writeMessageEnd()
5909 
    self._oprot.trans.flush()
5910 
 
5911 
  def recv_getOrderAttributeValue(self, ):
5912 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5913 
    if mtype == TMessageType.EXCEPTION:
5914 
      x = TApplicationException()
5915 
      x.read(self._iprot)
5916 
      self._iprot.readMessageEnd()
5917 
      raise x
5918 
    result = getOrderAttributeValue_result()
5919 
    result.read(self._iprot)
5920 
    self._iprot.readMessageEnd()
5921 
    if result.success is not None:
5922 
      return result.success
5923 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5924 
 
6019 rajveer 5925 
  def changeJacketNumber(self, orderId, jacketNumber):
5926 
    """
5927 
    Parameters:
5928 
     - orderId
5929 
     - jacketNumber
5930 
    """
5931 
    self.send_changeJacketNumber(orderId, jacketNumber)
5932 
    return self.recv_changeJacketNumber()
5933 
 
5934 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5935 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5936 
    args = changeJacketNumber_args()
5937 
    args.orderId = orderId
5938 
    args.jacketNumber = jacketNumber
5939 
    args.write(self._oprot)
5940 
    self._oprot.writeMessageEnd()
5941 
    self._oprot.trans.flush()
5942 
 
5943 
  def recv_changeJacketNumber(self, ):
5944 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5945 
    if mtype == TMessageType.EXCEPTION:
5946 
      x = TApplicationException()
5947 
      x.read(self._iprot)
5948 
      self._iprot.readMessageEnd()
5949 
      raise x
5950 
    result = changeJacketNumber_result()
5951 
    result.read(self._iprot)
5952 
    self._iprot.readMessageEnd()
5953 
    if result.success is not None:
5954 
      return result.success
5955 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5956 
 
5957 
  def markOrderAsRtoInTransit(self, orderId):
5958 
    """
5959 
    Parameters:
5960 
     - orderId
5961 
    """
5962 
    self.send_markOrderAsRtoInTransit(orderId)
5963 
    return self.recv_markOrderAsRtoInTransit()
5964 
 
5965 
  def send_markOrderAsRtoInTransit(self, orderId):
5966 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5967 
    args = markOrderAsRtoInTransit_args()
5968 
    args.orderId = orderId
5969 
    args.write(self._oprot)
5970 
    self._oprot.writeMessageEnd()
5971 
    self._oprot.trans.flush()
5972 
 
5973 
  def recv_markOrderAsRtoInTransit(self, ):
5974 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5975 
    if mtype == TMessageType.EXCEPTION:
5976 
      x = TApplicationException()
5977 
      x.read(self._iprot)
5978 
      self._iprot.readMessageEnd()
5979 
      raise x
5980 
    result = markOrderAsRtoInTransit_result()
5981 
    result.read(self._iprot)
5982 
    self._iprot.readMessageEnd()
5983 
    if result.success is not None:
5984 
      return result.success
5985 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5986 
 
5593 mandeep.dh 5987 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5988 
    """
5989 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5990 
    invoked while scanning IN of items.
5553 rajveer 5991 
 
5593 mandeep.dh 5992 
    Parameters:
5993 
     - itemId
5994 
     - quantity
5995 
     - fulfilmentWarehouseId
5996 
     - billingWarehouseId
5997 
    """
5998 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5999 
    self.recv_acceptOrderForItem()
6000 
 
6001 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
6002 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
6003 
    args = acceptOrderForItem_args()
6004 
    args.itemId = itemId
6005 
    args.quantity = quantity
6006 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
6007 
    args.billingWarehouseId = billingWarehouseId
6008 
    args.write(self._oprot)
6009 
    self._oprot.writeMessageEnd()
6010 
    self._oprot.trans.flush()
6011 
 
6012 
  def recv_acceptOrderForItem(self, ):
6013 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6014 
    if mtype == TMessageType.EXCEPTION:
6015 
      x = TApplicationException()
6016 
      x.read(self._iprot)
6017 
      self._iprot.readMessageEnd()
6018 
      raise x
6019 
    result = acceptOrderForItem_result()
6020 
    result.read(self._iprot)
6021 
    self._iprot.readMessageEnd()
6022 
    return
6023 
 
6000 mandeep.dh 6024 
  def createRechargeOrder(self, rechargeOrder):
6025 
    """
6026 
    Parameters:
6027 
     - rechargeOrder
6028 
    """
6029 
    self.send_createRechargeOrder(rechargeOrder)
6030 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 6031 
 
6000 mandeep.dh 6032 
  def send_createRechargeOrder(self, rechargeOrder):
6033 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
6034 
    args = createRechargeOrder_args()
6035 
    args.rechargeOrder = rechargeOrder
6036 
    args.write(self._oprot)
6037 
    self._oprot.writeMessageEnd()
6038 
    self._oprot.trans.flush()
6039 
 
6040 
  def recv_createRechargeOrder(self, ):
6041 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6042 
    if mtype == TMessageType.EXCEPTION:
6043 
      x = TApplicationException()
6044 
      x.read(self._iprot)
6045 
      self._iprot.readMessageEnd()
6046 
      raise x
6047 
    result = createRechargeOrder_result()
6048 
    result.read(self._iprot)
6049 
    self._iprot.readMessageEnd()
6050 
    if result.success is not None:
6051 
      return result.success
6052 
    if result.ex is not None:
6053 
      raise result.ex
6054 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
6055 
 
6031 rajveer 6056 
  def getRechargeOrder(self, rechargeRrderId):
6057 
    """
6058 
    Parameters:
6059 
     - rechargeRrderId
6060 
    """
6061 
    self.send_getRechargeOrder(rechargeRrderId)
6062 
    return self.recv_getRechargeOrder()
6063 
 
6064 
  def send_getRechargeOrder(self, rechargeRrderId):
6065 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
6066 
    args = getRechargeOrder_args()
6067 
    args.rechargeRrderId = rechargeRrderId
6068 
    args.write(self._oprot)
6069 
    self._oprot.writeMessageEnd()
6070 
    self._oprot.trans.flush()
6071 
 
6072 
  def recv_getRechargeOrder(self, ):
6073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6074 
    if mtype == TMessageType.EXCEPTION:
6075 
      x = TApplicationException()
6076 
      x.read(self._iprot)
6077 
      self._iprot.readMessageEnd()
6078 
      raise x
6079 
    result = getRechargeOrder_result()
6080 
    result.read(self._iprot)
6081 
    self._iprot.readMessageEnd()
6082 
    if result.success is not None:
6083 
      return result.success
6084 
    if result.ex is not None:
6085 
      raise result.ex
6086 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
6087 
 
6088 
  def getRechargeOrders(self, userId):
6089 
    """
6090 
    Parameters:
6091 
     - userId
6092 
    """
6093 
    self.send_getRechargeOrders(userId)
6094 
    return self.recv_getRechargeOrders()
6095 
 
6096 
  def send_getRechargeOrders(self, userId):
6097 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
6098 
    args = getRechargeOrders_args()
6099 
    args.userId = userId
6100 
    args.write(self._oprot)
6101 
    self._oprot.writeMessageEnd()
6102 
    self._oprot.trans.flush()
6103 
 
6104 
  def recv_getRechargeOrders(self, ):
6105 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6106 
    if mtype == TMessageType.EXCEPTION:
6107 
      x = TApplicationException()
6108 
      x.read(self._iprot)
6109 
      self._iprot.readMessageEnd()
6110 
      raise x
6111 
    result = getRechargeOrders_result()
6112 
    result.read(self._iprot)
6113 
    self._iprot.readMessageEnd()
6114 
    if result.success is not None:
6115 
      return result.success
6116 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
6117 
 
6000 mandeep.dh 6118 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6119 
    """
6120 
    Parameters:
6121 
     - rechargeOrderId
6122 
     - rechargeOrderStatus
6123 
    """
6124 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 6125 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 6126 
 
6127 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6128 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
6129 
    args = updateRechargeOrderStatus_args()
6130 
    args.rechargeOrderId = rechargeOrderId
6131 
    args.rechargeOrderStatus = rechargeOrderStatus
6132 
    args.write(self._oprot)
6133 
    self._oprot.writeMessageEnd()
6134 
    self._oprot.trans.flush()
6135 
 
6136 
  def recv_updateRechargeOrderStatus(self, ):
6137 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6138 
    if mtype == TMessageType.EXCEPTION:
6139 
      x = TApplicationException()
6140 
      x.read(self._iprot)
6141 
      self._iprot.readMessageEnd()
6142 
      raise x
6143 
    result = updateRechargeOrderStatus_result()
6144 
    result.read(self._iprot)
6145 
    self._iprot.readMessageEnd()
6031 rajveer 6146 
    if result.success is not None:
6147 
      return result.success
6000 mandeep.dh 6148 
    if result.ex is not None:
6149 
      raise result.ex
6031 rajveer 6150 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6151 
 
6031 rajveer 6152 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6153 
    """
6154 
    Parameters:
6031 rajveer 6155 
     - rechargeOrderId
6000 mandeep.dh 6156 
    """
6031 rajveer 6157 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6158 
    return self.recv_activateRechargeTxn()
6159 
 
6031 rajveer 6160 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6161 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6162 
    args = activateRechargeTxn_args()
6031 rajveer 6163 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6164 
    args.write(self._oprot)
6165 
    self._oprot.writeMessageEnd()
6166 
    self._oprot.trans.flush()
6167 
 
6168 
  def recv_activateRechargeTxn(self, ):
6169 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6170 
    if mtype == TMessageType.EXCEPTION:
6171 
      x = TApplicationException()
6172 
      x.read(self._iprot)
6173 
      self._iprot.readMessageEnd()
6174 
      raise x
6175 
    result = activateRechargeTxn_result()
6176 
    result.read(self._iprot)
6177 
    self._iprot.readMessageEnd()
6178 
    if result.success is not None:
6179 
      return result.success
6180 
    if result.ex is not None:
6181 
      raise result.ex
6182 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6183 
 
6031 rajveer 6184 
  def getUserWallet(self, userId):
6000 mandeep.dh 6185 
    """
6186 
    Parameters:
6031 rajveer 6187 
     - userId
6000 mandeep.dh 6188 
    """
6031 rajveer 6189 
    self.send_getUserWallet(userId)
6190 
    return self.recv_getUserWallet()
6000 mandeep.dh 6191 
 
6031 rajveer 6192 
  def send_getUserWallet(self, userId):
6193 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6194 
    args = getUserWallet_args()
6195 
    args.userId = userId
6000 mandeep.dh 6196 
    args.write(self._oprot)
6197 
    self._oprot.writeMessageEnd()
6198 
    self._oprot.trans.flush()
6199 
 
6031 rajveer 6200 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6201 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6202 
    if mtype == TMessageType.EXCEPTION:
6203 
      x = TApplicationException()
6204 
      x.read(self._iprot)
6205 
      self._iprot.readMessageEnd()
6206 
      raise x
6031 rajveer 6207 
    result = getUserWallet_result()
6000 mandeep.dh 6208 
    result.read(self._iprot)
6209 
    self._iprot.readMessageEnd()
6210 
    if result.success is not None:
6211 
      return result.success
6031 rajveer 6212 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6213 
 
6031 rajveer 6214 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6215 
    """
6216 
    Parameters:
6031 rajveer 6217 
     - userId
6000 mandeep.dh 6218 
    """
6031 rajveer 6219 
    self.send_getUserWalletHistory(userId)
6220 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6221 
 
6031 rajveer 6222 
  def send_getUserWalletHistory(self, userId):
6223 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6224 
    args = getUserWalletHistory_args()
6225 
    args.userId = userId
6000 mandeep.dh 6226 
    args.write(self._oprot)
6227 
    self._oprot.writeMessageEnd()
6228 
    self._oprot.trans.flush()
6229 
 
6031 rajveer 6230 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6232 
    if mtype == TMessageType.EXCEPTION:
6233 
      x = TApplicationException()
6234 
      x.read(self._iprot)
6235 
      self._iprot.readMessageEnd()
6236 
      raise x
6031 rajveer 6237 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6238 
    result.read(self._iprot)
6239 
    self._iprot.readMessageEnd()
6240 
    if result.success is not None:
6241 
      return result.success
6031 rajveer 6242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6243 
 
6050 anupam.sin 6244 
  def getRechargeOrdersForTransaction(self, txnId):
6245 
    """
6246 
    Returns a recharge order for a given transactionId
6247 
 
6248 
    Parameters:
6249 
     - txnId
6250 
    """
6251 
    self.send_getRechargeOrdersForTransaction(txnId)
6252 
    return self.recv_getRechargeOrdersForTransaction()
6253 
 
6254 
  def send_getRechargeOrdersForTransaction(self, txnId):
6255 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6256 
    args = getRechargeOrdersForTransaction_args()
6257 
    args.txnId = txnId
6258 
    args.write(self._oprot)
6259 
    self._oprot.writeMessageEnd()
6260 
    self._oprot.trans.flush()
6261 
 
6262 
  def recv_getRechargeOrdersForTransaction(self, ):
6263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6264 
    if mtype == TMessageType.EXCEPTION:
6265 
      x = TApplicationException()
6266 
      x.read(self._iprot)
6267 
      self._iprot.readMessageEnd()
6268 
      raise x
6269 
    result = getRechargeOrdersForTransaction_result()
6270 
    result.read(self._iprot)
6271 
    self._iprot.readMessageEnd()
6272 
    if result.success is not None:
6273 
      return result.success
6274 
    if result.ex is not None:
6275 
      raise result.ex
6276 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6277 
 
6206 rajveer 6278 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6279 
    """
6280 
    Parameters:
6281 
     - rechargeType
6206 rajveer 6282 
     - onlyActive
6048 rajveer 6283 
    """
6206 rajveer 6284 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6285 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6286 
 
6206 rajveer 6287 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6288 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6289 
    args = getServiceProviders_args()
6290 
    args.rechargeType = rechargeType
6206 rajveer 6291 
    args.onlyActive = onlyActive
6048 rajveer 6292 
    args.write(self._oprot)
6293 
    self._oprot.writeMessageEnd()
6294 
    self._oprot.trans.flush()
6295 
 
6296 
  def recv_getServiceProviders(self, ):
6297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6298 
    if mtype == TMessageType.EXCEPTION:
6299 
      x = TApplicationException()
6300 
      x.read(self._iprot)
6301 
      self._iprot.readMessageEnd()
6302 
      raise x
6303 
    result = getServiceProviders_result()
6304 
    result.read(self._iprot)
6305 
    self._iprot.readMessageEnd()
6306 
    if result.success is not None:
6307 
      return result.success
6308 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6309 
 
6049 rajveer 6310 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6311 
    """
6312 
    Parameters:
6049 rajveer 6313 
     - rechargeType
6048 rajveer 6314 
     - deviceNumber
6315 
    """
6049 rajveer 6316 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6317 
    return self.recv_getServiceProviderForDevice()
6318 
 
6049 rajveer 6319 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6320 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6321 
    args = getServiceProviderForDevice_args()
6049 rajveer 6322 
    args.rechargeType = rechargeType
6048 rajveer 6323 
    args.deviceNumber = deviceNumber
6324 
    args.write(self._oprot)
6325 
    self._oprot.writeMessageEnd()
6326 
    self._oprot.trans.flush()
6327 
 
6328 
  def recv_getServiceProviderForDevice(self, ):
6329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6330 
    if mtype == TMessageType.EXCEPTION:
6331 
      x = TApplicationException()
6332 
      x.read(self._iprot)
6333 
      self._iprot.readMessageEnd()
6334 
      raise x
6335 
    result = getServiceProviderForDevice_result()
6336 
    result.read(self._iprot)
6337 
    self._iprot.readMessageEnd()
6338 
    if result.success is not None:
6339 
      return result.success
6340 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6341 
 
6591 anupam.sin 6342 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6343 
    """
6344 
    Parameters:
6345 
     - rechargeType
6346 
     - deviceNumber
6307 anupam.sin 6347 
     - userSelectedProviderId
6591 anupam.sin 6348 
     - clientAddress
6269 rajveer 6349 
    """
6591 anupam.sin 6350 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId, clientAddress)
6269 rajveer 6351 
    return self.recv_validateRecharge()
6352 
 
6591 anupam.sin 6353 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6354 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6355 
    args = validateRecharge_args()
6356 
    args.rechargeType = rechargeType
6357 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6358 
    args.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 6359 
    args.clientAddress = clientAddress
6269 rajveer 6360 
    args.write(self._oprot)
6361 
    self._oprot.writeMessageEnd()
6362 
    self._oprot.trans.flush()
6363 
 
6364 
  def recv_validateRecharge(self, ):
6365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6366 
    if mtype == TMessageType.EXCEPTION:
6367 
      x = TApplicationException()
6368 
      x.read(self._iprot)
6369 
      self._iprot.readMessageEnd()
6370 
      raise x
6371 
    result = validateRecharge_result()
6372 
    result.read(self._iprot)
6373 
    self._iprot.readMessageEnd()
6374 
    if result.success is not None:
6375 
      return result.success
6376 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6377 
 
6094 rajveer 6378 
  def getRechargeOrdersForDevice(self, deviceNumber):
6379 
    """
6380 
    Parameters:
6381 
     - deviceNumber
6382 
    """
6383 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6384 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6385 
 
6094 rajveer 6386 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6387 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6388 
    args = getRechargeOrdersForDevice_args()
6389 
    args.deviceNumber = deviceNumber
6390 
    args.write(self._oprot)
6391 
    self._oprot.writeMessageEnd()
6392 
    self._oprot.trans.flush()
6393 
 
6394 
  def recv_getRechargeOrdersForDevice(self, ):
6395 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6396 
    if mtype == TMessageType.EXCEPTION:
6397 
      x = TApplicationException()
6398 
      x.read(self._iprot)
6399 
      self._iprot.readMessageEnd()
6400 
      raise x
6401 
    result = getRechargeOrdersForDevice_result()
6402 
    result.read(self._iprot)
6403 
    self._iprot.readMessageEnd()
6404 
    if result.success is not None:
6405 
      return result.success
6406 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6407 
 
6408 
  def addAmountToWallet(self, userId, orderId, amount):
6409 
    """
6410 
    Parameters:
6411 
     - userId
6412 
     - orderId
6413 
     - amount
6414 
    """
6415 
    self.send_addAmountToWallet(userId, orderId, amount)
6416 
    self.recv_addAmountToWallet()
6417 
 
6418 
  def send_addAmountToWallet(self, userId, orderId, amount):
6419 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6420 
    args = addAmountToWallet_args()
6421 
    args.userId = userId
6422 
    args.orderId = orderId
6423 
    args.amount = amount
6424 
    args.write(self._oprot)
6425 
    self._oprot.writeMessageEnd()
6426 
    self._oprot.trans.flush()
6427 
 
6428 
  def recv_addAmountToWallet(self, ):
6429 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6430 
    if mtype == TMessageType.EXCEPTION:
6431 
      x = TApplicationException()
6432 
      x.read(self._iprot)
6433 
      self._iprot.readMessageEnd()
6434 
      raise x
6435 
    result = addAmountToWallet_result()
6436 
    result.read(self._iprot)
6437 
    self._iprot.readMessageEnd()
6438 
    return
6439 
 
6188 rajveer 6440 
  def getRechargeStatistics(self, ):
6441 
    self.send_getRechargeStatistics()
6442 
    return self.recv_getRechargeStatistics()
6443 
 
6444 
  def send_getRechargeStatistics(self, ):
6445 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6446 
    args = getRechargeStatistics_args()
6447 
    args.write(self._oprot)
6448 
    self._oprot.writeMessageEnd()
6449 
    self._oprot.trans.flush()
6450 
 
6451 
  def recv_getRechargeStatistics(self, ):
6452 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6453 
    if mtype == TMessageType.EXCEPTION:
6454 
      x = TApplicationException()
6455 
      x.read(self._iprot)
6456 
      self._iprot.readMessageEnd()
6457 
      raise x
6458 
    result = getRechargeStatistics_result()
6459 
    result.read(self._iprot)
6460 
    self._iprot.readMessageEnd()
6461 
    if result.success is not None:
6462 
      return result.success
6463 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6464 
 
6154 rajveer 6465 
  def getRechargeOrdersForStatus(self, status):
6466 
    """
6467 
    Parameters:
6468 
     - status
6469 
    """
6470 
    self.send_getRechargeOrdersForStatus(status)
6471 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6472 
 
6154 rajveer 6473 
  def send_getRechargeOrdersForStatus(self, status):
6474 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6475 
    args = getRechargeOrdersForStatus_args()
6476 
    args.status = status
6477 
    args.write(self._oprot)
6478 
    self._oprot.writeMessageEnd()
6479 
    self._oprot.trans.flush()
6480 
 
6481 
  def recv_getRechargeOrdersForStatus(self, ):
6482 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6483 
    if mtype == TMessageType.EXCEPTION:
6484 
      x = TApplicationException()
6485 
      x.read(self._iprot)
6486 
      self._iprot.readMessageEnd()
6487 
      raise x
6488 
    result = getRechargeOrdersForStatus_result()
6489 
    result.read(self._iprot)
6490 
    self._iprot.readMessageEnd()
6491 
    if result.success is not None:
6492 
      return result.success
6493 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6494 
 
6159 rajveer 6495 
  def getPlansForOperator(self, operatorId):
6496 
    """
6497 
    Parameters:
6498 
     - operatorId
6499 
    """
6500 
    self.send_getPlansForOperator(operatorId)
6501 
    return self.recv_getPlansForOperator()
6154 rajveer 6502 
 
6159 rajveer 6503 
  def send_getPlansForOperator(self, operatorId):
6504 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6505 
    args = getPlansForOperator_args()
6506 
    args.operatorId = operatorId
6507 
    args.write(self._oprot)
6508 
    self._oprot.writeMessageEnd()
6509 
    self._oprot.trans.flush()
6510 
 
6511 
  def recv_getPlansForOperator(self, ):
6512 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6513 
    if mtype == TMessageType.EXCEPTION:
6514 
      x = TApplicationException()
6515 
      x.read(self._iprot)
6516 
      self._iprot.readMessageEnd()
6517 
      raise x
6518 
    result = getPlansForOperator_result()
6519 
    result.read(self._iprot)
6520 
    self._iprot.readMessageEnd()
6521 
    if result.success is not None:
6522 
      return result.success
6523 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6524 
 
6307 anupam.sin 6525 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6526 
    """
6527 
    Returns denominations for a given operator and circle
6159 rajveer 6528 
 
6289 anupam.sin 6529 
    Parameters:
6530 
     - operatorId
6307 anupam.sin 6531 
     - circleCode
6289 anupam.sin 6532 
     - denominationType
6533 
    """
6307 anupam.sin 6534 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6535 
    return self.recv_getRechargeDenominations()
6536 
 
6307 anupam.sin 6537 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6538 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6539 
    args = getRechargeDenominations_args()
6540 
    args.operatorId = operatorId
6307 anupam.sin 6541 
    args.circleCode = circleCode
6289 anupam.sin 6542 
    args.denominationType = denominationType
6543 
    args.write(self._oprot)
6544 
    self._oprot.writeMessageEnd()
6545 
    self._oprot.trans.flush()
6546 
 
6547 
  def recv_getRechargeDenominations(self, ):
6548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6549 
    if mtype == TMessageType.EXCEPTION:
6550 
      x = TApplicationException()
6551 
      x.read(self._iprot)
6552 
      self._iprot.readMessageEnd()
6553 
      raise x
6554 
    result = getRechargeDenominations_result()
6555 
    result.read(self._iprot)
6556 
    self._iprot.readMessageEnd()
6557 
    if result.success is not None:
6558 
      return result.success
6559 
    if result.ex is not None:
6560 
      raise result.ex
6561 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6562 
 
6371 rajveer 6563 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6564 
    """
6565 
    Parameters:
6566 
     - operatorId
6567 
     - circleId
6568 
     - isAvailable
6569 
    """
6570 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6571 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6572 
 
6371 rajveer 6573 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6574 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6575 
    args = updateAvailabilityStatus_args()
6576 
    args.operatorId = operatorId
6577 
    args.circleId = circleId
6578 
    args.isAvailable = isAvailable
6579 
    args.write(self._oprot)
6580 
    self._oprot.writeMessageEnd()
6581 
    self._oprot.trans.flush()
6582 
 
6583 
  def recv_updateAvailabilityStatus(self, ):
6584 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6585 
    if mtype == TMessageType.EXCEPTION:
6586 
      x = TApplicationException()
6587 
      x.read(self._iprot)
6588 
      self._iprot.readMessageEnd()
6589 
      raise x
6590 
    result = updateAvailabilityStatus_result()
6591 
    result.read(self._iprot)
6592 
    self._iprot.readMessageEnd()
6593 
    return
6594 
 
6389 rajveer 6595 
  def getAvailableEmiSchemes(self, ):
6596 
    self.send_getAvailableEmiSchemes()
6597 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6598 
 
6389 rajveer 6599 
  def send_getAvailableEmiSchemes(self, ):
6600 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6601 
    args = getAvailableEmiSchemes_args()
6602 
    args.write(self._oprot)
6603 
    self._oprot.writeMessageEnd()
6604 
    self._oprot.trans.flush()
6605 
 
6606 
  def recv_getAvailableEmiSchemes(self, ):
6607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6608 
    if mtype == TMessageType.EXCEPTION:
6609 
      x = TApplicationException()
6610 
      x.read(self._iprot)
6611 
      self._iprot.readMessageEnd()
6612 
      raise x
6613 
    result = getAvailableEmiSchemes_result()
6614 
    result.read(self._iprot)
6615 
    self._iprot.readMessageEnd()
6616 
    if result.success is not None:
6617 
      return result.success
6618 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6619 
 
6620 
  def getMiscCharges(self, transactionId):
6621 
    """
6622 
    Parameters:
6623 
     - transactionId
6624 
    """
6625 
    self.send_getMiscCharges(transactionId)
6626 
    return self.recv_getMiscCharges()
6627 
 
6628 
  def send_getMiscCharges(self, transactionId):
6629 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6630 
    args = getMiscCharges_args()
6631 
    args.transactionId = transactionId
6632 
    args.write(self._oprot)
6633 
    self._oprot.writeMessageEnd()
6634 
    self._oprot.trans.flush()
6635 
 
6636 
  def recv_getMiscCharges(self, ):
6637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6638 
    if mtype == TMessageType.EXCEPTION:
6639 
      x = TApplicationException()
6640 
      x.read(self._iprot)
6641 
      self._iprot.readMessageEnd()
6642 
      raise x
6643 
    result = getMiscCharges_result()
6644 
    result.read(self._iprot)
6645 
    self._iprot.readMessageEnd()
6646 
    if result.success is not None:
6647 
      return result.success
6648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6649 
 
6507 anupam.sin 6650 
  def refundRechargeOrder(self, rechargeOrderId):
6651 
    """
6652 
    Parameters:
6653 
     - rechargeOrderId
6654 
    """
6655 
    self.send_refundRechargeOrder(rechargeOrderId)
6656 
    return self.recv_refundRechargeOrder()
6389 rajveer 6657 
 
6507 anupam.sin 6658 
  def send_refundRechargeOrder(self, rechargeOrderId):
6659 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6660 
    args = refundRechargeOrder_args()
6661 
    args.rechargeOrderId = rechargeOrderId
6662 
    args.write(self._oprot)
6663 
    self._oprot.writeMessageEnd()
6664 
    self._oprot.trans.flush()
6665 
 
6666 
  def recv_refundRechargeOrder(self, ):
6667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6668 
    if mtype == TMessageType.EXCEPTION:
6669 
      x = TApplicationException()
6670 
      x.read(self._iprot)
6671 
      self._iprot.readMessageEnd()
6672 
      raise x
6673 
    result = refundRechargeOrder_result()
6674 
    result.read(self._iprot)
6675 
    self._iprot.readMessageEnd()
6676 
    if result.success is not None:
6677 
      return result.success
6678 
    if result.ex is not None:
6679 
      raise result.ex
6680 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6681 
 
6821 amar.kumar 6682 
  def getPhysicalOrders(self, fromDate, toDate):
6683 
    """
6684 
    Parameters:
6685 
     - fromDate
6686 
     - toDate
6687 
    """
6688 
    self.send_getPhysicalOrders(fromDate, toDate)
6689 
    return self.recv_getPhysicalOrders()
6507 anupam.sin 6690 
 
6821 amar.kumar 6691 
  def send_getPhysicalOrders(self, fromDate, toDate):
6692 
    self._oprot.writeMessageBegin('getPhysicalOrders', TMessageType.CALL, self._seqid)
6693 
    args = getPhysicalOrders_args()
6694 
    args.fromDate = fromDate
6695 
    args.toDate = toDate
6696 
    args.write(self._oprot)
6697 
    self._oprot.writeMessageEnd()
6698 
    self._oprot.trans.flush()
6699 
 
6700 
  def recv_getPhysicalOrders(self, ):
6701 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6702 
    if mtype == TMessageType.EXCEPTION:
6703 
      x = TApplicationException()
6704 
      x.read(self._iprot)
6705 
      self._iprot.readMessageEnd()
6706 
      raise x
6707 
    result = getPhysicalOrders_result()
6708 
    result.read(self._iprot)
6709 
    self._iprot.readMessageEnd()
6710 
    if result.success is not None:
6711 
      return result.success
6712 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPhysicalOrders failed: unknown result");
6713 
 
6906 rajveer 6714 
  def getDocument(self, docType, docSource):
6715 
    """
6716 
    Parameters:
6717 
     - docType
6718 
     - docSource
6719 
    """
6720 
    self.send_getDocument(docType, docSource)
6721 
    return self.recv_getDocument()
6821 amar.kumar 6722 
 
6906 rajveer 6723 
  def send_getDocument(self, docType, docSource):
6724 
    self._oprot.writeMessageBegin('getDocument', TMessageType.CALL, self._seqid)
6725 
    args = getDocument_args()
6726 
    args.docType = docType
6727 
    args.docSource = docSource
6728 
    args.write(self._oprot)
6729 
    self._oprot.writeMessageEnd()
6730 
    self._oprot.trans.flush()
6731 
 
6732 
  def recv_getDocument(self, ):
6733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6734 
    if mtype == TMessageType.EXCEPTION:
6735 
      x = TApplicationException()
6736 
      x.read(self._iprot)
6737 
      self._iprot.readMessageEnd()
6738 
      raise x
6739 
    result = getDocument_result()
6740 
    result.read(self._iprot)
6741 
    self._iprot.readMessageEnd()
6742 
    if result.success is not None:
6743 
      return result.success
6744 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDocument failed: unknown result");
6745 
 
6985 anupam.sin 6746 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6747 
    """
6748 
    Parameters:
6749 
     - orderId
6750 
     - line1
6751 
     - line2
6752 
     - city
6753 
     - state
6754 
     - pin
6755 
    """
6756 
    self.send_changeShippingAddress(orderId, line1, line2, city, state, pin)
6757 
    return self.recv_changeShippingAddress()
6906 rajveer 6758 
 
6985 anupam.sin 6759 
  def send_changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6760 
    self._oprot.writeMessageBegin('changeShippingAddress', TMessageType.CALL, self._seqid)
6761 
    args = changeShippingAddress_args()
6762 
    args.orderId = orderId
6763 
    args.line1 = line1
6764 
    args.line2 = line2
6765 
    args.city = city
6766 
    args.state = state
6767 
    args.pin = pin
6768 
    args.write(self._oprot)
6769 
    self._oprot.writeMessageEnd()
6770 
    self._oprot.trans.flush()
6771 
 
6772 
  def recv_changeShippingAddress(self, ):
6773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6774 
    if mtype == TMessageType.EXCEPTION:
6775 
      x = TApplicationException()
6776 
      x.read(self._iprot)
6777 
      self._iprot.readMessageEnd()
6778 
      raise x
6779 
    result = changeShippingAddress_result()
6780 
    result.read(self._iprot)
6781 
    self._iprot.readMessageEnd()
6782 
    if result.success is not None:
6783 
      return result.success
6784 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeShippingAddress failed: unknown result");
6785 
 
7075 rajveer 6786 
  def retrieveInvoice(self, orderId, userId):
6988 rajveer 6787 
    """
6788 
    Parameters:
6789 
     - orderId
7075 rajveer 6790 
     - userId
6988 rajveer 6791 
    """
7075 rajveer 6792 
    self.send_retrieveInvoice(orderId, userId)
6988 rajveer 6793 
    return self.recv_retrieveInvoice()
6985 anupam.sin 6794 
 
7075 rajveer 6795 
  def send_retrieveInvoice(self, orderId, userId):
6988 rajveer 6796 
    self._oprot.writeMessageBegin('retrieveInvoice', TMessageType.CALL, self._seqid)
6797 
    args = retrieveInvoice_args()
6798 
    args.orderId = orderId
7075 rajveer 6799 
    args.userId = userId
6988 rajveer 6800 
    args.write(self._oprot)
6801 
    self._oprot.writeMessageEnd()
6802 
    self._oprot.trans.flush()
6803 
 
6804 
  def recv_retrieveInvoice(self, ):
6805 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6806 
    if mtype == TMessageType.EXCEPTION:
6807 
      x = TApplicationException()
6808 
      x.read(self._iprot)
6809 
      self._iprot.readMessageEnd()
6810 
      raise x
6811 
    result = retrieveInvoice_result()
6812 
    result.read(self._iprot)
6813 
    self._iprot.readMessageEnd()
6814 
    if result.success is not None:
6815 
      return result.success
6816 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveInvoice failed: unknown result");
6817 
 
7026 rajveer 6818 
  def receiveUpdatesForRedExpress(self, awbNumber):
6819 
    """
6820 
    Parameters:
6821 
     - awbNumber
6822 
    """
6823 
    self.send_receiveUpdatesForRedExpress(awbNumber)
6824 
    return self.recv_receiveUpdatesForRedExpress()
6988 rajveer 6825 
 
7026 rajveer 6826 
  def send_receiveUpdatesForRedExpress(self, awbNumber):
6827 
    self._oprot.writeMessageBegin('receiveUpdatesForRedExpress', TMessageType.CALL, self._seqid)
6828 
    args = receiveUpdatesForRedExpress_args()
6829 
    args.awbNumber = awbNumber
6830 
    args.write(self._oprot)
6831 
    self._oprot.writeMessageEnd()
6832 
    self._oprot.trans.flush()
6833 
 
6834 
  def recv_receiveUpdatesForRedExpress(self, ):
6835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6836 
    if mtype == TMessageType.EXCEPTION:
6837 
      x = TApplicationException()
6838 
      x.read(self._iprot)
6839 
      self._iprot.readMessageEnd()
6840 
      raise x
6841 
    result = receiveUpdatesForRedExpress_result()
6842 
    result.read(self._iprot)
6843 
    self._iprot.readMessageEnd()
6844 
    if result.success is not None:
6845 
      return result.success
6846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveUpdatesForRedExpress failed: unknown result");
6847 
 
7073 anupam.sin 6848 
  def createRechargeTransaction(self, thriftRechargeTransaction):
6849 
    """
6850 
    Parameters:
6851 
     - thriftRechargeTransaction
6852 
    """
6853 
    self.send_createRechargeTransaction(thriftRechargeTransaction)
6854 
    return self.recv_createRechargeTransaction()
7026 rajveer 6855 
 
7073 anupam.sin 6856 
  def send_createRechargeTransaction(self, thriftRechargeTransaction):
6857 
    self._oprot.writeMessageBegin('createRechargeTransaction', TMessageType.CALL, self._seqid)
6858 
    args = createRechargeTransaction_args()
6859 
    args.thriftRechargeTransaction = thriftRechargeTransaction
6860 
    args.write(self._oprot)
6861 
    self._oprot.writeMessageEnd()
6862 
    self._oprot.trans.flush()
6863 
 
6864 
  def recv_createRechargeTransaction(self, ):
6865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6866 
    if mtype == TMessageType.EXCEPTION:
6867 
      x = TApplicationException()
6868 
      x.read(self._iprot)
6869 
      self._iprot.readMessageEnd()
6870 
      raise x
6871 
    result = createRechargeTransaction_result()
6872 
    result.read(self._iprot)
6873 
    self._iprot.readMessageEnd()
6874 
    if result.success is not None:
6875 
      return result.success
6876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeTransaction failed: unknown result");
6877 
 
7085 rajveer 6878 
  def getRechargeTransactions(self, storeId):
6879 
    """
6880 
    Parameters:
6881 
     - storeId
6882 
    """
6883 
    self.send_getRechargeTransactions(storeId)
6884 
    return self.recv_getRechargeTransactions()
6885 
 
6886 
  def send_getRechargeTransactions(self, storeId):
6887 
    self._oprot.writeMessageBegin('getRechargeTransactions', TMessageType.CALL, self._seqid)
6888 
    args = getRechargeTransactions_args()
6889 
    args.storeId = storeId
6890 
    args.write(self._oprot)
6891 
    self._oprot.writeMessageEnd()
6892 
    self._oprot.trans.flush()
6893 
 
6894 
  def recv_getRechargeTransactions(self, ):
6895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6896 
    if mtype == TMessageType.EXCEPTION:
6897 
      x = TApplicationException()
6898 
      x.read(self._iprot)
6899 
      self._iprot.readMessageEnd()
6900 
      raise x
6901 
    result = getRechargeTransactions_result()
6902 
    result.read(self._iprot)
6903 
    self._iprot.readMessageEnd()
6904 
    if result.success is not None:
6905 
      return result.success
6906 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransactions failed: unknown result");
6907 
 
7151 amit.gupta 6908 
  def getRechargeTrans(self, storeId, startDate, endDate, status):
6909 
    """
6910 
    Parameters:
6911 
     - storeId
6912 
     - startDate
6913 
     - endDate
6914 
     - status
6915 
    """
6916 
    self.send_getRechargeTrans(storeId, startDate, endDate, status)
6917 
    return self.recv_getRechargeTrans()
6918 
 
6919 
  def send_getRechargeTrans(self, storeId, startDate, endDate, status):
6920 
    self._oprot.writeMessageBegin('getRechargeTrans', TMessageType.CALL, self._seqid)
6921 
    args = getRechargeTrans_args()
6922 
    args.storeId = storeId
6923 
    args.startDate = startDate
6924 
    args.endDate = endDate
6925 
    args.status = status
6926 
    args.write(self._oprot)
6927 
    self._oprot.writeMessageEnd()
6928 
    self._oprot.trans.flush()
6929 
 
6930 
  def recv_getRechargeTrans(self, ):
6931 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6932 
    if mtype == TMessageType.EXCEPTION:
6933 
      x = TApplicationException()
6934 
      x.read(self._iprot)
6935 
      self._iprot.readMessageEnd()
6936 
      raise x
6937 
    result = getRechargeTrans_result()
6938 
    result.read(self._iprot)
6939 
    self._iprot.readMessageEnd()
6940 
    if result.success is not None:
6941 
      return result.success
6942 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTrans failed: unknown result");
6943 
 
7080 anupam.sin 6944 
  def getRechargeTransaction(self, rechargeId):
6945 
    """
6946 
    Parameters:
6947 
     - rechargeId
6948 
    """
6949 
    self.send_getRechargeTransaction(rechargeId)
6950 
    return self.recv_getRechargeTransaction()
7073 anupam.sin 6951 
 
7080 anupam.sin 6952 
  def send_getRechargeTransaction(self, rechargeId):
6953 
    self._oprot.writeMessageBegin('getRechargeTransaction', TMessageType.CALL, self._seqid)
6954 
    args = getRechargeTransaction_args()
6955 
    args.rechargeId = rechargeId
6956 
    args.write(self._oprot)
6957 
    self._oprot.writeMessageEnd()
6958 
    self._oprot.trans.flush()
6959 
 
6960 
  def recv_getRechargeTransaction(self, ):
6961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6962 
    if mtype == TMessageType.EXCEPTION:
6963 
      x = TApplicationException()
6964 
      x.read(self._iprot)
6965 
      self._iprot.readMessageEnd()
6966 
      raise x
6967 
    result = getRechargeTransaction_result()
6968 
    result.read(self._iprot)
6969 
    self._iprot.readMessageEnd()
6970 
    if result.success is not None:
6971 
      return result.success
6972 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransaction failed: unknown result");
6973 
 
6974 
  def getFRCs(self, circleId, operatorId):
6975 
    """
6976 
    Parameters:
6977 
     - circleId
6978 
     - operatorId
6979 
    """
6980 
    self.send_getFRCs(circleId, operatorId)
6981 
    return self.recv_getFRCs()
6982 
 
6983 
  def send_getFRCs(self, circleId, operatorId):
6984 
    self._oprot.writeMessageBegin('getFRCs', TMessageType.CALL, self._seqid)
6985 
    args = getFRCs_args()
6986 
    args.circleId = circleId
6987 
    args.operatorId = operatorId
6988 
    args.write(self._oprot)
6989 
    self._oprot.writeMessageEnd()
6990 
    self._oprot.trans.flush()
6991 
 
6992 
  def recv_getFRCs(self, ):
6993 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6994 
    if mtype == TMessageType.EXCEPTION:
6995 
      x = TApplicationException()
6996 
      x.read(self._iprot)
6997 
      self._iprot.readMessageEnd()
6998 
      raise x
6999 
    result = getFRCs_result()
7000 
    result.read(self._iprot)
7001 
    self._iprot.readMessageEnd()
7002 
    if result.success is not None:
7003 
      return result.success
7004 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFRCs failed: unknown result");
7005 
 
7096 anupam.sin 7006 
  def getHotspotStore(self, id, hotspotid):
7007 
    """
7008 
    Parameters:
7009 
     - id
7010 
     - hotspotid
7011 
    """
7012 
    self.send_getHotspotStore(id, hotspotid)
7013 
    return self.recv_getHotspotStore()
7080 anupam.sin 7014 
 
7096 anupam.sin 7015 
  def send_getHotspotStore(self, id, hotspotid):
7016 
    self._oprot.writeMessageBegin('getHotspotStore', TMessageType.CALL, self._seqid)
7017 
    args = getHotspotStore_args()
7018 
    args.id = id
7019 
    args.hotspotid = hotspotid
7020 
    args.write(self._oprot)
7021 
    self._oprot.writeMessageEnd()
7022 
    self._oprot.trans.flush()
7023 
 
7024 
  def recv_getHotspotStore(self, ):
7025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7026 
    if mtype == TMessageType.EXCEPTION:
7027 
      x = TApplicationException()
7028 
      x.read(self._iprot)
7029 
      self._iprot.readMessageEnd()
7030 
      raise x
7031 
    result = getHotspotStore_result()
7032 
    result.read(self._iprot)
7033 
    self._iprot.readMessageEnd()
7034 
    if result.success is not None:
7035 
      return result.success
7036 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHotspotStore failed: unknown result");
7037 
 
7038 
  def getTelecomCircle(self, id, code):
7039 
    """
7040 
    Parameters:
7041 
     - id
7042 
     - code
7043 
    """
7044 
    self.send_getTelecomCircle(id, code)
7045 
    return self.recv_getTelecomCircle()
7046 
 
7047 
  def send_getTelecomCircle(self, id, code):
7048 
    self._oprot.writeMessageBegin('getTelecomCircle', TMessageType.CALL, self._seqid)
7049 
    args = getTelecomCircle_args()
7050 
    args.id = id
7051 
    args.code = code
7052 
    args.write(self._oprot)
7053 
    self._oprot.writeMessageEnd()
7054 
    self._oprot.trans.flush()
7055 
 
7056 
  def recv_getTelecomCircle(self, ):
7057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7058 
    if mtype == TMessageType.EXCEPTION:
7059 
      x = TApplicationException()
7060 
      x.read(self._iprot)
7061 
      self._iprot.readMessageEnd()
7062 
      raise x
7063 
    result = getTelecomCircle_result()
7064 
    result.read(self._iprot)
7065 
    self._iprot.readMessageEnd()
7066 
    if result.success is not None:
7067 
      return result.success
7068 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTelecomCircle failed: unknown result");
7069 
 
7109 anupam.sin 7070 
  def retrieveHotspotRechargeInvoice(self, rechargeId):
7071 
    """
7072 
    Parameters:
7073 
     - rechargeId
7074 
    """
7075 
    self.send_retrieveHotspotRechargeInvoice(rechargeId)
7076 
    return self.recv_retrieveHotspotRechargeInvoice()
7096 anupam.sin 7077 
 
7109 anupam.sin 7078 
  def send_retrieveHotspotRechargeInvoice(self, rechargeId):
7079 
    self._oprot.writeMessageBegin('retrieveHotspotRechargeInvoice', TMessageType.CALL, self._seqid)
7080 
    args = retrieveHotspotRechargeInvoice_args()
7081 
    args.rechargeId = rechargeId
7082 
    args.write(self._oprot)
7083 
    self._oprot.writeMessageEnd()
7084 
    self._oprot.trans.flush()
7085 
 
7086 
  def recv_retrieveHotspotRechargeInvoice(self, ):
7087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7088 
    if mtype == TMessageType.EXCEPTION:
7089 
      x = TApplicationException()
7090 
      x.read(self._iprot)
7091 
      self._iprot.readMessageEnd()
7092 
      raise x
7093 
    result = retrieveHotspotRechargeInvoice_result()
7094 
    result.read(self._iprot)
7095 
    self._iprot.readMessageEnd()
7096 
    if result.success is not None:
7097 
      return result.success
7098 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveHotspotRechargeInvoice failed: unknown result");
7099 
 
7190 amar.kumar 7100 
  def splitFreebieOrder(self, orderId, splitReason, shippingDate):
7101 
    """
7102 
    Parameters:
7103 
     - orderId
7104 
     - splitReason
7105 
     - shippingDate
7106 
    """
7107 
    self.send_splitFreebieOrder(orderId, splitReason, shippingDate)
7108 
    return self.recv_splitFreebieOrder()
7109 
 
7110 
  def send_splitFreebieOrder(self, orderId, splitReason, shippingDate):
7111 
    self._oprot.writeMessageBegin('splitFreebieOrder', TMessageType.CALL, self._seqid)
7112 
    args = splitFreebieOrder_args()
7113 
    args.orderId = orderId
7114 
    args.splitReason = splitReason
7115 
    args.shippingDate = shippingDate
7116 
    args.write(self._oprot)
7117 
    self._oprot.writeMessageEnd()
7118 
    self._oprot.trans.flush()
7119 
 
7120 
  def recv_splitFreebieOrder(self, ):
7121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7122 
    if mtype == TMessageType.EXCEPTION:
7123 
      x = TApplicationException()
7124 
      x.read(self._iprot)
7125 
      self._iprot.readMessageEnd()
7126 
      raise x
7127 
    result = splitFreebieOrder_result()
7128 
    result.read(self._iprot)
7129 
    self._iprot.readMessageEnd()
7130 
    if result.success is not None:
7131 
      return result.success
7132 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "splitFreebieOrder failed: unknown result");
7133 
 
7172 anupam.sin 7134 
  def getRechargeTransactionsByNumber(self, number, storeId):
7169 anupam.sin 7135 
    """
7136 
    Parameters:
7137 
     - number
7172 anupam.sin 7138 
     - storeId
7169 anupam.sin 7139 
    """
7172 anupam.sin 7140 
    self.send_getRechargeTransactionsByNumber(number, storeId)
7169 anupam.sin 7141 
    return self.recv_getRechargeTransactionsByNumber()
7109 anupam.sin 7142 
 
7172 anupam.sin 7143 
  def send_getRechargeTransactionsByNumber(self, number, storeId):
7169 anupam.sin 7144 
    self._oprot.writeMessageBegin('getRechargeTransactionsByNumber', TMessageType.CALL, self._seqid)
7145 
    args = getRechargeTransactionsByNumber_args()
7146 
    args.number = number
7172 anupam.sin 7147 
    args.storeId = storeId
7169 anupam.sin 7148 
    args.write(self._oprot)
7149 
    self._oprot.writeMessageEnd()
7150 
    self._oprot.trans.flush()
7151 
 
7152 
  def recv_getRechargeTransactionsByNumber(self, ):
7153 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7154 
    if mtype == TMessageType.EXCEPTION:
7155 
      x = TApplicationException()
7156 
      x.read(self._iprot)
7157 
      self._iprot.readMessageEnd()
7158 
      raise x
7159 
    result = getRechargeTransactionsByNumber_result()
7160 
    result.read(self._iprot)
7161 
    self._iprot.readMessageEnd()
7162 
    if result.success is not None:
7163 
      return result.success
7164 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransactionsByNumber failed: unknown result");
7165 
 
7166 
  def updateHotspotStorePassword(self, storeId, password):
7167 
    """
7168 
    Parameters:
7169 
     - storeId
7170 
     - password
7171 
    """
7172 
    self.send_updateHotspotStorePassword(storeId, password)
7173 
    return self.recv_updateHotspotStorePassword()
7174 
 
7175 
  def send_updateHotspotStorePassword(self, storeId, password):
7176 
    self._oprot.writeMessageBegin('updateHotspotStorePassword', TMessageType.CALL, self._seqid)
7177 
    args = updateHotspotStorePassword_args()
7178 
    args.storeId = storeId
7179 
    args.password = password
7180 
    args.write(self._oprot)
7181 
    self._oprot.writeMessageEnd()
7182 
    self._oprot.trans.flush()
7183 
 
7184 
  def recv_updateHotspotStorePassword(self, ):
7185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7186 
    if mtype == TMessageType.EXCEPTION:
7187 
      x = TApplicationException()
7188 
      x.read(self._iprot)
7189 
      self._iprot.readMessageEnd()
7190 
      raise x
7191 
    result = updateHotspotStorePassword_result()
7192 
    result.read(self._iprot)
7193 
    self._iprot.readMessageEnd()
7194 
    if result.success is not None:
7195 
      return result.success
7196 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateHotspotStorePassword failed: unknown result");
7197 
 
7198 
 
3376 rajveer 7199 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 7200 
  def __init__(self, handler):
3376 rajveer 7201 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 7202 
    self._processMap["createTransaction"] = Processor.process_createTransaction
7203 
    self._processMap["getTransaction"] = Processor.process_getTransaction
7204 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 7205 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 7206 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
7207 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 7208 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 7209 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 7210 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
7211 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 7212 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 7213 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 7214 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
7215 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 7216 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
7217 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
7218 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
7219 
    self._processMap["createOrder"] = Processor.process_createOrder
7220 
    self._processMap["getOrder"] = Processor.process_getOrder
7221 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 7222 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 7223 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 7224 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 7225 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 7226 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 7227 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 7228 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
7229 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
7230 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
7231 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 7232 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 7233 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 7234 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
7235 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
7236 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 7237 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 7238 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 7239 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 7240 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 7241 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 7242 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 7243 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
7244 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 7245 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 7246 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
7247 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
7248 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
7249 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
7250 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 7251 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 7252 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 7253 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 7254 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 7255 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 7256 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
7257 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 7258 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
7259 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 7260 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
7261 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 7262 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 7263 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 7264 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 7265 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 7266 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 7267 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 7268 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 7269 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
7270 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 7271 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 7272 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 7273 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 7274 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 7275 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 7276 
    self._processMap["changeItem"] = Processor.process_changeItem
7277 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 7278 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 7279 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 7280 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
7281 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 7282 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 7283 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 7284 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
7285 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
7286 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 7287 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 7288 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 7289 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 7290 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 7291 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
7292 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
7293 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 7294 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 7295 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 7296 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 7297 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 7298 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 7299 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 7300 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 7301 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
7302 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
7303 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 7304 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
7305 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 7306 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
7307 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
7308 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 7309 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
7310 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 7311 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 7312 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 7313 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 7314 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 7315 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 7316 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 7317 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 7318 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 7319 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 7320 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 7321 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 7322 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
7323 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 7324 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 7325 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 7326 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
7327 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 7328 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 7329 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 7330 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
7331 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 7332 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
7333 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 7334 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
7335 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 7336 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 7337 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
7338 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 7339 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 7340 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
7341 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 7342 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 7343 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 7344 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 7345 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 7346 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 7347 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
7348 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 7349 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
6821 amar.kumar 7350 
    self._processMap["getPhysicalOrders"] = Processor.process_getPhysicalOrders
6906 rajveer 7351 
    self._processMap["getDocument"] = Processor.process_getDocument
6985 anupam.sin 7352 
    self._processMap["changeShippingAddress"] = Processor.process_changeShippingAddress
6988 rajveer 7353 
    self._processMap["retrieveInvoice"] = Processor.process_retrieveInvoice
7026 rajveer 7354 
    self._processMap["receiveUpdatesForRedExpress"] = Processor.process_receiveUpdatesForRedExpress
7073 anupam.sin 7355 
    self._processMap["createRechargeTransaction"] = Processor.process_createRechargeTransaction
7085 rajveer 7356 
    self._processMap["getRechargeTransactions"] = Processor.process_getRechargeTransactions
7151 amit.gupta 7357 
    self._processMap["getRechargeTrans"] = Processor.process_getRechargeTrans
7080 anupam.sin 7358 
    self._processMap["getRechargeTransaction"] = Processor.process_getRechargeTransaction
7359 
    self._processMap["getFRCs"] = Processor.process_getFRCs
7096 anupam.sin 7360 
    self._processMap["getHotspotStore"] = Processor.process_getHotspotStore
7361 
    self._processMap["getTelecomCircle"] = Processor.process_getTelecomCircle
7109 anupam.sin 7362 
    self._processMap["retrieveHotspotRechargeInvoice"] = Processor.process_retrieveHotspotRechargeInvoice
7190 amar.kumar 7363 
    self._processMap["splitFreebieOrder"] = Processor.process_splitFreebieOrder
7169 anupam.sin 7364 
    self._processMap["getRechargeTransactionsByNumber"] = Processor.process_getRechargeTransactionsByNumber
7365 
    self._processMap["updateHotspotStorePassword"] = Processor.process_updateHotspotStorePassword
94 ashish 7366 
 
7367 
  def process(self, iprot, oprot):
7368 
    (name, type, seqid) = iprot.readMessageBegin()
7369 
    if name not in self._processMap:
7370 
      iprot.skip(TType.STRUCT)
7371 
      iprot.readMessageEnd()
7372 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
7373 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
7374 
      x.write(oprot)
7375 
      oprot.writeMessageEnd()
7376 
      oprot.trans.flush()
7377 
      return
7378 
    else:
7379 
      self._processMap[name](self, seqid, iprot, oprot)
7380 
    return True
7381 
 
7382 
  def process_createTransaction(self, seqid, iprot, oprot):
7383 
    args = createTransaction_args()
7384 
    args.read(iprot)
7385 
    iprot.readMessageEnd()
7386 
    result = createTransaction_result()
7387 
    try:
132 ashish 7388 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 7389 
    except TransactionServiceException, ex:
7390 
      result.ex = ex
7391 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
7392 
    result.write(oprot)
7393 
    oprot.writeMessageEnd()
7394 
    oprot.trans.flush()
7395 
 
7396 
  def process_getTransaction(self, seqid, iprot, oprot):
7397 
    args = getTransaction_args()
7398 
    args.read(iprot)
7399 
    iprot.readMessageEnd()
7400 
    result = getTransaction_result()
7401 
    try:
7402 
      result.success = self._handler.getTransaction(args.id)
7403 
    except TransactionServiceException, ex:
7404 
      result.ex = ex
7405 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
7406 
    result.write(oprot)
7407 
    oprot.writeMessageEnd()
7408 
    oprot.trans.flush()
7409 
 
7410 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
7411 
    args = getTransactionsForCustomer_args()
7412 
    args.read(iprot)
7413 
    iprot.readMessageEnd()
7414 
    result = getTransactionsForCustomer_result()
7415 
    try:
7416 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
7417 
    except TransactionServiceException, ex:
7418 
      result.ex = ex
7419 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
7420 
    result.write(oprot)
7421 
    oprot.writeMessageEnd()
7422 
    oprot.trans.flush()
7423 
 
132 ashish 7424 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
7425 
    args = getTransactionsForShoppingCartId_args()
7426 
    args.read(iprot)
7427 
    iprot.readMessageEnd()
7428 
    result = getTransactionsForShoppingCartId_result()
7429 
    try:
7430 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
7431 
    except TransactionServiceException, ex:
7432 
      result.ex = ex
7433 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
7434 
    result.write(oprot)
7435 
    oprot.writeMessageEnd()
7436 
    oprot.trans.flush()
7437 
 
94 ashish 7438 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
7439 
    args = getTransactionStatus_args()
7440 
    args.read(iprot)
7441 
    iprot.readMessageEnd()
7442 
    result = getTransactionStatus_result()
7443 
    try:
7444 
      result.success = self._handler.getTransactionStatus(args.transactionId)
7445 
    except TransactionServiceException, ex:
7446 
      result.ex = ex
7447 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
7448 
    result.write(oprot)
7449 
    oprot.writeMessageEnd()
7450 
    oprot.trans.flush()
7451 
 
7452 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
7453 
    args = changeTransactionStatus_args()
7454 
    args.read(iprot)
7455 
    iprot.readMessageEnd()
7456 
    result = changeTransactionStatus_result()
7457 
    try:
5527 anupam.sin 7458 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 7459 
    except TransactionServiceException, ex:
7460 
      result.ex = ex
7461 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
7462 
    result.write(oprot)
7463 
    oprot.writeMessageEnd()
7464 
    oprot.trans.flush()
7465 
 
1398 varun.gupt 7466 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
7467 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 7468 
    args.read(iprot)
7469 
    iprot.readMessageEnd()
1398 varun.gupt 7470 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 7471 
    try:
1398 varun.gupt 7472 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 7473 
    except TransactionServiceException, ex:
7474 
      result.ex = ex
1398 varun.gupt 7475 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 7476 
    result.write(oprot)
7477 
    oprot.writeMessageEnd()
7478 
    oprot.trans.flush()
7479 
 
483 rajveer 7480 
  def process_getAllOrders(self, seqid, iprot, oprot):
7481 
    args = getAllOrders_args()
94 ashish 7482 
    args.read(iprot)
7483 
    iprot.readMessageEnd()
483 rajveer 7484 
    result = getAllOrders_result()
94 ashish 7485 
    try:
4801 anupam.sin 7486 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 7487 
    except TransactionServiceException, ex:
7488 
      result.ex = ex
483 rajveer 7489 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 7490 
    result.write(oprot)
7491 
    oprot.writeMessageEnd()
7492 
    oprot.trans.flush()
7493 
 
4133 chandransh 7494 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
7495 
    args = getOrdersInBatch_args()
7496 
    args.read(iprot)
7497 
    iprot.readMessageEnd()
7498 
    result = getOrdersInBatch_result()
7499 
    try:
7500 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
7501 
    except TransactionServiceException, ex:
7502 
      result.ex = ex
7503 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
7504 
    result.write(oprot)
7505 
    oprot.writeMessageEnd()
7506 
    oprot.trans.flush()
7507 
 
7508 
  def process_getOrderCount(self, seqid, iprot, oprot):
7509 
    args = getOrderCount_args()
7510 
    args.read(iprot)
7511 
    iprot.readMessageEnd()
7512 
    result = getOrderCount_result()
7513 
    try:
7514 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
7515 
    except TransactionServiceException, ex:
7516 
      result.ex = ex
7517 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
7518 
    result.write(oprot)
7519 
    oprot.writeMessageEnd()
7520 
    oprot.trans.flush()
7521 
 
999 varun.gupt 7522 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
7523 
    args = getOrdersByBillingDate_args()
7524 
    args.read(iprot)
7525 
    iprot.readMessageEnd()
7526 
    result = getOrdersByBillingDate_result()
7527 
    try:
7528 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
7529 
    except TransactionServiceException, ex:
7530 
      result.ex = ex
7531 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
7532 
    result.write(oprot)
7533 
    oprot.writeMessageEnd()
7534 
    oprot.trans.flush()
7535 
 
3427 chandransh 7536 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
7537 
    args = getOrdersByShippingDate_args()
7538 
    args.read(iprot)
7539 
    iprot.readMessageEnd()
7540 
    result = getOrdersByShippingDate_result()
7541 
    try:
3451 chandransh 7542 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 7543 
    except TransactionServiceException, ex:
7544 
      result.ex = ex
7545 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
7546 
    result.write(oprot)
7547 
    oprot.writeMessageEnd()
7548 
    oprot.trans.flush()
7549 
 
1382 varun.gupt 7550 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
7551 
    args = getReturnableOrdersForCustomer_args()
7552 
    args.read(iprot)
7553 
    iprot.readMessageEnd()
7554 
    result = getReturnableOrdersForCustomer_result()
7555 
    try:
7556 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
7557 
    except TransactionServiceException, ex:
7558 
      result.ex = ex
7559 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
7560 
    result.write(oprot)
7561 
    oprot.writeMessageEnd()
7562 
    oprot.trans.flush()
7563 
 
7564 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
7565 
    args = getCancellableOrdersForCustomer_args()
7566 
    args.read(iprot)
7567 
    iprot.readMessageEnd()
7568 
    result = getCancellableOrdersForCustomer_result()
7569 
    try:
7570 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
7571 
    except TransactionServiceException, ex:
7572 
      result.ex = ex
7573 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
7574 
    result.write(oprot)
7575 
    oprot.writeMessageEnd()
7576 
    oprot.trans.flush()
7577 
 
483 rajveer 7578 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
7579 
    args = changeOrderStatus_args()
94 ashish 7580 
    args.read(iprot)
7581 
    iprot.readMessageEnd()
483 rajveer 7582 
    result = changeOrderStatus_result()
94 ashish 7583 
    try:
483 rajveer 7584 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 7585 
    except TransactionServiceException, ex:
7586 
      result.ex = ex
483 rajveer 7587 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 7588 
    result.write(oprot)
7589 
    oprot.writeMessageEnd()
7590 
    oprot.trans.flush()
7591 
 
483 rajveer 7592 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
7593 
    args = getOrdersForTransaction_args()
94 ashish 7594 
    args.read(iprot)
7595 
    iprot.readMessageEnd()
483 rajveer 7596 
    result = getOrdersForTransaction_result()
94 ashish 7597 
    try:
1528 ankur.sing 7598 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 7599 
    except TransactionServiceException, ex:
7600 
      result.ex = ex
483 rajveer 7601 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 7602 
    result.write(oprot)
7603 
    oprot.writeMessageEnd()
7604 
    oprot.trans.flush()
7605 
 
483 rajveer 7606 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
7607 
    args = getOrdersForCustomer_args()
94 ashish 7608 
    args.read(iprot)
7609 
    iprot.readMessageEnd()
483 rajveer 7610 
    result = getOrdersForCustomer_result()
94 ashish 7611 
    try:
3014 chandransh 7612 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 7613 
    except TransactionServiceException, ex:
7614 
      result.ex = ex
483 rajveer 7615 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 7616 
    result.write(oprot)
7617 
    oprot.writeMessageEnd()
7618 
    oprot.trans.flush()
7619 
 
483 rajveer 7620 
  def process_createOrder(self, seqid, iprot, oprot):
7621 
    args = createOrder_args()
94 ashish 7622 
    args.read(iprot)
7623 
    iprot.readMessageEnd()
483 rajveer 7624 
    result = createOrder_result()
94 ashish 7625 
    try:
483 rajveer 7626 
      result.success = self._handler.createOrder(args.order)
94 ashish 7627 
    except TransactionServiceException, ex:
7628 
      result.ex = ex
483 rajveer 7629 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 7630 
    result.write(oprot)
7631 
    oprot.writeMessageEnd()
7632 
    oprot.trans.flush()
7633 
 
483 rajveer 7634 
  def process_getOrder(self, seqid, iprot, oprot):
7635 
    args = getOrder_args()
94 ashish 7636 
    args.read(iprot)
7637 
    iprot.readMessageEnd()
483 rajveer 7638 
    result = getOrder_result()
94 ashish 7639 
    try:
483 rajveer 7640 
      result.success = self._handler.getOrder(args.id)
94 ashish 7641 
    except TransactionServiceException, ex:
7642 
      result.ex = ex
483 rajveer 7643 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 7644 
    result.write(oprot)
7645 
    oprot.writeMessageEnd()
7646 
    oprot.trans.flush()
7647 
 
483 rajveer 7648 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
7649 
    args = getLineItemsForOrder_args()
94 ashish 7650 
    args.read(iprot)
7651 
    iprot.readMessageEnd()
483 rajveer 7652 
    result = getLineItemsForOrder_result()
94 ashish 7653 
    try:
483 rajveer 7654 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 7655 
    except TransactionServiceException, ex:
7656 
      result.ex = ex
483 rajveer 7657 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 7658 
    result.write(oprot)
7659 
    oprot.writeMessageEnd()
7660 
    oprot.trans.flush()
7661 
 
4999 phani.kuma 7662 
  def process_getOrderList(self, seqid, iprot, oprot):
7663 
    args = getOrderList_args()
7664 
    args.read(iprot)
7665 
    iprot.readMessageEnd()
7666 
    result = getOrderList_result()
7667 
    result.success = self._handler.getOrderList(args.order_ids)
7668 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
7669 
    result.write(oprot)
7670 
    oprot.writeMessageEnd()
7671 
    oprot.trans.flush()
7672 
 
5386 phani.kuma 7673 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
7674 
    args = getOrderListForVendor_args()
7675 
    args.read(iprot)
7676 
    iprot.readMessageEnd()
7677 
    result = getOrderListForVendor_result()
7678 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
7679 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
7680 
    result.write(oprot)
7681 
    oprot.writeMessageEnd()
7682 
    oprot.trans.flush()
7683 
 
1528 ankur.sing 7684 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
7685 
    args = getOrderForCustomer_args()
7686 
    args.read(iprot)
7687 
    iprot.readMessageEnd()
7688 
    result = getOrderForCustomer_result()
7689 
    try:
7690 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
7691 
    except TransactionServiceException, ex:
7692 
      result.ex = ex
7693 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
7694 
    result.write(oprot)
7695 
    oprot.writeMessageEnd()
7696 
    oprot.trans.flush()
7697 
 
3064 chandransh 7698 
  def process_getAlerts(self, seqid, iprot, oprot):
7699 
    args = getAlerts_args()
7700 
    args.read(iprot)
7701 
    iprot.readMessageEnd()
7702 
    result = getAlerts_result()
4444 rajveer 7703 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 7704 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
7705 
    result.write(oprot)
7706 
    oprot.writeMessageEnd()
7707 
    oprot.trans.flush()
7708 
 
4394 rajveer 7709 
  def process_addAlert(self, seqid, iprot, oprot):
7710 
    args = addAlert_args()
3064 chandransh 7711 
    args.read(iprot)
7712 
    iprot.readMessageEnd()
4394 rajveer 7713 
    result = addAlert_result()
4444 rajveer 7714 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 7715 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 7716 
    result.write(oprot)
7717 
    oprot.writeMessageEnd()
7718 
    oprot.trans.flush()
7719 
 
4444 rajveer 7720 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
7721 
    args = markAlertsAsSeen_args()
7722 
    args.read(iprot)
7723 
    iprot.readMessageEnd()
7724 
    result = markAlertsAsSeen_result()
7725 
    self._handler.markAlertsAsSeen(args.warehouseId)
7726 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
7727 
    result.write(oprot)
7728 
    oprot.writeMessageEnd()
7729 
    oprot.trans.flush()
7730 
 
3064 chandransh 7731 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
7732 
    args = getValidOrderCount_args()
7733 
    args.read(iprot)
7734 
    iprot.readMessageEnd()
7735 
    result = getValidOrderCount_result()
7736 
    result.success = self._handler.getValidOrderCount()
7737 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
7738 
    result.write(oprot)
7739 
    oprot.writeMessageEnd()
7740 
    oprot.trans.flush()
7741 
 
7742 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
7743 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
7744 
    args.read(iprot)
7745 
    iprot.readMessageEnd()
7746 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
7747 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
7748 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
7749 
    result.write(oprot)
7750 
    oprot.writeMessageEnd()
7751 
    oprot.trans.flush()
7752 
 
7753 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
7754 
    args = getValidOrdersAmountRange_args()
7755 
    args.read(iprot)
7756 
    iprot.readMessageEnd()
7757 
    result = getValidOrdersAmountRange_result()
7758 
    result.success = self._handler.getValidOrdersAmountRange()
7759 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
7760 
    result.write(oprot)
7761 
    oprot.writeMessageEnd()
7762 
    oprot.trans.flush()
7763 
 
7764 
  def process_getValidOrders(self, seqid, iprot, oprot):
7765 
    args = getValidOrders_args()
7766 
    args.read(iprot)
7767 
    iprot.readMessageEnd()
7768 
    result = getValidOrders_result()
5874 rajveer 7769 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 7770 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
7771 
    result.write(oprot)
7772 
    oprot.writeMessageEnd()
7773 
    oprot.trans.flush()
7774 
 
1220 chandransh 7775 
  def process_batchOrders(self, seqid, iprot, oprot):
7776 
    args = batchOrders_args()
7777 
    args.read(iprot)
7778 
    iprot.readMessageEnd()
7779 
    result = batchOrders_result()
7780 
    try:
7781 
      result.success = self._handler.batchOrders(args.warehouseId)
7782 
    except TransactionServiceException, ex:
7783 
      result.ex = ex
7784 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
7785 
    result.write(oprot)
7786 
    oprot.writeMessageEnd()
7787 
    oprot.trans.flush()
7788 
 
1208 chandransh 7789 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
7790 
    args = markOrderAsOutOfStock_args()
7791 
    args.read(iprot)
7792 
    iprot.readMessageEnd()
7793 
    result = markOrderAsOutOfStock_result()
7794 
    try:
7795 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
7796 
    except TransactionServiceException, ex:
7797 
      result.ex = ex
7798 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
7799 
    result.write(oprot)
7800 
    oprot.writeMessageEnd()
7801 
    oprot.trans.flush()
7802 
 
3064 chandransh 7803 
  def process_verifyOrder(self, seqid, iprot, oprot):
7804 
    args = verifyOrder_args()
759 chandransh 7805 
    args.read(iprot)
7806 
    iprot.readMessageEnd()
3064 chandransh 7807 
    result = verifyOrder_result()
759 chandransh 7808 
    try:
3064 chandransh 7809 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 7810 
    except TransactionServiceException, ex:
7811 
      result.ex = ex
3064 chandransh 7812 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 7813 
    result.write(oprot)
7814 
    oprot.writeMessageEnd()
7815 
    oprot.trans.flush()
7816 
 
3064 chandransh 7817 
  def process_acceptOrder(self, seqid, iprot, oprot):
7818 
    args = acceptOrder_args()
1113 chandransh 7819 
    args.read(iprot)
7820 
    iprot.readMessageEnd()
3064 chandransh 7821 
    result = acceptOrder_result()
1113 chandransh 7822 
    try:
3064 chandransh 7823 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7824 
    except TransactionServiceException, ex:
7825 
      result.ex = ex
3064 chandransh 7826 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7827 
    result.write(oprot)
7828 
    oprot.writeMessageEnd()
7829 
    oprot.trans.flush()
7830 
 
3064 chandransh 7831 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7832 
    args = addBillingDetails_args()
1135 chandransh 7833 
    args.read(iprot)
7834 
    iprot.readMessageEnd()
3064 chandransh 7835 
    result = addBillingDetails_result()
1135 chandransh 7836 
    try:
7190 amar.kumar 7837 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.serialNumber, args.itemNumber, args.freebieWarehouseId, args.billed_by, args.jacketNumber, args.billingType, args.fulfilmentWarehouseId, args.authorize)
1135 chandransh 7838 
    except TransactionServiceException, ex:
7839 
      result.ex = ex
3064 chandransh 7840 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7841 
    result.write(oprot)
7842 
    oprot.writeMessageEnd()
7843 
    oprot.trans.flush()
7844 
 
4579 rajveer 7845 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7846 
    args = addInvoiceNumber_args()
7847 
    args.read(iprot)
7848 
    iprot.readMessageEnd()
7849 
    result = addInvoiceNumber_result()
7850 
    try:
6756 amar.kumar 7851 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color, args.serialNumber, args.itemNumber)
4579 rajveer 7852 
    except TransactionServiceException, ex:
7853 
      result.ex = ex
7854 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7855 
    result.write(oprot)
7856 
    oprot.writeMessageEnd()
7857 
    oprot.trans.flush()
7858 
 
4410 rajveer 7859 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7860 
    args = markOrdersAsShippedFromWarehouse_args()
7861 
    args.read(iprot)
7862 
    iprot.readMessageEnd()
7863 
    result = markOrdersAsShippedFromWarehouse_result()
7864 
    try:
4789 rajveer 7865 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7866 
    except TransactionServiceException, ex:
7867 
      result.ex = ex
7868 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7869 
    result.write(oprot)
7870 
    oprot.writeMessageEnd()
7871 
    oprot.trans.flush()
7872 
 
5676 rajveer 7873 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7874 
    args = markOrdersAsReturnedFromStore_args()
7875 
    args.read(iprot)
7876 
    iprot.readMessageEnd()
7877 
    result = markOrdersAsReturnedFromStore_result()
7878 
    try:
5713 rajveer 7879 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7880 
    except TransactionServiceException, ex:
7881 
      result.ex = ex
7882 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7883 
    result.write(oprot)
7884 
    oprot.writeMessageEnd()
7885 
    oprot.trans.flush()
7886 
 
3064 chandransh 7887 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7888 
    args = markOrdersAsPickedUp_args()
304 ashish 7889 
    args.read(iprot)
7890 
    iprot.readMessageEnd()
3064 chandransh 7891 
    result = markOrdersAsPickedUp_result()
7892 
    try:
4910 phani.kuma 7893 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7894 
    except TransactionServiceException, ex:
7895 
      result.ex = ex
7896 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7897 
    result.write(oprot)
7898 
    oprot.writeMessageEnd()
7899 
    oprot.trans.flush()
94 ashish 7900 
 
4910 phani.kuma 7901 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7902 
    args = getOrdersNotPickedUp_args()
7903 
    args.read(iprot)
7904 
    iprot.readMessageEnd()
7905 
    result = getOrdersNotPickedUp_result()
7906 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7907 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7908 
    result.write(oprot)
7909 
    oprot.writeMessageEnd()
7910 
    oprot.trans.flush()
7911 
 
3064 chandransh 7912 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7913 
    args = markOrdersAsDelivered_args()
304 ashish 7914 
    args.read(iprot)
7915 
    iprot.readMessageEnd()
3064 chandransh 7916 
    result = markOrdersAsDelivered_result()
7917 
    try:
7918 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7919 
    except TransactionServiceException, ex:
7920 
      result.ex = ex
7921 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7922 
    result.write(oprot)
7923 
    oprot.writeMessageEnd()
7924 
    oprot.trans.flush()
7925 
 
4910 phani.kuma 7926 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7927 
    args = markAsRTOrders_args()
1596 ankur.sing 7928 
    args.read(iprot)
7929 
    iprot.readMessageEnd()
4910 phani.kuma 7930 
    result = markAsRTOrders_result()
3064 chandransh 7931 
    try:
4910 phani.kuma 7932 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7933 
    except TransactionServiceException, ex:
7934 
      result.ex = ex
4910 phani.kuma 7935 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7936 
    result.write(oprot)
7937 
    oprot.writeMessageEnd()
7938 
    oprot.trans.flush()
304 ashish 7939 
 
4910 phani.kuma 7940 
  def process_getRTOrders(self, seqid, iprot, oprot):
7941 
    args = getRTOrders_args()
7942 
    args.read(iprot)
7943 
    iprot.readMessageEnd()
7944 
    result = getRTOrders_result()
7945 
    result.success = self._handler.getRTOrders(args.providerId)
7946 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7947 
    result.write(oprot)
7948 
    oprot.writeMessageEnd()
7949 
    oprot.trans.flush()
7950 
 
3064 chandransh 7951 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7952 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7953 
    args.read(iprot)
7954 
    iprot.readMessageEnd()
3064 chandransh 7955 
    result = updateNonDeliveryReason_result()
7956 
    try:
4910 phani.kuma 7957 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7958 
    except TransactionServiceException, ex:
7959 
      result.ex = ex
7960 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7961 
    result.write(oprot)
7962 
    oprot.writeMessageEnd()
7963 
    oprot.trans.flush()
1596 ankur.sing 7964 
 
4910 phani.kuma 7965 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7966 
    args = getNonDeliveredOrdersbyCourier_args()
7967 
    args.read(iprot)
7968 
    iprot.readMessageEnd()
7969 
    result = getNonDeliveredOrdersbyCourier_result()
7970 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7971 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7972 
    result.write(oprot)
7973 
    oprot.writeMessageEnd()
7974 
    oprot.trans.flush()
7975 
 
7976 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7977 
    args = markOrdersAsLocalConnected_args()
7978 
    args.read(iprot)
7979 
    iprot.readMessageEnd()
7980 
    result = markOrdersAsLocalConnected_result()
7981 
    try:
7982 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7983 
    except TransactionServiceException, ex:
7984 
      result.ex = ex
7985 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7986 
    result.write(oprot)
7987 
    oprot.writeMessageEnd()
7988 
    oprot.trans.flush()
7989 
 
7990 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7991 
    args = getOrdersNotLocalConnected_args()
7992 
    args.read(iprot)
7993 
    iprot.readMessageEnd()
7994 
    result = getOrdersNotLocalConnected_result()
7995 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7996 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7997 
    result.write(oprot)
7998 
    oprot.writeMessageEnd()
7999 
    oprot.trans.flush()
8000 
 
8001 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
8002 
    args = markOrdersAsDestinationCityReached_args()
8003 
    args.read(iprot)
8004 
    iprot.readMessageEnd()
8005 
    result = markOrdersAsDestinationCityReached_result()
8006 
    try:
8007 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
8008 
    except TransactionServiceException, ex:
8009 
      result.ex = ex
8010 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
8011 
    result.write(oprot)
8012 
    oprot.writeMessageEnd()
8013 
    oprot.trans.flush()
8014 
 
8015 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
8016 
    args = markOrdersAsFirstDeliveryAttempted_args()
8017 
    args.read(iprot)
8018 
    iprot.readMessageEnd()
8019 
    result = markOrdersAsFirstDeliveryAttempted_result()
8020 
    try:
8021 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
8022 
    except TransactionServiceException, ex:
8023 
      result.ex = ex
8024 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
8025 
    result.write(oprot)
8026 
    oprot.writeMessageEnd()
8027 
    oprot.trans.flush()
8028 
 
3064 chandransh 8029 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
8030 
    args = getUndeliveredOrders_args()
1627 ankur.sing 8031 
    args.read(iprot)
8032 
    iprot.readMessageEnd()
3064 chandransh 8033 
    result = getUndeliveredOrders_result()
8034 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
8035 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 8036 
    result.write(oprot)
8037 
    oprot.writeMessageEnd()
8038 
    oprot.trans.flush()
8039 
 
4783 phani.kuma 8040 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
8041 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
8042 
    args.read(iprot)
8043 
    iprot.readMessageEnd()
8044 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
8045 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
8046 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
8047 
    result.write(oprot)
8048 
    oprot.writeMessageEnd()
8049 
    oprot.trans.flush()
8050 
 
2536 chandransh 8051 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
8052 
    args = toggleDOAFlag_args()
8053 
    args.read(iprot)
8054 
    iprot.readMessageEnd()
8055 
    result = toggleDOAFlag_result()
8056 
    try:
8057 
      result.success = self._handler.toggleDOAFlag(args.orderId)
8058 
    except TransactionServiceException, ex:
8059 
      result.ex = ex
8060 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
8061 
    result.write(oprot)
8062 
    oprot.writeMessageEnd()
8063 
    oprot.trans.flush()
1886 ankur.sing 8064 
 
4712 rajveer 8065 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
8066 
    args = markOrderAsDelivered_args()
8067 
    args.read(iprot)
8068 
    iprot.readMessageEnd()
8069 
    result = markOrderAsDelivered_result()
8070 
    try:
8071 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
8072 
    except TransactionServiceException, ex:
8073 
      result.ex = ex
8074 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
8075 
    result.write(oprot)
8076 
    oprot.writeMessageEnd()
8077 
    oprot.trans.flush()
8078 
 
5553 rajveer 8079 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
8080 
    args = markOrderAsReceivedAtStore_args()
8081 
    args.read(iprot)
8082 
    iprot.readMessageEnd()
8083 
    result = markOrderAsReceivedAtStore_result()
8084 
    try:
8085 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
8086 
    except TransactionServiceException, ex:
8087 
      result.ex = ex
8088 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
8089 
    result.write(oprot)
8090 
    oprot.writeMessageEnd()
8091 
    oprot.trans.flush()
8092 
 
4454 rajveer 8093 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
8094 
    args = markOrderDoaRequestReceived_args()
8095 
    args.read(iprot)
8096 
    iprot.readMessageEnd()
8097 
    result = markOrderDoaRequestReceived_result()
8098 
    try:
8099 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
8100 
    except TransactionServiceException, ex:
8101 
      result.ex = ex
8102 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
8103 
    result.write(oprot)
8104 
    oprot.writeMessageEnd()
8105 
    oprot.trans.flush()
8106 
 
8107 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
8108 
    args = markOrderDoaRequestAuthorized_args()
8109 
    args.read(iprot)
8110 
    iprot.readMessageEnd()
8111 
    result = markOrderDoaRequestAuthorized_result()
8112 
    try:
8113 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
8114 
    except TransactionServiceException, ex:
8115 
      result.ex = ex
8116 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
8117 
    result.write(oprot)
8118 
    oprot.writeMessageEnd()
8119 
    oprot.trans.flush()
8120 
 
4488 rajveer 8121 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
8122 
    args = markOrderReturnRequestReceived_args()
8123 
    args.read(iprot)
8124 
    iprot.readMessageEnd()
8125 
    result = markOrderReturnRequestReceived_result()
8126 
    try:
8127 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
8128 
    except TransactionServiceException, ex:
8129 
      result.ex = ex
8130 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
8131 
    result.write(oprot)
8132 
    oprot.writeMessageEnd()
8133 
    oprot.trans.flush()
8134 
 
8135 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
8136 
    args = markOrderReturnRequestAuthorized_args()
8137 
    args.read(iprot)
8138 
    iprot.readMessageEnd()
8139 
    result = markOrderReturnRequestAuthorized_result()
8140 
    try:
8141 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
8142 
    except TransactionServiceException, ex:
8143 
      result.ex = ex
8144 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
8145 
    result.write(oprot)
8146 
    oprot.writeMessageEnd()
8147 
    oprot.trans.flush()
8148 
 
2536 chandransh 8149 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
8150 
    args = requestPickupNumber_args()
8151 
    args.read(iprot)
8152 
    iprot.readMessageEnd()
8153 
    result = requestPickupNumber_result()
8154 
    try:
4579 rajveer 8155 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 8156 
    except TransactionServiceException, ex:
8157 
      result.ex = ex
8158 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
8159 
    result.write(oprot)
8160 
    oprot.writeMessageEnd()
8161 
    oprot.trans.flush()
8162 
 
8163 
  def process_authorizePickup(self, seqid, iprot, oprot):
8164 
    args = authorizePickup_args()
8165 
    args.read(iprot)
8166 
    iprot.readMessageEnd()
8167 
    result = authorizePickup_result()
8168 
    try:
4602 rajveer 8169 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 8170 
    except TransactionServiceException, ex:
8171 
      result.ex = ex
8172 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
8173 
    result.write(oprot)
8174 
    oprot.writeMessageEnd()
8175 
    oprot.trans.flush()
8176 
 
2764 chandransh 8177 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
8178 
    args = markDoasAsPickedUp_args()
8179 
    args.read(iprot)
8180 
    iprot.readMessageEnd()
8181 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 8182 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 8183 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
8184 
    result.write(oprot)
8185 
    oprot.writeMessageEnd()
8186 
    oprot.trans.flush()
8187 
 
4910 phani.kuma 8188 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
8189 
    args = getDoasNotPickedUp_args()
8190 
    args.read(iprot)
8191 
    iprot.readMessageEnd()
8192 
    result = getDoasNotPickedUp_result()
8193 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
8194 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
8195 
    result.write(oprot)
8196 
    oprot.writeMessageEnd()
8197 
    oprot.trans.flush()
8198 
 
4741 phani.kuma 8199 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
8200 
    args = markReturnOrdersAsPickedUp_args()
8201 
    args.read(iprot)
8202 
    iprot.readMessageEnd()
8203 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 8204 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 8205 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
8206 
    result.write(oprot)
8207 
    oprot.writeMessageEnd()
8208 
    oprot.trans.flush()
8209 
 
4910 phani.kuma 8210 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
8211 
    args = getReturnOrdersNotPickedUp_args()
8212 
    args.read(iprot)
8213 
    iprot.readMessageEnd()
8214 
    result = getReturnOrdersNotPickedUp_result()
8215 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
8216 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
8217 
    result.write(oprot)
8218 
    oprot.writeMessageEnd()
8219 
    oprot.trans.flush()
8220 
 
2616 chandransh 8221 
  def process_receiveReturn(self, seqid, iprot, oprot):
8222 
    args = receiveReturn_args()
2591 chandransh 8223 
    args.read(iprot)
8224 
    iprot.readMessageEnd()
2616 chandransh 8225 
    result = receiveReturn_result()
2591 chandransh 8226 
    try:
4479 rajveer 8227 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 8228 
    except TransactionServiceException, ex:
8229 
      result.ex = ex
2616 chandransh 8230 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 8231 
    result.write(oprot)
8232 
    oprot.writeMessageEnd()
8233 
    oprot.trans.flush()
2536 chandransh 8234 
 
2591 chandransh 8235 
  def process_validateDoa(self, seqid, iprot, oprot):
8236 
    args = validateDoa_args()
8237 
    args.read(iprot)
8238 
    iprot.readMessageEnd()
8239 
    result = validateDoa_result()
8240 
    try:
8241 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
8242 
    except TransactionServiceException, ex:
8243 
      result.ex = ex
8244 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
8245 
    result.write(oprot)
8246 
    oprot.writeMessageEnd()
8247 
    oprot.trans.flush()
8248 
 
4495 rajveer 8249 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
8250 
    args = validateReturnProduct_args()
8251 
    args.read(iprot)
8252 
    iprot.readMessageEnd()
8253 
    result = validateReturnProduct_result()
8254 
    try:
8255 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
8256 
    except TransactionServiceException, ex:
8257 
      result.ex = ex
8258 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
8259 
    result.write(oprot)
8260 
    oprot.writeMessageEnd()
8261 
    oprot.trans.flush()
8262 
 
2616 chandransh 8263 
  def process_reshipOrder(self, seqid, iprot, oprot):
8264 
    args = reshipOrder_args()
8265 
    args.read(iprot)
8266 
    iprot.readMessageEnd()
8267 
    result = reshipOrder_result()
8268 
    try:
8269 
      result.success = self._handler.reshipOrder(args.orderId)
8270 
    except TransactionServiceException, ex:
8271 
      result.ex = ex
8272 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
8273 
    result.write(oprot)
8274 
    oprot.writeMessageEnd()
8275 
    oprot.trans.flush()
2591 chandransh 8276 
 
2616 chandransh 8277 
  def process_refundOrder(self, seqid, iprot, oprot):
8278 
    args = refundOrder_args()
8279 
    args.read(iprot)
8280 
    iprot.readMessageEnd()
8281 
    result = refundOrder_result()
8282 
    try:
3226 chandransh 8283 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 8284 
    except TransactionServiceException, ex:
8285 
      result.ex = ex
8286 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
8287 
    result.write(oprot)
8288 
    oprot.writeMessageEnd()
8289 
    oprot.trans.flush()
8290 
 
2690 chandransh 8291 
  def process_getReturnOrders(self, seqid, iprot, oprot):
8292 
    args = getReturnOrders_args()
8293 
    args.read(iprot)
8294 
    iprot.readMessageEnd()
8295 
    result = getReturnOrders_result()
8296 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
8297 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
8298 
    result.write(oprot)
8299 
    oprot.writeMessageEnd()
8300 
    oprot.trans.flush()
2616 chandransh 8301 
 
5481 phani.kuma 8302 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
8303 
    args = getAllReturnOrders_args()
8304 
    args.read(iprot)
8305 
    iprot.readMessageEnd()
8306 
    result = getAllReturnOrders_result()
8307 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
8308 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
8309 
    result.write(oprot)
8310 
    oprot.writeMessageEnd()
8311 
    oprot.trans.flush()
8312 
 
2700 chandransh 8313 
  def process_getReturnOrder(self, seqid, iprot, oprot):
8314 
    args = getReturnOrder_args()
8315 
    args.read(iprot)
8316 
    iprot.readMessageEnd()
8317 
    result = getReturnOrder_result()
8318 
    try:
8319 
      result.success = self._handler.getReturnOrder(args.id)
8320 
    except TransactionServiceException, ex:
8321 
      result.ex = ex
8322 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
8323 
    result.write(oprot)
8324 
    oprot.writeMessageEnd()
8325 
    oprot.trans.flush()
8326 
 
2690 chandransh 8327 
  def process_processReturn(self, seqid, iprot, oprot):
8328 
    args = processReturn_args()
8329 
    args.read(iprot)
8330 
    iprot.readMessageEnd()
8331 
    result = processReturn_result()
8332 
    try:
8333 
      self._handler.processReturn(args.returnOrderId)
8334 
    except TransactionServiceException, ex:
8335 
      result.ex = ex
8336 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
8337 
    result.write(oprot)
8338 
    oprot.writeMessageEnd()
8339 
    oprot.trans.flush()
8340 
 
3451 chandransh 8341 
  def process_updateWeight(self, seqid, iprot, oprot):
8342 
    args = updateWeight_args()
8343 
    args.read(iprot)
8344 
    iprot.readMessageEnd()
8345 
    result = updateWeight_result()
8346 
    try:
8347 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
8348 
    except TransactionServiceException, ex:
8349 
      result.ex = ex
8350 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
8351 
    result.write(oprot)
8352 
    oprot.writeMessageEnd()
8353 
    oprot.trans.flush()
2819 chandransh 8354 
 
3469 chandransh 8355 
  def process_changeItem(self, seqid, iprot, oprot):
8356 
    args = changeItem_args()
8357 
    args.read(iprot)
8358 
    iprot.readMessageEnd()
8359 
    result = changeItem_result()
8360 
    try:
8361 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
8362 
    except TransactionServiceException, ex:
8363 
      result.ex = ex
8364 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
8365 
    result.write(oprot)
8366 
    oprot.writeMessageEnd()
8367 
    oprot.trans.flush()
3451 chandransh 8368 
 
3469 chandransh 8369 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
8370 
    args = shiftToWarehouse_args()
8371 
    args.read(iprot)
8372 
    iprot.readMessageEnd()
8373 
    result = shiftToWarehouse_result()
8374 
    try:
8375 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
8376 
    except TransactionServiceException, ex:
8377 
      result.ex = ex
8378 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
8379 
    result.write(oprot)
8380 
    oprot.writeMessageEnd()
8381 
    oprot.trans.flush()
8382 
 
3553 chandransh 8383 
  def process_addDelayReason(self, seqid, iprot, oprot):
8384 
    args = addDelayReason_args()
8385 
    args.read(iprot)
8386 
    iprot.readMessageEnd()
8387 
    result = addDelayReason_result()
8388 
    try:
4647 rajveer 8389 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 8390 
    except TransactionServiceException, ex:
8391 
      result.ex = ex
8392 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
8393 
    result.write(oprot)
8394 
    oprot.writeMessageEnd()
8395 
    oprot.trans.flush()
3469 chandransh 8396 
 
3956 chandransh 8397 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
8398 
    args = reconcileCodCollection_args()
8399 
    args.read(iprot)
8400 
    iprot.readMessageEnd()
8401 
    result = reconcileCodCollection_result()
8402 
    try:
8403 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
8404 
    except TransactionServiceException, ex:
8405 
      result.ex = ex
8406 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
8407 
    result.write(oprot)
8408 
    oprot.writeMessageEnd()
8409 
    oprot.trans.flush()
3553 chandransh 8410 
 
4008 mandeep.dh 8411 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
8412 
    args = getTransactionsRequiringExtraProcessing_args()
8413 
    args.read(iprot)
8414 
    iprot.readMessageEnd()
8415 
    result = getTransactionsRequiringExtraProcessing_result()
8416 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
8417 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
8418 
    result.write(oprot)
8419 
    oprot.writeMessageEnd()
8420 
    oprot.trans.flush()
3956 chandransh 8421 
 
4008 mandeep.dh 8422 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
8423 
    args = markTransactionAsProcessed_args()
8424 
    args.read(iprot)
8425 
    iprot.readMessageEnd()
8426 
    result = markTransactionAsProcessed_result()
8427 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
8428 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
8429 
    result.write(oprot)
8430 
    oprot.writeMessageEnd()
8431 
    oprot.trans.flush()
8432 
 
4018 chandransh 8433 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
8434 
    args = getItemWiseRiskyOrdersCount_args()
8435 
    args.read(iprot)
8436 
    iprot.readMessageEnd()
8437 
    result = getItemWiseRiskyOrdersCount_result()
8438 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
8439 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
8440 
    result.write(oprot)
8441 
    oprot.writeMessageEnd()
8442 
    oprot.trans.flush()
4008 mandeep.dh 8443 
 
4295 varun.gupt 8444 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
8445 
    args = getOrdersForItemIds_args()
8446 
    args.read(iprot)
8447 
    iprot.readMessageEnd()
8448 
    result = getOrdersForItemIds_result()
8449 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
8450 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
8451 
    result.write(oprot)
8452 
    oprot.writeMessageEnd()
8453 
    oprot.trans.flush()
8454 
 
4247 rajveer 8455 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
8456 
    args = markOrderCancellationRequestReceived_args()
8457 
    args.read(iprot)
8458 
    iprot.readMessageEnd()
8459 
    result = markOrderCancellationRequestReceived_result()
8460 
    try:
8461 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
8462 
    except TransactionServiceException, ex:
8463 
      result.ex = ex
8464 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
8465 
    result.write(oprot)
8466 
    oprot.writeMessageEnd()
8467 
    oprot.trans.flush()
4018 chandransh 8468 
 
4247 rajveer 8469 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
8470 
    args = markOrderCancellationRequestConfirmed_args()
8471 
    args.read(iprot)
8472 
    iprot.readMessageEnd()
8473 
    result = markOrderCancellationRequestConfirmed_result()
8474 
    try:
8475 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
8476 
    except TransactionServiceException, ex:
8477 
      result.ex = ex
8478 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
8479 
    result.write(oprot)
8480 
    oprot.writeMessageEnd()
8481 
    oprot.trans.flush()
8482 
 
8483 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
8484 
    args = markOrderCancellationRequestDenied_args()
8485 
    args.read(iprot)
8486 
    iprot.readMessageEnd()
8487 
    result = markOrderCancellationRequestDenied_result()
8488 
    try:
8489 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
8490 
    except TransactionServiceException, ex:
8491 
      result.ex = ex
8492 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
8493 
    result.write(oprot)
8494 
    oprot.writeMessageEnd()
8495 
    oprot.trans.flush()
8496 
 
4258 rajveer 8497 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
8498 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 8499 
    args.read(iprot)
8500 
    iprot.readMessageEnd()
4258 rajveer 8501 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 8502 
    try:
4258 rajveer 8503 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 8504 
    except TransactionServiceException, ex:
8505 
      result.ex = ex
4258 rajveer 8506 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 8507 
    result.write(oprot)
8508 
    oprot.writeMessageEnd()
8509 
    oprot.trans.flush()
8510 
 
4259 anupam.sin 8511 
  def process_refundTransaction(self, seqid, iprot, oprot):
8512 
    args = refundTransaction_args()
8513 
    args.read(iprot)
8514 
    iprot.readMessageEnd()
8515 
    result = refundTransaction_result()
8516 
    try:
8517 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
8518 
    except TransactionServiceException, ex:
8519 
      result.ex = ex
8520 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
8521 
    result.write(oprot)
8522 
    oprot.writeMessageEnd()
8523 
    oprot.trans.flush()
4247 rajveer 8524 
 
4324 mandeep.dh 8525 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
8526 
    args = updateShipmentAddress_args()
8527 
    args.read(iprot)
8528 
    iprot.readMessageEnd()
8529 
    result = updateShipmentAddress_result()
8530 
    try:
8531 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
8532 
    except TransactionServiceException, ex:
8533 
      result.ex = ex
8534 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
8535 
    result.write(oprot)
8536 
    oprot.writeMessageEnd()
8537 
    oprot.trans.flush()
8538 
 
4285 rajveer 8539 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
8540 
    args = acceptOrdersForItemId_args()
8541 
    args.read(iprot)
8542 
    iprot.readMessageEnd()
8543 
    result = acceptOrdersForItemId_result()
8544 
    try:
8545 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
8546 
    except TransactionServiceException, ex:
8547 
      result.ex = ex
8548 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
8549 
    result.write(oprot)
8550 
    oprot.writeMessageEnd()
8551 
    oprot.trans.flush()
4259 anupam.sin 8552 
 
4303 rajveer 8553 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
8554 
    args = markOrdersAsPORaised_args()
8555 
    args.read(iprot)
8556 
    iprot.readMessageEnd()
8557 
    result = markOrdersAsPORaised_result()
8558 
    try:
4369 rajveer 8559 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8560 
    except TransactionServiceException, ex:
8561 
      result.ex = ex
8562 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
8563 
    result.write(oprot)
8564 
    oprot.writeMessageEnd()
8565 
    oprot.trans.flush()
4285 rajveer 8566 
 
4303 rajveer 8567 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
8568 
    args = markOrdersAsReversalInitiated_args()
8569 
    args.read(iprot)
8570 
    iprot.readMessageEnd()
8571 
    result = markOrdersAsReversalInitiated_result()
8572 
    try:
4369 rajveer 8573 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8574 
    except TransactionServiceException, ex:
8575 
      result.ex = ex
8576 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
8577 
    result.write(oprot)
8578 
    oprot.writeMessageEnd()
8579 
    oprot.trans.flush()
8580 
 
8581 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
8582 
    args = markOrdersAsNotAvailabke_args()
8583 
    args.read(iprot)
8584 
    iprot.readMessageEnd()
8585 
    result = markOrdersAsNotAvailabke_result()
8586 
    try:
4369 rajveer 8587 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8588 
    except TransactionServiceException, ex:
8589 
      result.ex = ex
8590 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
8591 
    result.write(oprot)
8592 
    oprot.writeMessageEnd()
8593 
    oprot.trans.flush()
8594 
 
4369 rajveer 8595 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
8596 
    args = markOrdersAsTimeout_args()
8597 
    args.read(iprot)
8598 
    iprot.readMessageEnd()
8599 
    result = markOrdersAsTimeout_result()
8600 
    try:
8601 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
8602 
    except TransactionServiceException, ex:
8603 
      result.ex = ex
8604 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
8605 
    result.write(oprot)
8606 
    oprot.writeMessageEnd()
8607 
    oprot.trans.flush()
4303 rajveer 8608 
 
4662 rajveer 8609 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
8610 
    args = markOrderAsLostInTransit_args()
8611 
    args.read(iprot)
8612 
    iprot.readMessageEnd()
8613 
    result = markOrderAsLostInTransit_result()
8614 
    try:
8615 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
8616 
    except TransactionServiceException, ex:
8617 
      result.ex = ex
8618 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
8619 
    result.write(oprot)
8620 
    oprot.writeMessageEnd()
8621 
    oprot.trans.flush()
8622 
 
4386 anupam.sin 8623 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
8624 
    args = getOrderForAwb_args()
8625 
    args.read(iprot)
8626 
    iprot.readMessageEnd()
8627 
    result = getOrderForAwb_result()
8628 
    try:
8629 
      result.success = self._handler.getOrderForAwb(args.awb)
8630 
    except TransactionServiceException, ex:
8631 
      result.ex = ex
8632 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
8633 
    result.write(oprot)
8634 
    oprot.writeMessageEnd()
8635 
    oprot.trans.flush()
4369 rajveer 8636 
 
4506 phani.kuma 8637 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
8638 
    args = getOrdersForProviderForStatus_args()
8639 
    args.read(iprot)
8640 
    iprot.readMessageEnd()
8641 
    result = getOrdersForProviderForStatus_result()
8642 
    try:
4910 phani.kuma 8643 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 8644 
    except TransactionServiceException, ex:
8645 
      result.ex = ex
8646 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
8647 
    result.write(oprot)
8648 
    oprot.writeMessageEnd()
8649 
    oprot.trans.flush()
4386 anupam.sin 8650 
 
4600 varun.gupt 8651 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
8652 
    args = getBilledOrdersForVendor_args()
8653 
    args.read(iprot)
8654 
    iprot.readMessageEnd()
8655 
    result = getBilledOrdersForVendor_result()
8656 
    try:
8657 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
8658 
    except TransactionServiceException, ex:
8659 
      result.ex = ex
8660 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
8661 
    result.write(oprot)
8662 
    oprot.writeMessageEnd()
8663 
    oprot.trans.flush()
4506 phani.kuma 8664 
 
4607 rajveer 8665 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
8666 
    args = getSlippedSippingDateOrders_args()
8667 
    args.read(iprot)
8668 
    iprot.readMessageEnd()
8669 
    result = getSlippedSippingDateOrders_result()
8670 
    try:
8671 
      result.success = self._handler.getSlippedSippingDateOrders()
8672 
    except TransactionServiceException, ex:
8673 
      result.ex = ex
8674 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
8675 
    result.write(oprot)
8676 
    oprot.writeMessageEnd()
8677 
    oprot.trans.flush()
8678 
 
4709 rajveer 8679 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
8680 
    args = getCancelledOrders_args()
8681 
    args.read(iprot)
8682 
    iprot.readMessageEnd()
8683 
    result = getCancelledOrders_result()
8684 
    try:
8685 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
8686 
    except TransactionServiceException, ex:
8687 
      result.ex = ex
8688 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
8689 
    result.write(oprot)
8690 
    oprot.writeMessageEnd()
8691 
    oprot.trans.flush()
8692 
 
4600 varun.gupt 8693 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
8694 
    args = saveBluedartSettlements_args()
8695 
    args.read(iprot)
8696 
    iprot.readMessageEnd()
8697 
    result = saveBluedartSettlements_result()
8698 
    try:
8699 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
8700 
    except TransactionServiceException, ex:
8701 
      result.ex = ex
8702 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
8703 
    result.write(oprot)
8704 
    oprot.writeMessageEnd()
8705 
    oprot.trans.flush()
8706 
 
8707 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
8708 
    args = savePaymentSettlements_args()
8709 
    args.read(iprot)
8710 
    iprot.readMessageEnd()
8711 
    result = savePaymentSettlements_result()
8712 
    try:
4905 varun.gupt 8713 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 8714 
    except TransactionServiceException, ex:
8715 
      result.ex = ex
8716 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
8717 
    result.write(oprot)
8718 
    oprot.writeMessageEnd()
8719 
    oprot.trans.flush()
8720 
 
8721 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
8722 
    args = saveEBSSettlementSummary_args()
8723 
    args.read(iprot)
8724 
    iprot.readMessageEnd()
8725 
    result = saveEBSSettlementSummary_result()
8726 
    try:
8727 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
8728 
    except TransactionServiceException, ex:
8729 
      result.ex = ex
8730 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
8731 
    result.write(oprot)
8732 
    oprot.writeMessageEnd()
8733 
    oprot.trans.flush()
8734 
 
5386 phani.kuma 8735 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
8736 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 8737 
    args.read(iprot)
8738 
    iprot.readMessageEnd()
5386 phani.kuma 8739 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 8740 
    try:
5386 phani.kuma 8741 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 8742 
    except TransactionServiceException, ex:
8743 
      result.ex = ex
5386 phani.kuma 8744 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 8745 
    result.write(oprot)
8746 
    oprot.writeMessageEnd()
8747 
    oprot.trans.flush()
8748 
 
5386 phani.kuma 8749 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
8750 
    args = getSettlementForCod_args()
8751 
    args.read(iprot)
8752 
    iprot.readMessageEnd()
8753 
    result = getSettlementForCod_result()
8754 
    try:
8755 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
8756 
    except TransactionServiceException, ex:
8757 
      result.ex = ex
8758 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
8759 
    result.write(oprot)
8760 
    oprot.writeMessageEnd()
8761 
    oprot.trans.flush()
8762 
 
4600 varun.gupt 8763 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
8764 
    args = getEBSSettlementSummaries_args()
8765 
    args.read(iprot)
8766 
    iprot.readMessageEnd()
8767 
    result = getEBSSettlementSummaries_result()
8768 
    try:
8769 
      result.success = self._handler.getEBSSettlementSummaries()
8770 
    except TransactionServiceException, ex:
8771 
      result.ex = ex
8772 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
8773 
    result.write(oprot)
8774 
    oprot.writeMessageEnd()
8775 
    oprot.trans.flush()
8776 
 
8777 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
8778 
    args = markEBSSettlementUploaded_args()
8779 
    args.read(iprot)
8780 
    iprot.readMessageEnd()
8781 
    result = markEBSSettlementUploaded_result()
8782 
    try:
8783 
      self._handler.markEBSSettlementUploaded(args.settlementId)
8784 
    except TransactionServiceException, ex:
8785 
      result.ex = ex
8786 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
8787 
    result.write(oprot)
8788 
    oprot.writeMessageEnd()
8789 
    oprot.trans.flush()
8790 
 
8791 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
8792 
    args = getEBSSettlementDate_args()
8793 
    args.read(iprot)
8794 
    iprot.readMessageEnd()
8795 
    result = getEBSSettlementDate_result()
8796 
    try:
8797 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
8798 
    except TransactionServiceException, ex:
8799 
      result.ex = ex
8800 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
8801 
    result.write(oprot)
8802 
    oprot.writeMessageEnd()
8803 
    oprot.trans.flush()
8804 
 
4715 varun.gupt 8805 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
8806 
    args = getSettlementsByDate_args()
8807 
    args.read(iprot)
8808 
    iprot.readMessageEnd()
8809 
    result = getSettlementsByDate_result()
8810 
    try:
8811 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
8812 
    except TransactionServiceException, ex:
8813 
      result.ex = ex
8814 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
8815 
    result.write(oprot)
8816 
    oprot.writeMessageEnd()
8817 
    oprot.trans.flush()
4600 varun.gupt 8818 
 
4715 varun.gupt 8819 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
8820 
    args = getReshippedOrderIds_args()
8821 
    args.read(iprot)
8822 
    iprot.readMessageEnd()
8823 
    result = getReshippedOrderIds_result()
8824 
    try:
8825 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8826 
    except TransactionServiceException, ex:
8827 
      result.ex = ex
8828 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8829 
    result.write(oprot)
8830 
    oprot.writeMessageEnd()
8831 
    oprot.trans.flush()
8832 
 
5481 phani.kuma 8833 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8834 
    args = getBilledOrders_args()
4875 varun.gupt 8835 
    args.read(iprot)
8836 
    iprot.readMessageEnd()
5481 phani.kuma 8837 
    result = getBilledOrders_result()
4875 varun.gupt 8838 
    try:
5481 phani.kuma 8839 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8840 
    except TransactionServiceException, ex:
8841 
      result.ex = ex
5481 phani.kuma 8842 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8843 
    result.write(oprot)
8844 
    oprot.writeMessageEnd()
8845 
    oprot.trans.flush()
4757 mandeep.dh 8846 
 
5031 varun.gupt 8847 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8848 
    args = getStatusDistributionOfOrders_args()
8849 
    args.read(iprot)
8850 
    iprot.readMessageEnd()
8851 
    result = getStatusDistributionOfOrders_result()
8852 
    try:
8853 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8854 
    except TransactionServiceException, ex:
8855 
      result.ex = ex
8856 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8857 
    result.write(oprot)
8858 
    oprot.writeMessageEnd()
8859 
    oprot.trans.flush()
4875 varun.gupt 8860 
 
5067 varun.gupt 8861 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8862 
    args = getOrderIdsForStatus_args()
8863 
    args.read(iprot)
8864 
    iprot.readMessageEnd()
8865 
    result = getOrderIdsForStatus_result()
8866 
    try:
8867 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8868 
    except TransactionServiceException, ex:
8869 
      result.ex = ex
8870 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8871 
    result.write(oprot)
8872 
    oprot.writeMessageEnd()
8873 
    oprot.trans.flush()
5031 varun.gupt 8874 
 
5348 anupam.sin 8875 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8876 
    args = updateCODAgent_args()
8877 
    args.read(iprot)
8878 
    iprot.readMessageEnd()
8879 
    result = updateCODAgent_result()
8880 
    try:
8881 
      self._handler.updateCODAgent(args.agent, args.orderId)
8882 
    except TransactionServiceException, ex:
8883 
      result.ex = ex
8884 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8885 
    result.write(oprot)
8886 
    oprot.writeMessageEnd()
8887 
    oprot.trans.flush()
8888 
 
5099 varun.gupt 8889 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8890 
    args = updateOrderAsPaidToVendor_args()
8891 
    args.read(iprot)
8892 
    iprot.readMessageEnd()
8893 
    result = updateOrderAsPaidToVendor_result()
8894 
    try:
8895 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8896 
    except TransactionServiceException, ex:
8897 
      result.ex = ex
8898 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8899 
    result.write(oprot)
8900 
    oprot.writeMessageEnd()
8901 
    oprot.trans.flush()
5067 varun.gupt 8902 
 
5386 phani.kuma 8903 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8904 
    args = updateOrderOnlyAsPaidToVendor_args()
8905 
    args.read(iprot)
8906 
    iprot.readMessageEnd()
8907 
    result = updateOrderOnlyAsPaidToVendor_result()
8908 
    try:
8909 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8910 
    except TransactionServiceException, ex:
8911 
      result.ex = ex
8912 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8913 
    result.write(oprot)
8914 
    oprot.writeMessageEnd()
8915 
    oprot.trans.flush()
8916 
 
5208 varun.gupt 8917 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8918 
    args = getRefundedOrdersMarkedPaid_args()
8919 
    args.read(iprot)
8920 
    iprot.readMessageEnd()
8921 
    result = getRefundedOrdersMarkedPaid_result()
8922 
    try:
8923 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8924 
    except TransactionServiceException, ex:
8925 
      result.ex = ex
8926 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8927 
    result.write(oprot)
8928 
    oprot.writeMessageEnd()
8929 
    oprot.trans.flush()
5099 varun.gupt 8930 
 
5447 anupam.sin 8931 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8932 
    args = getAllVerificationAgents_args()
8933 
    args.read(iprot)
8934 
    iprot.readMessageEnd()
8935 
    result = getAllVerificationAgents_result()
8936 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8937 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8938 
    result.write(oprot)
8939 
    oprot.writeMessageEnd()
8940 
    oprot.trans.flush()
5208 varun.gupt 8941 
 
5527 anupam.sin 8942 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8943 
    args = getAllAttributesForOrderId_args()
8944 
    args.read(iprot)
8945 
    iprot.readMessageEnd()
8946 
    result = getAllAttributesForOrderId_result()
8947 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8948 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8949 
    result.write(oprot)
8950 
    oprot.writeMessageEnd()
8951 
    oprot.trans.flush()
5447 anupam.sin 8952 
 
5676 rajveer 8953 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8954 
    args = setOrderAttributes_args()
8955 
    args.read(iprot)
8956 
    iprot.readMessageEnd()
8957 
    result = setOrderAttributes_result()
8958 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8959 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8960 
    result.write(oprot)
8961 
    oprot.writeMessageEnd()
8962 
    oprot.trans.flush()
8963 
 
5527 anupam.sin 8964 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8965 
    args = setOrderAttributeForTransaction_args()
8966 
    args.read(iprot)
8967 
    iprot.readMessageEnd()
8968 
    result = setOrderAttributeForTransaction_result()
8969 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8970 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8971 
    result.write(oprot)
8972 
    oprot.writeMessageEnd()
8973 
    oprot.trans.flush()
8974 
 
5553 rajveer 8975 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8976 
    args = getReceivePendingOrders_args()
8977 
    args.read(iprot)
8978 
    iprot.readMessageEnd()
8979 
    result = getReceivePendingOrders_result()
8980 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8981 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8982 
    result.write(oprot)
8983 
    oprot.writeMessageEnd()
8984 
    oprot.trans.flush()
5527 anupam.sin 8985 
 
5553 rajveer 8986 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8987 
    args = getReceivedAtStoreOrders_args()
8988 
    args.read(iprot)
8989 
    iprot.readMessageEnd()
8990 
    result = getReceivedAtStoreOrders_result()
8991 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8992 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8993 
    result.write(oprot)
8994 
    oprot.writeMessageEnd()
8995 
    oprot.trans.flush()
8996 
 
5713 rajveer 8997 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8998 
    args = getOrdersCollectionAtStore_args()
8999 
    args.read(iprot)
9000 
    iprot.readMessageEnd()
9001 
    result = getOrdersCollectionAtStore_result()
9002 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
9003 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
9004 
    result.write(oprot)
9005 
    oprot.writeMessageEnd()
9006 
    oprot.trans.flush()
9007 
 
5833 rajveer 9008 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
9009 
    args = getOrderAttributeValue_args()
9010 
    args.read(iprot)
9011 
    iprot.readMessageEnd()
9012 
    result = getOrderAttributeValue_result()
9013 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
9014 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
9015 
    result.write(oprot)
9016 
    oprot.writeMessageEnd()
9017 
    oprot.trans.flush()
9018 
 
6019 rajveer 9019 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
9020 
    args = changeJacketNumber_args()
9021 
    args.read(iprot)
9022 
    iprot.readMessageEnd()
9023 
    result = changeJacketNumber_result()
9024 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
9025 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
9026 
    result.write(oprot)
9027 
    oprot.writeMessageEnd()
9028 
    oprot.trans.flush()
9029 
 
9030 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
9031 
    args = markOrderAsRtoInTransit_args()
9032 
    args.read(iprot)
9033 
    iprot.readMessageEnd()
9034 
    result = markOrderAsRtoInTransit_result()
9035 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
9036 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
9037 
    result.write(oprot)
9038 
    oprot.writeMessageEnd()
9039 
    oprot.trans.flush()
9040 
 
5593 mandeep.dh 9041 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
9042 
    args = acceptOrderForItem_args()
9043 
    args.read(iprot)
9044 
    iprot.readMessageEnd()
9045 
    result = acceptOrderForItem_result()
9046 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
9047 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
9048 
    result.write(oprot)
9049 
    oprot.writeMessageEnd()
9050 
    oprot.trans.flush()
5553 rajveer 9051 
 
6000 mandeep.dh 9052 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
9053 
    args = createRechargeOrder_args()
9054 
    args.read(iprot)
9055 
    iprot.readMessageEnd()
9056 
    result = createRechargeOrder_result()
9057 
    try:
9058 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
9059 
    except TransactionServiceException, ex:
9060 
      result.ex = ex
9061 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
9062 
    result.write(oprot)
9063 
    oprot.writeMessageEnd()
9064 
    oprot.trans.flush()
5593 mandeep.dh 9065 
 
6031 rajveer 9066 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
9067 
    args = getRechargeOrder_args()
9068 
    args.read(iprot)
9069 
    iprot.readMessageEnd()
9070 
    result = getRechargeOrder_result()
9071 
    try:
9072 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
9073 
    except TransactionServiceException, ex:
9074 
      result.ex = ex
9075 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
9076 
    result.write(oprot)
9077 
    oprot.writeMessageEnd()
9078 
    oprot.trans.flush()
9079 
 
9080 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
9081 
    args = getRechargeOrders_args()
9082 
    args.read(iprot)
9083 
    iprot.readMessageEnd()
9084 
    result = getRechargeOrders_result()
9085 
    result.success = self._handler.getRechargeOrders(args.userId)
9086 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
9087 
    result.write(oprot)
9088 
    oprot.writeMessageEnd()
9089 
    oprot.trans.flush()
9090 
 
6000 mandeep.dh 9091 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
9092 
    args = updateRechargeOrderStatus_args()
9093 
    args.read(iprot)
9094 
    iprot.readMessageEnd()
9095 
    result = updateRechargeOrderStatus_result()
9096 
    try:
6031 rajveer 9097 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 9098 
    except TransactionServiceException, ex:
9099 
      result.ex = ex
9100 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
9101 
    result.write(oprot)
9102 
    oprot.writeMessageEnd()
9103 
    oprot.trans.flush()
9104 
 
9105 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
9106 
    args = activateRechargeTxn_args()
9107 
    args.read(iprot)
9108 
    iprot.readMessageEnd()
9109 
    result = activateRechargeTxn_result()
9110 
    try:
6031 rajveer 9111 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 9112 
    except TransactionServiceException, ex:
9113 
      result.ex = ex
9114 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
9115 
    result.write(oprot)
9116 
    oprot.writeMessageEnd()
9117 
    oprot.trans.flush()
9118 
 
6031 rajveer 9119 
  def process_getUserWallet(self, seqid, iprot, oprot):
9120 
    args = getUserWallet_args()
6000 mandeep.dh 9121 
    args.read(iprot)
9122 
    iprot.readMessageEnd()
6031 rajveer 9123 
    result = getUserWallet_result()
9124 
    result.success = self._handler.getUserWallet(args.userId)
9125 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 9126 
    result.write(oprot)
9127 
    oprot.writeMessageEnd()
9128 
    oprot.trans.flush()
9129 
 
6031 rajveer 9130 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
9131 
    args = getUserWalletHistory_args()
6000 mandeep.dh 9132 
    args.read(iprot)
9133 
    iprot.readMessageEnd()
6031 rajveer 9134 
    result = getUserWalletHistory_result()
9135 
    result.success = self._handler.getUserWalletHistory(args.userId)
9136 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 9137 
    result.write(oprot)
9138 
    oprot.writeMessageEnd()
9139 
    oprot.trans.flush()
9140 
 
6050 anupam.sin 9141 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
9142 
    args = getRechargeOrdersForTransaction_args()
9143 
    args.read(iprot)
9144 
    iprot.readMessageEnd()
9145 
    result = getRechargeOrdersForTransaction_result()
9146 
    try:
9147 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
9148 
    except TransactionServiceException, ex:
9149 
      result.ex = ex
9150 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
9151 
    result.write(oprot)
9152 
    oprot.writeMessageEnd()
9153 
    oprot.trans.flush()
9154 
 
6048 rajveer 9155 
  def process_getServiceProviders(self, seqid, iprot, oprot):
9156 
    args = getServiceProviders_args()
9157 
    args.read(iprot)
9158 
    iprot.readMessageEnd()
9159 
    result = getServiceProviders_result()
6206 rajveer 9160 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 9161 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
9162 
    result.write(oprot)
9163 
    oprot.writeMessageEnd()
9164 
    oprot.trans.flush()
6000 mandeep.dh 9165 
 
6048 rajveer 9166 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
9167 
    args = getServiceProviderForDevice_args()
9168 
    args.read(iprot)
9169 
    iprot.readMessageEnd()
9170 
    result = getServiceProviderForDevice_result()
6049 rajveer 9171 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 9172 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
9173 
    result.write(oprot)
9174 
    oprot.writeMessageEnd()
9175 
    oprot.trans.flush()
9176 
 
6269 rajveer 9177 
  def process_validateRecharge(self, seqid, iprot, oprot):
9178 
    args = validateRecharge_args()
9179 
    args.read(iprot)
9180 
    iprot.readMessageEnd()
9181 
    result = validateRecharge_result()
6591 anupam.sin 9182 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId, args.clientAddress)
6269 rajveer 9183 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
9184 
    result.write(oprot)
9185 
    oprot.writeMessageEnd()
9186 
    oprot.trans.flush()
9187 
 
6094 rajveer 9188 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
9189 
    args = getRechargeOrdersForDevice_args()
9190 
    args.read(iprot)
9191 
    iprot.readMessageEnd()
9192 
    result = getRechargeOrdersForDevice_result()
9193 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
9194 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
9195 
    result.write(oprot)
9196 
    oprot.writeMessageEnd()
9197 
    oprot.trans.flush()
6048 rajveer 9198 
 
6094 rajveer 9199 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
9200 
    args = addAmountToWallet_args()
9201 
    args.read(iprot)
9202 
    iprot.readMessageEnd()
9203 
    result = addAmountToWallet_result()
9204 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
9205 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
9206 
    result.write(oprot)
9207 
    oprot.writeMessageEnd()
9208 
    oprot.trans.flush()
9209 
 
6188 rajveer 9210 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
9211 
    args = getRechargeStatistics_args()
9212 
    args.read(iprot)
9213 
    iprot.readMessageEnd()
9214 
    result = getRechargeStatistics_result()
9215 
    result.success = self._handler.getRechargeStatistics()
9216 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
9217 
    result.write(oprot)
9218 
    oprot.writeMessageEnd()
9219 
    oprot.trans.flush()
9220 
 
6154 rajveer 9221 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
9222 
    args = getRechargeOrdersForStatus_args()
9223 
    args.read(iprot)
9224 
    iprot.readMessageEnd()
9225 
    result = getRechargeOrdersForStatus_result()
9226 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
9227 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
9228 
    result.write(oprot)
9229 
    oprot.writeMessageEnd()
9230 
    oprot.trans.flush()
6094 rajveer 9231 
 
6159 rajveer 9232 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
9233 
    args = getPlansForOperator_args()
9234 
    args.read(iprot)
9235 
    iprot.readMessageEnd()
9236 
    result = getPlansForOperator_result()
9237 
    result.success = self._handler.getPlansForOperator(args.operatorId)
9238 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
9239 
    result.write(oprot)
9240 
    oprot.writeMessageEnd()
9241 
    oprot.trans.flush()
6154 rajveer 9242 
 
6289 anupam.sin 9243 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
9244 
    args = getRechargeDenominations_args()
9245 
    args.read(iprot)
9246 
    iprot.readMessageEnd()
9247 
    result = getRechargeDenominations_result()
9248 
    try:
6307 anupam.sin 9249 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 9250 
    except TransactionServiceException, ex:
9251 
      result.ex = ex
9252 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
9253 
    result.write(oprot)
9254 
    oprot.writeMessageEnd()
9255 
    oprot.trans.flush()
6159 rajveer 9256 
 
6371 rajveer 9257 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
9258 
    args = updateAvailabilityStatus_args()
9259 
    args.read(iprot)
9260 
    iprot.readMessageEnd()
9261 
    result = updateAvailabilityStatus_result()
9262 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
9263 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
9264 
    result.write(oprot)
9265 
    oprot.writeMessageEnd()
9266 
    oprot.trans.flush()
6289 anupam.sin 9267 
 
6389 rajveer 9268 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
9269 
    args = getAvailableEmiSchemes_args()
9270 
    args.read(iprot)
9271 
    iprot.readMessageEnd()
9272 
    result = getAvailableEmiSchemes_result()
9273 
    result.success = self._handler.getAvailableEmiSchemes()
9274 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
9275 
    result.write(oprot)
9276 
    oprot.writeMessageEnd()
9277 
    oprot.trans.flush()
6371 rajveer 9278 
 
6389 rajveer 9279 
  def process_getMiscCharges(self, seqid, iprot, oprot):
9280 
    args = getMiscCharges_args()
9281 
    args.read(iprot)
9282 
    iprot.readMessageEnd()
9283 
    result = getMiscCharges_result()
9284 
    result.success = self._handler.getMiscCharges(args.transactionId)
9285 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
9286 
    result.write(oprot)
9287 
    oprot.writeMessageEnd()
9288 
    oprot.trans.flush()
9289 
 
6507 anupam.sin 9290 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
9291 
    args = refundRechargeOrder_args()
9292 
    args.read(iprot)
9293 
    iprot.readMessageEnd()
9294 
    result = refundRechargeOrder_result()
9295 
    try:
9296 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
9297 
    except TransactionServiceException, ex:
9298 
      result.ex = ex
9299 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
9300 
    result.write(oprot)
9301 
    oprot.writeMessageEnd()
9302 
    oprot.trans.flush()
6389 rajveer 9303 
 
6821 amar.kumar 9304 
  def process_getPhysicalOrders(self, seqid, iprot, oprot):
9305 
    args = getPhysicalOrders_args()
9306 
    args.read(iprot)
9307 
    iprot.readMessageEnd()
9308 
    result = getPhysicalOrders_result()
9309 
    result.success = self._handler.getPhysicalOrders(args.fromDate, args.toDate)
9310 
    oprot.writeMessageBegin("getPhysicalOrders", TMessageType.REPLY, seqid)
9311 
    result.write(oprot)
9312 
    oprot.writeMessageEnd()
9313 
    oprot.trans.flush()
6507 anupam.sin 9314 
 
6906 rajveer 9315 
  def process_getDocument(self, seqid, iprot, oprot):
9316 
    args = getDocument_args()
9317 
    args.read(iprot)
9318 
    iprot.readMessageEnd()
9319 
    result = getDocument_result()
9320 
    result.success = self._handler.getDocument(args.docType, args.docSource)
9321 
    oprot.writeMessageBegin("getDocument", TMessageType.REPLY, seqid)
9322 
    result.write(oprot)
9323 
    oprot.writeMessageEnd()
9324 
    oprot.trans.flush()
6821 amar.kumar 9325 
 
6985 anupam.sin 9326 
  def process_changeShippingAddress(self, seqid, iprot, oprot):
9327 
    args = changeShippingAddress_args()
9328 
    args.read(iprot)
9329 
    iprot.readMessageEnd()
9330 
    result = changeShippingAddress_result()
9331 
    result.success = self._handler.changeShippingAddress(args.orderId, args.line1, args.line2, args.city, args.state, args.pin)
9332 
    oprot.writeMessageBegin("changeShippingAddress", TMessageType.REPLY, seqid)
9333 
    result.write(oprot)
9334 
    oprot.writeMessageEnd()
9335 
    oprot.trans.flush()
6906 rajveer 9336 
 
6988 rajveer 9337 
  def process_retrieveInvoice(self, seqid, iprot, oprot):
9338 
    args = retrieveInvoice_args()
9339 
    args.read(iprot)
9340 
    iprot.readMessageEnd()
9341 
    result = retrieveInvoice_result()
7075 rajveer 9342 
    result.success = self._handler.retrieveInvoice(args.orderId, args.userId)
6988 rajveer 9343 
    oprot.writeMessageBegin("retrieveInvoice", TMessageType.REPLY, seqid)
9344 
    result.write(oprot)
9345 
    oprot.writeMessageEnd()
9346 
    oprot.trans.flush()
6985 anupam.sin 9347 
 
7026 rajveer 9348 
  def process_receiveUpdatesForRedExpress(self, seqid, iprot, oprot):
9349 
    args = receiveUpdatesForRedExpress_args()
9350 
    args.read(iprot)
9351 
    iprot.readMessageEnd()
9352 
    result = receiveUpdatesForRedExpress_result()
9353 
    result.success = self._handler.receiveUpdatesForRedExpress(args.awbNumber)
9354 
    oprot.writeMessageBegin("receiveUpdatesForRedExpress", TMessageType.REPLY, seqid)
9355 
    result.write(oprot)
9356 
    oprot.writeMessageEnd()
9357 
    oprot.trans.flush()
6988 rajveer 9358 
 
7073 anupam.sin 9359 
  def process_createRechargeTransaction(self, seqid, iprot, oprot):
9360 
    args = createRechargeTransaction_args()
9361 
    args.read(iprot)
9362 
    iprot.readMessageEnd()
9363 
    result = createRechargeTransaction_result()
9364 
    result.success = self._handler.createRechargeTransaction(args.thriftRechargeTransaction)
9365 
    oprot.writeMessageBegin("createRechargeTransaction", TMessageType.REPLY, seqid)
9366 
    result.write(oprot)
9367 
    oprot.writeMessageEnd()
9368 
    oprot.trans.flush()
7026 rajveer 9369 
 
7085 rajveer 9370 
  def process_getRechargeTransactions(self, seqid, iprot, oprot):
9371 
    args = getRechargeTransactions_args()
9372 
    args.read(iprot)
9373 
    iprot.readMessageEnd()
9374 
    result = getRechargeTransactions_result()
9375 
    result.success = self._handler.getRechargeTransactions(args.storeId)
9376 
    oprot.writeMessageBegin("getRechargeTransactions", TMessageType.REPLY, seqid)
9377 
    result.write(oprot)
9378 
    oprot.writeMessageEnd()
9379 
    oprot.trans.flush()
9380 
 
7151 amit.gupta 9381 
  def process_getRechargeTrans(self, seqid, iprot, oprot):
9382 
    args = getRechargeTrans_args()
9383 
    args.read(iprot)
9384 
    iprot.readMessageEnd()
9385 
    result = getRechargeTrans_result()
9386 
    result.success = self._handler.getRechargeTrans(args.storeId, args.startDate, args.endDate, args.status)
9387 
    oprot.writeMessageBegin("getRechargeTrans", TMessageType.REPLY, seqid)
9388 
    result.write(oprot)
9389 
    oprot.writeMessageEnd()
9390 
    oprot.trans.flush()
9391 
 
7080 anupam.sin 9392 
  def process_getRechargeTransaction(self, seqid, iprot, oprot):
9393 
    args = getRechargeTransaction_args()
9394 
    args.read(iprot)
9395 
    iprot.readMessageEnd()
9396 
    result = getRechargeTransaction_result()
9397 
    result.success = self._handler.getRechargeTransaction(args.rechargeId)
9398 
    oprot.writeMessageBegin("getRechargeTransaction", TMessageType.REPLY, seqid)
9399 
    result.write(oprot)
9400 
    oprot.writeMessageEnd()
9401 
    oprot.trans.flush()
7073 anupam.sin 9402 
 
7080 anupam.sin 9403 
  def process_getFRCs(self, seqid, iprot, oprot):
9404 
    args = getFRCs_args()
9405 
    args.read(iprot)
9406 
    iprot.readMessageEnd()
9407 
    result = getFRCs_result()
9408 
    result.success = self._handler.getFRCs(args.circleId, args.operatorId)
9409 
    oprot.writeMessageBegin("getFRCs", TMessageType.REPLY, seqid)
9410 
    result.write(oprot)
9411 
    oprot.writeMessageEnd()
9412 
    oprot.trans.flush()
9413 
 
7096 anupam.sin 9414 
  def process_getHotspotStore(self, seqid, iprot, oprot):
9415 
    args = getHotspotStore_args()
9416 
    args.read(iprot)
9417 
    iprot.readMessageEnd()
9418 
    result = getHotspotStore_result()
9419 
    result.success = self._handler.getHotspotStore(args.id, args.hotspotid)
9420 
    oprot.writeMessageBegin("getHotspotStore", TMessageType.REPLY, seqid)
9421 
    result.write(oprot)
9422 
    oprot.writeMessageEnd()
9423 
    oprot.trans.flush()
7080 anupam.sin 9424 
 
7096 anupam.sin 9425 
  def process_getTelecomCircle(self, seqid, iprot, oprot):
9426 
    args = getTelecomCircle_args()
9427 
    args.read(iprot)
9428 
    iprot.readMessageEnd()
9429 
    result = getTelecomCircle_result()
9430 
    result.success = self._handler.getTelecomCircle(args.id, args.code)
9431 
    oprot.writeMessageBegin("getTelecomCircle", TMessageType.REPLY, seqid)
9432 
    result.write(oprot)
9433 
    oprot.writeMessageEnd()
9434 
    oprot.trans.flush()
9435 
 
7109 anupam.sin 9436 
  def process_retrieveHotspotRechargeInvoice(self, seqid, iprot, oprot):
9437 
    args = retrieveHotspotRechargeInvoice_args()
9438 
    args.read(iprot)
9439 
    iprot.readMessageEnd()
9440 
    result = retrieveHotspotRechargeInvoice_result()
9441 
    result.success = self._handler.retrieveHotspotRechargeInvoice(args.rechargeId)
9442 
    oprot.writeMessageBegin("retrieveHotspotRechargeInvoice", TMessageType.REPLY, seqid)
9443 
    result.write(oprot)
9444 
    oprot.writeMessageEnd()
9445 
    oprot.trans.flush()
7096 anupam.sin 9446 
 
7190 amar.kumar 9447 
  def process_splitFreebieOrder(self, seqid, iprot, oprot):
9448 
    args = splitFreebieOrder_args()
9449 
    args.read(iprot)
9450 
    iprot.readMessageEnd()
9451 
    result = splitFreebieOrder_result()
9452 
    result.success = self._handler.splitFreebieOrder(args.orderId, args.splitReason, args.shippingDate)
9453 
    oprot.writeMessageBegin("splitFreebieOrder", TMessageType.REPLY, seqid)
9454 
    result.write(oprot)
9455 
    oprot.writeMessageEnd()
9456 
    oprot.trans.flush()
9457 
 
7169 anupam.sin 9458 
  def process_getRechargeTransactionsByNumber(self, seqid, iprot, oprot):
9459 
    args = getRechargeTransactionsByNumber_args()
9460 
    args.read(iprot)
9461 
    iprot.readMessageEnd()
9462 
    result = getRechargeTransactionsByNumber_result()
7172 anupam.sin 9463 
    result.success = self._handler.getRechargeTransactionsByNumber(args.number, args.storeId)
7169 anupam.sin 9464 
    oprot.writeMessageBegin("getRechargeTransactionsByNumber", TMessageType.REPLY, seqid)
9465 
    result.write(oprot)
9466 
    oprot.writeMessageEnd()
9467 
    oprot.trans.flush()
7109 anupam.sin 9468 
 
7169 anupam.sin 9469 
  def process_updateHotspotStorePassword(self, seqid, iprot, oprot):
9470 
    args = updateHotspotStorePassword_args()
9471 
    args.read(iprot)
9472 
    iprot.readMessageEnd()
9473 
    result = updateHotspotStorePassword_result()
9474 
    result.success = self._handler.updateHotspotStorePassword(args.storeId, args.password)
9475 
    oprot.writeMessageBegin("updateHotspotStorePassword", TMessageType.REPLY, seqid)
9476 
    result.write(oprot)
9477 
    oprot.writeMessageEnd()
9478 
    oprot.trans.flush()
9479 
 
9480 
 
94 ashish 9481 
# HELPER FUNCTIONS AND STRUCTURES
9482 
 
9483 
class createTransaction_args:
9484 
  """
9485 
  Attributes:
9486 
   - transaction
9487 
  """
9488 
 
9489 
  thrift_spec = (
9490 
    None, # 0
9491 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
9492 
  )
9493 
 
9494 
  def __init__(self, transaction=None,):
9495 
    self.transaction = transaction
9496 
 
9497 
  def read(self, iprot):
9498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9500 
      return
9501 
    iprot.readStructBegin()
9502 
    while True:
9503 
      (fname, ftype, fid) = iprot.readFieldBegin()
9504 
      if ftype == TType.STOP:
9505 
        break
9506 
      if fid == 1:
9507 
        if ftype == TType.STRUCT:
9508 
          self.transaction = Transaction()
9509 
          self.transaction.read(iprot)
9510 
        else:
9511 
          iprot.skip(ftype)
9512 
      else:
9513 
        iprot.skip(ftype)
9514 
      iprot.readFieldEnd()
9515 
    iprot.readStructEnd()
9516 
 
9517 
  def write(self, oprot):
9518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9520 
      return
9521 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 9522 
    if self.transaction is not None:
94 ashish 9523 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
9524 
      self.transaction.write(oprot)
9525 
      oprot.writeFieldEnd()
9526 
    oprot.writeFieldStop()
9527 
    oprot.writeStructEnd()
9528 
 
3431 rajveer 9529 
  def validate(self):
9530 
    return
9531 
 
9532 
 
94 ashish 9533 
  def __repr__(self):
9534 
    L = ['%s=%r' % (key, value)
9535 
      for key, value in self.__dict__.iteritems()]
9536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9537 
 
9538 
  def __eq__(self, other):
9539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9540 
 
9541 
  def __ne__(self, other):
9542 
    return not (self == other)
9543 
 
9544 
class createTransaction_result:
9545 
  """
9546 
  Attributes:
132 ashish 9547 
   - success
94 ashish 9548 
   - ex
9549 
  """
9550 
 
9551 
  thrift_spec = (
132 ashish 9552 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9553 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9554 
  )
9555 
 
132 ashish 9556 
  def __init__(self, success=None, ex=None,):
9557 
    self.success = success
94 ashish 9558 
    self.ex = ex
9559 
 
9560 
  def read(self, iprot):
9561 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9562 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9563 
      return
9564 
    iprot.readStructBegin()
9565 
    while True:
9566 
      (fname, ftype, fid) = iprot.readFieldBegin()
9567 
      if ftype == TType.STOP:
9568 
        break
132 ashish 9569 
      if fid == 0:
9570 
        if ftype == TType.I64:
9571 
          self.success = iprot.readI64();
9572 
        else:
9573 
          iprot.skip(ftype)
9574 
      elif fid == 1:
94 ashish 9575 
        if ftype == TType.STRUCT:
9576 
          self.ex = TransactionServiceException()
9577 
          self.ex.read(iprot)
9578 
        else:
9579 
          iprot.skip(ftype)
9580 
      else:
9581 
        iprot.skip(ftype)
9582 
      iprot.readFieldEnd()
9583 
    iprot.readStructEnd()
9584 
 
9585 
  def write(self, oprot):
9586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9588 
      return
9589 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 9590 
    if self.success is not None:
132 ashish 9591 
      oprot.writeFieldBegin('success', TType.I64, 0)
9592 
      oprot.writeI64(self.success)
9593 
      oprot.writeFieldEnd()
3431 rajveer 9594 
    if self.ex is not None:
94 ashish 9595 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9596 
      self.ex.write(oprot)
9597 
      oprot.writeFieldEnd()
9598 
    oprot.writeFieldStop()
9599 
    oprot.writeStructEnd()
9600 
 
3431 rajveer 9601 
  def validate(self):
9602 
    return
9603 
 
9604 
 
94 ashish 9605 
  def __repr__(self):
9606 
    L = ['%s=%r' % (key, value)
9607 
      for key, value in self.__dict__.iteritems()]
9608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9609 
 
9610 
  def __eq__(self, other):
9611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9612 
 
9613 
  def __ne__(self, other):
9614 
    return not (self == other)
9615 
 
9616 
class getTransaction_args:
9617 
  """
9618 
  Attributes:
9619 
   - id
9620 
  """
9621 
 
9622 
  thrift_spec = (
9623 
    None, # 0
9624 
    (1, TType.I64, 'id', None, None, ), # 1
9625 
  )
9626 
 
9627 
  def __init__(self, id=None,):
9628 
    self.id = id
9629 
 
9630 
  def read(self, iprot):
9631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9633 
      return
9634 
    iprot.readStructBegin()
9635 
    while True:
9636 
      (fname, ftype, fid) = iprot.readFieldBegin()
9637 
      if ftype == TType.STOP:
9638 
        break
9639 
      if fid == 1:
9640 
        if ftype == TType.I64:
9641 
          self.id = iprot.readI64();
9642 
        else:
9643 
          iprot.skip(ftype)
9644 
      else:
9645 
        iprot.skip(ftype)
9646 
      iprot.readFieldEnd()
9647 
    iprot.readStructEnd()
9648 
 
9649 
  def write(self, oprot):
9650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9652 
      return
9653 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 9654 
    if self.id is not None:
94 ashish 9655 
      oprot.writeFieldBegin('id', TType.I64, 1)
9656 
      oprot.writeI64(self.id)
9657 
      oprot.writeFieldEnd()
9658 
    oprot.writeFieldStop()
9659 
    oprot.writeStructEnd()
9660 
 
3431 rajveer 9661 
  def validate(self):
9662 
    return
9663 
 
9664 
 
94 ashish 9665 
  def __repr__(self):
9666 
    L = ['%s=%r' % (key, value)
9667 
      for key, value in self.__dict__.iteritems()]
9668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9669 
 
9670 
  def __eq__(self, other):
9671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9672 
 
9673 
  def __ne__(self, other):
9674 
    return not (self == other)
9675 
 
9676 
class getTransaction_result:
9677 
  """
9678 
  Attributes:
9679 
   - success
9680 
   - ex
9681 
  """
9682 
 
9683 
  thrift_spec = (
9684 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
9685 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9686 
  )
9687 
 
9688 
  def __init__(self, success=None, ex=None,):
9689 
    self.success = success
9690 
    self.ex = ex
9691 
 
9692 
  def read(self, iprot):
9693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9695 
      return
9696 
    iprot.readStructBegin()
9697 
    while True:
9698 
      (fname, ftype, fid) = iprot.readFieldBegin()
9699 
      if ftype == TType.STOP:
9700 
        break
9701 
      if fid == 0:
9702 
        if ftype == TType.STRUCT:
9703 
          self.success = Transaction()
9704 
          self.success.read(iprot)
9705 
        else:
9706 
          iprot.skip(ftype)
9707 
      elif fid == 1:
9708 
        if ftype == TType.STRUCT:
9709 
          self.ex = TransactionServiceException()
9710 
          self.ex.read(iprot)
9711 
        else:
9712 
          iprot.skip(ftype)
9713 
      else:
9714 
        iprot.skip(ftype)
9715 
      iprot.readFieldEnd()
9716 
    iprot.readStructEnd()
9717 
 
9718 
  def write(self, oprot):
9719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9721 
      return
9722 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 9723 
    if self.success is not None:
94 ashish 9724 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9725 
      self.success.write(oprot)
9726 
      oprot.writeFieldEnd()
3431 rajveer 9727 
    if self.ex is not None:
94 ashish 9728 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9729 
      self.ex.write(oprot)
9730 
      oprot.writeFieldEnd()
9731 
    oprot.writeFieldStop()
9732 
    oprot.writeStructEnd()
9733 
 
3431 rajveer 9734 
  def validate(self):
9735 
    return
9736 
 
9737 
 
94 ashish 9738 
  def __repr__(self):
9739 
    L = ['%s=%r' % (key, value)
9740 
      for key, value in self.__dict__.iteritems()]
9741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9742 
 
9743 
  def __eq__(self, other):
9744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9745 
 
9746 
  def __ne__(self, other):
9747 
    return not (self == other)
9748 
 
9749 
class getTransactionsForCustomer_args:
9750 
  """
9751 
  Attributes:
9752 
   - customerId
9753 
   - from_date
9754 
   - to_date
9755 
   - status
9756 
  """
9757 
 
9758 
  thrift_spec = (
9759 
    None, # 0
9760 
    (1, TType.I64, 'customerId', None, None, ), # 1
9761 
    (2, TType.I64, 'from_date', None, None, ), # 2
9762 
    (3, TType.I64, 'to_date', None, None, ), # 3
9763 
    (4, TType.I32, 'status', None, None, ), # 4
9764 
  )
9765 
 
9766 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
9767 
    self.customerId = customerId
9768 
    self.from_date = from_date
9769 
    self.to_date = to_date
9770 
    self.status = status
9771 
 
9772 
  def read(self, iprot):
9773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9775 
      return
9776 
    iprot.readStructBegin()
9777 
    while True:
9778 
      (fname, ftype, fid) = iprot.readFieldBegin()
9779 
      if ftype == TType.STOP:
9780 
        break
9781 
      if fid == 1:
9782 
        if ftype == TType.I64:
9783 
          self.customerId = iprot.readI64();
9784 
        else:
9785 
          iprot.skip(ftype)
9786 
      elif fid == 2:
9787 
        if ftype == TType.I64:
9788 
          self.from_date = iprot.readI64();
9789 
        else:
9790 
          iprot.skip(ftype)
9791 
      elif fid == 3:
9792 
        if ftype == TType.I64:
9793 
          self.to_date = iprot.readI64();
9794 
        else:
9795 
          iprot.skip(ftype)
9796 
      elif fid == 4:
9797 
        if ftype == TType.I32:
9798 
          self.status = iprot.readI32();
9799 
        else:
9800 
          iprot.skip(ftype)
9801 
      else:
9802 
        iprot.skip(ftype)
9803 
      iprot.readFieldEnd()
9804 
    iprot.readStructEnd()
9805 
 
9806 
  def write(self, oprot):
9807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9809 
      return
9810 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 9811 
    if self.customerId is not None:
94 ashish 9812 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9813 
      oprot.writeI64(self.customerId)
9814 
      oprot.writeFieldEnd()
3431 rajveer 9815 
    if self.from_date is not None:
94 ashish 9816 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9817 
      oprot.writeI64(self.from_date)
9818 
      oprot.writeFieldEnd()
3431 rajveer 9819 
    if self.to_date is not None:
94 ashish 9820 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9821 
      oprot.writeI64(self.to_date)
9822 
      oprot.writeFieldEnd()
3431 rajveer 9823 
    if self.status is not None:
94 ashish 9824 
      oprot.writeFieldBegin('status', TType.I32, 4)
9825 
      oprot.writeI32(self.status)
9826 
      oprot.writeFieldEnd()
9827 
    oprot.writeFieldStop()
9828 
    oprot.writeStructEnd()
9829 
 
3431 rajveer 9830 
  def validate(self):
9831 
    return
9832 
 
9833 
 
94 ashish 9834 
  def __repr__(self):
9835 
    L = ['%s=%r' % (key, value)
9836 
      for key, value in self.__dict__.iteritems()]
9837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9838 
 
9839 
  def __eq__(self, other):
9840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9841 
 
9842 
  def __ne__(self, other):
9843 
    return not (self == other)
9844 
 
9845 
class getTransactionsForCustomer_result:
9846 
  """
9847 
  Attributes:
9848 
   - success
9849 
   - ex
9850 
  """
9851 
 
9852 
  thrift_spec = (
9853 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9854 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9855 
  )
9856 
 
9857 
  def __init__(self, success=None, ex=None,):
9858 
    self.success = success
9859 
    self.ex = ex
9860 
 
9861 
  def read(self, iprot):
9862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9864 
      return
9865 
    iprot.readStructBegin()
9866 
    while True:
9867 
      (fname, ftype, fid) = iprot.readFieldBegin()
9868 
      if ftype == TType.STOP:
9869 
        break
9870 
      if fid == 0:
9871 
        if ftype == TType.LIST:
9872 
          self.success = []
6188 rajveer 9873 
          (_etype109, _size106) = iprot.readListBegin()
9874 
          for _i110 in xrange(_size106):
9875 
            _elem111 = Transaction()
9876 
            _elem111.read(iprot)
9877 
            self.success.append(_elem111)
94 ashish 9878 
          iprot.readListEnd()
9879 
        else:
9880 
          iprot.skip(ftype)
9881 
      elif fid == 1:
9882 
        if ftype == TType.STRUCT:
9883 
          self.ex = TransactionServiceException()
9884 
          self.ex.read(iprot)
9885 
        else:
9886 
          iprot.skip(ftype)
9887 
      else:
9888 
        iprot.skip(ftype)
9889 
      iprot.readFieldEnd()
9890 
    iprot.readStructEnd()
9891 
 
9892 
  def write(self, oprot):
9893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9895 
      return
9896 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 9897 
    if self.success is not None:
94 ashish 9898 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9899 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9900 
      for iter112 in self.success:
9901 
        iter112.write(oprot)
94 ashish 9902 
      oprot.writeListEnd()
9903 
      oprot.writeFieldEnd()
3431 rajveer 9904 
    if self.ex is not None:
94 ashish 9905 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9906 
      self.ex.write(oprot)
9907 
      oprot.writeFieldEnd()
9908 
    oprot.writeFieldStop()
9909 
    oprot.writeStructEnd()
9910 
 
3431 rajveer 9911 
  def validate(self):
9912 
    return
9913 
 
9914 
 
94 ashish 9915 
  def __repr__(self):
9916 
    L = ['%s=%r' % (key, value)
9917 
      for key, value in self.__dict__.iteritems()]
9918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9919 
 
9920 
  def __eq__(self, other):
9921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9922 
 
9923 
  def __ne__(self, other):
9924 
    return not (self == other)
9925 
 
132 ashish 9926 
class getTransactionsForShoppingCartId_args:
9927 
  """
9928 
  Attributes:
9929 
   - shoppingCartId
9930 
  """
9931 
 
9932 
  thrift_spec = (
9933 
    None, # 0
9934 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
9935 
  )
9936 
 
9937 
  def __init__(self, shoppingCartId=None,):
9938 
    self.shoppingCartId = shoppingCartId
9939 
 
9940 
  def read(self, iprot):
9941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9943 
      return
9944 
    iprot.readStructBegin()
9945 
    while True:
9946 
      (fname, ftype, fid) = iprot.readFieldBegin()
9947 
      if ftype == TType.STOP:
9948 
        break
9949 
      if fid == 1:
9950 
        if ftype == TType.I64:
9951 
          self.shoppingCartId = iprot.readI64();
9952 
        else:
9953 
          iprot.skip(ftype)
9954 
      else:
9955 
        iprot.skip(ftype)
9956 
      iprot.readFieldEnd()
9957 
    iprot.readStructEnd()
9958 
 
9959 
  def write(self, oprot):
9960 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9961 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9962 
      return
9963 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 9964 
    if self.shoppingCartId is not None:
132 ashish 9965 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
9966 
      oprot.writeI64(self.shoppingCartId)
9967 
      oprot.writeFieldEnd()
9968 
    oprot.writeFieldStop()
9969 
    oprot.writeStructEnd()
9970 
 
3431 rajveer 9971 
  def validate(self):
9972 
    return
9973 
 
9974 
 
132 ashish 9975 
  def __repr__(self):
9976 
    L = ['%s=%r' % (key, value)
9977 
      for key, value in self.__dict__.iteritems()]
9978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9979 
 
9980 
  def __eq__(self, other):
9981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9982 
 
9983 
  def __ne__(self, other):
9984 
    return not (self == other)
9985 
 
9986 
class getTransactionsForShoppingCartId_result:
9987 
  """
9988 
  Attributes:
9989 
   - success
9990 
   - ex
9991 
  """
9992 
 
9993 
  thrift_spec = (
9994 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9995 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9996 
  )
9997 
 
9998 
  def __init__(self, success=None, ex=None,):
9999 
    self.success = success
10000 
    self.ex = ex
10001 
 
10002 
  def read(self, iprot):
10003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10005 
      return
10006 
    iprot.readStructBegin()
10007 
    while True:
10008 
      (fname, ftype, fid) = iprot.readFieldBegin()
10009 
      if ftype == TType.STOP:
10010 
        break
10011 
      if fid == 0:
10012 
        if ftype == TType.LIST:
10013 
          self.success = []
6188 rajveer 10014 
          (_etype116, _size113) = iprot.readListBegin()
10015 
          for _i117 in xrange(_size113):
10016 
            _elem118 = Transaction()
10017 
            _elem118.read(iprot)
10018 
            self.success.append(_elem118)
132 ashish 10019 
          iprot.readListEnd()
10020 
        else:
10021 
          iprot.skip(ftype)
10022 
      elif fid == 1:
10023 
        if ftype == TType.STRUCT:
10024 
          self.ex = TransactionServiceException()
10025 
          self.ex.read(iprot)
10026 
        else:
10027 
          iprot.skip(ftype)
10028 
      else:
10029 
        iprot.skip(ftype)
10030 
      iprot.readFieldEnd()
10031 
    iprot.readStructEnd()
10032 
 
10033 
  def write(self, oprot):
10034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10036 
      return
10037 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 10038 
    if self.success is not None:
132 ashish 10039 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10040 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10041 
      for iter119 in self.success:
10042 
        iter119.write(oprot)
132 ashish 10043 
      oprot.writeListEnd()
10044 
      oprot.writeFieldEnd()
3431 rajveer 10045 
    if self.ex is not None:
132 ashish 10046 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10047 
      self.ex.write(oprot)
10048 
      oprot.writeFieldEnd()
10049 
    oprot.writeFieldStop()
10050 
    oprot.writeStructEnd()
10051 
 
3431 rajveer 10052 
  def validate(self):
10053 
    return
10054 
 
10055 
 
132 ashish 10056 
  def __repr__(self):
10057 
    L = ['%s=%r' % (key, value)
10058 
      for key, value in self.__dict__.iteritems()]
10059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10060 
 
10061 
  def __eq__(self, other):
10062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10063 
 
10064 
  def __ne__(self, other):
10065 
    return not (self == other)
10066 
 
94 ashish 10067 
class getTransactionStatus_args:
10068 
  """
10069 
  Attributes:
10070 
   - transactionId
10071 
  """
10072 
 
10073 
  thrift_spec = (
10074 
    None, # 0
10075 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10076 
  )
10077 
 
10078 
  def __init__(self, transactionId=None,):
10079 
    self.transactionId = transactionId
10080 
 
10081 
  def read(self, iprot):
10082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10084 
      return
10085 
    iprot.readStructBegin()
10086 
    while True:
10087 
      (fname, ftype, fid) = iprot.readFieldBegin()
10088 
      if ftype == TType.STOP:
10089 
        break
10090 
      if fid == 1:
10091 
        if ftype == TType.I64:
10092 
          self.transactionId = iprot.readI64();
10093 
        else:
10094 
          iprot.skip(ftype)
10095 
      else:
10096 
        iprot.skip(ftype)
10097 
      iprot.readFieldEnd()
10098 
    iprot.readStructEnd()
10099 
 
10100 
  def write(self, oprot):
10101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10103 
      return
10104 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 10105 
    if self.transactionId is not None:
94 ashish 10106 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10107 
      oprot.writeI64(self.transactionId)
10108 
      oprot.writeFieldEnd()
10109 
    oprot.writeFieldStop()
10110 
    oprot.writeStructEnd()
10111 
 
3431 rajveer 10112 
  def validate(self):
10113 
    return
10114 
 
10115 
 
94 ashish 10116 
  def __repr__(self):
10117 
    L = ['%s=%r' % (key, value)
10118 
      for key, value in self.__dict__.iteritems()]
10119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10120 
 
10121 
  def __eq__(self, other):
10122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10123 
 
10124 
  def __ne__(self, other):
10125 
    return not (self == other)
10126 
 
10127 
class getTransactionStatus_result:
10128 
  """
10129 
  Attributes:
10130 
   - success
10131 
   - ex
10132 
  """
10133 
 
10134 
  thrift_spec = (
10135 
    (0, TType.I32, 'success', None, None, ), # 0
10136 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10137 
  )
10138 
 
10139 
  def __init__(self, success=None, ex=None,):
10140 
    self.success = success
10141 
    self.ex = ex
10142 
 
10143 
  def read(self, iprot):
10144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10146 
      return
10147 
    iprot.readStructBegin()
10148 
    while True:
10149 
      (fname, ftype, fid) = iprot.readFieldBegin()
10150 
      if ftype == TType.STOP:
10151 
        break
10152 
      if fid == 0:
10153 
        if ftype == TType.I32:
10154 
          self.success = iprot.readI32();
10155 
        else:
10156 
          iprot.skip(ftype)
10157 
      elif fid == 1:
10158 
        if ftype == TType.STRUCT:
10159 
          self.ex = TransactionServiceException()
10160 
          self.ex.read(iprot)
10161 
        else:
10162 
          iprot.skip(ftype)
10163 
      else:
10164 
        iprot.skip(ftype)
10165 
      iprot.readFieldEnd()
10166 
    iprot.readStructEnd()
10167 
 
10168 
  def write(self, oprot):
10169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10171 
      return
10172 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 10173 
    if self.success is not None:
94 ashish 10174 
      oprot.writeFieldBegin('success', TType.I32, 0)
10175 
      oprot.writeI32(self.success)
10176 
      oprot.writeFieldEnd()
3431 rajveer 10177 
    if self.ex is not None:
94 ashish 10178 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10179 
      self.ex.write(oprot)
10180 
      oprot.writeFieldEnd()
10181 
    oprot.writeFieldStop()
10182 
    oprot.writeStructEnd()
10183 
 
3431 rajveer 10184 
  def validate(self):
10185 
    return
10186 
 
10187 
 
94 ashish 10188 
  def __repr__(self):
10189 
    L = ['%s=%r' % (key, value)
10190 
      for key, value in self.__dict__.iteritems()]
10191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10192 
 
10193 
  def __eq__(self, other):
10194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10195 
 
10196 
  def __ne__(self, other):
10197 
    return not (self == other)
10198 
 
10199 
class changeTransactionStatus_args:
10200 
  """
10201 
  Attributes:
10202 
   - transactionId
10203 
   - status
10204 
   - description
5527 anupam.sin 10205 
   - pickUp
10206 
   - orderType
94 ashish 10207 
  """
10208 
 
10209 
  thrift_spec = (
10210 
    None, # 0
10211 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10212 
    (2, TType.I32, 'status', None, None, ), # 2
10213 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 10214 
    (4, TType.I64, 'pickUp', None, None, ), # 4
10215 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 10216 
  )
10217 
 
5527 anupam.sin 10218 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 10219 
    self.transactionId = transactionId
10220 
    self.status = status
10221 
    self.description = description
5527 anupam.sin 10222 
    self.pickUp = pickUp
10223 
    self.orderType = orderType
94 ashish 10224 
 
10225 
  def read(self, iprot):
10226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10228 
      return
10229 
    iprot.readStructBegin()
10230 
    while True:
10231 
      (fname, ftype, fid) = iprot.readFieldBegin()
10232 
      if ftype == TType.STOP:
10233 
        break
10234 
      if fid == 1:
10235 
        if ftype == TType.I64:
10236 
          self.transactionId = iprot.readI64();
10237 
        else:
10238 
          iprot.skip(ftype)
10239 
      elif fid == 2:
10240 
        if ftype == TType.I32:
10241 
          self.status = iprot.readI32();
10242 
        else:
10243 
          iprot.skip(ftype)
10244 
      elif fid == 3:
10245 
        if ftype == TType.STRING:
10246 
          self.description = iprot.readString();
10247 
        else:
10248 
          iprot.skip(ftype)
5387 rajveer 10249 
      elif fid == 4:
5527 anupam.sin 10250 
        if ftype == TType.I64:
10251 
          self.pickUp = iprot.readI64();
5387 rajveer 10252 
        else:
10253 
          iprot.skip(ftype)
5527 anupam.sin 10254 
      elif fid == 5:
10255 
        if ftype == TType.I32:
10256 
          self.orderType = iprot.readI32();
10257 
        else:
10258 
          iprot.skip(ftype)
94 ashish 10259 
      else:
10260 
        iprot.skip(ftype)
10261 
      iprot.readFieldEnd()
10262 
    iprot.readStructEnd()
10263 
 
10264 
  def write(self, oprot):
10265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10267 
      return
10268 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 10269 
    if self.transactionId is not None:
94 ashish 10270 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10271 
      oprot.writeI64(self.transactionId)
10272 
      oprot.writeFieldEnd()
3431 rajveer 10273 
    if self.status is not None:
94 ashish 10274 
      oprot.writeFieldBegin('status', TType.I32, 2)
10275 
      oprot.writeI32(self.status)
10276 
      oprot.writeFieldEnd()
3431 rajveer 10277 
    if self.description is not None:
94 ashish 10278 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10279 
      oprot.writeString(self.description)
10280 
      oprot.writeFieldEnd()
5527 anupam.sin 10281 
    if self.pickUp is not None:
10282 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
10283 
      oprot.writeI64(self.pickUp)
5387 rajveer 10284 
      oprot.writeFieldEnd()
5527 anupam.sin 10285 
    if self.orderType is not None:
10286 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
10287 
      oprot.writeI32(self.orderType)
10288 
      oprot.writeFieldEnd()
94 ashish 10289 
    oprot.writeFieldStop()
10290 
    oprot.writeStructEnd()
10291 
 
3431 rajveer 10292 
  def validate(self):
10293 
    return
10294 
 
10295 
 
94 ashish 10296 
  def __repr__(self):
10297 
    L = ['%s=%r' % (key, value)
10298 
      for key, value in self.__dict__.iteritems()]
10299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10300 
 
10301 
  def __eq__(self, other):
10302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10303 
 
10304 
  def __ne__(self, other):
10305 
    return not (self == other)
10306 
 
10307 
class changeTransactionStatus_result:
10308 
  """
10309 
  Attributes:
10310 
   - success
10311 
   - ex
10312 
  """
10313 
 
10314 
  thrift_spec = (
10315 
    (0, TType.BOOL, 'success', None, None, ), # 0
10316 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10317 
  )
10318 
 
10319 
  def __init__(self, success=None, ex=None,):
10320 
    self.success = success
10321 
    self.ex = ex
10322 
 
10323 
  def read(self, iprot):
10324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10326 
      return
10327 
    iprot.readStructBegin()
10328 
    while True:
10329 
      (fname, ftype, fid) = iprot.readFieldBegin()
10330 
      if ftype == TType.STOP:
10331 
        break
10332 
      if fid == 0:
10333 
        if ftype == TType.BOOL:
10334 
          self.success = iprot.readBool();
10335 
        else:
10336 
          iprot.skip(ftype)
10337 
      elif fid == 1:
10338 
        if ftype == TType.STRUCT:
10339 
          self.ex = TransactionServiceException()
10340 
          self.ex.read(iprot)
10341 
        else:
10342 
          iprot.skip(ftype)
10343 
      else:
10344 
        iprot.skip(ftype)
10345 
      iprot.readFieldEnd()
10346 
    iprot.readStructEnd()
10347 
 
10348 
  def write(self, oprot):
10349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10351 
      return
10352 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 10353 
    if self.success is not None:
94 ashish 10354 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10355 
      oprot.writeBool(self.success)
10356 
      oprot.writeFieldEnd()
3431 rajveer 10357 
    if self.ex is not None:
94 ashish 10358 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10359 
      self.ex.write(oprot)
10360 
      oprot.writeFieldEnd()
10361 
    oprot.writeFieldStop()
10362 
    oprot.writeStructEnd()
10363 
 
3431 rajveer 10364 
  def validate(self):
10365 
    return
10366 
 
10367 
 
94 ashish 10368 
  def __repr__(self):
10369 
    L = ['%s=%r' % (key, value)
10370 
      for key, value in self.__dict__.iteritems()]
10371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10372 
 
10373 
  def __eq__(self, other):
10374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10375 
 
10376 
  def __ne__(self, other):
10377 
    return not (self == other)
10378 
 
1398 varun.gupt 10379 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 10380 
  """
10381 
  Attributes:
10382 
   - transactionId
10383 
  """
10384 
 
10385 
  thrift_spec = (
10386 
    None, # 0
10387 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10388 
  )
10389 
 
10390 
  def __init__(self, transactionId=None,):
10391 
    self.transactionId = transactionId
10392 
 
10393 
  def read(self, iprot):
10394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10396 
      return
10397 
    iprot.readStructBegin()
10398 
    while True:
10399 
      (fname, ftype, fid) = iprot.readFieldBegin()
10400 
      if ftype == TType.STOP:
10401 
        break
10402 
      if fid == 1:
10403 
        if ftype == TType.I64:
10404 
          self.transactionId = iprot.readI64();
10405 
        else:
10406 
          iprot.skip(ftype)
10407 
      else:
10408 
        iprot.skip(ftype)
10409 
      iprot.readFieldEnd()
10410 
    iprot.readStructEnd()
10411 
 
10412 
  def write(self, oprot):
10413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10415 
      return
1398 varun.gupt 10416 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 10417 
    if self.transactionId is not None:
1382 varun.gupt 10418 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10419 
      oprot.writeI64(self.transactionId)
10420 
      oprot.writeFieldEnd()
10421 
    oprot.writeFieldStop()
10422 
    oprot.writeStructEnd()
10423 
 
3431 rajveer 10424 
  def validate(self):
10425 
    return
10426 
 
10427 
 
1382 varun.gupt 10428 
  def __repr__(self):
10429 
    L = ['%s=%r' % (key, value)
10430 
      for key, value in self.__dict__.iteritems()]
10431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10432 
 
10433 
  def __eq__(self, other):
10434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10435 
 
10436 
  def __ne__(self, other):
10437 
    return not (self == other)
10438 
 
1398 varun.gupt 10439 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 10440 
  """
10441 
  Attributes:
10442 
   - success
10443 
   - ex
10444 
  """
10445 
 
10446 
  thrift_spec = (
10447 
    (0, TType.BOOL, 'success', None, None, ), # 0
10448 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10449 
  )
10450 
 
10451 
  def __init__(self, success=None, ex=None,):
10452 
    self.success = success
10453 
    self.ex = ex
10454 
 
10455 
  def read(self, iprot):
10456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10458 
      return
10459 
    iprot.readStructBegin()
10460 
    while True:
10461 
      (fname, ftype, fid) = iprot.readFieldBegin()
10462 
      if ftype == TType.STOP:
10463 
        break
10464 
      if fid == 0:
10465 
        if ftype == TType.BOOL:
10466 
          self.success = iprot.readBool();
10467 
        else:
10468 
          iprot.skip(ftype)
10469 
      elif fid == 1:
10470 
        if ftype == TType.STRUCT:
10471 
          self.ex = TransactionServiceException()
10472 
          self.ex.read(iprot)
10473 
        else:
10474 
          iprot.skip(ftype)
10475 
      else:
10476 
        iprot.skip(ftype)
10477 
      iprot.readFieldEnd()
10478 
    iprot.readStructEnd()
10479 
 
10480 
  def write(self, oprot):
10481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10483 
      return
1398 varun.gupt 10484 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 10485 
    if self.success is not None:
1382 varun.gupt 10486 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10487 
      oprot.writeBool(self.success)
10488 
      oprot.writeFieldEnd()
3431 rajveer 10489 
    if self.ex is not None:
1382 varun.gupt 10490 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10491 
      self.ex.write(oprot)
10492 
      oprot.writeFieldEnd()
10493 
    oprot.writeFieldStop()
10494 
    oprot.writeStructEnd()
10495 
 
3431 rajveer 10496 
  def validate(self):
10497 
    return
10498 
 
10499 
 
1382 varun.gupt 10500 
  def __repr__(self):
10501 
    L = ['%s=%r' % (key, value)
10502 
      for key, value in self.__dict__.iteritems()]
10503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10504 
 
10505 
  def __eq__(self, other):
10506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10507 
 
10508 
  def __ne__(self, other):
10509 
    return not (self == other)
10510 
 
483 rajveer 10511 
class getAllOrders_args:
94 ashish 10512 
  """
10513 
  Attributes:
4801 anupam.sin 10514 
   - statuses
483 rajveer 10515 
   - from_date
10516 
   - to_date
10517 
   - warehouse_id
94 ashish 10518 
  """
10519 
 
10520 
  thrift_spec = (
10521 
    None, # 0
4801 anupam.sin 10522 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 10523 
    (2, TType.I64, 'from_date', None, None, ), # 2
10524 
    (3, TType.I64, 'to_date', None, None, ), # 3
10525 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 10526 
  )
10527 
 
4801 anupam.sin 10528 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
10529 
    self.statuses = statuses
483 rajveer 10530 
    self.from_date = from_date
10531 
    self.to_date = to_date
10532 
    self.warehouse_id = warehouse_id
94 ashish 10533 
 
10534 
  def read(self, iprot):
10535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10537 
      return
10538 
    iprot.readStructBegin()
10539 
    while True:
10540 
      (fname, ftype, fid) = iprot.readFieldBegin()
10541 
      if ftype == TType.STOP:
10542 
        break
10543 
      if fid == 1:
4801 anupam.sin 10544 
        if ftype == TType.LIST:
10545 
          self.statuses = []
6188 rajveer 10546 
          (_etype123, _size120) = iprot.readListBegin()
10547 
          for _i124 in xrange(_size120):
10548 
            _elem125 = iprot.readI32();
10549 
            self.statuses.append(_elem125)
4801 anupam.sin 10550 
          iprot.readListEnd()
94 ashish 10551 
        else:
10552 
          iprot.skip(ftype)
483 rajveer 10553 
      elif fid == 2:
10554 
        if ftype == TType.I64:
10555 
          self.from_date = iprot.readI64();
94 ashish 10556 
        else:
10557 
          iprot.skip(ftype)
483 rajveer 10558 
      elif fid == 3:
10559 
        if ftype == TType.I64:
10560 
          self.to_date = iprot.readI64();
94 ashish 10561 
        else:
10562 
          iprot.skip(ftype)
483 rajveer 10563 
      elif fid == 4:
94 ashish 10564 
        if ftype == TType.I64:
483 rajveer 10565 
          self.warehouse_id = iprot.readI64();
94 ashish 10566 
        else:
10567 
          iprot.skip(ftype)
10568 
      else:
10569 
        iprot.skip(ftype)
10570 
      iprot.readFieldEnd()
10571 
    iprot.readStructEnd()
10572 
 
10573 
  def write(self, oprot):
10574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10576 
      return
483 rajveer 10577 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 10578 
    if self.statuses is not None:
10579 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10580 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10581 
      for iter126 in self.statuses:
10582 
        oprot.writeI32(iter126)
4801 anupam.sin 10583 
      oprot.writeListEnd()
94 ashish 10584 
      oprot.writeFieldEnd()
3431 rajveer 10585 
    if self.from_date is not None:
483 rajveer 10586 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10587 
      oprot.writeI64(self.from_date)
94 ashish 10588 
      oprot.writeFieldEnd()
3431 rajveer 10589 
    if self.to_date is not None:
483 rajveer 10590 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10591 
      oprot.writeI64(self.to_date)
94 ashish 10592 
      oprot.writeFieldEnd()
3431 rajveer 10593 
    if self.warehouse_id is not None:
483 rajveer 10594 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10595 
      oprot.writeI64(self.warehouse_id)
94 ashish 10596 
      oprot.writeFieldEnd()
10597 
    oprot.writeFieldStop()
10598 
    oprot.writeStructEnd()
10599 
 
3431 rajveer 10600 
  def validate(self):
10601 
    return
10602 
 
10603 
 
94 ashish 10604 
  def __repr__(self):
10605 
    L = ['%s=%r' % (key, value)
10606 
      for key, value in self.__dict__.iteritems()]
10607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10608 
 
10609 
  def __eq__(self, other):
10610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10611 
 
10612 
  def __ne__(self, other):
10613 
    return not (self == other)
10614 
 
483 rajveer 10615 
class getAllOrders_result:
94 ashish 10616 
  """
10617 
  Attributes:
10618 
   - success
10619 
   - ex
10620 
  """
10621 
 
10622 
  thrift_spec = (
483 rajveer 10623 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 10624 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10625 
  )
10626 
 
10627 
  def __init__(self, success=None, ex=None,):
10628 
    self.success = success
10629 
    self.ex = ex
10630 
 
10631 
  def read(self, iprot):
10632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10634 
      return
10635 
    iprot.readStructBegin()
10636 
    while True:
10637 
      (fname, ftype, fid) = iprot.readFieldBegin()
10638 
      if ftype == TType.STOP:
10639 
        break
10640 
      if fid == 0:
483 rajveer 10641 
        if ftype == TType.LIST:
10642 
          self.success = []
6188 rajveer 10643 
          (_etype130, _size127) = iprot.readListBegin()
10644 
          for _i131 in xrange(_size127):
10645 
            _elem132 = Order()
10646 
            _elem132.read(iprot)
10647 
            self.success.append(_elem132)
483 rajveer 10648 
          iprot.readListEnd()
94 ashish 10649 
        else:
10650 
          iprot.skip(ftype)
10651 
      elif fid == 1:
10652 
        if ftype == TType.STRUCT:
10653 
          self.ex = TransactionServiceException()
10654 
          self.ex.read(iprot)
10655 
        else:
10656 
          iprot.skip(ftype)
10657 
      else:
10658 
        iprot.skip(ftype)
10659 
      iprot.readFieldEnd()
10660 
    iprot.readStructEnd()
10661 
 
10662 
  def write(self, oprot):
10663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10665 
      return
483 rajveer 10666 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 10667 
    if self.success is not None:
483 rajveer 10668 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10669 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10670 
      for iter133 in self.success:
10671 
        iter133.write(oprot)
483 rajveer 10672 
      oprot.writeListEnd()
94 ashish 10673 
      oprot.writeFieldEnd()
3431 rajveer 10674 
    if self.ex is not None:
94 ashish 10675 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10676 
      self.ex.write(oprot)
10677 
      oprot.writeFieldEnd()
10678 
    oprot.writeFieldStop()
10679 
    oprot.writeStructEnd()
10680 
 
3431 rajveer 10681 
  def validate(self):
10682 
    return
10683 
 
10684 
 
94 ashish 10685 
  def __repr__(self):
10686 
    L = ['%s=%r' % (key, value)
10687 
      for key, value in self.__dict__.iteritems()]
10688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10689 
 
10690 
  def __eq__(self, other):
10691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10692 
 
10693 
  def __ne__(self, other):
10694 
    return not (self == other)
10695 
 
4133 chandransh 10696 
class getOrdersInBatch_args:
10697 
  """
10698 
  Attributes:
10699 
   - statuses
10700 
   - offset
10701 
   - limit
10702 
   - warehouse_id
10703 
  """
10704 
 
10705 
  thrift_spec = (
10706 
    None, # 0
10707 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10708 
    (2, TType.I64, 'offset', None, None, ), # 2
10709 
    (3, TType.I64, 'limit', None, None, ), # 3
10710 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10711 
  )
10712 
 
10713 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
10714 
    self.statuses = statuses
10715 
    self.offset = offset
10716 
    self.limit = limit
10717 
    self.warehouse_id = warehouse_id
10718 
 
10719 
  def read(self, iprot):
10720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10722 
      return
10723 
    iprot.readStructBegin()
10724 
    while True:
10725 
      (fname, ftype, fid) = iprot.readFieldBegin()
10726 
      if ftype == TType.STOP:
10727 
        break
10728 
      if fid == 1:
10729 
        if ftype == TType.LIST:
10730 
          self.statuses = []
6188 rajveer 10731 
          (_etype137, _size134) = iprot.readListBegin()
10732 
          for _i138 in xrange(_size134):
10733 
            _elem139 = iprot.readI32();
10734 
            self.statuses.append(_elem139)
4133 chandransh 10735 
          iprot.readListEnd()
10736 
        else:
10737 
          iprot.skip(ftype)
10738 
      elif fid == 2:
10739 
        if ftype == TType.I64:
10740 
          self.offset = iprot.readI64();
10741 
        else:
10742 
          iprot.skip(ftype)
10743 
      elif fid == 3:
10744 
        if ftype == TType.I64:
10745 
          self.limit = iprot.readI64();
10746 
        else:
10747 
          iprot.skip(ftype)
10748 
      elif fid == 4:
10749 
        if ftype == TType.I64:
10750 
          self.warehouse_id = iprot.readI64();
10751 
        else:
10752 
          iprot.skip(ftype)
10753 
      else:
10754 
        iprot.skip(ftype)
10755 
      iprot.readFieldEnd()
10756 
    iprot.readStructEnd()
10757 
 
10758 
  def write(self, oprot):
10759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10761 
      return
10762 
    oprot.writeStructBegin('getOrdersInBatch_args')
10763 
    if self.statuses is not None:
10764 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10765 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10766 
      for iter140 in self.statuses:
10767 
        oprot.writeI32(iter140)
4133 chandransh 10768 
      oprot.writeListEnd()
10769 
      oprot.writeFieldEnd()
10770 
    if self.offset is not None:
10771 
      oprot.writeFieldBegin('offset', TType.I64, 2)
10772 
      oprot.writeI64(self.offset)
10773 
      oprot.writeFieldEnd()
10774 
    if self.limit is not None:
10775 
      oprot.writeFieldBegin('limit', TType.I64, 3)
10776 
      oprot.writeI64(self.limit)
10777 
      oprot.writeFieldEnd()
10778 
    if self.warehouse_id is not None:
10779 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10780 
      oprot.writeI64(self.warehouse_id)
10781 
      oprot.writeFieldEnd()
10782 
    oprot.writeFieldStop()
10783 
    oprot.writeStructEnd()
10784 
 
10785 
  def validate(self):
10786 
    return
10787 
 
10788 
 
10789 
  def __repr__(self):
10790 
    L = ['%s=%r' % (key, value)
10791 
      for key, value in self.__dict__.iteritems()]
10792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10793 
 
10794 
  def __eq__(self, other):
10795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10796 
 
10797 
  def __ne__(self, other):
10798 
    return not (self == other)
10799 
 
10800 
class getOrdersInBatch_result:
10801 
  """
10802 
  Attributes:
10803 
   - success
10804 
   - ex
10805 
  """
10806 
 
10807 
  thrift_spec = (
10808 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10809 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10810 
  )
10811 
 
10812 
  def __init__(self, success=None, ex=None,):
10813 
    self.success = success
10814 
    self.ex = ex
10815 
 
10816 
  def read(self, iprot):
10817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10819 
      return
10820 
    iprot.readStructBegin()
10821 
    while True:
10822 
      (fname, ftype, fid) = iprot.readFieldBegin()
10823 
      if ftype == TType.STOP:
10824 
        break
10825 
      if fid == 0:
10826 
        if ftype == TType.LIST:
10827 
          self.success = []
6188 rajveer 10828 
          (_etype144, _size141) = iprot.readListBegin()
10829 
          for _i145 in xrange(_size141):
10830 
            _elem146 = Order()
10831 
            _elem146.read(iprot)
10832 
            self.success.append(_elem146)
4133 chandransh 10833 
          iprot.readListEnd()
10834 
        else:
10835 
          iprot.skip(ftype)
10836 
      elif fid == 1:
10837 
        if ftype == TType.STRUCT:
10838 
          self.ex = TransactionServiceException()
10839 
          self.ex.read(iprot)
10840 
        else:
10841 
          iprot.skip(ftype)
10842 
      else:
10843 
        iprot.skip(ftype)
10844 
      iprot.readFieldEnd()
10845 
    iprot.readStructEnd()
10846 
 
10847 
  def write(self, oprot):
10848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10850 
      return
10851 
    oprot.writeStructBegin('getOrdersInBatch_result')
10852 
    if self.success is not None:
10853 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10854 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10855 
      for iter147 in self.success:
10856 
        iter147.write(oprot)
4133 chandransh 10857 
      oprot.writeListEnd()
10858 
      oprot.writeFieldEnd()
10859 
    if self.ex is not None:
10860 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10861 
      self.ex.write(oprot)
10862 
      oprot.writeFieldEnd()
10863 
    oprot.writeFieldStop()
10864 
    oprot.writeStructEnd()
10865 
 
10866 
  def validate(self):
10867 
    return
10868 
 
10869 
 
10870 
  def __repr__(self):
10871 
    L = ['%s=%r' % (key, value)
10872 
      for key, value in self.__dict__.iteritems()]
10873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10874 
 
10875 
  def __eq__(self, other):
10876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10877 
 
10878 
  def __ne__(self, other):
10879 
    return not (self == other)
10880 
 
10881 
class getOrderCount_args:
10882 
  """
10883 
  Attributes:
10884 
   - statuses
10885 
   - warehouseId
10886 
  """
10887 
 
10888 
  thrift_spec = (
10889 
    None, # 0
10890 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10891 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10892 
  )
10893 
 
10894 
  def __init__(self, statuses=None, warehouseId=None,):
10895 
    self.statuses = statuses
10896 
    self.warehouseId = warehouseId
10897 
 
10898 
  def read(self, iprot):
10899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10901 
      return
10902 
    iprot.readStructBegin()
10903 
    while True:
10904 
      (fname, ftype, fid) = iprot.readFieldBegin()
10905 
      if ftype == TType.STOP:
10906 
        break
10907 
      if fid == 1:
10908 
        if ftype == TType.LIST:
10909 
          self.statuses = []
6188 rajveer 10910 
          (_etype151, _size148) = iprot.readListBegin()
10911 
          for _i152 in xrange(_size148):
10912 
            _elem153 = iprot.readI32();
10913 
            self.statuses.append(_elem153)
4133 chandransh 10914 
          iprot.readListEnd()
10915 
        else:
10916 
          iprot.skip(ftype)
10917 
      elif fid == 2:
10918 
        if ftype == TType.I64:
10919 
          self.warehouseId = iprot.readI64();
10920 
        else:
10921 
          iprot.skip(ftype)
10922 
      else:
10923 
        iprot.skip(ftype)
10924 
      iprot.readFieldEnd()
10925 
    iprot.readStructEnd()
10926 
 
10927 
  def write(self, oprot):
10928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10930 
      return
10931 
    oprot.writeStructBegin('getOrderCount_args')
10932 
    if self.statuses is not None:
10933 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10934 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10935 
      for iter154 in self.statuses:
10936 
        oprot.writeI32(iter154)
4133 chandransh 10937 
      oprot.writeListEnd()
10938 
      oprot.writeFieldEnd()
10939 
    if self.warehouseId is not None:
10940 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10941 
      oprot.writeI64(self.warehouseId)
10942 
      oprot.writeFieldEnd()
10943 
    oprot.writeFieldStop()
10944 
    oprot.writeStructEnd()
10945 
 
10946 
  def validate(self):
10947 
    return
10948 
 
10949 
 
10950 
  def __repr__(self):
10951 
    L = ['%s=%r' % (key, value)
10952 
      for key, value in self.__dict__.iteritems()]
10953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10954 
 
10955 
  def __eq__(self, other):
10956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10957 
 
10958 
  def __ne__(self, other):
10959 
    return not (self == other)
10960 
 
10961 
class getOrderCount_result:
10962 
  """
10963 
  Attributes:
10964 
   - success
10965 
   - ex
10966 
  """
10967 
 
10968 
  thrift_spec = (
10969 
    (0, TType.I32, 'success', None, None, ), # 0
10970 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10971 
  )
10972 
 
10973 
  def __init__(self, success=None, ex=None,):
10974 
    self.success = success
10975 
    self.ex = ex
10976 
 
10977 
  def read(self, iprot):
10978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10980 
      return
10981 
    iprot.readStructBegin()
10982 
    while True:
10983 
      (fname, ftype, fid) = iprot.readFieldBegin()
10984 
      if ftype == TType.STOP:
10985 
        break
10986 
      if fid == 0:
10987 
        if ftype == TType.I32:
10988 
          self.success = iprot.readI32();
10989 
        else:
10990 
          iprot.skip(ftype)
10991 
      elif fid == 1:
10992 
        if ftype == TType.STRUCT:
10993 
          self.ex = TransactionServiceException()
10994 
          self.ex.read(iprot)
10995 
        else:
10996 
          iprot.skip(ftype)
10997 
      else:
10998 
        iprot.skip(ftype)
10999 
      iprot.readFieldEnd()
11000 
    iprot.readStructEnd()
11001 
 
11002 
  def write(self, oprot):
11003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11005 
      return
11006 
    oprot.writeStructBegin('getOrderCount_result')
11007 
    if self.success is not None:
11008 
      oprot.writeFieldBegin('success', TType.I32, 0)
11009 
      oprot.writeI32(self.success)
11010 
      oprot.writeFieldEnd()
11011 
    if self.ex is not None:
11012 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11013 
      self.ex.write(oprot)
11014 
      oprot.writeFieldEnd()
11015 
    oprot.writeFieldStop()
11016 
    oprot.writeStructEnd()
11017 
 
11018 
  def validate(self):
11019 
    return
11020 
 
11021 
 
11022 
  def __repr__(self):
11023 
    L = ['%s=%r' % (key, value)
11024 
      for key, value in self.__dict__.iteritems()]
11025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11026 
 
11027 
  def __eq__(self, other):
11028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11029 
 
11030 
  def __ne__(self, other):
11031 
    return not (self == other)
11032 
 
999 varun.gupt 11033 
class getOrdersByBillingDate_args:
11034 
  """
11035 
  Attributes:
11036 
   - status
11037 
   - start_billing_date
11038 
   - end_billing_date
11039 
   - warehouse_id
11040 
  """
11041 
 
11042 
  thrift_spec = (
11043 
    None, # 0
11044 
    (1, TType.I32, 'status', None, None, ), # 1
11045 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
11046 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
11047 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
11048 
  )
11049 
 
11050 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
11051 
    self.status = status
11052 
    self.start_billing_date = start_billing_date
11053 
    self.end_billing_date = end_billing_date
11054 
    self.warehouse_id = warehouse_id
11055 
 
11056 
  def read(self, iprot):
11057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11059 
      return
11060 
    iprot.readStructBegin()
11061 
    while True:
11062 
      (fname, ftype, fid) = iprot.readFieldBegin()
11063 
      if ftype == TType.STOP:
11064 
        break
11065 
      if fid == 1:
11066 
        if ftype == TType.I32:
11067 
          self.status = iprot.readI32();
11068 
        else:
11069 
          iprot.skip(ftype)
11070 
      elif fid == 2:
11071 
        if ftype == TType.I64:
11072 
          self.start_billing_date = iprot.readI64();
11073 
        else:
11074 
          iprot.skip(ftype)
11075 
      elif fid == 3:
11076 
        if ftype == TType.I64:
11077 
          self.end_billing_date = iprot.readI64();
11078 
        else:
11079 
          iprot.skip(ftype)
11080 
      elif fid == 4:
11081 
        if ftype == TType.I64:
11082 
          self.warehouse_id = iprot.readI64();
11083 
        else:
11084 
          iprot.skip(ftype)
11085 
      else:
11086 
        iprot.skip(ftype)
11087 
      iprot.readFieldEnd()
11088 
    iprot.readStructEnd()
11089 
 
11090 
  def write(self, oprot):
11091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11093 
      return
11094 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 11095 
    if self.status is not None:
999 varun.gupt 11096 
      oprot.writeFieldBegin('status', TType.I32, 1)
11097 
      oprot.writeI32(self.status)
11098 
      oprot.writeFieldEnd()
3431 rajveer 11099 
    if self.start_billing_date is not None:
999 varun.gupt 11100 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
11101 
      oprot.writeI64(self.start_billing_date)
11102 
      oprot.writeFieldEnd()
3431 rajveer 11103 
    if self.end_billing_date is not None:
999 varun.gupt 11104 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
11105 
      oprot.writeI64(self.end_billing_date)
11106 
      oprot.writeFieldEnd()
3431 rajveer 11107 
    if self.warehouse_id is not None:
999 varun.gupt 11108 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
11109 
      oprot.writeI64(self.warehouse_id)
11110 
      oprot.writeFieldEnd()
11111 
    oprot.writeFieldStop()
11112 
    oprot.writeStructEnd()
11113 
 
3431 rajveer 11114 
  def validate(self):
11115 
    return
11116 
 
11117 
 
999 varun.gupt 11118 
  def __repr__(self):
11119 
    L = ['%s=%r' % (key, value)
11120 
      for key, value in self.__dict__.iteritems()]
11121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11122 
 
11123 
  def __eq__(self, other):
11124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11125 
 
11126 
  def __ne__(self, other):
11127 
    return not (self == other)
11128 
 
11129 
class getOrdersByBillingDate_result:
11130 
  """
11131 
  Attributes:
11132 
   - success
11133 
   - ex
11134 
  """
11135 
 
11136 
  thrift_spec = (
11137 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11138 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11139 
  )
11140 
 
11141 
  def __init__(self, success=None, ex=None,):
11142 
    self.success = success
11143 
    self.ex = ex
11144 
 
11145 
  def read(self, iprot):
11146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11148 
      return
11149 
    iprot.readStructBegin()
11150 
    while True:
11151 
      (fname, ftype, fid) = iprot.readFieldBegin()
11152 
      if ftype == TType.STOP:
11153 
        break
11154 
      if fid == 0:
11155 
        if ftype == TType.LIST:
11156 
          self.success = []
6188 rajveer 11157 
          (_etype158, _size155) = iprot.readListBegin()
11158 
          for _i159 in xrange(_size155):
11159 
            _elem160 = Order()
11160 
            _elem160.read(iprot)
11161 
            self.success.append(_elem160)
999 varun.gupt 11162 
          iprot.readListEnd()
11163 
        else:
11164 
          iprot.skip(ftype)
11165 
      elif fid == 1:
11166 
        if ftype == TType.STRUCT:
11167 
          self.ex = TransactionServiceException()
11168 
          self.ex.read(iprot)
11169 
        else:
11170 
          iprot.skip(ftype)
11171 
      else:
11172 
        iprot.skip(ftype)
11173 
      iprot.readFieldEnd()
11174 
    iprot.readStructEnd()
11175 
 
11176 
  def write(self, oprot):
11177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11179 
      return
11180 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 11181 
    if self.success is not None:
999 varun.gupt 11182 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11183 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11184 
      for iter161 in self.success:
11185 
        iter161.write(oprot)
999 varun.gupt 11186 
      oprot.writeListEnd()
11187 
      oprot.writeFieldEnd()
3431 rajveer 11188 
    if self.ex is not None:
999 varun.gupt 11189 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11190 
      self.ex.write(oprot)
11191 
      oprot.writeFieldEnd()
11192 
    oprot.writeFieldStop()
11193 
    oprot.writeStructEnd()
11194 
 
3431 rajveer 11195 
  def validate(self):
11196 
    return
11197 
 
11198 
 
999 varun.gupt 11199 
  def __repr__(self):
11200 
    L = ['%s=%r' % (key, value)
11201 
      for key, value in self.__dict__.iteritems()]
11202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11203 
 
11204 
  def __eq__(self, other):
11205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11206 
 
11207 
  def __ne__(self, other):
11208 
    return not (self == other)
11209 
 
3427 chandransh 11210 
class getOrdersByShippingDate_args:
11211 
  """
11212 
  Attributes:
11213 
   - fromShippingDate
11214 
   - toShippingDate
11215 
   - providerId
11216 
   - warehouseId
3451 chandransh 11217 
   - cod
3427 chandransh 11218 
  """
11219 
 
11220 
  thrift_spec = (
11221 
    None, # 0
11222 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
11223 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
11224 
    (3, TType.I64, 'providerId', None, None, ), # 3
11225 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 11226 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 11227 
  )
11228 
 
3451 chandransh 11229 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 11230 
    self.fromShippingDate = fromShippingDate
11231 
    self.toShippingDate = toShippingDate
11232 
    self.providerId = providerId
11233 
    self.warehouseId = warehouseId
3451 chandransh 11234 
    self.cod = cod
3427 chandransh 11235 
 
11236 
  def read(self, iprot):
11237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11239 
      return
11240 
    iprot.readStructBegin()
11241 
    while True:
11242 
      (fname, ftype, fid) = iprot.readFieldBegin()
11243 
      if ftype == TType.STOP:
11244 
        break
11245 
      if fid == 1:
11246 
        if ftype == TType.I64:
11247 
          self.fromShippingDate = iprot.readI64();
11248 
        else:
11249 
          iprot.skip(ftype)
11250 
      elif fid == 2:
11251 
        if ftype == TType.I64:
11252 
          self.toShippingDate = iprot.readI64();
11253 
        else:
11254 
          iprot.skip(ftype)
11255 
      elif fid == 3:
11256 
        if ftype == TType.I64:
11257 
          self.providerId = iprot.readI64();
11258 
        else:
11259 
          iprot.skip(ftype)
11260 
      elif fid == 4:
11261 
        if ftype == TType.I64:
11262 
          self.warehouseId = iprot.readI64();
11263 
        else:
11264 
          iprot.skip(ftype)
3451 chandransh 11265 
      elif fid == 5:
11266 
        if ftype == TType.BOOL:
11267 
          self.cod = iprot.readBool();
11268 
        else:
11269 
          iprot.skip(ftype)
3427 chandransh 11270 
      else:
11271 
        iprot.skip(ftype)
11272 
      iprot.readFieldEnd()
11273 
    iprot.readStructEnd()
11274 
 
11275 
  def write(self, oprot):
11276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11278 
      return
11279 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 11280 
    if self.fromShippingDate is not None:
3427 chandransh 11281 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
11282 
      oprot.writeI64(self.fromShippingDate)
11283 
      oprot.writeFieldEnd()
3431 rajveer 11284 
    if self.toShippingDate is not None:
3427 chandransh 11285 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
11286 
      oprot.writeI64(self.toShippingDate)
11287 
      oprot.writeFieldEnd()
3431 rajveer 11288 
    if self.providerId is not None:
3427 chandransh 11289 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
11290 
      oprot.writeI64(self.providerId)
11291 
      oprot.writeFieldEnd()
3431 rajveer 11292 
    if self.warehouseId is not None:
3427 chandransh 11293 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
11294 
      oprot.writeI64(self.warehouseId)
11295 
      oprot.writeFieldEnd()
3451 chandransh 11296 
    if self.cod is not None:
11297 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
11298 
      oprot.writeBool(self.cod)
11299 
      oprot.writeFieldEnd()
3427 chandransh 11300 
    oprot.writeFieldStop()
11301 
    oprot.writeStructEnd()
11302 
 
3431 rajveer 11303 
  def validate(self):
11304 
    return
11305 
 
11306 
 
3427 chandransh 11307 
  def __repr__(self):
11308 
    L = ['%s=%r' % (key, value)
11309 
      for key, value in self.__dict__.iteritems()]
11310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11311 
 
11312 
  def __eq__(self, other):
11313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11314 
 
11315 
  def __ne__(self, other):
11316 
    return not (self == other)
11317 
 
11318 
class getOrdersByShippingDate_result:
11319 
  """
11320 
  Attributes:
11321 
   - success
11322 
   - ex
11323 
  """
11324 
 
11325 
  thrift_spec = (
11326 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11327 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11328 
  )
11329 
 
11330 
  def __init__(self, success=None, ex=None,):
11331 
    self.success = success
11332 
    self.ex = ex
11333 
 
11334 
  def read(self, iprot):
11335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11337 
      return
11338 
    iprot.readStructBegin()
11339 
    while True:
11340 
      (fname, ftype, fid) = iprot.readFieldBegin()
11341 
      if ftype == TType.STOP:
11342 
        break
11343 
      if fid == 0:
11344 
        if ftype == TType.LIST:
11345 
          self.success = []
6188 rajveer 11346 
          (_etype165, _size162) = iprot.readListBegin()
11347 
          for _i166 in xrange(_size162):
11348 
            _elem167 = Order()
11349 
            _elem167.read(iprot)
11350 
            self.success.append(_elem167)
3427 chandransh 11351 
          iprot.readListEnd()
11352 
        else:
11353 
          iprot.skip(ftype)
11354 
      elif fid == 1:
11355 
        if ftype == TType.STRUCT:
11356 
          self.ex = TransactionServiceException()
11357 
          self.ex.read(iprot)
11358 
        else:
11359 
          iprot.skip(ftype)
11360 
      else:
11361 
        iprot.skip(ftype)
11362 
      iprot.readFieldEnd()
11363 
    iprot.readStructEnd()
11364 
 
11365 
  def write(self, oprot):
11366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11368 
      return
11369 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 11370 
    if self.success is not None:
3427 chandransh 11371 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11372 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11373 
      for iter168 in self.success:
11374 
        iter168.write(oprot)
3427 chandransh 11375 
      oprot.writeListEnd()
11376 
      oprot.writeFieldEnd()
3431 rajveer 11377 
    if self.ex is not None:
3427 chandransh 11378 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11379 
      self.ex.write(oprot)
11380 
      oprot.writeFieldEnd()
11381 
    oprot.writeFieldStop()
11382 
    oprot.writeStructEnd()
11383 
 
3431 rajveer 11384 
  def validate(self):
11385 
    return
11386 
 
11387 
 
3427 chandransh 11388 
  def __repr__(self):
11389 
    L = ['%s=%r' % (key, value)
11390 
      for key, value in self.__dict__.iteritems()]
11391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11392 
 
11393 
  def __eq__(self, other):
11394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11395 
 
11396 
  def __ne__(self, other):
11397 
    return not (self == other)
11398 
 
1382 varun.gupt 11399 
class getReturnableOrdersForCustomer_args:
11400 
  """
11401 
  Attributes:
11402 
   - customer_id
11403 
   - limit
11404 
  """
11405 
 
11406 
  thrift_spec = (
11407 
    None, # 0
11408 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11409 
    (2, TType.I64, 'limit', None, None, ), # 2
11410 
  )
11411 
 
11412 
  def __init__(self, customer_id=None, limit=None,):
11413 
    self.customer_id = customer_id
11414 
    self.limit = limit
11415 
 
11416 
  def read(self, iprot):
11417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11419 
      return
11420 
    iprot.readStructBegin()
11421 
    while True:
11422 
      (fname, ftype, fid) = iprot.readFieldBegin()
11423 
      if ftype == TType.STOP:
11424 
        break
11425 
      if fid == 1:
11426 
        if ftype == TType.I64:
11427 
          self.customer_id = iprot.readI64();
11428 
        else:
11429 
          iprot.skip(ftype)
11430 
      elif fid == 2:
11431 
        if ftype == TType.I64:
11432 
          self.limit = iprot.readI64();
11433 
        else:
11434 
          iprot.skip(ftype)
11435 
      else:
11436 
        iprot.skip(ftype)
11437 
      iprot.readFieldEnd()
11438 
    iprot.readStructEnd()
11439 
 
11440 
  def write(self, oprot):
11441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11443 
      return
11444 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 11445 
    if self.customer_id is not None:
1382 varun.gupt 11446 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11447 
      oprot.writeI64(self.customer_id)
11448 
      oprot.writeFieldEnd()
3431 rajveer 11449 
    if self.limit is not None:
1382 varun.gupt 11450 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11451 
      oprot.writeI64(self.limit)
11452 
      oprot.writeFieldEnd()
11453 
    oprot.writeFieldStop()
11454 
    oprot.writeStructEnd()
11455 
 
3431 rajveer 11456 
  def validate(self):
11457 
    return
11458 
 
11459 
 
1382 varun.gupt 11460 
  def __repr__(self):
11461 
    L = ['%s=%r' % (key, value)
11462 
      for key, value in self.__dict__.iteritems()]
11463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11464 
 
11465 
  def __eq__(self, other):
11466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11467 
 
11468 
  def __ne__(self, other):
11469 
    return not (self == other)
11470 
 
11471 
class getReturnableOrdersForCustomer_result:
11472 
  """
11473 
  Attributes:
11474 
   - success
11475 
   - ex
11476 
  """
11477 
 
11478 
  thrift_spec = (
11479 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11480 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11481 
  )
11482 
 
11483 
  def __init__(self, success=None, ex=None,):
11484 
    self.success = success
11485 
    self.ex = ex
11486 
 
11487 
  def read(self, iprot):
11488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11490 
      return
11491 
    iprot.readStructBegin()
11492 
    while True:
11493 
      (fname, ftype, fid) = iprot.readFieldBegin()
11494 
      if ftype == TType.STOP:
11495 
        break
11496 
      if fid == 0:
11497 
        if ftype == TType.LIST:
11498 
          self.success = []
6188 rajveer 11499 
          (_etype172, _size169) = iprot.readListBegin()
11500 
          for _i173 in xrange(_size169):
11501 
            _elem174 = iprot.readI64();
11502 
            self.success.append(_elem174)
1382 varun.gupt 11503 
          iprot.readListEnd()
11504 
        else:
11505 
          iprot.skip(ftype)
11506 
      elif fid == 1:
11507 
        if ftype == TType.STRUCT:
11508 
          self.ex = TransactionServiceException()
11509 
          self.ex.read(iprot)
11510 
        else:
11511 
          iprot.skip(ftype)
11512 
      else:
11513 
        iprot.skip(ftype)
11514 
      iprot.readFieldEnd()
11515 
    iprot.readStructEnd()
11516 
 
11517 
  def write(self, oprot):
11518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11520 
      return
11521 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 11522 
    if self.success is not None:
1382 varun.gupt 11523 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11524 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11525 
      for iter175 in self.success:
11526 
        oprot.writeI64(iter175)
1382 varun.gupt 11527 
      oprot.writeListEnd()
11528 
      oprot.writeFieldEnd()
3431 rajveer 11529 
    if self.ex is not None:
1382 varun.gupt 11530 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11531 
      self.ex.write(oprot)
11532 
      oprot.writeFieldEnd()
11533 
    oprot.writeFieldStop()
11534 
    oprot.writeStructEnd()
11535 
 
3431 rajveer 11536 
  def validate(self):
11537 
    return
11538 
 
11539 
 
1382 varun.gupt 11540 
  def __repr__(self):
11541 
    L = ['%s=%r' % (key, value)
11542 
      for key, value in self.__dict__.iteritems()]
11543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11544 
 
11545 
  def __eq__(self, other):
11546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11547 
 
11548 
  def __ne__(self, other):
11549 
    return not (self == other)
11550 
 
11551 
class getCancellableOrdersForCustomer_args:
11552 
  """
11553 
  Attributes:
11554 
   - customer_id
11555 
   - limit
11556 
  """
11557 
 
11558 
  thrift_spec = (
11559 
    None, # 0
11560 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11561 
    (2, TType.I64, 'limit', None, None, ), # 2
11562 
  )
11563 
 
11564 
  def __init__(self, customer_id=None, limit=None,):
11565 
    self.customer_id = customer_id
11566 
    self.limit = limit
11567 
 
11568 
  def read(self, iprot):
11569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11571 
      return
11572 
    iprot.readStructBegin()
11573 
    while True:
11574 
      (fname, ftype, fid) = iprot.readFieldBegin()
11575 
      if ftype == TType.STOP:
11576 
        break
11577 
      if fid == 1:
11578 
        if ftype == TType.I64:
11579 
          self.customer_id = iprot.readI64();
11580 
        else:
11581 
          iprot.skip(ftype)
11582 
      elif fid == 2:
11583 
        if ftype == TType.I64:
11584 
          self.limit = iprot.readI64();
11585 
        else:
11586 
          iprot.skip(ftype)
11587 
      else:
11588 
        iprot.skip(ftype)
11589 
      iprot.readFieldEnd()
11590 
    iprot.readStructEnd()
11591 
 
11592 
  def write(self, oprot):
11593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11595 
      return
11596 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 11597 
    if self.customer_id is not None:
1382 varun.gupt 11598 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11599 
      oprot.writeI64(self.customer_id)
11600 
      oprot.writeFieldEnd()
3431 rajveer 11601 
    if self.limit is not None:
1382 varun.gupt 11602 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11603 
      oprot.writeI64(self.limit)
11604 
      oprot.writeFieldEnd()
11605 
    oprot.writeFieldStop()
11606 
    oprot.writeStructEnd()
11607 
 
3431 rajveer 11608 
  def validate(self):
11609 
    return
11610 
 
11611 
 
1382 varun.gupt 11612 
  def __repr__(self):
11613 
    L = ['%s=%r' % (key, value)
11614 
      for key, value in self.__dict__.iteritems()]
11615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11616 
 
11617 
  def __eq__(self, other):
11618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11619 
 
11620 
  def __ne__(self, other):
11621 
    return not (self == other)
11622 
 
11623 
class getCancellableOrdersForCustomer_result:
11624 
  """
11625 
  Attributes:
11626 
   - success
11627 
   - ex
11628 
  """
11629 
 
11630 
  thrift_spec = (
11631 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11632 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11633 
  )
11634 
 
11635 
  def __init__(self, success=None, ex=None,):
11636 
    self.success = success
11637 
    self.ex = ex
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 
          (_etype179, _size176) = iprot.readListBegin()
11652 
          for _i180 in xrange(_size176):
11653 
            _elem181 = iprot.readI64();
11654 
            self.success.append(_elem181)
1382 varun.gupt 11655 
          iprot.readListEnd()
11656 
        else:
11657 
          iprot.skip(ftype)
11658 
      elif fid == 1:
11659 
        if ftype == TType.STRUCT:
11660 
          self.ex = TransactionServiceException()
11661 
          self.ex.read(iprot)
11662 
        else:
11663 
          iprot.skip(ftype)
11664 
      else:
11665 
        iprot.skip(ftype)
11666 
      iprot.readFieldEnd()
11667 
    iprot.readStructEnd()
11668 
 
11669 
  def write(self, oprot):
11670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11672 
      return
11673 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 11674 
    if self.success is not None:
1382 varun.gupt 11675 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11676 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11677 
      for iter182 in self.success:
11678 
        oprot.writeI64(iter182)
1382 varun.gupt 11679 
      oprot.writeListEnd()
11680 
      oprot.writeFieldEnd()
3431 rajveer 11681 
    if self.ex is not None:
1382 varun.gupt 11682 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11683 
      self.ex.write(oprot)
11684 
      oprot.writeFieldEnd()
11685 
    oprot.writeFieldStop()
11686 
    oprot.writeStructEnd()
11687 
 
3431 rajveer 11688 
  def validate(self):
11689 
    return
11690 
 
11691 
 
1382 varun.gupt 11692 
  def __repr__(self):
11693 
    L = ['%s=%r' % (key, value)
11694 
      for key, value in self.__dict__.iteritems()]
11695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11696 
 
11697 
  def __eq__(self, other):
11698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11699 
 
11700 
  def __ne__(self, other):
11701 
    return not (self == other)
11702 
 
483 rajveer 11703 
class changeOrderStatus_args:
94 ashish 11704 
  """
11705 
  Attributes:
483 rajveer 11706 
   - orderId
11707 
   - status
11708 
   - description
94 ashish 11709 
  """
11710 
 
11711 
  thrift_spec = (
11712 
    None, # 0
483 rajveer 11713 
    (1, TType.I64, 'orderId', None, None, ), # 1
11714 
    (2, TType.I32, 'status', None, None, ), # 2
11715 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11716 
  )
11717 
 
483 rajveer 11718 
  def __init__(self, orderId=None, status=None, description=None,):
11719 
    self.orderId = orderId
11720 
    self.status = status
11721 
    self.description = description
94 ashish 11722 
 
11723 
  def read(self, iprot):
11724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11726 
      return
11727 
    iprot.readStructBegin()
11728 
    while True:
11729 
      (fname, ftype, fid) = iprot.readFieldBegin()
11730 
      if ftype == TType.STOP:
11731 
        break
11732 
      if fid == 1:
11733 
        if ftype == TType.I64:
483 rajveer 11734 
          self.orderId = iprot.readI64();
94 ashish 11735 
        else:
11736 
          iprot.skip(ftype)
11737 
      elif fid == 2:
483 rajveer 11738 
        if ftype == TType.I32:
11739 
          self.status = iprot.readI32();
94 ashish 11740 
        else:
11741 
          iprot.skip(ftype)
483 rajveer 11742 
      elif fid == 3:
11743 
        if ftype == TType.STRING:
11744 
          self.description = iprot.readString();
11745 
        else:
11746 
          iprot.skip(ftype)
94 ashish 11747 
      else:
11748 
        iprot.skip(ftype)
11749 
      iprot.readFieldEnd()
11750 
    iprot.readStructEnd()
11751 
 
11752 
  def write(self, oprot):
11753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11755 
      return
483 rajveer 11756 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 11757 
    if self.orderId is not None:
483 rajveer 11758 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11759 
      oprot.writeI64(self.orderId)
94 ashish 11760 
      oprot.writeFieldEnd()
3431 rajveer 11761 
    if self.status is not None:
483 rajveer 11762 
      oprot.writeFieldBegin('status', TType.I32, 2)
11763 
      oprot.writeI32(self.status)
94 ashish 11764 
      oprot.writeFieldEnd()
3431 rajveer 11765 
    if self.description is not None:
483 rajveer 11766 
      oprot.writeFieldBegin('description', TType.STRING, 3)
11767 
      oprot.writeString(self.description)
11768 
      oprot.writeFieldEnd()
94 ashish 11769 
    oprot.writeFieldStop()
11770 
    oprot.writeStructEnd()
11771 
 
3431 rajveer 11772 
  def validate(self):
11773 
    return
11774 
 
11775 
 
94 ashish 11776 
  def __repr__(self):
11777 
    L = ['%s=%r' % (key, value)
11778 
      for key, value in self.__dict__.iteritems()]
11779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11780 
 
11781 
  def __eq__(self, other):
11782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11783 
 
11784 
  def __ne__(self, other):
11785 
    return not (self == other)
11786 
 
483 rajveer 11787 
class changeOrderStatus_result:
94 ashish 11788 
  """
11789 
  Attributes:
11790 
   - success
11791 
   - ex
11792 
  """
11793 
 
11794 
  thrift_spec = (
11795 
    (0, TType.BOOL, 'success', None, None, ), # 0
11796 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11797 
  )
11798 
 
11799 
  def __init__(self, success=None, ex=None,):
11800 
    self.success = success
11801 
    self.ex = ex
11802 
 
11803 
  def read(self, iprot):
11804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11806 
      return
11807 
    iprot.readStructBegin()
11808 
    while True:
11809 
      (fname, ftype, fid) = iprot.readFieldBegin()
11810 
      if ftype == TType.STOP:
11811 
        break
11812 
      if fid == 0:
11813 
        if ftype == TType.BOOL:
11814 
          self.success = iprot.readBool();
11815 
        else:
11816 
          iprot.skip(ftype)
11817 
      elif fid == 1:
11818 
        if ftype == TType.STRUCT:
11819 
          self.ex = TransactionServiceException()
11820 
          self.ex.read(iprot)
11821 
        else:
11822 
          iprot.skip(ftype)
11823 
      else:
11824 
        iprot.skip(ftype)
11825 
      iprot.readFieldEnd()
11826 
    iprot.readStructEnd()
11827 
 
11828 
  def write(self, oprot):
11829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11831 
      return
483 rajveer 11832 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 11833 
    if self.success is not None:
94 ashish 11834 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11835 
      oprot.writeBool(self.success)
11836 
      oprot.writeFieldEnd()
3431 rajveer 11837 
    if self.ex is not None:
94 ashish 11838 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11839 
      self.ex.write(oprot)
11840 
      oprot.writeFieldEnd()
11841 
    oprot.writeFieldStop()
11842 
    oprot.writeStructEnd()
11843 
 
3431 rajveer 11844 
  def validate(self):
11845 
    return
11846 
 
11847 
 
94 ashish 11848 
  def __repr__(self):
11849 
    L = ['%s=%r' % (key, value)
11850 
      for key, value in self.__dict__.iteritems()]
11851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11852 
 
11853 
  def __eq__(self, other):
11854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11855 
 
11856 
  def __ne__(self, other):
11857 
    return not (self == other)
11858 
 
3064 chandransh 11859 
class getOrdersForTransaction_args:
494 rajveer 11860 
  """
11861 
  Attributes:
3064 chandransh 11862 
   - transactionId
11863 
   - customerId
494 rajveer 11864 
  """
11865 
 
11866 
  thrift_spec = (
11867 
    None, # 0
3064 chandransh 11868 
    (1, TType.I64, 'transactionId', None, None, ), # 1
11869 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 11870 
  )
11871 
 
3064 chandransh 11872 
  def __init__(self, transactionId=None, customerId=None,):
11873 
    self.transactionId = transactionId
11874 
    self.customerId = customerId
494 rajveer 11875 
 
11876 
  def read(self, iprot):
11877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11879 
      return
11880 
    iprot.readStructBegin()
11881 
    while True:
11882 
      (fname, ftype, fid) = iprot.readFieldBegin()
11883 
      if ftype == TType.STOP:
11884 
        break
11885 
      if fid == 1:
11886 
        if ftype == TType.I64:
3064 chandransh 11887 
          self.transactionId = iprot.readI64();
494 rajveer 11888 
        else:
11889 
          iprot.skip(ftype)
11890 
      elif fid == 2:
3064 chandransh 11891 
        if ftype == TType.I64:
11892 
          self.customerId = iprot.readI64();
494 rajveer 11893 
        else:
11894 
          iprot.skip(ftype)
11895 
      else:
11896 
        iprot.skip(ftype)
11897 
      iprot.readFieldEnd()
11898 
    iprot.readStructEnd()
11899 
 
11900 
  def write(self, oprot):
11901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11903 
      return
3064 chandransh 11904 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 11905 
    if self.transactionId is not None:
3064 chandransh 11906 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
11907 
      oprot.writeI64(self.transactionId)
494 rajveer 11908 
      oprot.writeFieldEnd()
3431 rajveer 11909 
    if self.customerId is not None:
3064 chandransh 11910 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
11911 
      oprot.writeI64(self.customerId)
494 rajveer 11912 
      oprot.writeFieldEnd()
11913 
    oprot.writeFieldStop()
11914 
    oprot.writeStructEnd()
11915 
 
3431 rajveer 11916 
  def validate(self):
11917 
    return
11918 
 
11919 
 
494 rajveer 11920 
  def __repr__(self):
11921 
    L = ['%s=%r' % (key, value)
11922 
      for key, value in self.__dict__.iteritems()]
11923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11924 
 
11925 
  def __eq__(self, other):
11926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11927 
 
11928 
  def __ne__(self, other):
11929 
    return not (self == other)
11930 
 
3064 chandransh 11931 
class getOrdersForTransaction_result:
494 rajveer 11932 
  """
11933 
  Attributes:
11934 
   - success
11935 
   - ex
11936 
  """
11937 
 
11938 
  thrift_spec = (
3064 chandransh 11939 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 11940 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11941 
  )
11942 
 
11943 
  def __init__(self, success=None, ex=None,):
11944 
    self.success = success
11945 
    self.ex = ex
11946 
 
11947 
  def read(self, iprot):
11948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11950 
      return
11951 
    iprot.readStructBegin()
11952 
    while True:
11953 
      (fname, ftype, fid) = iprot.readFieldBegin()
11954 
      if ftype == TType.STOP:
11955 
        break
11956 
      if fid == 0:
3064 chandransh 11957 
        if ftype == TType.LIST:
11958 
          self.success = []
6188 rajveer 11959 
          (_etype186, _size183) = iprot.readListBegin()
11960 
          for _i187 in xrange(_size183):
11961 
            _elem188 = Order()
11962 
            _elem188.read(iprot)
11963 
            self.success.append(_elem188)
3064 chandransh 11964 
          iprot.readListEnd()
494 rajveer 11965 
        else:
11966 
          iprot.skip(ftype)
11967 
      elif fid == 1:
11968 
        if ftype == TType.STRUCT:
11969 
          self.ex = TransactionServiceException()
11970 
          self.ex.read(iprot)
11971 
        else:
11972 
          iprot.skip(ftype)
11973 
      else:
11974 
        iprot.skip(ftype)
11975 
      iprot.readFieldEnd()
11976 
    iprot.readStructEnd()
11977 
 
11978 
  def write(self, oprot):
11979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11981 
      return
3064 chandransh 11982 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 11983 
    if self.success is not None:
3064 chandransh 11984 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11985 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11986 
      for iter189 in self.success:
11987 
        iter189.write(oprot)
3064 chandransh 11988 
      oprot.writeListEnd()
494 rajveer 11989 
      oprot.writeFieldEnd()
3431 rajveer 11990 
    if self.ex is not None:
494 rajveer 11991 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11992 
      self.ex.write(oprot)
11993 
      oprot.writeFieldEnd()
11994 
    oprot.writeFieldStop()
11995 
    oprot.writeStructEnd()
11996 
 
3431 rajveer 11997 
  def validate(self):
11998 
    return
11999 
 
12000 
 
494 rajveer 12001 
  def __repr__(self):
12002 
    L = ['%s=%r' % (key, value)
12003 
      for key, value in self.__dict__.iteritems()]
12004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12005 
 
12006 
  def __eq__(self, other):
12007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12008 
 
12009 
  def __ne__(self, other):
12010 
    return not (self == other)
12011 
 
3064 chandransh 12012 
class getOrdersForCustomer_args:
1149 chandransh 12013 
  """
12014 
  Attributes:
3064 chandransh 12015 
   - customerId
12016 
   - from_date
12017 
   - to_date
12018 
   - statuses
1149 chandransh 12019 
  """
12020 
 
12021 
  thrift_spec = (
12022 
    None, # 0
3064 chandransh 12023 
    (1, TType.I64, 'customerId', None, None, ), # 1
12024 
    (2, TType.I64, 'from_date', None, None, ), # 2
12025 
    (3, TType.I64, 'to_date', None, None, ), # 3
12026 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 12027 
  )
12028 
 
3064 chandransh 12029 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
12030 
    self.customerId = customerId
12031 
    self.from_date = from_date
12032 
    self.to_date = to_date
12033 
    self.statuses = statuses
1149 chandransh 12034 
 
12035 
  def read(self, iprot):
12036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12038 
      return
12039 
    iprot.readStructBegin()
12040 
    while True:
12041 
      (fname, ftype, fid) = iprot.readFieldBegin()
12042 
      if ftype == TType.STOP:
12043 
        break
12044 
      if fid == 1:
12045 
        if ftype == TType.I64:
3064 chandransh 12046 
          self.customerId = iprot.readI64();
1149 chandransh 12047 
        else:
12048 
          iprot.skip(ftype)
12049 
      elif fid == 2:
12050 
        if ftype == TType.I64:
3064 chandransh 12051 
          self.from_date = iprot.readI64();
1149 chandransh 12052 
        else:
12053 
          iprot.skip(ftype)
2783 chandransh 12054 
      elif fid == 3:
12055 
        if ftype == TType.I64:
3064 chandransh 12056 
          self.to_date = iprot.readI64();
2783 chandransh 12057 
        else:
12058 
          iprot.skip(ftype)
12059 
      elif fid == 4:
3064 chandransh 12060 
        if ftype == TType.LIST:
12061 
          self.statuses = []
6188 rajveer 12062 
          (_etype193, _size190) = iprot.readListBegin()
12063 
          for _i194 in xrange(_size190):
12064 
            _elem195 = iprot.readI32();
12065 
            self.statuses.append(_elem195)
3064 chandransh 12066 
          iprot.readListEnd()
2783 chandransh 12067 
        else:
12068 
          iprot.skip(ftype)
1149 chandransh 12069 
      else:
12070 
        iprot.skip(ftype)
12071 
      iprot.readFieldEnd()
12072 
    iprot.readStructEnd()
12073 
 
12074 
  def write(self, oprot):
12075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12077 
      return
3064 chandransh 12078 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 12079 
    if self.customerId is not None:
3064 chandransh 12080 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
12081 
      oprot.writeI64(self.customerId)
1149 chandransh 12082 
      oprot.writeFieldEnd()
3431 rajveer 12083 
    if self.from_date is not None:
3064 chandransh 12084 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
12085 
      oprot.writeI64(self.from_date)
1149 chandransh 12086 
      oprot.writeFieldEnd()
3431 rajveer 12087 
    if self.to_date is not None:
3064 chandransh 12088 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
12089 
      oprot.writeI64(self.to_date)
2783 chandransh 12090 
      oprot.writeFieldEnd()
3431 rajveer 12091 
    if self.statuses is not None:
3064 chandransh 12092 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
12093 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 12094 
      for iter196 in self.statuses:
12095 
        oprot.writeI32(iter196)
3064 chandransh 12096 
      oprot.writeListEnd()
2783 chandransh 12097 
      oprot.writeFieldEnd()
1149 chandransh 12098 
    oprot.writeFieldStop()
12099 
    oprot.writeStructEnd()
12100 
 
3431 rajveer 12101 
  def validate(self):
12102 
    return
12103 
 
12104 
 
1149 chandransh 12105 
  def __repr__(self):
12106 
    L = ['%s=%r' % (key, value)
12107 
      for key, value in self.__dict__.iteritems()]
12108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12109 
 
12110 
  def __eq__(self, other):
12111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12112 
 
12113 
  def __ne__(self, other):
12114 
    return not (self == other)
12115 
 
3064 chandransh 12116 
class getOrdersForCustomer_result:
1149 chandransh 12117 
  """
12118 
  Attributes:
12119 
   - success
12120 
   - ex
12121 
  """
12122 
 
12123 
  thrift_spec = (
3064 chandransh 12124 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 12125 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12126 
  )
12127 
 
12128 
  def __init__(self, success=None, ex=None,):
12129 
    self.success = success
12130 
    self.ex = ex
12131 
 
12132 
  def read(self, iprot):
12133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12135 
      return
12136 
    iprot.readStructBegin()
12137 
    while True:
12138 
      (fname, ftype, fid) = iprot.readFieldBegin()
12139 
      if ftype == TType.STOP:
12140 
        break
12141 
      if fid == 0:
3064 chandransh 12142 
        if ftype == TType.LIST:
12143 
          self.success = []
6188 rajveer 12144 
          (_etype200, _size197) = iprot.readListBegin()
12145 
          for _i201 in xrange(_size197):
12146 
            _elem202 = Order()
12147 
            _elem202.read(iprot)
12148 
            self.success.append(_elem202)
3064 chandransh 12149 
          iprot.readListEnd()
1149 chandransh 12150 
        else:
12151 
          iprot.skip(ftype)
12152 
      elif fid == 1:
12153 
        if ftype == TType.STRUCT:
12154 
          self.ex = TransactionServiceException()
12155 
          self.ex.read(iprot)
12156 
        else:
12157 
          iprot.skip(ftype)
12158 
      else:
12159 
        iprot.skip(ftype)
12160 
      iprot.readFieldEnd()
12161 
    iprot.readStructEnd()
12162 
 
12163 
  def write(self, oprot):
12164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12166 
      return
3064 chandransh 12167 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 12168 
    if self.success is not None:
3064 chandransh 12169 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12170 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12171 
      for iter203 in self.success:
12172 
        iter203.write(oprot)
3064 chandransh 12173 
      oprot.writeListEnd()
1149 chandransh 12174 
      oprot.writeFieldEnd()
3431 rajveer 12175 
    if self.ex is not None:
1149 chandransh 12176 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12177 
      self.ex.write(oprot)
12178 
      oprot.writeFieldEnd()
12179 
    oprot.writeFieldStop()
12180 
    oprot.writeStructEnd()
12181 
 
3431 rajveer 12182 
  def validate(self):
12183 
    return
12184 
 
12185 
 
1149 chandransh 12186 
  def __repr__(self):
12187 
    L = ['%s=%r' % (key, value)
12188 
      for key, value in self.__dict__.iteritems()]
12189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12190 
 
12191 
  def __eq__(self, other):
12192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12193 
 
12194 
  def __ne__(self, other):
12195 
    return not (self == other)
12196 
 
3064 chandransh 12197 
class createOrder_args:
921 rajveer 12198 
  """
12199 
  Attributes:
3064 chandransh 12200 
   - order
921 rajveer 12201 
  """
12202 
 
12203 
  thrift_spec = (
12204 
    None, # 0
3064 chandransh 12205 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 12206 
  )
12207 
 
3064 chandransh 12208 
  def __init__(self, order=None,):
12209 
    self.order = order
921 rajveer 12210 
 
12211 
  def read(self, iprot):
12212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12214 
      return
12215 
    iprot.readStructBegin()
12216 
    while True:
12217 
      (fname, ftype, fid) = iprot.readFieldBegin()
12218 
      if ftype == TType.STOP:
12219 
        break
12220 
      if fid == 1:
3064 chandransh 12221 
        if ftype == TType.STRUCT:
12222 
          self.order = Order()
12223 
          self.order.read(iprot)
921 rajveer 12224 
        else:
12225 
          iprot.skip(ftype)
12226 
      else:
12227 
        iprot.skip(ftype)
12228 
      iprot.readFieldEnd()
12229 
    iprot.readStructEnd()
12230 
 
12231 
  def write(self, oprot):
12232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12234 
      return
3064 chandransh 12235 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 12236 
    if self.order is not None:
3064 chandransh 12237 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
12238 
      self.order.write(oprot)
921 rajveer 12239 
      oprot.writeFieldEnd()
12240 
    oprot.writeFieldStop()
12241 
    oprot.writeStructEnd()
12242 
 
3431 rajveer 12243 
  def validate(self):
12244 
    return
12245 
 
12246 
 
921 rajveer 12247 
  def __repr__(self):
12248 
    L = ['%s=%r' % (key, value)
12249 
      for key, value in self.__dict__.iteritems()]
12250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12251 
 
12252 
  def __eq__(self, other):
12253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12254 
 
12255 
  def __ne__(self, other):
12256 
    return not (self == other)
12257 
 
3064 chandransh 12258 
class createOrder_result:
921 rajveer 12259 
  """
12260 
  Attributes:
12261 
   - success
12262 
   - ex
12263 
  """
12264 
 
12265 
  thrift_spec = (
3064 chandransh 12266 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 12267 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12268 
  )
12269 
 
12270 
  def __init__(self, success=None, ex=None,):
12271 
    self.success = success
12272 
    self.ex = ex
12273 
 
12274 
  def read(self, iprot):
12275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12277 
      return
12278 
    iprot.readStructBegin()
12279 
    while True:
12280 
      (fname, ftype, fid) = iprot.readFieldBegin()
12281 
      if ftype == TType.STOP:
12282 
        break
12283 
      if fid == 0:
3064 chandransh 12284 
        if ftype == TType.I64:
12285 
          self.success = iprot.readI64();
921 rajveer 12286 
        else:
12287 
          iprot.skip(ftype)
12288 
      elif fid == 1:
12289 
        if ftype == TType.STRUCT:
12290 
          self.ex = TransactionServiceException()
12291 
          self.ex.read(iprot)
12292 
        else:
12293 
          iprot.skip(ftype)
12294 
      else:
12295 
        iprot.skip(ftype)
12296 
      iprot.readFieldEnd()
12297 
    iprot.readStructEnd()
12298 
 
12299 
  def write(self, oprot):
12300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12302 
      return
3064 chandransh 12303 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 12304 
    if self.success is not None:
3064 chandransh 12305 
      oprot.writeFieldBegin('success', TType.I64, 0)
12306 
      oprot.writeI64(self.success)
921 rajveer 12307 
      oprot.writeFieldEnd()
3431 rajveer 12308 
    if self.ex is not None:
921 rajveer 12309 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12310 
      self.ex.write(oprot)
12311 
      oprot.writeFieldEnd()
12312 
    oprot.writeFieldStop()
12313 
    oprot.writeStructEnd()
12314 
 
3431 rajveer 12315 
  def validate(self):
12316 
    return
12317 
 
12318 
 
921 rajveer 12319 
  def __repr__(self):
12320 
    L = ['%s=%r' % (key, value)
12321 
      for key, value in self.__dict__.iteritems()]
12322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12323 
 
12324 
  def __eq__(self, other):
12325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12326 
 
12327 
  def __ne__(self, other):
12328 
    return not (self == other)
12329 
 
3064 chandransh 12330 
class getOrder_args:
921 rajveer 12331 
  """
12332 
  Attributes:
3064 chandransh 12333 
   - id
921 rajveer 12334 
  """
12335 
 
12336 
  thrift_spec = (
12337 
    None, # 0
3064 chandransh 12338 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 12339 
  )
12340 
 
3064 chandransh 12341 
  def __init__(self, id=None,):
12342 
    self.id = id
921 rajveer 12343 
 
12344 
  def read(self, iprot):
12345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12347 
      return
12348 
    iprot.readStructBegin()
12349 
    while True:
12350 
      (fname, ftype, fid) = iprot.readFieldBegin()
12351 
      if ftype == TType.STOP:
12352 
        break
12353 
      if fid == 1:
12354 
        if ftype == TType.I64:
3064 chandransh 12355 
          self.id = iprot.readI64();
921 rajveer 12356 
        else:
12357 
          iprot.skip(ftype)
12358 
      else:
12359 
        iprot.skip(ftype)
12360 
      iprot.readFieldEnd()
12361 
    iprot.readStructEnd()
12362 
 
12363 
  def write(self, oprot):
12364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12366 
      return
3064 chandransh 12367 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 12368 
    if self.id is not None:
3064 chandransh 12369 
      oprot.writeFieldBegin('id', TType.I64, 1)
12370 
      oprot.writeI64(self.id)
921 rajveer 12371 
      oprot.writeFieldEnd()
12372 
    oprot.writeFieldStop()
12373 
    oprot.writeStructEnd()
12374 
 
3431 rajveer 12375 
  def validate(self):
12376 
    return
12377 
 
12378 
 
921 rajveer 12379 
  def __repr__(self):
12380 
    L = ['%s=%r' % (key, value)
12381 
      for key, value in self.__dict__.iteritems()]
12382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12383 
 
12384 
  def __eq__(self, other):
12385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12386 
 
12387 
  def __ne__(self, other):
12388 
    return not (self == other)
12389 
 
3064 chandransh 12390 
class getOrder_result:
921 rajveer 12391 
  """
12392 
  Attributes:
12393 
   - success
12394 
   - ex
12395 
  """
12396 
 
12397 
  thrift_spec = (
3064 chandransh 12398 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 12399 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12400 
  )
12401 
 
12402 
  def __init__(self, success=None, ex=None,):
12403 
    self.success = success
12404 
    self.ex = ex
12405 
 
12406 
  def read(self, iprot):
12407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12409 
      return
12410 
    iprot.readStructBegin()
12411 
    while True:
12412 
      (fname, ftype, fid) = iprot.readFieldBegin()
12413 
      if ftype == TType.STOP:
12414 
        break
12415 
      if fid == 0:
3064 chandransh 12416 
        if ftype == TType.STRUCT:
12417 
          self.success = Order()
12418 
          self.success.read(iprot)
921 rajveer 12419 
        else:
12420 
          iprot.skip(ftype)
12421 
      elif fid == 1:
12422 
        if ftype == TType.STRUCT:
12423 
          self.ex = TransactionServiceException()
12424 
          self.ex.read(iprot)
12425 
        else:
12426 
          iprot.skip(ftype)
12427 
      else:
12428 
        iprot.skip(ftype)
12429 
      iprot.readFieldEnd()
12430 
    iprot.readStructEnd()
12431 
 
12432 
  def write(self, oprot):
12433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12435 
      return
3064 chandransh 12436 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 12437 
    if self.success is not None:
3064 chandransh 12438 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12439 
      self.success.write(oprot)
921 rajveer 12440 
      oprot.writeFieldEnd()
3431 rajveer 12441 
    if self.ex is not None:
921 rajveer 12442 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12443 
      self.ex.write(oprot)
12444 
      oprot.writeFieldEnd()
12445 
    oprot.writeFieldStop()
12446 
    oprot.writeStructEnd()
12447 
 
3431 rajveer 12448 
  def validate(self):
12449 
    return
12450 
 
12451 
 
921 rajveer 12452 
  def __repr__(self):
12453 
    L = ['%s=%r' % (key, value)
12454 
      for key, value in self.__dict__.iteritems()]
12455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12456 
 
12457 
  def __eq__(self, other):
12458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12459 
 
12460 
  def __ne__(self, other):
12461 
    return not (self == other)
12462 
 
3064 chandransh 12463 
class getLineItemsForOrder_args:
94 ashish 12464 
  """
12465 
  Attributes:
3064 chandransh 12466 
   - orderId
94 ashish 12467 
  """
12468 
 
12469 
  thrift_spec = (
12470 
    None, # 0
3064 chandransh 12471 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 12472 
  )
12473 
 
3064 chandransh 12474 
  def __init__(self, orderId=None,):
12475 
    self.orderId = orderId
94 ashish 12476 
 
12477 
  def read(self, iprot):
12478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12480 
      return
12481 
    iprot.readStructBegin()
12482 
    while True:
12483 
      (fname, ftype, fid) = iprot.readFieldBegin()
12484 
      if ftype == TType.STOP:
12485 
        break
12486 
      if fid == 1:
12487 
        if ftype == TType.I64:
3064 chandransh 12488 
          self.orderId = iprot.readI64();
94 ashish 12489 
        else:
12490 
          iprot.skip(ftype)
12491 
      else:
12492 
        iprot.skip(ftype)
12493 
      iprot.readFieldEnd()
12494 
    iprot.readStructEnd()
12495 
 
12496 
  def write(self, oprot):
12497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12499 
      return
3064 chandransh 12500 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 12501 
    if self.orderId is not None:
3064 chandransh 12502 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12503 
      oprot.writeI64(self.orderId)
94 ashish 12504 
      oprot.writeFieldEnd()
12505 
    oprot.writeFieldStop()
12506 
    oprot.writeStructEnd()
12507 
 
3431 rajveer 12508 
  def validate(self):
12509 
    return
12510 
 
12511 
 
94 ashish 12512 
  def __repr__(self):
12513 
    L = ['%s=%r' % (key, value)
12514 
      for key, value in self.__dict__.iteritems()]
12515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12516 
 
12517 
  def __eq__(self, other):
12518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12519 
 
12520 
  def __ne__(self, other):
12521 
    return not (self == other)
12522 
 
3064 chandransh 12523 
class getLineItemsForOrder_result:
94 ashish 12524 
  """
12525 
  Attributes:
12526 
   - success
12527 
   - ex
12528 
  """
12529 
 
12530 
  thrift_spec = (
3064 chandransh 12531 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 12532 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12533 
  )
12534 
 
12535 
  def __init__(self, success=None, ex=None,):
12536 
    self.success = success
12537 
    self.ex = ex
12538 
 
12539 
  def read(self, iprot):
12540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12542 
      return
12543 
    iprot.readStructBegin()
12544 
    while True:
12545 
      (fname, ftype, fid) = iprot.readFieldBegin()
12546 
      if ftype == TType.STOP:
12547 
        break
12548 
      if fid == 0:
483 rajveer 12549 
        if ftype == TType.LIST:
12550 
          self.success = []
6188 rajveer 12551 
          (_etype207, _size204) = iprot.readListBegin()
12552 
          for _i208 in xrange(_size204):
12553 
            _elem209 = LineItem()
12554 
            _elem209.read(iprot)
12555 
            self.success.append(_elem209)
483 rajveer 12556 
          iprot.readListEnd()
94 ashish 12557 
        else:
12558 
          iprot.skip(ftype)
12559 
      elif fid == 1:
12560 
        if ftype == TType.STRUCT:
12561 
          self.ex = TransactionServiceException()
12562 
          self.ex.read(iprot)
12563 
        else:
12564 
          iprot.skip(ftype)
12565 
      else:
12566 
        iprot.skip(ftype)
12567 
      iprot.readFieldEnd()
12568 
    iprot.readStructEnd()
12569 
 
12570 
  def write(self, oprot):
12571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12573 
      return
3064 chandransh 12574 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 12575 
    if self.success is not None:
483 rajveer 12576 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12577 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12578 
      for iter210 in self.success:
12579 
        iter210.write(oprot)
483 rajveer 12580 
      oprot.writeListEnd()
94 ashish 12581 
      oprot.writeFieldEnd()
3431 rajveer 12582 
    if self.ex is not None:
94 ashish 12583 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12584 
      self.ex.write(oprot)
12585 
      oprot.writeFieldEnd()
12586 
    oprot.writeFieldStop()
12587 
    oprot.writeStructEnd()
12588 
 
3431 rajveer 12589 
  def validate(self):
12590 
    return
12591 
 
12592 
 
94 ashish 12593 
  def __repr__(self):
12594 
    L = ['%s=%r' % (key, value)
12595 
      for key, value in self.__dict__.iteritems()]
12596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12597 
 
12598 
  def __eq__(self, other):
12599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12600 
 
12601 
  def __ne__(self, other):
12602 
    return not (self == other)
12603 
 
4999 phani.kuma 12604 
class getOrderList_args:
12605 
  """
12606 
  Attributes:
12607 
   - order_ids
12608 
  """
12609 
 
12610 
  thrift_spec = (
12611 
    None, # 0
12612 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12613 
  )
12614 
 
12615 
  def __init__(self, order_ids=None,):
12616 
    self.order_ids = order_ids
12617 
 
12618 
  def read(self, iprot):
12619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12621 
      return
12622 
    iprot.readStructBegin()
12623 
    while True:
12624 
      (fname, ftype, fid) = iprot.readFieldBegin()
12625 
      if ftype == TType.STOP:
12626 
        break
12627 
      if fid == 1:
12628 
        if ftype == TType.LIST:
12629 
          self.order_ids = []
6188 rajveer 12630 
          (_etype214, _size211) = iprot.readListBegin()
12631 
          for _i215 in xrange(_size211):
12632 
            _elem216 = iprot.readI64();
12633 
            self.order_ids.append(_elem216)
4999 phani.kuma 12634 
          iprot.readListEnd()
12635 
        else:
12636 
          iprot.skip(ftype)
12637 
      else:
12638 
        iprot.skip(ftype)
12639 
      iprot.readFieldEnd()
12640 
    iprot.readStructEnd()
12641 
 
12642 
  def write(self, oprot):
12643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12645 
      return
12646 
    oprot.writeStructBegin('getOrderList_args')
12647 
    if self.order_ids is not None:
12648 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12649 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12650 
      for iter217 in self.order_ids:
12651 
        oprot.writeI64(iter217)
4999 phani.kuma 12652 
      oprot.writeListEnd()
12653 
      oprot.writeFieldEnd()
12654 
    oprot.writeFieldStop()
12655 
    oprot.writeStructEnd()
12656 
 
12657 
  def validate(self):
12658 
    return
12659 
 
12660 
 
12661 
  def __repr__(self):
12662 
    L = ['%s=%r' % (key, value)
12663 
      for key, value in self.__dict__.iteritems()]
12664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12665 
 
12666 
  def __eq__(self, other):
12667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12668 
 
12669 
  def __ne__(self, other):
12670 
    return not (self == other)
12671 
 
12672 
class getOrderList_result:
12673 
  """
12674 
  Attributes:
12675 
   - success
12676 
  """
12677 
 
12678 
  thrift_spec = (
12679 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12680 
  )
12681 
 
12682 
  def __init__(self, success=None,):
12683 
    self.success = success
12684 
 
12685 
  def read(self, iprot):
12686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12688 
      return
12689 
    iprot.readStructBegin()
12690 
    while True:
12691 
      (fname, ftype, fid) = iprot.readFieldBegin()
12692 
      if ftype == TType.STOP:
12693 
        break
12694 
      if fid == 0:
12695 
        if ftype == TType.LIST:
12696 
          self.success = []
6188 rajveer 12697 
          (_etype221, _size218) = iprot.readListBegin()
12698 
          for _i222 in xrange(_size218):
12699 
            _elem223 = Order()
12700 
            _elem223.read(iprot)
12701 
            self.success.append(_elem223)
4999 phani.kuma 12702 
          iprot.readListEnd()
12703 
        else:
12704 
          iprot.skip(ftype)
12705 
      else:
12706 
        iprot.skip(ftype)
12707 
      iprot.readFieldEnd()
12708 
    iprot.readStructEnd()
12709 
 
12710 
  def write(self, oprot):
12711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12713 
      return
12714 
    oprot.writeStructBegin('getOrderList_result')
12715 
    if self.success is not None:
12716 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12717 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12718 
      for iter224 in self.success:
12719 
        iter224.write(oprot)
4999 phani.kuma 12720 
      oprot.writeListEnd()
12721 
      oprot.writeFieldEnd()
12722 
    oprot.writeFieldStop()
12723 
    oprot.writeStructEnd()
12724 
 
12725 
  def validate(self):
12726 
    return
12727 
 
12728 
 
12729 
  def __repr__(self):
12730 
    L = ['%s=%r' % (key, value)
12731 
      for key, value in self.__dict__.iteritems()]
12732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12733 
 
12734 
  def __eq__(self, other):
12735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12736 
 
12737 
  def __ne__(self, other):
12738 
    return not (self == other)
12739 
 
5386 phani.kuma 12740 
class getOrderListForVendor_args:
12741 
  """
12742 
  Attributes:
12743 
   - order_ids
12744 
   - vendorId
12745 
  """
12746 
 
12747 
  thrift_spec = (
12748 
    None, # 0
12749 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12750 
    (2, TType.I64, 'vendorId', None, None, ), # 2
12751 
  )
12752 
 
12753 
  def __init__(self, order_ids=None, vendorId=None,):
12754 
    self.order_ids = order_ids
12755 
    self.vendorId = vendorId
12756 
 
12757 
  def read(self, iprot):
12758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12760 
      return
12761 
    iprot.readStructBegin()
12762 
    while True:
12763 
      (fname, ftype, fid) = iprot.readFieldBegin()
12764 
      if ftype == TType.STOP:
12765 
        break
12766 
      if fid == 1:
12767 
        if ftype == TType.LIST:
12768 
          self.order_ids = []
6188 rajveer 12769 
          (_etype228, _size225) = iprot.readListBegin()
12770 
          for _i229 in xrange(_size225):
12771 
            _elem230 = iprot.readI64();
12772 
            self.order_ids.append(_elem230)
5386 phani.kuma 12773 
          iprot.readListEnd()
12774 
        else:
12775 
          iprot.skip(ftype)
12776 
      elif fid == 2:
12777 
        if ftype == TType.I64:
12778 
          self.vendorId = iprot.readI64();
12779 
        else:
12780 
          iprot.skip(ftype)
12781 
      else:
12782 
        iprot.skip(ftype)
12783 
      iprot.readFieldEnd()
12784 
    iprot.readStructEnd()
12785 
 
12786 
  def write(self, oprot):
12787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12789 
      return
12790 
    oprot.writeStructBegin('getOrderListForVendor_args')
12791 
    if self.order_ids is not None:
12792 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12793 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12794 
      for iter231 in self.order_ids:
12795 
        oprot.writeI64(iter231)
5386 phani.kuma 12796 
      oprot.writeListEnd()
12797 
      oprot.writeFieldEnd()
12798 
    if self.vendorId is not None:
12799 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
12800 
      oprot.writeI64(self.vendorId)
12801 
      oprot.writeFieldEnd()
12802 
    oprot.writeFieldStop()
12803 
    oprot.writeStructEnd()
12804 
 
12805 
  def validate(self):
12806 
    return
12807 
 
12808 
 
12809 
  def __repr__(self):
12810 
    L = ['%s=%r' % (key, value)
12811 
      for key, value in self.__dict__.iteritems()]
12812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12813 
 
12814 
  def __eq__(self, other):
12815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12816 
 
12817 
  def __ne__(self, other):
12818 
    return not (self == other)
12819 
 
12820 
class getOrderListForVendor_result:
12821 
  """
12822 
  Attributes:
12823 
   - success
12824 
  """
12825 
 
12826 
  thrift_spec = (
12827 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12828 
  )
12829 
 
12830 
  def __init__(self, success=None,):
12831 
    self.success = success
12832 
 
12833 
  def read(self, iprot):
12834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12836 
      return
12837 
    iprot.readStructBegin()
12838 
    while True:
12839 
      (fname, ftype, fid) = iprot.readFieldBegin()
12840 
      if ftype == TType.STOP:
12841 
        break
12842 
      if fid == 0:
12843 
        if ftype == TType.LIST:
12844 
          self.success = []
6188 rajveer 12845 
          (_etype235, _size232) = iprot.readListBegin()
12846 
          for _i236 in xrange(_size232):
12847 
            _elem237 = Order()
12848 
            _elem237.read(iprot)
12849 
            self.success.append(_elem237)
5386 phani.kuma 12850 
          iprot.readListEnd()
12851 
        else:
12852 
          iprot.skip(ftype)
12853 
      else:
12854 
        iprot.skip(ftype)
12855 
      iprot.readFieldEnd()
12856 
    iprot.readStructEnd()
12857 
 
12858 
  def write(self, oprot):
12859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12861 
      return
12862 
    oprot.writeStructBegin('getOrderListForVendor_result')
12863 
    if self.success is not None:
12864 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12865 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12866 
      for iter238 in self.success:
12867 
        iter238.write(oprot)
5386 phani.kuma 12868 
      oprot.writeListEnd()
12869 
      oprot.writeFieldEnd()
12870 
    oprot.writeFieldStop()
12871 
    oprot.writeStructEnd()
12872 
 
12873 
  def validate(self):
12874 
    return
12875 
 
12876 
 
12877 
  def __repr__(self):
12878 
    L = ['%s=%r' % (key, value)
12879 
      for key, value in self.__dict__.iteritems()]
12880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12881 
 
12882 
  def __eq__(self, other):
12883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12884 
 
12885 
  def __ne__(self, other):
12886 
    return not (self == other)
12887 
 
3064 chandransh 12888 
class getOrderForCustomer_args:
94 ashish 12889 
  """
12890 
  Attributes:
3064 chandransh 12891 
   - orderId
483 rajveer 12892 
   - customerId
94 ashish 12893 
  """
12894 
 
12895 
  thrift_spec = (
12896 
    None, # 0
3064 chandransh 12897 
    (1, TType.I64, 'orderId', None, None, ), # 1
12898 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 12899 
  )
12900 
 
3064 chandransh 12901 
  def __init__(self, orderId=None, customerId=None,):
12902 
    self.orderId = orderId
483 rajveer 12903 
    self.customerId = customerId
94 ashish 12904 
 
12905 
  def read(self, iprot):
12906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12908 
      return
12909 
    iprot.readStructBegin()
12910 
    while True:
12911 
      (fname, ftype, fid) = iprot.readFieldBegin()
12912 
      if ftype == TType.STOP:
12913 
        break
12914 
      if fid == 1:
12915 
        if ftype == TType.I64:
3064 chandransh 12916 
          self.orderId = iprot.readI64();
94 ashish 12917 
        else:
12918 
          iprot.skip(ftype)
12919 
      elif fid == 2:
12920 
        if ftype == TType.I64:
3064 chandransh 12921 
          self.customerId = iprot.readI64();
94 ashish 12922 
        else:
12923 
          iprot.skip(ftype)
12924 
      else:
12925 
        iprot.skip(ftype)
12926 
      iprot.readFieldEnd()
12927 
    iprot.readStructEnd()
12928 
 
12929 
  def write(self, oprot):
12930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12932 
      return
3064 chandransh 12933 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 12934 
    if self.orderId is not None:
3064 chandransh 12935 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12936 
      oprot.writeI64(self.orderId)
12937 
      oprot.writeFieldEnd()
3431 rajveer 12938 
    if self.customerId is not None:
3064 chandransh 12939 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 12940 
      oprot.writeI64(self.customerId)
94 ashish 12941 
      oprot.writeFieldEnd()
12942 
    oprot.writeFieldStop()
12943 
    oprot.writeStructEnd()
12944 
 
3431 rajveer 12945 
  def validate(self):
12946 
    return
12947 
 
12948 
 
94 ashish 12949 
  def __repr__(self):
12950 
    L = ['%s=%r' % (key, value)
12951 
      for key, value in self.__dict__.iteritems()]
12952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12953 
 
12954 
  def __eq__(self, other):
12955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12956 
 
12957 
  def __ne__(self, other):
12958 
    return not (self == other)
12959 
 
3064 chandransh 12960 
class getOrderForCustomer_result:
94 ashish 12961 
  """
12962 
  Attributes:
12963 
   - success
12964 
   - ex
12965 
  """
12966 
 
12967 
  thrift_spec = (
3064 chandransh 12968 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 12969 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12970 
  )
12971 
 
12972 
  def __init__(self, success=None, ex=None,):
12973 
    self.success = success
12974 
    self.ex = ex
12975 
 
12976 
  def read(self, iprot):
12977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12979 
      return
12980 
    iprot.readStructBegin()
12981 
    while True:
12982 
      (fname, ftype, fid) = iprot.readFieldBegin()
12983 
      if ftype == TType.STOP:
12984 
        break
12985 
      if fid == 0:
3064 chandransh 12986 
        if ftype == TType.STRUCT:
12987 
          self.success = Order()
12988 
          self.success.read(iprot)
94 ashish 12989 
        else:
12990 
          iprot.skip(ftype)
12991 
      elif fid == 1:
12992 
        if ftype == TType.STRUCT:
12993 
          self.ex = TransactionServiceException()
12994 
          self.ex.read(iprot)
12995 
        else:
12996 
          iprot.skip(ftype)
12997 
      else:
12998 
        iprot.skip(ftype)
12999 
      iprot.readFieldEnd()
13000 
    iprot.readStructEnd()
13001 
 
13002 
  def write(self, oprot):
13003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13005 
      return
3064 chandransh 13006 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 13007 
    if self.success is not None:
3064 chandransh 13008 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13009 
      self.success.write(oprot)
94 ashish 13010 
      oprot.writeFieldEnd()
3431 rajveer 13011 
    if self.ex is not None:
94 ashish 13012 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13013 
      self.ex.write(oprot)
13014 
      oprot.writeFieldEnd()
13015 
    oprot.writeFieldStop()
13016 
    oprot.writeStructEnd()
13017 
 
3431 rajveer 13018 
  def validate(self):
13019 
    return
13020 
 
13021 
 
94 ashish 13022 
  def __repr__(self):
13023 
    L = ['%s=%r' % (key, value)
13024 
      for key, value in self.__dict__.iteritems()]
13025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13026 
 
13027 
  def __eq__(self, other):
13028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13029 
 
13030 
  def __ne__(self, other):
13031 
    return not (self == other)
13032 
 
3064 chandransh 13033 
class getAlerts_args:
94 ashish 13034 
  """
13035 
  Attributes:
4394 rajveer 13036 
   - type
4444 rajveer 13037 
   - warehouseId
4394 rajveer 13038 
   - status
13039 
   - timestamp
94 ashish 13040 
  """
13041 
 
13042 
  thrift_spec = (
13043 
    None, # 0
4394 rajveer 13044 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 13045 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13046 
    (3, TType.I64, 'status', None, None, ), # 3
13047 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 13048 
  )
13049 
 
4444 rajveer 13050 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 13051 
    self.type = type
4444 rajveer 13052 
    self.warehouseId = warehouseId
4394 rajveer 13053 
    self.status = status
13054 
    self.timestamp = timestamp
94 ashish 13055 
 
13056 
  def read(self, iprot):
13057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13059 
      return
13060 
    iprot.readStructBegin()
13061 
    while True:
13062 
      (fname, ftype, fid) = iprot.readFieldBegin()
13063 
      if ftype == TType.STOP:
13064 
        break
13065 
      if fid == 1:
3064 chandransh 13066 
        if ftype == TType.I64:
4394 rajveer 13067 
          self.type = iprot.readI64();
94 ashish 13068 
        else:
13069 
          iprot.skip(ftype)
3064 chandransh 13070 
      elif fid == 2:
4394 rajveer 13071 
        if ftype == TType.I64:
4444 rajveer 13072 
          self.warehouseId = iprot.readI64();
3064 chandransh 13073 
        else:
13074 
          iprot.skip(ftype)
4394 rajveer 13075 
      elif fid == 3:
13076 
        if ftype == TType.I64:
4444 rajveer 13077 
          self.status = iprot.readI64();
13078 
        else:
13079 
          iprot.skip(ftype)
13080 
      elif fid == 4:
13081 
        if ftype == TType.I64:
4394 rajveer 13082 
          self.timestamp = iprot.readI64();
13083 
        else:
13084 
          iprot.skip(ftype)
94 ashish 13085 
      else:
13086 
        iprot.skip(ftype)
13087 
      iprot.readFieldEnd()
13088 
    iprot.readStructEnd()
13089 
 
13090 
  def write(self, oprot):
13091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13093 
      return
3064 chandransh 13094 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 13095 
    if self.type is not None:
13096 
      oprot.writeFieldBegin('type', TType.I64, 1)
13097 
      oprot.writeI64(self.type)
94 ashish 13098 
      oprot.writeFieldEnd()
4444 rajveer 13099 
    if self.warehouseId is not None:
13100 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13101 
      oprot.writeI64(self.warehouseId)
13102 
      oprot.writeFieldEnd()
4394 rajveer 13103 
    if self.status is not None:
4444 rajveer 13104 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 13105 
      oprot.writeI64(self.status)
3064 chandransh 13106 
      oprot.writeFieldEnd()
4394 rajveer 13107 
    if self.timestamp is not None:
4444 rajveer 13108 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 13109 
      oprot.writeI64(self.timestamp)
13110 
      oprot.writeFieldEnd()
94 ashish 13111 
    oprot.writeFieldStop()
13112 
    oprot.writeStructEnd()
13113 
 
3431 rajveer 13114 
  def validate(self):
13115 
    return
13116 
 
13117 
 
94 ashish 13118 
  def __repr__(self):
13119 
    L = ['%s=%r' % (key, value)
13120 
      for key, value in self.__dict__.iteritems()]
13121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13122 
 
13123 
  def __eq__(self, other):
13124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13125 
 
13126 
  def __ne__(self, other):
13127 
    return not (self == other)
13128 
 
3064 chandransh 13129 
class getAlerts_result:
94 ashish 13130 
  """
13131 
  Attributes:
13132 
   - success
13133 
  """
13134 
 
13135 
  thrift_spec = (
3064 chandransh 13136 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 13137 
  )
13138 
 
3064 chandransh 13139 
  def __init__(self, success=None,):
94 ashish 13140 
    self.success = success
13141 
 
13142 
  def read(self, iprot):
13143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13145 
      return
13146 
    iprot.readStructBegin()
13147 
    while True:
13148 
      (fname, ftype, fid) = iprot.readFieldBegin()
13149 
      if ftype == TType.STOP:
13150 
        break
13151 
      if fid == 0:
3064 chandransh 13152 
        if ftype == TType.LIST:
13153 
          self.success = []
6188 rajveer 13154 
          (_etype242, _size239) = iprot.readListBegin()
13155 
          for _i243 in xrange(_size239):
13156 
            _elem244 = Alert()
13157 
            _elem244.read(iprot)
13158 
            self.success.append(_elem244)
3064 chandransh 13159 
          iprot.readListEnd()
94 ashish 13160 
        else:
13161 
          iprot.skip(ftype)
13162 
      else:
13163 
        iprot.skip(ftype)
13164 
      iprot.readFieldEnd()
13165 
    iprot.readStructEnd()
13166 
 
13167 
  def write(self, oprot):
13168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13170 
      return
3064 chandransh 13171 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 13172 
    if self.success is not None:
3064 chandransh 13173 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13174 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13175 
      for iter245 in self.success:
13176 
        iter245.write(oprot)
3064 chandransh 13177 
      oprot.writeListEnd()
94 ashish 13178 
      oprot.writeFieldEnd()
13179 
    oprot.writeFieldStop()
13180 
    oprot.writeStructEnd()
13181 
 
3431 rajveer 13182 
  def validate(self):
13183 
    return
13184 
 
13185 
 
94 ashish 13186 
  def __repr__(self):
13187 
    L = ['%s=%r' % (key, value)
13188 
      for key, value in self.__dict__.iteritems()]
13189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13190 
 
13191 
  def __eq__(self, other):
13192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13193 
 
13194 
  def __ne__(self, other):
13195 
    return not (self == other)
13196 
 
4394 rajveer 13197 
class addAlert_args:
94 ashish 13198 
  """
13199 
  Attributes:
3064 chandransh 13200 
   - type
4444 rajveer 13201 
   - warehouseId
4394 rajveer 13202 
   - description
94 ashish 13203 
  """
13204 
 
13205 
  thrift_spec = (
13206 
    None, # 0
4394 rajveer 13207 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 13208 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13209 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 13210 
  )
13211 
 
4444 rajveer 13212 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 13213 
    self.type = type
4444 rajveer 13214 
    self.warehouseId = warehouseId
4394 rajveer 13215 
    self.description = description
94 ashish 13216 
 
13217 
  def read(self, iprot):
13218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13220 
      return
13221 
    iprot.readStructBegin()
13222 
    while True:
13223 
      (fname, ftype, fid) = iprot.readFieldBegin()
13224 
      if ftype == TType.STOP:
13225 
        break
13226 
      if fid == 1:
13227 
        if ftype == TType.I64:
4394 rajveer 13228 
          self.type = iprot.readI64();
94 ashish 13229 
        else:
13230 
          iprot.skip(ftype)
3064 chandransh 13231 
      elif fid == 2:
4444 rajveer 13232 
        if ftype == TType.I64:
13233 
          self.warehouseId = iprot.readI64();
13234 
        else:
13235 
          iprot.skip(ftype)
13236 
      elif fid == 3:
3064 chandransh 13237 
        if ftype == TType.STRING:
4394 rajveer 13238 
          self.description = iprot.readString();
3064 chandransh 13239 
        else:
13240 
          iprot.skip(ftype)
94 ashish 13241 
      else:
13242 
        iprot.skip(ftype)
13243 
      iprot.readFieldEnd()
13244 
    iprot.readStructEnd()
13245 
 
13246 
  def write(self, oprot):
13247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13249 
      return
4394 rajveer 13250 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 13251 
    if self.type is not None:
4394 rajveer 13252 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 13253 
      oprot.writeI64(self.type)
13254 
      oprot.writeFieldEnd()
4444 rajveer 13255 
    if self.warehouseId is not None:
13256 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13257 
      oprot.writeI64(self.warehouseId)
13258 
      oprot.writeFieldEnd()
4394 rajveer 13259 
    if self.description is not None:
4444 rajveer 13260 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 13261 
      oprot.writeString(self.description)
3064 chandransh 13262 
      oprot.writeFieldEnd()
94 ashish 13263 
    oprot.writeFieldStop()
13264 
    oprot.writeStructEnd()
13265 
 
3431 rajveer 13266 
  def validate(self):
13267 
    return
13268 
 
13269 
 
94 ashish 13270 
  def __repr__(self):
13271 
    L = ['%s=%r' % (key, value)
13272 
      for key, value in self.__dict__.iteritems()]
13273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13274 
 
13275 
  def __eq__(self, other):
13276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13277 
 
13278 
  def __ne__(self, other):
13279 
    return not (self == other)
13280 
 
4394 rajveer 13281 
class addAlert_result:
3064 chandransh 13282 
 
13283 
  thrift_spec = (
13284 
  )
13285 
 
13286 
  def read(self, iprot):
13287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13289 
      return
13290 
    iprot.readStructBegin()
13291 
    while True:
13292 
      (fname, ftype, fid) = iprot.readFieldBegin()
13293 
      if ftype == TType.STOP:
13294 
        break
13295 
      else:
13296 
        iprot.skip(ftype)
13297 
      iprot.readFieldEnd()
13298 
    iprot.readStructEnd()
13299 
 
13300 
  def write(self, oprot):
13301 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13302 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13303 
      return
4394 rajveer 13304 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 13305 
    oprot.writeFieldStop()
13306 
    oprot.writeStructEnd()
13307 
 
3431 rajveer 13308 
  def validate(self):
13309 
    return
13310 
 
13311 
 
3064 chandransh 13312 
  def __repr__(self):
13313 
    L = ['%s=%r' % (key, value)
13314 
      for key, value in self.__dict__.iteritems()]
13315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13316 
 
13317 
  def __eq__(self, other):
13318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13319 
 
13320 
  def __ne__(self, other):
13321 
    return not (self == other)
13322 
 
4444 rajveer 13323 
class markAlertsAsSeen_args:
13324 
  """
13325 
  Attributes:
13326 
   - warehouseId
13327 
  """
13328 
 
13329 
  thrift_spec = (
13330 
    None, # 0
13331 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13332 
  )
13333 
 
13334 
  def __init__(self, warehouseId=None,):
13335 
    self.warehouseId = warehouseId
13336 
 
13337 
  def read(self, iprot):
13338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13340 
      return
13341 
    iprot.readStructBegin()
13342 
    while True:
13343 
      (fname, ftype, fid) = iprot.readFieldBegin()
13344 
      if ftype == TType.STOP:
13345 
        break
13346 
      if fid == 1:
13347 
        if ftype == TType.I64:
13348 
          self.warehouseId = iprot.readI64();
13349 
        else:
13350 
          iprot.skip(ftype)
13351 
      else:
13352 
        iprot.skip(ftype)
13353 
      iprot.readFieldEnd()
13354 
    iprot.readStructEnd()
13355 
 
13356 
  def write(self, oprot):
13357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13359 
      return
13360 
    oprot.writeStructBegin('markAlertsAsSeen_args')
13361 
    if self.warehouseId is not None:
13362 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13363 
      oprot.writeI64(self.warehouseId)
13364 
      oprot.writeFieldEnd()
13365 
    oprot.writeFieldStop()
13366 
    oprot.writeStructEnd()
13367 
 
13368 
  def validate(self):
13369 
    return
13370 
 
13371 
 
13372 
  def __repr__(self):
13373 
    L = ['%s=%r' % (key, value)
13374 
      for key, value in self.__dict__.iteritems()]
13375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13376 
 
13377 
  def __eq__(self, other):
13378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13379 
 
13380 
  def __ne__(self, other):
13381 
    return not (self == other)
13382 
 
13383 
class markAlertsAsSeen_result:
13384 
 
13385 
  thrift_spec = (
13386 
  )
13387 
 
13388 
  def read(self, iprot):
13389 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13390 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13391 
      return
13392 
    iprot.readStructBegin()
13393 
    while True:
13394 
      (fname, ftype, fid) = iprot.readFieldBegin()
13395 
      if ftype == TType.STOP:
13396 
        break
13397 
      else:
13398 
        iprot.skip(ftype)
13399 
      iprot.readFieldEnd()
13400 
    iprot.readStructEnd()
13401 
 
13402 
  def write(self, oprot):
13403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13405 
      return
13406 
    oprot.writeStructBegin('markAlertsAsSeen_result')
13407 
    oprot.writeFieldStop()
13408 
    oprot.writeStructEnd()
13409 
 
13410 
  def validate(self):
13411 
    return
13412 
 
13413 
 
13414 
  def __repr__(self):
13415 
    L = ['%s=%r' % (key, value)
13416 
      for key, value in self.__dict__.iteritems()]
13417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13418 
 
13419 
  def __eq__(self, other):
13420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13421 
 
13422 
  def __ne__(self, other):
13423 
    return not (self == other)
13424 
 
3064 chandransh 13425 
class getValidOrderCount_args:
13426 
 
13427 
  thrift_spec = (
13428 
  )
13429 
 
13430 
  def read(self, iprot):
13431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13433 
      return
13434 
    iprot.readStructBegin()
13435 
    while True:
13436 
      (fname, ftype, fid) = iprot.readFieldBegin()
13437 
      if ftype == TType.STOP:
13438 
        break
13439 
      else:
13440 
        iprot.skip(ftype)
13441 
      iprot.readFieldEnd()
13442 
    iprot.readStructEnd()
13443 
 
13444 
  def write(self, oprot):
13445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13447 
      return
13448 
    oprot.writeStructBegin('getValidOrderCount_args')
13449 
    oprot.writeFieldStop()
13450 
    oprot.writeStructEnd()
13451 
 
3431 rajveer 13452 
  def validate(self):
13453 
    return
13454 
 
13455 
 
3064 chandransh 13456 
  def __repr__(self):
13457 
    L = ['%s=%r' % (key, value)
13458 
      for key, value in self.__dict__.iteritems()]
13459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13460 
 
13461 
  def __eq__(self, other):
13462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13463 
 
13464 
  def __ne__(self, other):
13465 
    return not (self == other)
13466 
 
13467 
class getValidOrderCount_result:
94 ashish 13468 
  """
13469 
  Attributes:
13470 
   - success
13471 
  """
13472 
 
13473 
  thrift_spec = (
3064 chandransh 13474 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13475 
  )
13476 
 
3064 chandransh 13477 
  def __init__(self, success=None,):
94 ashish 13478 
    self.success = success
13479 
 
13480 
  def read(self, iprot):
13481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13483 
      return
13484 
    iprot.readStructBegin()
13485 
    while True:
13486 
      (fname, ftype, fid) = iprot.readFieldBegin()
13487 
      if ftype == TType.STOP:
13488 
        break
13489 
      if fid == 0:
3064 chandransh 13490 
        if ftype == TType.I64:
13491 
          self.success = iprot.readI64();
94 ashish 13492 
        else:
13493 
          iprot.skip(ftype)
13494 
      else:
13495 
        iprot.skip(ftype)
13496 
      iprot.readFieldEnd()
13497 
    iprot.readStructEnd()
13498 
 
13499 
  def write(self, oprot):
13500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13502 
      return
3064 chandransh 13503 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 13504 
    if self.success is not None:
3064 chandransh 13505 
      oprot.writeFieldBegin('success', TType.I64, 0)
13506 
      oprot.writeI64(self.success)
94 ashish 13507 
      oprot.writeFieldEnd()
13508 
    oprot.writeFieldStop()
13509 
    oprot.writeStructEnd()
13510 
 
3431 rajveer 13511 
  def validate(self):
13512 
    return
13513 
 
13514 
 
94 ashish 13515 
  def __repr__(self):
13516 
    L = ['%s=%r' % (key, value)
13517 
      for key, value in self.__dict__.iteritems()]
13518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13519 
 
13520 
  def __eq__(self, other):
13521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13522 
 
13523 
  def __ne__(self, other):
13524 
    return not (self == other)
13525 
 
3064 chandransh 13526 
class getNoOfCustomersWithSuccessfulTransaction_args:
13527 
 
13528 
  thrift_spec = (
13529 
  )
13530 
 
13531 
  def read(self, iprot):
13532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13534 
      return
13535 
    iprot.readStructBegin()
13536 
    while True:
13537 
      (fname, ftype, fid) = iprot.readFieldBegin()
13538 
      if ftype == TType.STOP:
13539 
        break
13540 
      else:
13541 
        iprot.skip(ftype)
13542 
      iprot.readFieldEnd()
13543 
    iprot.readStructEnd()
13544 
 
13545 
  def write(self, oprot):
13546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13548 
      return
13549 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
13550 
    oprot.writeFieldStop()
13551 
    oprot.writeStructEnd()
13552 
 
3431 rajveer 13553 
  def validate(self):
13554 
    return
13555 
 
13556 
 
3064 chandransh 13557 
  def __repr__(self):
13558 
    L = ['%s=%r' % (key, value)
13559 
      for key, value in self.__dict__.iteritems()]
13560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13561 
 
13562 
  def __eq__(self, other):
13563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13564 
 
13565 
  def __ne__(self, other):
13566 
    return not (self == other)
13567 
 
13568 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 13569 
  """
13570 
  Attributes:
3064 chandransh 13571 
   - success
94 ashish 13572 
  """
13573 
 
13574 
  thrift_spec = (
3064 chandransh 13575 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13576 
  )
13577 
 
3064 chandransh 13578 
  def __init__(self, success=None,):
13579 
    self.success = success
94 ashish 13580 
 
13581 
  def read(self, iprot):
13582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13584 
      return
13585 
    iprot.readStructBegin()
13586 
    while True:
13587 
      (fname, ftype, fid) = iprot.readFieldBegin()
13588 
      if ftype == TType.STOP:
13589 
        break
3064 chandransh 13590 
      if fid == 0:
94 ashish 13591 
        if ftype == TType.I64:
3064 chandransh 13592 
          self.success = iprot.readI64();
94 ashish 13593 
        else:
13594 
          iprot.skip(ftype)
13595 
      else:
13596 
        iprot.skip(ftype)
13597 
      iprot.readFieldEnd()
13598 
    iprot.readStructEnd()
13599 
 
13600 
  def write(self, oprot):
13601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13603 
      return
3064 chandransh 13604 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 13605 
    if self.success is not None:
3064 chandransh 13606 
      oprot.writeFieldBegin('success', TType.I64, 0)
13607 
      oprot.writeI64(self.success)
94 ashish 13608 
      oprot.writeFieldEnd()
13609 
    oprot.writeFieldStop()
13610 
    oprot.writeStructEnd()
13611 
 
3431 rajveer 13612 
  def validate(self):
13613 
    return
13614 
 
13615 
 
94 ashish 13616 
  def __repr__(self):
13617 
    L = ['%s=%r' % (key, value)
13618 
      for key, value in self.__dict__.iteritems()]
13619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13620 
 
13621 
  def __eq__(self, other):
13622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13623 
 
13624 
  def __ne__(self, other):
13625 
    return not (self == other)
13626 
 
3064 chandransh 13627 
class getValidOrdersAmountRange_args:
13628 
 
13629 
  thrift_spec = (
13630 
  )
13631 
 
13632 
  def read(self, iprot):
13633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13635 
      return
13636 
    iprot.readStructBegin()
13637 
    while True:
13638 
      (fname, ftype, fid) = iprot.readFieldBegin()
13639 
      if ftype == TType.STOP:
13640 
        break
13641 
      else:
13642 
        iprot.skip(ftype)
13643 
      iprot.readFieldEnd()
13644 
    iprot.readStructEnd()
13645 
 
13646 
  def write(self, oprot):
13647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13649 
      return
13650 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
13651 
    oprot.writeFieldStop()
13652 
    oprot.writeStructEnd()
13653 
 
3431 rajveer 13654 
  def validate(self):
13655 
    return
13656 
 
13657 
 
3064 chandransh 13658 
  def __repr__(self):
13659 
    L = ['%s=%r' % (key, value)
13660 
      for key, value in self.__dict__.iteritems()]
13661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13662 
 
13663 
  def __eq__(self, other):
13664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13665 
 
13666 
  def __ne__(self, other):
13667 
    return not (self == other)
13668 
 
13669 
class getValidOrdersAmountRange_result:
94 ashish 13670 
  """
13671 
  Attributes:
13672 
   - success
13673 
  """
13674 
 
13675 
  thrift_spec = (
3064 chandransh 13676 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 13677 
  )
13678 
 
3064 chandransh 13679 
  def __init__(self, success=None,):
94 ashish 13680 
    self.success = success
13681 
 
13682 
  def read(self, iprot):
13683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13685 
      return
13686 
    iprot.readStructBegin()
13687 
    while True:
13688 
      (fname, ftype, fid) = iprot.readFieldBegin()
13689 
      if ftype == TType.STOP:
13690 
        break
13691 
      if fid == 0:
483 rajveer 13692 
        if ftype == TType.LIST:
13693 
          self.success = []
6188 rajveer 13694 
          (_etype249, _size246) = iprot.readListBegin()
13695 
          for _i250 in xrange(_size246):
13696 
            _elem251 = iprot.readDouble();
13697 
            self.success.append(_elem251)
483 rajveer 13698 
          iprot.readListEnd()
94 ashish 13699 
        else:
13700 
          iprot.skip(ftype)
13701 
      else:
13702 
        iprot.skip(ftype)
13703 
      iprot.readFieldEnd()
13704 
    iprot.readStructEnd()
13705 
 
13706 
  def write(self, oprot):
13707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13709 
      return
3064 chandransh 13710 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 13711 
    if self.success is not None:
483 rajveer 13712 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 13713 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 13714 
      for iter252 in self.success:
13715 
        oprot.writeDouble(iter252)
483 rajveer 13716 
      oprot.writeListEnd()
94 ashish 13717 
      oprot.writeFieldEnd()
13718 
    oprot.writeFieldStop()
13719 
    oprot.writeStructEnd()
13720 
 
3431 rajveer 13721 
  def validate(self):
13722 
    return
13723 
 
13724 
 
94 ashish 13725 
  def __repr__(self):
13726 
    L = ['%s=%r' % (key, value)
13727 
      for key, value in self.__dict__.iteritems()]
13728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13729 
 
13730 
  def __eq__(self, other):
13731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13732 
 
13733 
  def __ne__(self, other):
13734 
    return not (self == other)
13735 
 
3064 chandransh 13736 
class getValidOrders_args:
1528 ankur.sing 13737 
  """
13738 
  Attributes:
3064 chandransh 13739 
   - limit
5874 rajveer 13740 
   - onlyStore
1528 ankur.sing 13741 
  """
13742 
 
13743 
  thrift_spec = (
13744 
    None, # 0
3064 chandransh 13745 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 13746 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 13747 
  )
13748 
 
5874 rajveer 13749 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 13750 
    self.limit = limit
5874 rajveer 13751 
    self.onlyStore = onlyStore
1528 ankur.sing 13752 
 
13753 
  def read(self, iprot):
13754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13756 
      return
13757 
    iprot.readStructBegin()
13758 
    while True:
13759 
      (fname, ftype, fid) = iprot.readFieldBegin()
13760 
      if ftype == TType.STOP:
13761 
        break
13762 
      if fid == 1:
13763 
        if ftype == TType.I64:
3064 chandransh 13764 
          self.limit = iprot.readI64();
1528 ankur.sing 13765 
        else:
13766 
          iprot.skip(ftype)
5874 rajveer 13767 
      elif fid == 2:
13768 
        if ftype == TType.BOOL:
13769 
          self.onlyStore = iprot.readBool();
13770 
        else:
13771 
          iprot.skip(ftype)
1528 ankur.sing 13772 
      else:
13773 
        iprot.skip(ftype)
13774 
      iprot.readFieldEnd()
13775 
    iprot.readStructEnd()
13776 
 
13777 
  def write(self, oprot):
13778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13780 
      return
3064 chandransh 13781 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 13782 
    if self.limit is not None:
3064 chandransh 13783 
      oprot.writeFieldBegin('limit', TType.I64, 1)
13784 
      oprot.writeI64(self.limit)
1528 ankur.sing 13785 
      oprot.writeFieldEnd()
5874 rajveer 13786 
    if self.onlyStore is not None:
13787 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
13788 
      oprot.writeBool(self.onlyStore)
13789 
      oprot.writeFieldEnd()
1528 ankur.sing 13790 
    oprot.writeFieldStop()
13791 
    oprot.writeStructEnd()
13792 
 
3431 rajveer 13793 
  def validate(self):
13794 
    return
13795 
 
13796 
 
1528 ankur.sing 13797 
  def __repr__(self):
13798 
    L = ['%s=%r' % (key, value)
13799 
      for key, value in self.__dict__.iteritems()]
13800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13801 
 
13802 
  def __eq__(self, other):
13803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13804 
 
13805 
  def __ne__(self, other):
13806 
    return not (self == other)
13807 
 
3064 chandransh 13808 
class getValidOrders_result:
1528 ankur.sing 13809 
  """
13810 
  Attributes:
13811 
   - success
13812 
  """
13813 
 
13814 
  thrift_spec = (
3064 chandransh 13815 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 13816 
  )
13817 
 
3064 chandransh 13818 
  def __init__(self, success=None,):
1528 ankur.sing 13819 
    self.success = success
13820 
 
13821 
  def read(self, iprot):
13822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13824 
      return
13825 
    iprot.readStructBegin()
13826 
    while True:
13827 
      (fname, ftype, fid) = iprot.readFieldBegin()
13828 
      if ftype == TType.STOP:
13829 
        break
13830 
      if fid == 0:
3064 chandransh 13831 
        if ftype == TType.LIST:
13832 
          self.success = []
6188 rajveer 13833 
          (_etype256, _size253) = iprot.readListBegin()
13834 
          for _i257 in xrange(_size253):
13835 
            _elem258 = Order()
13836 
            _elem258.read(iprot)
13837 
            self.success.append(_elem258)
3064 chandransh 13838 
          iprot.readListEnd()
1528 ankur.sing 13839 
        else:
13840 
          iprot.skip(ftype)
13841 
      else:
13842 
        iprot.skip(ftype)
13843 
      iprot.readFieldEnd()
13844 
    iprot.readStructEnd()
13845 
 
13846 
  def write(self, oprot):
13847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13849 
      return
3064 chandransh 13850 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 13851 
    if self.success is not None:
3064 chandransh 13852 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13853 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13854 
      for iter259 in self.success:
13855 
        iter259.write(oprot)
3064 chandransh 13856 
      oprot.writeListEnd()
1528 ankur.sing 13857 
      oprot.writeFieldEnd()
13858 
    oprot.writeFieldStop()
13859 
    oprot.writeStructEnd()
13860 
 
3431 rajveer 13861 
  def validate(self):
13862 
    return
13863 
 
13864 
 
1528 ankur.sing 13865 
  def __repr__(self):
13866 
    L = ['%s=%r' % (key, value)
13867 
      for key, value in self.__dict__.iteritems()]
13868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13869 
 
13870 
  def __eq__(self, other):
13871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13872 
 
13873 
  def __ne__(self, other):
13874 
    return not (self == other)
13875 
 
1220 chandransh 13876 
class batchOrders_args:
13877 
  """
13878 
  Attributes:
13879 
   - warehouseId
13880 
  """
13881 
 
13882 
  thrift_spec = (
13883 
    None, # 0
13884 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13885 
  )
13886 
 
13887 
  def __init__(self, warehouseId=None,):
13888 
    self.warehouseId = warehouseId
13889 
 
13890 
  def read(self, iprot):
13891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13893 
      return
13894 
    iprot.readStructBegin()
13895 
    while True:
13896 
      (fname, ftype, fid) = iprot.readFieldBegin()
13897 
      if ftype == TType.STOP:
13898 
        break
13899 
      if fid == 1:
13900 
        if ftype == TType.I64:
13901 
          self.warehouseId = iprot.readI64();
13902 
        else:
13903 
          iprot.skip(ftype)
13904 
      else:
13905 
        iprot.skip(ftype)
13906 
      iprot.readFieldEnd()
13907 
    iprot.readStructEnd()
13908 
 
13909 
  def write(self, oprot):
13910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13912 
      return
13913 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 13914 
    if self.warehouseId is not None:
1220 chandransh 13915 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13916 
      oprot.writeI64(self.warehouseId)
13917 
      oprot.writeFieldEnd()
13918 
    oprot.writeFieldStop()
13919 
    oprot.writeStructEnd()
13920 
 
3431 rajveer 13921 
  def validate(self):
13922 
    return
13923 
 
13924 
 
1220 chandransh 13925 
  def __repr__(self):
13926 
    L = ['%s=%r' % (key, value)
13927 
      for key, value in self.__dict__.iteritems()]
13928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13929 
 
13930 
  def __eq__(self, other):
13931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13932 
 
13933 
  def __ne__(self, other):
13934 
    return not (self == other)
13935 
 
13936 
class batchOrders_result:
13937 
  """
13938 
  Attributes:
13939 
   - success
13940 
   - ex
13941 
  """
13942 
 
13943 
  thrift_spec = (
13944 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13945 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13946 
  )
13947 
 
13948 
  def __init__(self, success=None, ex=None,):
13949 
    self.success = success
13950 
    self.ex = ex
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 == 0:
13962 
        if ftype == TType.LIST:
13963 
          self.success = []
6188 rajveer 13964 
          (_etype263, _size260) = iprot.readListBegin()
13965 
          for _i264 in xrange(_size260):
13966 
            _elem265 = Order()
13967 
            _elem265.read(iprot)
13968 
            self.success.append(_elem265)
1220 chandransh 13969 
          iprot.readListEnd()
13970 
        else:
13971 
          iprot.skip(ftype)
13972 
      elif fid == 1:
13973 
        if ftype == TType.STRUCT:
13974 
          self.ex = TransactionServiceException()
13975 
          self.ex.read(iprot)
13976 
        else:
13977 
          iprot.skip(ftype)
13978 
      else:
13979 
        iprot.skip(ftype)
13980 
      iprot.readFieldEnd()
13981 
    iprot.readStructEnd()
13982 
 
13983 
  def write(self, oprot):
13984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13986 
      return
13987 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 13988 
    if self.success is not None:
1220 chandransh 13989 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13990 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13991 
      for iter266 in self.success:
13992 
        iter266.write(oprot)
1220 chandransh 13993 
      oprot.writeListEnd()
13994 
      oprot.writeFieldEnd()
3431 rajveer 13995 
    if self.ex is not None:
1220 chandransh 13996 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13997 
      self.ex.write(oprot)
13998 
      oprot.writeFieldEnd()
13999 
    oprot.writeFieldStop()
14000 
    oprot.writeStructEnd()
14001 
 
3431 rajveer 14002 
  def validate(self):
14003 
    return
14004 
 
14005 
 
1220 chandransh 14006 
  def __repr__(self):
14007 
    L = ['%s=%r' % (key, value)
14008 
      for key, value in self.__dict__.iteritems()]
14009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14010 
 
14011 
  def __eq__(self, other):
14012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14013 
 
14014 
  def __ne__(self, other):
14015 
    return not (self == other)
14016 
 
1208 chandransh 14017 
class markOrderAsOutOfStock_args:
14018 
  """
14019 
  Attributes:
14020 
   - orderId
14021 
  """
14022 
 
14023 
  thrift_spec = (
14024 
    None, # 0
14025 
    (1, TType.I64, 'orderId', None, None, ), # 1
14026 
  )
14027 
 
14028 
  def __init__(self, orderId=None,):
14029 
    self.orderId = orderId
14030 
 
14031 
  def read(self, iprot):
14032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14034 
      return
14035 
    iprot.readStructBegin()
14036 
    while True:
14037 
      (fname, ftype, fid) = iprot.readFieldBegin()
14038 
      if ftype == TType.STOP:
14039 
        break
14040 
      if fid == 1:
14041 
        if ftype == TType.I64:
14042 
          self.orderId = iprot.readI64();
14043 
        else:
14044 
          iprot.skip(ftype)
14045 
      else:
14046 
        iprot.skip(ftype)
14047 
      iprot.readFieldEnd()
14048 
    iprot.readStructEnd()
14049 
 
14050 
  def write(self, oprot):
14051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14053 
      return
14054 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 14055 
    if self.orderId is not None:
1208 chandransh 14056 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14057 
      oprot.writeI64(self.orderId)
14058 
      oprot.writeFieldEnd()
14059 
    oprot.writeFieldStop()
14060 
    oprot.writeStructEnd()
14061 
 
3431 rajveer 14062 
  def validate(self):
14063 
    return
14064 
 
14065 
 
1208 chandransh 14066 
  def __repr__(self):
14067 
    L = ['%s=%r' % (key, value)
14068 
      for key, value in self.__dict__.iteritems()]
14069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14070 
 
14071 
  def __eq__(self, other):
14072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14073 
 
14074 
  def __ne__(self, other):
14075 
    return not (self == other)
14076 
 
14077 
class markOrderAsOutOfStock_result:
14078 
  """
14079 
  Attributes:
14080 
   - success
14081 
   - ex
14082 
  """
14083 
 
14084 
  thrift_spec = (
14085 
    (0, TType.BOOL, 'success', None, None, ), # 0
14086 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14087 
  )
14088 
 
14089 
  def __init__(self, success=None, ex=None,):
14090 
    self.success = success
14091 
    self.ex = ex
14092 
 
14093 
  def read(self, iprot):
14094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14096 
      return
14097 
    iprot.readStructBegin()
14098 
    while True:
14099 
      (fname, ftype, fid) = iprot.readFieldBegin()
14100 
      if ftype == TType.STOP:
14101 
        break
14102 
      if fid == 0:
14103 
        if ftype == TType.BOOL:
14104 
          self.success = iprot.readBool();
14105 
        else:
14106 
          iprot.skip(ftype)
14107 
      elif fid == 1:
14108 
        if ftype == TType.STRUCT:
14109 
          self.ex = TransactionServiceException()
14110 
          self.ex.read(iprot)
14111 
        else:
14112 
          iprot.skip(ftype)
14113 
      else:
14114 
        iprot.skip(ftype)
14115 
      iprot.readFieldEnd()
14116 
    iprot.readStructEnd()
14117 
 
14118 
  def write(self, oprot):
14119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14121 
      return
14122 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 14123 
    if self.success is not None:
1208 chandransh 14124 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14125 
      oprot.writeBool(self.success)
14126 
      oprot.writeFieldEnd()
3431 rajveer 14127 
    if self.ex is not None:
1208 chandransh 14128 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14129 
      self.ex.write(oprot)
14130 
      oprot.writeFieldEnd()
14131 
    oprot.writeFieldStop()
14132 
    oprot.writeStructEnd()
14133 
 
3431 rajveer 14134 
  def validate(self):
14135 
    return
14136 
 
14137 
 
1208 chandransh 14138 
  def __repr__(self):
14139 
    L = ['%s=%r' % (key, value)
14140 
      for key, value in self.__dict__.iteritems()]
14141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14142 
 
14143 
  def __eq__(self, other):
14144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14145 
 
14146 
  def __ne__(self, other):
14147 
    return not (self == other)
14148 
 
3064 chandransh 14149 
class verifyOrder_args:
759 chandransh 14150 
  """
14151 
  Attributes:
3064 chandransh 14152 
   - orderId
759 chandransh 14153 
  """
14154 
 
14155 
  thrift_spec = (
14156 
    None, # 0
3064 chandransh 14157 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 14158 
  )
14159 
 
3064 chandransh 14160 
  def __init__(self, orderId=None,):
14161 
    self.orderId = orderId
759 chandransh 14162 
 
14163 
  def read(self, iprot):
14164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14166 
      return
14167 
    iprot.readStructBegin()
14168 
    while True:
14169 
      (fname, ftype, fid) = iprot.readFieldBegin()
14170 
      if ftype == TType.STOP:
14171 
        break
14172 
      if fid == 1:
14173 
        if ftype == TType.I64:
3064 chandransh 14174 
          self.orderId = iprot.readI64();
759 chandransh 14175 
        else:
14176 
          iprot.skip(ftype)
14177 
      else:
14178 
        iprot.skip(ftype)
14179 
      iprot.readFieldEnd()
14180 
    iprot.readStructEnd()
14181 
 
14182 
  def write(self, oprot):
14183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14185 
      return
3064 chandransh 14186 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 14187 
    if self.orderId is not None:
3064 chandransh 14188 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14189 
      oprot.writeI64(self.orderId)
759 chandransh 14190 
      oprot.writeFieldEnd()
14191 
    oprot.writeFieldStop()
14192 
    oprot.writeStructEnd()
14193 
 
3431 rajveer 14194 
  def validate(self):
14195 
    return
14196 
 
14197 
 
759 chandransh 14198 
  def __repr__(self):
14199 
    L = ['%s=%r' % (key, value)
14200 
      for key, value in self.__dict__.iteritems()]
14201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14202 
 
14203 
  def __eq__(self, other):
14204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14205 
 
14206 
  def __ne__(self, other):
14207 
    return not (self == other)
14208 
 
3064 chandransh 14209 
class verifyOrder_result:
759 chandransh 14210 
  """
14211 
  Attributes:
14212 
   - success
14213 
   - ex
14214 
  """
14215 
 
14216 
  thrift_spec = (
14217 
    (0, TType.BOOL, 'success', None, None, ), # 0
14218 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14219 
  )
14220 
 
14221 
  def __init__(self, success=None, ex=None,):
14222 
    self.success = success
14223 
    self.ex = ex
14224 
 
14225 
  def read(self, iprot):
14226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14228 
      return
14229 
    iprot.readStructBegin()
14230 
    while True:
14231 
      (fname, ftype, fid) = iprot.readFieldBegin()
14232 
      if ftype == TType.STOP:
14233 
        break
14234 
      if fid == 0:
14235 
        if ftype == TType.BOOL:
14236 
          self.success = iprot.readBool();
14237 
        else:
14238 
          iprot.skip(ftype)
14239 
      elif fid == 1:
14240 
        if ftype == TType.STRUCT:
14241 
          self.ex = TransactionServiceException()
14242 
          self.ex.read(iprot)
14243 
        else:
14244 
          iprot.skip(ftype)
14245 
      else:
14246 
        iprot.skip(ftype)
14247 
      iprot.readFieldEnd()
14248 
    iprot.readStructEnd()
14249 
 
14250 
  def write(self, oprot):
14251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14253 
      return
3064 chandransh 14254 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 14255 
    if self.success is not None:
759 chandransh 14256 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14257 
      oprot.writeBool(self.success)
14258 
      oprot.writeFieldEnd()
3431 rajveer 14259 
    if self.ex is not None:
759 chandransh 14260 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14261 
      self.ex.write(oprot)
14262 
      oprot.writeFieldEnd()
14263 
    oprot.writeFieldStop()
14264 
    oprot.writeStructEnd()
14265 
 
3431 rajveer 14266 
  def validate(self):
14267 
    return
14268 
 
14269 
 
759 chandransh 14270 
  def __repr__(self):
14271 
    L = ['%s=%r' % (key, value)
14272 
      for key, value in self.__dict__.iteritems()]
14273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14274 
 
14275 
  def __eq__(self, other):
14276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14277 
 
14278 
  def __ne__(self, other):
14279 
    return not (self == other)
14280 
 
3064 chandransh 14281 
class acceptOrder_args:
1113 chandransh 14282 
  """
14283 
  Attributes:
3064 chandransh 14284 
   - orderId
1113 chandransh 14285 
  """
14286 
 
14287 
  thrift_spec = (
14288 
    None, # 0
3064 chandransh 14289 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 14290 
  )
14291 
 
3064 chandransh 14292 
  def __init__(self, orderId=None,):
14293 
    self.orderId = orderId
1113 chandransh 14294 
 
14295 
  def read(self, iprot):
14296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14298 
      return
14299 
    iprot.readStructBegin()
14300 
    while True:
14301 
      (fname, ftype, fid) = iprot.readFieldBegin()
14302 
      if ftype == TType.STOP:
14303 
        break
14304 
      if fid == 1:
14305 
        if ftype == TType.I64:
3064 chandransh 14306 
          self.orderId = iprot.readI64();
1113 chandransh 14307 
        else:
14308 
          iprot.skip(ftype)
14309 
      else:
14310 
        iprot.skip(ftype)
14311 
      iprot.readFieldEnd()
14312 
    iprot.readStructEnd()
14313 
 
14314 
  def write(self, oprot):
14315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14317 
      return
3064 chandransh 14318 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 14319 
    if self.orderId is not None:
3064 chandransh 14320 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14321 
      oprot.writeI64(self.orderId)
1113 chandransh 14322 
      oprot.writeFieldEnd()
14323 
    oprot.writeFieldStop()
14324 
    oprot.writeStructEnd()
14325 
 
3431 rajveer 14326 
  def validate(self):
14327 
    return
14328 
 
14329 
 
1113 chandransh 14330 
  def __repr__(self):
14331 
    L = ['%s=%r' % (key, value)
14332 
      for key, value in self.__dict__.iteritems()]
14333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14334 
 
14335 
  def __eq__(self, other):
14336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14337 
 
14338 
  def __ne__(self, other):
14339 
    return not (self == other)
14340 
 
3064 chandransh 14341 
class acceptOrder_result:
1113 chandransh 14342 
  """
14343 
  Attributes:
14344 
   - success
14345 
   - ex
14346 
  """
14347 
 
14348 
  thrift_spec = (
3064 chandransh 14349 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 14350 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14351 
  )
14352 
 
14353 
  def __init__(self, success=None, ex=None,):
14354 
    self.success = success
14355 
    self.ex = ex
14356 
 
14357 
  def read(self, iprot):
14358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14360 
      return
14361 
    iprot.readStructBegin()
14362 
    while True:
14363 
      (fname, ftype, fid) = iprot.readFieldBegin()
14364 
      if ftype == TType.STOP:
14365 
        break
14366 
      if fid == 0:
3064 chandransh 14367 
        if ftype == TType.BOOL:
14368 
          self.success = iprot.readBool();
1113 chandransh 14369 
        else:
14370 
          iprot.skip(ftype)
14371 
      elif fid == 1:
14372 
        if ftype == TType.STRUCT:
14373 
          self.ex = TransactionServiceException()
14374 
          self.ex.read(iprot)
14375 
        else:
14376 
          iprot.skip(ftype)
14377 
      else:
14378 
        iprot.skip(ftype)
14379 
      iprot.readFieldEnd()
14380 
    iprot.readStructEnd()
14381 
 
14382 
  def write(self, oprot):
14383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14385 
      return
3064 chandransh 14386 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 14387 
    if self.success is not None:
3064 chandransh 14388 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14389 
      oprot.writeBool(self.success)
1113 chandransh 14390 
      oprot.writeFieldEnd()
3431 rajveer 14391 
    if self.ex is not None:
1113 chandransh 14392 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14393 
      self.ex.write(oprot)
14394 
      oprot.writeFieldEnd()
14395 
    oprot.writeFieldStop()
14396 
    oprot.writeStructEnd()
14397 
 
3431 rajveer 14398 
  def validate(self):
14399 
    return
14400 
 
14401 
 
1113 chandransh 14402 
  def __repr__(self):
14403 
    L = ['%s=%r' % (key, value)
14404 
      for key, value in self.__dict__.iteritems()]
14405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14406 
 
14407 
  def __eq__(self, other):
14408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14409 
 
14410 
  def __ne__(self, other):
14411 
    return not (self == other)
14412 
 
3064 chandransh 14413 
class addBillingDetails_args:
1135 chandransh 14414 
  """
14415 
  Attributes:
3064 chandransh 14416 
   - orderId
14417 
   - invoice_number
4658 mandeep.dh 14418 
   - serialNumber
4283 anupam.sin 14419 
   - itemNumber
7190 amar.kumar 14420 
   - freebieWarehouseId
3064 chandransh 14421 
   - billed_by
4264 rajveer 14422 
   - jacketNumber
4283 anupam.sin 14423 
   - billingType
5110 mandeep.dh 14424 
   - fulfilmentWarehouseId
4763 rajveer 14425 
   - authorize
1135 chandransh 14426 
  """
14427 
 
14428 
  thrift_spec = (
14429 
    None, # 0
3064 chandransh 14430 
    (1, TType.I64, 'orderId', None, None, ), # 1
14431 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 14432 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
14433 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
7190 amar.kumar 14434 
    (5, TType.I64, 'freebieWarehouseId', None, None, ), # 5
14435 
    (6, TType.STRING, 'billed_by', None, None, ), # 6
14436 
    (7, TType.I64, 'jacketNumber', None, None, ), # 7
14437 
    (8, TType.I64, 'billingType', None, None, ), # 8
14438 
    (9, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 9
14439 
    (10, TType.BOOL, 'authorize', None, None, ), # 10
1135 chandransh 14440 
  )
14441 
 
7190 amar.kumar 14442 
  def __init__(self, orderId=None, invoice_number=None, serialNumber=None, itemNumber=None, freebieWarehouseId=None, billed_by=None, jacketNumber=None, billingType=None, fulfilmentWarehouseId=None, authorize=None,):
3064 chandransh 14443 
    self.orderId = orderId
14444 
    self.invoice_number = invoice_number
4658 mandeep.dh 14445 
    self.serialNumber = serialNumber
4283 anupam.sin 14446 
    self.itemNumber = itemNumber
7190 amar.kumar 14447 
    self.freebieWarehouseId = freebieWarehouseId
3064 chandransh 14448 
    self.billed_by = billed_by
4264 rajveer 14449 
    self.jacketNumber = jacketNumber
4283 anupam.sin 14450 
    self.billingType = billingType
5110 mandeep.dh 14451 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 14452 
    self.authorize = authorize
1135 chandransh 14453 
 
14454 
  def read(self, iprot):
14455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14457 
      return
14458 
    iprot.readStructBegin()
14459 
    while True:
14460 
      (fname, ftype, fid) = iprot.readFieldBegin()
14461 
      if ftype == TType.STOP:
14462 
        break
14463 
      if fid == 1:
14464 
        if ftype == TType.I64:
3064 chandransh 14465 
          self.orderId = iprot.readI64();
1135 chandransh 14466 
        else:
14467 
          iprot.skip(ftype)
14468 
      elif fid == 2:
3064 chandransh 14469 
        if ftype == TType.STRING:
14470 
          self.invoice_number = iprot.readString();
1135 chandransh 14471 
        else:
14472 
          iprot.skip(ftype)
3064 chandransh 14473 
      elif fid == 3:
5411 rajveer 14474 
        if ftype == TType.LIST:
14475 
          self.serialNumber = []
6188 rajveer 14476 
          (_etype270, _size267) = iprot.readListBegin()
14477 
          for _i271 in xrange(_size267):
14478 
            _elem272 = iprot.readString();
14479 
            self.serialNumber.append(_elem272)
5411 rajveer 14480 
          iprot.readListEnd()
3064 chandransh 14481 
        else:
14482 
          iprot.skip(ftype)
14483 
      elif fid == 4:
5411 rajveer 14484 
        if ftype == TType.LIST:
14485 
          self.itemNumber = []
6188 rajveer 14486 
          (_etype276, _size273) = iprot.readListBegin()
14487 
          for _i277 in xrange(_size273):
14488 
            _elem278 = iprot.readString();
14489 
            self.itemNumber.append(_elem278)
5411 rajveer 14490 
          iprot.readListEnd()
3064 chandransh 14491 
        else:
14492 
          iprot.skip(ftype)
14493 
      elif fid == 5:
7190 amar.kumar 14494 
        if ftype == TType.I64:
14495 
          self.freebieWarehouseId = iprot.readI64();
14496 
        else:
14497 
          iprot.skip(ftype)
14498 
      elif fid == 6:
3064 chandransh 14499 
        if ftype == TType.STRING:
4283 anupam.sin 14500 
          self.billed_by = iprot.readString();
3064 chandransh 14501 
        else:
14502 
          iprot.skip(ftype)
7190 amar.kumar 14503 
      elif fid == 7:
3064 chandransh 14504 
        if ftype == TType.I64:
4283 anupam.sin 14505 
          self.jacketNumber = iprot.readI64();
14506 
        else:
14507 
          iprot.skip(ftype)
7190 amar.kumar 14508 
      elif fid == 8:
4283 anupam.sin 14509 
        if ftype == TType.I64:
3064 chandransh 14510 
          self.billingType = iprot.readI64();
14511 
        else:
14512 
          iprot.skip(ftype)
7190 amar.kumar 14513 
      elif fid == 9:
4283 anupam.sin 14514 
        if ftype == TType.I64:
5110 mandeep.dh 14515 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 14516 
        else:
14517 
          iprot.skip(ftype)
7190 amar.kumar 14518 
      elif fid == 10:
4763 rajveer 14519 
        if ftype == TType.BOOL:
14520 
          self.authorize = iprot.readBool();
14521 
        else:
14522 
          iprot.skip(ftype)
1246 chandransh 14523 
      else:
14524 
        iprot.skip(ftype)
14525 
      iprot.readFieldEnd()
14526 
    iprot.readStructEnd()
14527 
 
14528 
  def write(self, oprot):
14529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14531 
      return
4283 anupam.sin 14532 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 14533 
    if self.orderId is not None:
3064 chandransh 14534 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14535 
      oprot.writeI64(self.orderId)
1246 chandransh 14536 
      oprot.writeFieldEnd()
4283 anupam.sin 14537 
    if self.invoice_number is not None:
14538 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
14539 
      oprot.writeString(self.invoice_number)
1246 chandransh 14540 
      oprot.writeFieldEnd()
4658 mandeep.dh 14541 
    if self.serialNumber is not None:
5411 rajveer 14542 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
14543 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 14544 
      for iter279 in self.serialNumber:
14545 
        oprot.writeString(iter279)
5411 rajveer 14546 
      oprot.writeListEnd()
3064 chandransh 14547 
      oprot.writeFieldEnd()
3431 rajveer 14548 
    if self.itemNumber is not None:
5411 rajveer 14549 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
14550 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 14551 
      for iter280 in self.itemNumber:
14552 
        oprot.writeString(iter280)
5411 rajveer 14553 
      oprot.writeListEnd()
3064 chandransh 14554 
      oprot.writeFieldEnd()
7190 amar.kumar 14555 
    if self.freebieWarehouseId is not None:
14556 
      oprot.writeFieldBegin('freebieWarehouseId', TType.I64, 5)
14557 
      oprot.writeI64(self.freebieWarehouseId)
14558 
      oprot.writeFieldEnd()
4283 anupam.sin 14559 
    if self.billed_by is not None:
7190 amar.kumar 14560 
      oprot.writeFieldBegin('billed_by', TType.STRING, 6)
4283 anupam.sin 14561 
      oprot.writeString(self.billed_by)
3064 chandransh 14562 
      oprot.writeFieldEnd()
4283 anupam.sin 14563 
    if self.jacketNumber is not None:
7190 amar.kumar 14564 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 7)
4283 anupam.sin 14565 
      oprot.writeI64(self.jacketNumber)
14566 
      oprot.writeFieldEnd()
3431 rajveer 14567 
    if self.billingType is not None:
7190 amar.kumar 14568 
      oprot.writeFieldBegin('billingType', TType.I64, 8)
3064 chandransh 14569 
      oprot.writeI64(self.billingType)
14570 
      oprot.writeFieldEnd()
5110 mandeep.dh 14571 
    if self.fulfilmentWarehouseId is not None:
7190 amar.kumar 14572 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 9)
5110 mandeep.dh 14573 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 14574 
      oprot.writeFieldEnd()
4763 rajveer 14575 
    if self.authorize is not None:
7190 amar.kumar 14576 
      oprot.writeFieldBegin('authorize', TType.BOOL, 10)
4763 rajveer 14577 
      oprot.writeBool(self.authorize)
14578 
      oprot.writeFieldEnd()
1246 chandransh 14579 
    oprot.writeFieldStop()
14580 
    oprot.writeStructEnd()
14581 
 
3431 rajveer 14582 
  def validate(self):
14583 
    return
14584 
 
14585 
 
1246 chandransh 14586 
  def __repr__(self):
14587 
    L = ['%s=%r' % (key, value)
14588 
      for key, value in self.__dict__.iteritems()]
14589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14590 
 
14591 
  def __eq__(self, other):
14592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14593 
 
14594 
  def __ne__(self, other):
14595 
    return not (self == other)
14596 
 
4283 anupam.sin 14597 
class addBillingDetails_result:
1246 chandransh 14598 
  """
14599 
  Attributes:
3064 chandransh 14600 
   - success
1246 chandransh 14601 
   - ex
14602 
  """
14603 
 
14604 
  thrift_spec = (
3064 chandransh 14605 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 14606 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14607 
  )
14608 
 
3064 chandransh 14609 
  def __init__(self, success=None, ex=None,):
14610 
    self.success = success
1246 chandransh 14611 
    self.ex = ex
14612 
 
14613 
  def read(self, iprot):
14614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14616 
      return
14617 
    iprot.readStructBegin()
14618 
    while True:
14619 
      (fname, ftype, fid) = iprot.readFieldBegin()
14620 
      if ftype == TType.STOP:
14621 
        break
3064 chandransh 14622 
      if fid == 0:
14623 
        if ftype == TType.BOOL:
14624 
          self.success = iprot.readBool();
14625 
        else:
14626 
          iprot.skip(ftype)
14627 
      elif fid == 1:
1246 chandransh 14628 
        if ftype == TType.STRUCT:
14629 
          self.ex = TransactionServiceException()
14630 
          self.ex.read(iprot)
14631 
        else:
14632 
          iprot.skip(ftype)
14633 
      else:
14634 
        iprot.skip(ftype)
14635 
      iprot.readFieldEnd()
14636 
    iprot.readStructEnd()
14637 
 
14638 
  def write(self, oprot):
14639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14641 
      return
4283 anupam.sin 14642 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 14643 
    if self.success is not None:
3064 chandransh 14644 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14645 
      oprot.writeBool(self.success)
14646 
      oprot.writeFieldEnd()
3431 rajveer 14647 
    if self.ex is not None:
1246 chandransh 14648 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14649 
      self.ex.write(oprot)
14650 
      oprot.writeFieldEnd()
14651 
    oprot.writeFieldStop()
14652 
    oprot.writeStructEnd()
14653 
 
3431 rajveer 14654 
  def validate(self):
14655 
    return
14656 
 
14657 
 
1246 chandransh 14658 
  def __repr__(self):
14659 
    L = ['%s=%r' % (key, value)
14660 
      for key, value in self.__dict__.iteritems()]
14661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14662 
 
14663 
  def __eq__(self, other):
14664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14665 
 
14666 
  def __ne__(self, other):
14667 
    return not (self == other)
14668 
 
4579 rajveer 14669 
class addInvoiceNumber_args:
14670 
  """
14671 
  Attributes:
14672 
   - orderId
14673 
   - invoiceNumber
4763 rajveer 14674 
   - color
6756 amar.kumar 14675 
   - serialNumber
14676 
   - itemNumber
4579 rajveer 14677 
  """
14678 
 
14679 
  thrift_spec = (
14680 
    None, # 0
14681 
    (1, TType.I64, 'orderId', None, None, ), # 1
14682 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 14683 
    (3, TType.STRING, 'color', None, None, ), # 3
6756 amar.kumar 14684 
    (4, TType.STRING, 'serialNumber', None, None, ), # 4
14685 
    (5, TType.STRING, 'itemNumber', None, None, ), # 5
4579 rajveer 14686 
  )
14687 
 
6756 amar.kumar 14688 
  def __init__(self, orderId=None, invoiceNumber=None, color=None, serialNumber=None, itemNumber=None,):
4579 rajveer 14689 
    self.orderId = orderId
14690 
    self.invoiceNumber = invoiceNumber
4763 rajveer 14691 
    self.color = color
6756 amar.kumar 14692 
    self.serialNumber = serialNumber
14693 
    self.itemNumber = itemNumber
4579 rajveer 14694 
 
14695 
  def read(self, iprot):
14696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14698 
      return
14699 
    iprot.readStructBegin()
14700 
    while True:
14701 
      (fname, ftype, fid) = iprot.readFieldBegin()
14702 
      if ftype == TType.STOP:
14703 
        break
14704 
      if fid == 1:
14705 
        if ftype == TType.I64:
14706 
          self.orderId = iprot.readI64();
14707 
        else:
14708 
          iprot.skip(ftype)
14709 
      elif fid == 2:
14710 
        if ftype == TType.STRING:
14711 
          self.invoiceNumber = iprot.readString();
14712 
        else:
14713 
          iprot.skip(ftype)
4763 rajveer 14714 
      elif fid == 3:
14715 
        if ftype == TType.STRING:
14716 
          self.color = iprot.readString();
14717 
        else:
14718 
          iprot.skip(ftype)
6756 amar.kumar 14719 
      elif fid == 4:
14720 
        if ftype == TType.STRING:
14721 
          self.serialNumber = iprot.readString();
14722 
        else:
14723 
          iprot.skip(ftype)
14724 
      elif fid == 5:
14725 
        if ftype == TType.STRING:
14726 
          self.itemNumber = iprot.readString();
14727 
        else:
14728 
          iprot.skip(ftype)
4579 rajveer 14729 
      else:
14730 
        iprot.skip(ftype)
14731 
      iprot.readFieldEnd()
14732 
    iprot.readStructEnd()
14733 
 
14734 
  def write(self, oprot):
14735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14737 
      return
14738 
    oprot.writeStructBegin('addInvoiceNumber_args')
14739 
    if self.orderId is not None:
14740 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14741 
      oprot.writeI64(self.orderId)
14742 
      oprot.writeFieldEnd()
14743 
    if self.invoiceNumber is not None:
14744 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
14745 
      oprot.writeString(self.invoiceNumber)
14746 
      oprot.writeFieldEnd()
4763 rajveer 14747 
    if self.color is not None:
14748 
      oprot.writeFieldBegin('color', TType.STRING, 3)
14749 
      oprot.writeString(self.color)
14750 
      oprot.writeFieldEnd()
6756 amar.kumar 14751 
    if self.serialNumber is not None:
14752 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 4)
14753 
      oprot.writeString(self.serialNumber)
14754 
      oprot.writeFieldEnd()
14755 
    if self.itemNumber is not None:
14756 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 5)
14757 
      oprot.writeString(self.itemNumber)
14758 
      oprot.writeFieldEnd()
4579 rajveer 14759 
    oprot.writeFieldStop()
14760 
    oprot.writeStructEnd()
14761 
 
14762 
  def validate(self):
14763 
    return
14764 
 
14765 
 
14766 
  def __repr__(self):
14767 
    L = ['%s=%r' % (key, value)
14768 
      for key, value in self.__dict__.iteritems()]
14769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14770 
 
14771 
  def __eq__(self, other):
14772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14773 
 
14774 
  def __ne__(self, other):
14775 
    return not (self == other)
14776 
 
14777 
class addInvoiceNumber_result:
14778 
  """
14779 
  Attributes:
14780 
   - ex
14781 
  """
14782 
 
14783 
  thrift_spec = (
14784 
    None, # 0
14785 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14786 
  )
14787 
 
14788 
  def __init__(self, ex=None,):
14789 
    self.ex = ex
14790 
 
14791 
  def read(self, iprot):
14792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14794 
      return
14795 
    iprot.readStructBegin()
14796 
    while True:
14797 
      (fname, ftype, fid) = iprot.readFieldBegin()
14798 
      if ftype == TType.STOP:
14799 
        break
14800 
      if fid == 1:
14801 
        if ftype == TType.STRUCT:
14802 
          self.ex = TransactionServiceException()
14803 
          self.ex.read(iprot)
14804 
        else:
14805 
          iprot.skip(ftype)
14806 
      else:
14807 
        iprot.skip(ftype)
14808 
      iprot.readFieldEnd()
14809 
    iprot.readStructEnd()
14810 
 
14811 
  def write(self, oprot):
14812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14814 
      return
14815 
    oprot.writeStructBegin('addInvoiceNumber_result')
14816 
    if self.ex is not None:
14817 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14818 
      self.ex.write(oprot)
14819 
      oprot.writeFieldEnd()
14820 
    oprot.writeFieldStop()
14821 
    oprot.writeStructEnd()
14822 
 
14823 
  def validate(self):
14824 
    return
14825 
 
14826 
 
14827 
  def __repr__(self):
14828 
    L = ['%s=%r' % (key, value)
14829 
      for key, value in self.__dict__.iteritems()]
14830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14831 
 
14832 
  def __eq__(self, other):
14833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14834 
 
14835 
  def __ne__(self, other):
14836 
    return not (self == other)
14837 
 
4910 phani.kuma 14838 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 14839 
  """
14840 
  Attributes:
3064 chandransh 14841 
   - warehouseId
1408 ankur.sing 14842 
   - providerId
3064 chandransh 14843 
   - cod
4910 phani.kuma 14844 
   - orderIds
1408 ankur.sing 14845 
  """
14846 
 
14847 
  thrift_spec = (
14848 
    None, # 0
3064 chandransh 14849 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14850 
    (2, TType.I64, 'providerId', None, None, ), # 2
14851 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 14852 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 14853 
  )
14854 
 
4910 phani.kuma 14855 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 14856 
    self.warehouseId = warehouseId
1408 ankur.sing 14857 
    self.providerId = providerId
3064 chandransh 14858 
    self.cod = cod
4910 phani.kuma 14859 
    self.orderIds = orderIds
1408 ankur.sing 14860 
 
14861 
  def read(self, iprot):
14862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14864 
      return
14865 
    iprot.readStructBegin()
14866 
    while True:
14867 
      (fname, ftype, fid) = iprot.readFieldBegin()
14868 
      if ftype == TType.STOP:
14869 
        break
14870 
      if fid == 1:
14871 
        if ftype == TType.I64:
3064 chandransh 14872 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 14873 
        else:
14874 
          iprot.skip(ftype)
14875 
      elif fid == 2:
14876 
        if ftype == TType.I64:
3064 chandransh 14877 
          self.providerId = iprot.readI64();
1408 ankur.sing 14878 
        else:
14879 
          iprot.skip(ftype)
3064 chandransh 14880 
      elif fid == 3:
14881 
        if ftype == TType.BOOL:
14882 
          self.cod = iprot.readBool();
14883 
        else:
14884 
          iprot.skip(ftype)
4910 phani.kuma 14885 
      elif fid == 4:
14886 
        if ftype == TType.LIST:
14887 
          self.orderIds = []
6188 rajveer 14888 
          (_etype284, _size281) = iprot.readListBegin()
14889 
          for _i285 in xrange(_size281):
14890 
            _elem286 = iprot.readI64();
14891 
            self.orderIds.append(_elem286)
4910 phani.kuma 14892 
          iprot.readListEnd()
14893 
        else:
14894 
          iprot.skip(ftype)
1408 ankur.sing 14895 
      else:
14896 
        iprot.skip(ftype)
14897 
      iprot.readFieldEnd()
14898 
    iprot.readStructEnd()
14899 
 
14900 
  def write(self, oprot):
14901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14903 
      return
4910 phani.kuma 14904 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 14905 
    if self.warehouseId is not None:
3064 chandransh 14906 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14907 
      oprot.writeI64(self.warehouseId)
14908 
      oprot.writeFieldEnd()
3431 rajveer 14909 
    if self.providerId is not None:
3064 chandransh 14910 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 14911 
      oprot.writeI64(self.providerId)
14912 
      oprot.writeFieldEnd()
3431 rajveer 14913 
    if self.cod is not None:
3064 chandransh 14914 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
14915 
      oprot.writeBool(self.cod)
1408 ankur.sing 14916 
      oprot.writeFieldEnd()
4910 phani.kuma 14917 
    if self.orderIds is not None:
14918 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
14919 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14920 
      for iter287 in self.orderIds:
14921 
        oprot.writeI64(iter287)
4910 phani.kuma 14922 
      oprot.writeListEnd()
14923 
      oprot.writeFieldEnd()
1408 ankur.sing 14924 
    oprot.writeFieldStop()
14925 
    oprot.writeStructEnd()
14926 
 
3431 rajveer 14927 
  def validate(self):
14928 
    return
14929 
 
14930 
 
1408 ankur.sing 14931 
  def __repr__(self):
14932 
    L = ['%s=%r' % (key, value)
14933 
      for key, value in self.__dict__.iteritems()]
14934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14935 
 
14936 
  def __eq__(self, other):
14937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14938 
 
14939 
  def __ne__(self, other):
14940 
    return not (self == other)
14941 
 
4910 phani.kuma 14942 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 14943 
  """
14944 
  Attributes:
14945 
   - success
3064 chandransh 14946 
   - ex
1408 ankur.sing 14947 
  """
14948 
 
14949 
  thrift_spec = (
3064 chandransh 14950 
    (0, TType.BOOL, 'success', None, None, ), # 0
14951 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 14952 
  )
14953 
 
3064 chandransh 14954 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 14955 
    self.success = success
3064 chandransh 14956 
    self.ex = ex
1408 ankur.sing 14957 
 
14958 
  def read(self, iprot):
14959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14961 
      return
14962 
    iprot.readStructBegin()
14963 
    while True:
14964 
      (fname, ftype, fid) = iprot.readFieldBegin()
14965 
      if ftype == TType.STOP:
14966 
        break
14967 
      if fid == 0:
3064 chandransh 14968 
        if ftype == TType.BOOL:
14969 
          self.success = iprot.readBool();
1408 ankur.sing 14970 
        else:
14971 
          iprot.skip(ftype)
3064 chandransh 14972 
      elif fid == 1:
14973 
        if ftype == TType.STRUCT:
14974 
          self.ex = TransactionServiceException()
14975 
          self.ex.read(iprot)
14976 
        else:
14977 
          iprot.skip(ftype)
1408 ankur.sing 14978 
      else:
14979 
        iprot.skip(ftype)
14980 
      iprot.readFieldEnd()
14981 
    iprot.readStructEnd()
14982 
 
14983 
  def write(self, oprot):
14984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14986 
      return
4910 phani.kuma 14987 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 14988 
    if self.success is not None:
3064 chandransh 14989 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14990 
      oprot.writeBool(self.success)
1408 ankur.sing 14991 
      oprot.writeFieldEnd()
3431 rajveer 14992 
    if self.ex is not None:
3064 chandransh 14993 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14994 
      self.ex.write(oprot)
14995 
      oprot.writeFieldEnd()
1408 ankur.sing 14996 
    oprot.writeFieldStop()
14997 
    oprot.writeStructEnd()
14998 
 
3431 rajveer 14999 
  def validate(self):
15000 
    return
15001 
 
15002 
 
1408 ankur.sing 15003 
  def __repr__(self):
15004 
    L = ['%s=%r' % (key, value)
15005 
      for key, value in self.__dict__.iteritems()]
15006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15007 
 
15008 
  def __eq__(self, other):
15009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15010 
 
15011 
  def __ne__(self, other):
15012 
    return not (self == other)
15013 
 
5676 rajveer 15014 
class markOrdersAsReturnedFromStore_args:
15015 
  """
15016 
  Attributes:
15017 
   - providerId
15018 
   - orderIds
5713 rajveer 15019 
   - awbs
5676 rajveer 15020 
  """
15021 
 
15022 
  thrift_spec = (
15023 
    None, # 0
15024 
    (1, TType.I64, 'providerId', None, None, ), # 1
15025 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 15026 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 15027 
  )
15028 
 
5713 rajveer 15029 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 15030 
    self.providerId = providerId
15031 
    self.orderIds = orderIds
5713 rajveer 15032 
    self.awbs = awbs
5676 rajveer 15033 
 
15034 
  def read(self, iprot):
15035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15037 
      return
15038 
    iprot.readStructBegin()
15039 
    while True:
15040 
      (fname, ftype, fid) = iprot.readFieldBegin()
15041 
      if ftype == TType.STOP:
15042 
        break
15043 
      if fid == 1:
15044 
        if ftype == TType.I64:
15045 
          self.providerId = iprot.readI64();
15046 
        else:
15047 
          iprot.skip(ftype)
15048 
      elif fid == 2:
15049 
        if ftype == TType.LIST:
15050 
          self.orderIds = []
6188 rajveer 15051 
          (_etype291, _size288) = iprot.readListBegin()
15052 
          for _i292 in xrange(_size288):
15053 
            _elem293 = iprot.readI64();
15054 
            self.orderIds.append(_elem293)
5676 rajveer 15055 
          iprot.readListEnd()
15056 
        else:
15057 
          iprot.skip(ftype)
5713 rajveer 15058 
      elif fid == 3:
15059 
        if ftype == TType.LIST:
15060 
          self.awbs = []
6188 rajveer 15061 
          (_etype297, _size294) = iprot.readListBegin()
15062 
          for _i298 in xrange(_size294):
15063 
            _elem299 = iprot.readString();
15064 
            self.awbs.append(_elem299)
5713 rajveer 15065 
          iprot.readListEnd()
15066 
        else:
15067 
          iprot.skip(ftype)
5676 rajveer 15068 
      else:
15069 
        iprot.skip(ftype)
15070 
      iprot.readFieldEnd()
15071 
    iprot.readStructEnd()
15072 
 
15073 
  def write(self, oprot):
15074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15076 
      return
15077 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
15078 
    if self.providerId is not None:
15079 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15080 
      oprot.writeI64(self.providerId)
15081 
      oprot.writeFieldEnd()
15082 
    if self.orderIds is not None:
15083 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
15084 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 15085 
      for iter300 in self.orderIds:
15086 
        oprot.writeI64(iter300)
5676 rajveer 15087 
      oprot.writeListEnd()
15088 
      oprot.writeFieldEnd()
5713 rajveer 15089 
    if self.awbs is not None:
15090 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
15091 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 15092 
      for iter301 in self.awbs:
15093 
        oprot.writeString(iter301)
5713 rajveer 15094 
      oprot.writeListEnd()
15095 
      oprot.writeFieldEnd()
5676 rajveer 15096 
    oprot.writeFieldStop()
15097 
    oprot.writeStructEnd()
15098 
 
15099 
  def validate(self):
15100 
    return
15101 
 
15102 
 
15103 
  def __repr__(self):
15104 
    L = ['%s=%r' % (key, value)
15105 
      for key, value in self.__dict__.iteritems()]
15106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15107 
 
15108 
  def __eq__(self, other):
15109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15110 
 
15111 
  def __ne__(self, other):
15112 
    return not (self == other)
15113 
 
15114 
class markOrdersAsReturnedFromStore_result:
15115 
  """
15116 
  Attributes:
15117 
   - success
15118 
   - ex
15119 
  """
15120 
 
15121 
  thrift_spec = (
15122 
    (0, TType.BOOL, 'success', None, None, ), # 0
15123 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15124 
  )
15125 
 
15126 
  def __init__(self, success=None, ex=None,):
15127 
    self.success = success
15128 
    self.ex = ex
15129 
 
15130 
  def read(self, iprot):
15131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15133 
      return
15134 
    iprot.readStructBegin()
15135 
    while True:
15136 
      (fname, ftype, fid) = iprot.readFieldBegin()
15137 
      if ftype == TType.STOP:
15138 
        break
15139 
      if fid == 0:
15140 
        if ftype == TType.BOOL:
15141 
          self.success = iprot.readBool();
15142 
        else:
15143 
          iprot.skip(ftype)
15144 
      elif fid == 1:
15145 
        if ftype == TType.STRUCT:
15146 
          self.ex = TransactionServiceException()
15147 
          self.ex.read(iprot)
15148 
        else:
15149 
          iprot.skip(ftype)
15150 
      else:
15151 
        iprot.skip(ftype)
15152 
      iprot.readFieldEnd()
15153 
    iprot.readStructEnd()
15154 
 
15155 
  def write(self, oprot):
15156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15158 
      return
15159 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
15160 
    if self.success is not None:
15161 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15162 
      oprot.writeBool(self.success)
15163 
      oprot.writeFieldEnd()
15164 
    if self.ex is not None:
15165 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15166 
      self.ex.write(oprot)
15167 
      oprot.writeFieldEnd()
15168 
    oprot.writeFieldStop()
15169 
    oprot.writeStructEnd()
15170 
 
15171 
  def validate(self):
15172 
    return
15173 
 
15174 
 
15175 
  def __repr__(self):
15176 
    L = ['%s=%r' % (key, value)
15177 
      for key, value in self.__dict__.iteritems()]
15178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15179 
 
15180 
  def __eq__(self, other):
15181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15182 
 
15183 
  def __ne__(self, other):
15184 
    return not (self == other)
15185 
 
4910 phani.kuma 15186 
class markOrdersAsPickedUp_args:
4410 rajveer 15187 
  """
15188 
  Attributes:
15189 
   - providerId
4910 phani.kuma 15190 
   - pickupDetails
4410 rajveer 15191 
  """
15192 
 
15193 
  thrift_spec = (
15194 
    None, # 0
4910 phani.kuma 15195 
    (1, TType.I64, 'providerId', None, None, ), # 1
15196 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 15197 
  )
15198 
 
4910 phani.kuma 15199 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 15200 
    self.providerId = providerId
4910 phani.kuma 15201 
    self.pickupDetails = pickupDetails
4410 rajveer 15202 
 
15203 
  def read(self, iprot):
15204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15206 
      return
15207 
    iprot.readStructBegin()
15208 
    while True:
15209 
      (fname, ftype, fid) = iprot.readFieldBegin()
15210 
      if ftype == TType.STOP:
15211 
        break
15212 
      if fid == 1:
15213 
        if ftype == TType.I64:
4910 phani.kuma 15214 
          self.providerId = iprot.readI64();
4410 rajveer 15215 
        else:
15216 
          iprot.skip(ftype)
15217 
      elif fid == 2:
4910 phani.kuma 15218 
        if ftype == TType.MAP:
15219 
          self.pickupDetails = {}
6188 rajveer 15220 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
15221 
          for _i306 in xrange(_size302):
15222 
            _key307 = iprot.readString();
15223 
            _val308 = iprot.readString();
15224 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 15225 
          iprot.readMapEnd()
4410 rajveer 15226 
        else:
15227 
          iprot.skip(ftype)
15228 
      else:
15229 
        iprot.skip(ftype)
15230 
      iprot.readFieldEnd()
15231 
    iprot.readStructEnd()
15232 
 
15233 
  def write(self, oprot):
15234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15236 
      return
4910 phani.kuma 15237 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 15238 
    if self.providerId is not None:
4910 phani.kuma 15239 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 15240 
      oprot.writeI64(self.providerId)
15241 
      oprot.writeFieldEnd()
4910 phani.kuma 15242 
    if self.pickupDetails is not None:
15243 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15244 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 15245 
      for kiter309,viter310 in self.pickupDetails.items():
15246 
        oprot.writeString(kiter309)
15247 
        oprot.writeString(viter310)
4910 phani.kuma 15248 
      oprot.writeMapEnd()
4410 rajveer 15249 
      oprot.writeFieldEnd()
15250 
    oprot.writeFieldStop()
15251 
    oprot.writeStructEnd()
15252 
 
15253 
  def validate(self):
15254 
    return
15255 
 
15256 
 
15257 
  def __repr__(self):
15258 
    L = ['%s=%r' % (key, value)
15259 
      for key, value in self.__dict__.iteritems()]
15260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15261 
 
15262 
  def __eq__(self, other):
15263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15264 
 
15265 
  def __ne__(self, other):
15266 
    return not (self == other)
15267 
 
4910 phani.kuma 15268 
class markOrdersAsPickedUp_result:
4410 rajveer 15269 
  """
15270 
  Attributes:
15271 
   - ex
15272 
  """
15273 
 
15274 
  thrift_spec = (
4910 phani.kuma 15275 
    None, # 0
4410 rajveer 15276 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15277 
  )
15278 
 
4910 phani.kuma 15279 
  def __init__(self, ex=None,):
4410 rajveer 15280 
    self.ex = ex
15281 
 
15282 
  def read(self, iprot):
15283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15285 
      return
15286 
    iprot.readStructBegin()
15287 
    while True:
15288 
      (fname, ftype, fid) = iprot.readFieldBegin()
15289 
      if ftype == TType.STOP:
15290 
        break
4910 phani.kuma 15291 
      if fid == 1:
4410 rajveer 15292 
        if ftype == TType.STRUCT:
15293 
          self.ex = TransactionServiceException()
15294 
          self.ex.read(iprot)
15295 
        else:
15296 
          iprot.skip(ftype)
15297 
      else:
15298 
        iprot.skip(ftype)
15299 
      iprot.readFieldEnd()
15300 
    iprot.readStructEnd()
15301 
 
15302 
  def write(self, oprot):
15303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15305 
      return
4910 phani.kuma 15306 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 15307 
    if self.ex is not None:
15308 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15309 
      self.ex.write(oprot)
15310 
      oprot.writeFieldEnd()
15311 
    oprot.writeFieldStop()
15312 
    oprot.writeStructEnd()
15313 
 
15314 
  def validate(self):
15315 
    return
15316 
 
15317 
 
15318 
  def __repr__(self):
15319 
    L = ['%s=%r' % (key, value)
15320 
      for key, value in self.__dict__.iteritems()]
15321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15322 
 
15323 
  def __eq__(self, other):
15324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15325 
 
15326 
  def __ne__(self, other):
15327 
    return not (self == other)
15328 
 
4910 phani.kuma 15329 
class getOrdersNotPickedUp_args:
304 ashish 15330 
  """
15331 
  Attributes:
3064 chandransh 15332 
   - providerId
304 ashish 15333 
  """
94 ashish 15334 
 
304 ashish 15335 
  thrift_spec = (
15336 
    None, # 0
3064 chandransh 15337 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 15338 
  )
15339 
 
4910 phani.kuma 15340 
  def __init__(self, providerId=None,):
3064 chandransh 15341 
    self.providerId = providerId
304 ashish 15342 
 
15343 
  def read(self, iprot):
15344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15346 
      return
15347 
    iprot.readStructBegin()
15348 
    while True:
15349 
      (fname, ftype, fid) = iprot.readFieldBegin()
15350 
      if ftype == TType.STOP:
15351 
        break
15352 
      if fid == 1:
15353 
        if ftype == TType.I64:
3064 chandransh 15354 
          self.providerId = iprot.readI64();
304 ashish 15355 
        else:
15356 
          iprot.skip(ftype)
15357 
      else:
15358 
        iprot.skip(ftype)
15359 
      iprot.readFieldEnd()
15360 
    iprot.readStructEnd()
15361 
 
15362 
  def write(self, oprot):
15363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15365 
      return
4910 phani.kuma 15366 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 15367 
    if self.providerId is not None:
3064 chandransh 15368 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15369 
      oprot.writeI64(self.providerId)
304 ashish 15370 
      oprot.writeFieldEnd()
15371 
    oprot.writeFieldStop()
15372 
    oprot.writeStructEnd()
15373 
 
3431 rajveer 15374 
  def validate(self):
15375 
    return
15376 
 
15377 
 
304 ashish 15378 
  def __repr__(self):
15379 
    L = ['%s=%r' % (key, value)
15380 
      for key, value in self.__dict__.iteritems()]
15381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15382 
 
15383 
  def __eq__(self, other):
15384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15385 
 
15386 
  def __ne__(self, other):
15387 
    return not (self == other)
15388 
 
4910 phani.kuma 15389 
class getOrdersNotPickedUp_result:
304 ashish 15390 
  """
15391 
  Attributes:
15392 
   - success
15393 
  """
15394 
 
15395 
  thrift_spec = (
3064 chandransh 15396 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 15397 
  )
15398 
 
4910 phani.kuma 15399 
  def __init__(self, success=None,):
304 ashish 15400 
    self.success = success
15401 
 
15402 
  def read(self, iprot):
15403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15405 
      return
15406 
    iprot.readStructBegin()
15407 
    while True:
15408 
      (fname, ftype, fid) = iprot.readFieldBegin()
15409 
      if ftype == TType.STOP:
15410 
        break
15411 
      if fid == 0:
15412 
        if ftype == TType.LIST:
15413 
          self.success = []
6188 rajveer 15414 
          (_etype314, _size311) = iprot.readListBegin()
15415 
          for _i315 in xrange(_size311):
15416 
            _elem316 = Order()
15417 
            _elem316.read(iprot)
15418 
            self.success.append(_elem316)
304 ashish 15419 
          iprot.readListEnd()
15420 
        else:
15421 
          iprot.skip(ftype)
15422 
      else:
15423 
        iprot.skip(ftype)
15424 
      iprot.readFieldEnd()
15425 
    iprot.readStructEnd()
15426 
 
15427 
  def write(self, oprot):
15428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15430 
      return
4910 phani.kuma 15431 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 15432 
    if self.success is not None:
304 ashish 15433 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15434 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15435 
      for iter317 in self.success:
15436 
        iter317.write(oprot)
304 ashish 15437 
      oprot.writeListEnd()
15438 
      oprot.writeFieldEnd()
15439 
    oprot.writeFieldStop()
15440 
    oprot.writeStructEnd()
15441 
 
3431 rajveer 15442 
  def validate(self):
15443 
    return
15444 
 
15445 
 
304 ashish 15446 
  def __repr__(self):
15447 
    L = ['%s=%r' % (key, value)
15448 
      for key, value in self.__dict__.iteritems()]
15449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15450 
 
15451 
  def __eq__(self, other):
15452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15453 
 
15454 
  def __ne__(self, other):
15455 
    return not (self == other)
15456 
 
3064 chandransh 15457 
class markOrdersAsDelivered_args:
304 ashish 15458 
  """
15459 
  Attributes:
3064 chandransh 15460 
   - providerId
15461 
   - deliveredOrders
304 ashish 15462 
  """
15463 
 
15464 
  thrift_spec = (
15465 
    None, # 0
3064 chandransh 15466 
    (1, TType.I64, 'providerId', None, None, ), # 1
15467 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 15468 
  )
15469 
 
3064 chandransh 15470 
  def __init__(self, providerId=None, deliveredOrders=None,):
15471 
    self.providerId = providerId
15472 
    self.deliveredOrders = deliveredOrders
304 ashish 15473 
 
15474 
  def read(self, iprot):
15475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15477 
      return
15478 
    iprot.readStructBegin()
15479 
    while True:
15480 
      (fname, ftype, fid) = iprot.readFieldBegin()
15481 
      if ftype == TType.STOP:
15482 
        break
15483 
      if fid == 1:
15484 
        if ftype == TType.I64:
3064 chandransh 15485 
          self.providerId = iprot.readI64();
304 ashish 15486 
        else:
15487 
          iprot.skip(ftype)
15488 
      elif fid == 2:
3064 chandransh 15489 
        if ftype == TType.MAP:
15490 
          self.deliveredOrders = {}
6188 rajveer 15491 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
15492 
          for _i322 in xrange(_size318):
15493 
            _key323 = iprot.readString();
15494 
            _val324 = iprot.readString();
15495 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 15496 
          iprot.readMapEnd()
304 ashish 15497 
        else:
15498 
          iprot.skip(ftype)
15499 
      else:
15500 
        iprot.skip(ftype)
15501 
      iprot.readFieldEnd()
15502 
    iprot.readStructEnd()
15503 
 
15504 
  def write(self, oprot):
15505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15507 
      return
3064 chandransh 15508 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 15509 
    if self.providerId is not None:
3064 chandransh 15510 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15511 
      oprot.writeI64(self.providerId)
304 ashish 15512 
      oprot.writeFieldEnd()
3431 rajveer 15513 
    if self.deliveredOrders is not None:
3064 chandransh 15514 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
15515 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 15516 
      for kiter325,viter326 in self.deliveredOrders.items():
15517 
        oprot.writeString(kiter325)
15518 
        oprot.writeString(viter326)
3064 chandransh 15519 
      oprot.writeMapEnd()
304 ashish 15520 
      oprot.writeFieldEnd()
15521 
    oprot.writeFieldStop()
15522 
    oprot.writeStructEnd()
15523 
 
3431 rajveer 15524 
  def validate(self):
15525 
    return
15526 
 
15527 
 
304 ashish 15528 
  def __repr__(self):
15529 
    L = ['%s=%r' % (key, value)
15530 
      for key, value in self.__dict__.iteritems()]
15531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15532 
 
15533 
  def __eq__(self, other):
15534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15535 
 
15536 
  def __ne__(self, other):
15537 
    return not (self == other)
15538 
 
3064 chandransh 15539 
class markOrdersAsDelivered_result:
15540 
  """
15541 
  Attributes:
15542 
   - ex
15543 
  """
304 ashish 15544 
 
15545 
  thrift_spec = (
3064 chandransh 15546 
    None, # 0
15547 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 15548 
  )
15549 
 
3064 chandransh 15550 
  def __init__(self, ex=None,):
15551 
    self.ex = ex
304 ashish 15552 
 
1596 ankur.sing 15553 
  def read(self, iprot):
15554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15556 
      return
15557 
    iprot.readStructBegin()
15558 
    while True:
15559 
      (fname, ftype, fid) = iprot.readFieldBegin()
15560 
      if ftype == TType.STOP:
15561 
        break
3064 chandransh 15562 
      if fid == 1:
15563 
        if ftype == TType.STRUCT:
15564 
          self.ex = TransactionServiceException()
15565 
          self.ex.read(iprot)
15566 
        else:
15567 
          iprot.skip(ftype)
1596 ankur.sing 15568 
      else:
15569 
        iprot.skip(ftype)
15570 
      iprot.readFieldEnd()
15571 
    iprot.readStructEnd()
15572 
 
15573 
  def write(self, oprot):
15574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15576 
      return
3064 chandransh 15577 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 15578 
    if self.ex is not None:
3064 chandransh 15579 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15580 
      self.ex.write(oprot)
15581 
      oprot.writeFieldEnd()
1596 ankur.sing 15582 
    oprot.writeFieldStop()
15583 
    oprot.writeStructEnd()
15584 
 
3431 rajveer 15585 
  def validate(self):
15586 
    return
15587 
 
15588 
 
1596 ankur.sing 15589 
  def __repr__(self):
15590 
    L = ['%s=%r' % (key, value)
15591 
      for key, value in self.__dict__.iteritems()]
15592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15593 
 
15594 
  def __eq__(self, other):
15595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15596 
 
15597 
  def __ne__(self, other):
15598 
    return not (self == other)
15599 
 
4910 phani.kuma 15600 
class markAsRTOrders_args:
1596 ankur.sing 15601 
  """
15602 
  Attributes:
3064 chandransh 15603 
   - providerId
15604 
   - returnedOrders
1596 ankur.sing 15605 
  """
15606 
 
15607 
  thrift_spec = (
3064 chandransh 15608 
    None, # 0
15609 
    (1, TType.I64, 'providerId', None, None, ), # 1
15610 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 15611 
  )
15612 
 
3064 chandransh 15613 
  def __init__(self, providerId=None, returnedOrders=None,):
15614 
    self.providerId = providerId
15615 
    self.returnedOrders = returnedOrders
1596 ankur.sing 15616 
 
15617 
  def read(self, iprot):
15618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15620 
      return
15621 
    iprot.readStructBegin()
15622 
    while True:
15623 
      (fname, ftype, fid) = iprot.readFieldBegin()
15624 
      if ftype == TType.STOP:
15625 
        break
3064 chandransh 15626 
      if fid == 1:
1596 ankur.sing 15627 
        if ftype == TType.I64:
3064 chandransh 15628 
          self.providerId = iprot.readI64();
1596 ankur.sing 15629 
        else:
15630 
          iprot.skip(ftype)
3064 chandransh 15631 
      elif fid == 2:
15632 
        if ftype == TType.MAP:
15633 
          self.returnedOrders = {}
6188 rajveer 15634 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
15635 
          for _i331 in xrange(_size327):
15636 
            _key332 = iprot.readString();
15637 
            _val333 = iprot.readString();
15638 
            self.returnedOrders[_key332] = _val333
3064 chandransh 15639 
          iprot.readMapEnd()
15640 
        else:
15641 
          iprot.skip(ftype)
1596 ankur.sing 15642 
      else:
15643 
        iprot.skip(ftype)
15644 
      iprot.readFieldEnd()
15645 
    iprot.readStructEnd()
15646 
 
15647 
  def write(self, oprot):
15648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15650 
      return
4910 phani.kuma 15651 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 15652 
    if self.providerId is not None:
3064 chandransh 15653 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15654 
      oprot.writeI64(self.providerId)
1596 ankur.sing 15655 
      oprot.writeFieldEnd()
3431 rajveer 15656 
    if self.returnedOrders is not None:
3064 chandransh 15657 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
15658 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 15659 
      for kiter334,viter335 in self.returnedOrders.items():
15660 
        oprot.writeString(kiter334)
15661 
        oprot.writeString(viter335)
3064 chandransh 15662 
      oprot.writeMapEnd()
15663 
      oprot.writeFieldEnd()
1596 ankur.sing 15664 
    oprot.writeFieldStop()
15665 
    oprot.writeStructEnd()
15666 
 
3431 rajveer 15667 
  def validate(self):
15668 
    return
15669 
 
15670 
 
1596 ankur.sing 15671 
  def __repr__(self):
15672 
    L = ['%s=%r' % (key, value)
15673 
      for key, value in self.__dict__.iteritems()]
15674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15675 
 
15676 
  def __eq__(self, other):
15677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15678 
 
15679 
  def __ne__(self, other):
15680 
    return not (self == other)
15681 
 
4910 phani.kuma 15682 
class markAsRTOrders_result:
3064 chandransh 15683 
  """
15684 
  Attributes:
15685 
   - ex
15686 
  """
1596 ankur.sing 15687 
 
1627 ankur.sing 15688 
  thrift_spec = (
3064 chandransh 15689 
    None, # 0
15690 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15691 
  )
15692 
 
3064 chandransh 15693 
  def __init__(self, ex=None,):
15694 
    self.ex = ex
15695 
 
1627 ankur.sing 15696 
  def read(self, iprot):
15697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15699 
      return
15700 
    iprot.readStructBegin()
15701 
    while True:
15702 
      (fname, ftype, fid) = iprot.readFieldBegin()
15703 
      if ftype == TType.STOP:
15704 
        break
3064 chandransh 15705 
      if fid == 1:
15706 
        if ftype == TType.STRUCT:
15707 
          self.ex = TransactionServiceException()
15708 
          self.ex.read(iprot)
15709 
        else:
15710 
          iprot.skip(ftype)
1627 ankur.sing 15711 
      else:
15712 
        iprot.skip(ftype)
15713 
      iprot.readFieldEnd()
15714 
    iprot.readStructEnd()
15715 
 
15716 
  def write(self, oprot):
15717 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15718 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15719 
      return
4910 phani.kuma 15720 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 15721 
    if self.ex is not None:
3064 chandransh 15722 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15723 
      self.ex.write(oprot)
15724 
      oprot.writeFieldEnd()
1627 ankur.sing 15725 
    oprot.writeFieldStop()
15726 
    oprot.writeStructEnd()
15727 
 
3431 rajveer 15728 
  def validate(self):
15729 
    return
15730 
 
15731 
 
1627 ankur.sing 15732 
  def __repr__(self):
15733 
    L = ['%s=%r' % (key, value)
15734 
      for key, value in self.__dict__.iteritems()]
15735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15736 
 
15737 
  def __eq__(self, other):
15738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15739 
 
15740 
  def __ne__(self, other):
15741 
    return not (self == other)
15742 
 
4910 phani.kuma 15743 
class getRTOrders_args:
15744 
  """
15745 
  Attributes:
15746 
   - providerId
15747 
  """
15748 
 
15749 
  thrift_spec = (
15750 
    None, # 0
15751 
    (1, TType.I64, 'providerId', None, None, ), # 1
15752 
  )
15753 
 
15754 
  def __init__(self, providerId=None,):
15755 
    self.providerId = providerId
15756 
 
15757 
  def read(self, iprot):
15758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15760 
      return
15761 
    iprot.readStructBegin()
15762 
    while True:
15763 
      (fname, ftype, fid) = iprot.readFieldBegin()
15764 
      if ftype == TType.STOP:
15765 
        break
15766 
      if fid == 1:
15767 
        if ftype == TType.I64:
15768 
          self.providerId = iprot.readI64();
15769 
        else:
15770 
          iprot.skip(ftype)
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('getRTOrders_args')
15781 
    if self.providerId is not None:
15782 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15783 
      oprot.writeI64(self.providerId)
15784 
      oprot.writeFieldEnd()
15785 
    oprot.writeFieldStop()
15786 
    oprot.writeStructEnd()
15787 
 
15788 
  def validate(self):
15789 
    return
15790 
 
15791 
 
15792 
  def __repr__(self):
15793 
    L = ['%s=%r' % (key, value)
15794 
      for key, value in self.__dict__.iteritems()]
15795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15796 
 
15797 
  def __eq__(self, other):
15798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15799 
 
15800 
  def __ne__(self, other):
15801 
    return not (self == other)
15802 
 
15803 
class getRTOrders_result:
15804 
  """
15805 
  Attributes:
15806 
   - success
15807 
  """
15808 
 
15809 
  thrift_spec = (
15810 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15811 
  )
15812 
 
15813 
  def __init__(self, success=None,):
15814 
    self.success = success
15815 
 
15816 
  def read(self, iprot):
15817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15819 
      return
15820 
    iprot.readStructBegin()
15821 
    while True:
15822 
      (fname, ftype, fid) = iprot.readFieldBegin()
15823 
      if ftype == TType.STOP:
15824 
        break
15825 
      if fid == 0:
15826 
        if ftype == TType.LIST:
15827 
          self.success = []
6188 rajveer 15828 
          (_etype339, _size336) = iprot.readListBegin()
15829 
          for _i340 in xrange(_size336):
15830 
            _elem341 = Order()
15831 
            _elem341.read(iprot)
15832 
            self.success.append(_elem341)
4910 phani.kuma 15833 
          iprot.readListEnd()
15834 
        else:
15835 
          iprot.skip(ftype)
15836 
      else:
15837 
        iprot.skip(ftype)
15838 
      iprot.readFieldEnd()
15839 
    iprot.readStructEnd()
15840 
 
15841 
  def write(self, oprot):
15842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15844 
      return
15845 
    oprot.writeStructBegin('getRTOrders_result')
15846 
    if self.success is not None:
15847 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15848 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15849 
      for iter342 in self.success:
15850 
        iter342.write(oprot)
4910 phani.kuma 15851 
      oprot.writeListEnd()
15852 
      oprot.writeFieldEnd()
15853 
    oprot.writeFieldStop()
15854 
    oprot.writeStructEnd()
15855 
 
15856 
  def validate(self):
15857 
    return
15858 
 
15859 
 
15860 
  def __repr__(self):
15861 
    L = ['%s=%r' % (key, value)
15862 
      for key, value in self.__dict__.iteritems()]
15863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15864 
 
15865 
  def __eq__(self, other):
15866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15867 
 
15868 
  def __ne__(self, other):
15869 
    return not (self == other)
15870 
 
3064 chandransh 15871 
class updateNonDeliveryReason_args:
1627 ankur.sing 15872 
  """
15873 
  Attributes:
3064 chandransh 15874 
   - providerId
15875 
   - undeliveredOrders
1627 ankur.sing 15876 
  """
15877 
 
15878 
  thrift_spec = (
3064 chandransh 15879 
    None, # 0
15880 
    (1, TType.I64, 'providerId', None, None, ), # 1
15881 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 15882 
  )
15883 
 
3064 chandransh 15884 
  def __init__(self, providerId=None, undeliveredOrders=None,):
15885 
    self.providerId = providerId
15886 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 15887 
 
15888 
  def read(self, iprot):
15889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15891 
      return
15892 
    iprot.readStructBegin()
15893 
    while True:
15894 
      (fname, ftype, fid) = iprot.readFieldBegin()
15895 
      if ftype == TType.STOP:
15896 
        break
3064 chandransh 15897 
      if fid == 1:
1627 ankur.sing 15898 
        if ftype == TType.I64:
3064 chandransh 15899 
          self.providerId = iprot.readI64();
1627 ankur.sing 15900 
        else:
15901 
          iprot.skip(ftype)
3064 chandransh 15902 
      elif fid == 2:
15903 
        if ftype == TType.MAP:
15904 
          self.undeliveredOrders = {}
6188 rajveer 15905 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
15906 
          for _i347 in xrange(_size343):
15907 
            _key348 = iprot.readString();
15908 
            _val349 = iprot.readString();
15909 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 15910 
          iprot.readMapEnd()
15911 
        else:
15912 
          iprot.skip(ftype)
1627 ankur.sing 15913 
      else:
15914 
        iprot.skip(ftype)
15915 
      iprot.readFieldEnd()
15916 
    iprot.readStructEnd()
15917 
 
15918 
  def write(self, oprot):
15919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15921 
      return
3064 chandransh 15922 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 15923 
    if self.providerId is not None:
3064 chandransh 15924 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15925 
      oprot.writeI64(self.providerId)
1627 ankur.sing 15926 
      oprot.writeFieldEnd()
3431 rajveer 15927 
    if self.undeliveredOrders is not None:
3064 chandransh 15928 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
15929 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 15930 
      for kiter350,viter351 in self.undeliveredOrders.items():
15931 
        oprot.writeString(kiter350)
15932 
        oprot.writeString(viter351)
3064 chandransh 15933 
      oprot.writeMapEnd()
15934 
      oprot.writeFieldEnd()
1627 ankur.sing 15935 
    oprot.writeFieldStop()
15936 
    oprot.writeStructEnd()
15937 
 
3431 rajveer 15938 
  def validate(self):
15939 
    return
15940 
 
15941 
 
1627 ankur.sing 15942 
  def __repr__(self):
15943 
    L = ['%s=%r' % (key, value)
15944 
      for key, value in self.__dict__.iteritems()]
15945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15946 
 
15947 
  def __eq__(self, other):
15948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15949 
 
15950 
  def __ne__(self, other):
15951 
    return not (self == other)
15952 
 
3064 chandransh 15953 
class updateNonDeliveryReason_result:
1627 ankur.sing 15954 
  """
15955 
  Attributes:
3064 chandransh 15956 
   - ex
1627 ankur.sing 15957 
  """
15958 
 
15959 
  thrift_spec = (
4910 phani.kuma 15960 
    None, # 0
3064 chandransh 15961 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15962 
  )
15963 
 
4910 phani.kuma 15964 
  def __init__(self, ex=None,):
3064 chandransh 15965 
    self.ex = ex
1627 ankur.sing 15966 
 
15967 
  def read(self, iprot):
15968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15970 
      return
15971 
    iprot.readStructBegin()
15972 
    while True:
15973 
      (fname, ftype, fid) = iprot.readFieldBegin()
15974 
      if ftype == TType.STOP:
15975 
        break
4910 phani.kuma 15976 
      if fid == 1:
15977 
        if ftype == TType.STRUCT:
15978 
          self.ex = TransactionServiceException()
15979 
          self.ex.read(iprot)
15980 
        else:
15981 
          iprot.skip(ftype)
15982 
      else:
15983 
        iprot.skip(ftype)
15984 
      iprot.readFieldEnd()
15985 
    iprot.readStructEnd()
15986 
 
15987 
  def write(self, oprot):
15988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15990 
      return
15991 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
15992 
    if self.ex is not None:
15993 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15994 
      self.ex.write(oprot)
15995 
      oprot.writeFieldEnd()
15996 
    oprot.writeFieldStop()
15997 
    oprot.writeStructEnd()
15998 
 
15999 
  def validate(self):
16000 
    return
16001 
 
16002 
 
16003 
  def __repr__(self):
16004 
    L = ['%s=%r' % (key, value)
16005 
      for key, value in self.__dict__.iteritems()]
16006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16007 
 
16008 
  def __eq__(self, other):
16009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16010 
 
16011 
  def __ne__(self, other):
16012 
    return not (self == other)
16013 
 
16014 
class getNonDeliveredOrdersbyCourier_args:
16015 
  """
16016 
  Attributes:
16017 
   - providerId
16018 
  """
16019 
 
16020 
  thrift_spec = (
16021 
    None, # 0
16022 
    (1, TType.I64, 'providerId', None, None, ), # 1
16023 
  )
16024 
 
16025 
  def __init__(self, providerId=None,):
16026 
    self.providerId = providerId
16027 
 
16028 
  def read(self, iprot):
16029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16031 
      return
16032 
    iprot.readStructBegin()
16033 
    while True:
16034 
      (fname, ftype, fid) = iprot.readFieldBegin()
16035 
      if ftype == TType.STOP:
16036 
        break
16037 
      if fid == 1:
16038 
        if ftype == TType.I64:
16039 
          self.providerId = iprot.readI64();
16040 
        else:
16041 
          iprot.skip(ftype)
16042 
      else:
16043 
        iprot.skip(ftype)
16044 
      iprot.readFieldEnd()
16045 
    iprot.readStructEnd()
16046 
 
16047 
  def write(self, oprot):
16048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16050 
      return
16051 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
16052 
    if self.providerId is not None:
16053 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16054 
      oprot.writeI64(self.providerId)
16055 
      oprot.writeFieldEnd()
16056 
    oprot.writeFieldStop()
16057 
    oprot.writeStructEnd()
16058 
 
16059 
  def validate(self):
16060 
    return
16061 
 
16062 
 
16063 
  def __repr__(self):
16064 
    L = ['%s=%r' % (key, value)
16065 
      for key, value in self.__dict__.iteritems()]
16066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16067 
 
16068 
  def __eq__(self, other):
16069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16070 
 
16071 
  def __ne__(self, other):
16072 
    return not (self == other)
16073 
 
16074 
class getNonDeliveredOrdersbyCourier_result:
16075 
  """
16076 
  Attributes:
16077 
   - success
16078 
  """
16079 
 
16080 
  thrift_spec = (
16081 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16082 
  )
16083 
 
16084 
  def __init__(self, success=None,):
16085 
    self.success = success
16086 
 
16087 
  def read(self, iprot):
16088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16090 
      return
16091 
    iprot.readStructBegin()
16092 
    while True:
16093 
      (fname, ftype, fid) = iprot.readFieldBegin()
16094 
      if ftype == TType.STOP:
16095 
        break
4581 phani.kuma 16096 
      if fid == 0:
16097 
        if ftype == TType.LIST:
16098 
          self.success = []
6188 rajveer 16099 
          (_etype355, _size352) = iprot.readListBegin()
16100 
          for _i356 in xrange(_size352):
16101 
            _elem357 = Order()
16102 
            _elem357.read(iprot)
16103 
            self.success.append(_elem357)
4581 phani.kuma 16104 
          iprot.readListEnd()
16105 
        else:
16106 
          iprot.skip(ftype)
4910 phani.kuma 16107 
      else:
16108 
        iprot.skip(ftype)
16109 
      iprot.readFieldEnd()
16110 
    iprot.readStructEnd()
16111 
 
16112 
  def write(self, oprot):
16113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16115 
      return
16116 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
16117 
    if self.success is not None:
16118 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16119 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16120 
      for iter358 in self.success:
16121 
        iter358.write(oprot)
4910 phani.kuma 16122 
      oprot.writeListEnd()
16123 
      oprot.writeFieldEnd()
16124 
    oprot.writeFieldStop()
16125 
    oprot.writeStructEnd()
16126 
 
16127 
  def validate(self):
16128 
    return
16129 
 
16130 
 
16131 
  def __repr__(self):
16132 
    L = ['%s=%r' % (key, value)
16133 
      for key, value in self.__dict__.iteritems()]
16134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16135 
 
16136 
  def __eq__(self, other):
16137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16138 
 
16139 
  def __ne__(self, other):
16140 
    return not (self == other)
16141 
 
16142 
class markOrdersAsLocalConnected_args:
16143 
  """
16144 
  Attributes:
16145 
   - providerId
16146 
   - local_connected_orders
16147 
  """
16148 
 
16149 
  thrift_spec = (
16150 
    None, # 0
16151 
    (1, TType.I64, 'providerId', None, None, ), # 1
16152 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16153 
  )
16154 
 
16155 
  def __init__(self, providerId=None, local_connected_orders=None,):
16156 
    self.providerId = providerId
16157 
    self.local_connected_orders = local_connected_orders
16158 
 
16159 
  def read(self, iprot):
16160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16162 
      return
16163 
    iprot.readStructBegin()
16164 
    while True:
16165 
      (fname, ftype, fid) = iprot.readFieldBegin()
16166 
      if ftype == TType.STOP:
16167 
        break
16168 
      if fid == 1:
16169 
        if ftype == TType.I64:
16170 
          self.providerId = iprot.readI64();
16171 
        else:
16172 
          iprot.skip(ftype)
16173 
      elif fid == 2:
16174 
        if ftype == TType.MAP:
16175 
          self.local_connected_orders = {}
6188 rajveer 16176 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
16177 
          for _i363 in xrange(_size359):
16178 
            _key364 = iprot.readString();
16179 
            _val365 = iprot.readString();
16180 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 16181 
          iprot.readMapEnd()
16182 
        else:
16183 
          iprot.skip(ftype)
16184 
      else:
16185 
        iprot.skip(ftype)
16186 
      iprot.readFieldEnd()
16187 
    iprot.readStructEnd()
16188 
 
16189 
  def write(self, oprot):
16190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16192 
      return
16193 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
16194 
    if self.providerId is not None:
16195 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16196 
      oprot.writeI64(self.providerId)
16197 
      oprot.writeFieldEnd()
16198 
    if self.local_connected_orders is not None:
16199 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
16200 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 16201 
      for kiter366,viter367 in self.local_connected_orders.items():
16202 
        oprot.writeString(kiter366)
16203 
        oprot.writeString(viter367)
4910 phani.kuma 16204 
      oprot.writeMapEnd()
16205 
      oprot.writeFieldEnd()
16206 
    oprot.writeFieldStop()
16207 
    oprot.writeStructEnd()
16208 
 
16209 
  def validate(self):
16210 
    return
16211 
 
16212 
 
16213 
  def __repr__(self):
16214 
    L = ['%s=%r' % (key, value)
16215 
      for key, value in self.__dict__.iteritems()]
16216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16217 
 
16218 
  def __eq__(self, other):
16219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16220 
 
16221 
  def __ne__(self, other):
16222 
    return not (self == other)
16223 
 
16224 
class markOrdersAsLocalConnected_result:
16225 
  """
16226 
  Attributes:
16227 
   - ex
16228 
  """
16229 
 
16230 
  thrift_spec = (
16231 
    None, # 0
16232 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16233 
  )
16234 
 
16235 
  def __init__(self, ex=None,):
16236 
    self.ex = ex
16237 
 
16238 
  def read(self, iprot):
16239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16241 
      return
16242 
    iprot.readStructBegin()
16243 
    while True:
16244 
      (fname, ftype, fid) = iprot.readFieldBegin()
16245 
      if ftype == TType.STOP:
16246 
        break
16247 
      if fid == 1:
3064 chandransh 16248 
        if ftype == TType.STRUCT:
16249 
          self.ex = TransactionServiceException()
16250 
          self.ex.read(iprot)
1627 ankur.sing 16251 
        else:
16252 
          iprot.skip(ftype)
16253 
      else:
16254 
        iprot.skip(ftype)
16255 
      iprot.readFieldEnd()
16256 
    iprot.readStructEnd()
16257 
 
16258 
  def write(self, oprot):
16259 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16260 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16261 
      return
4910 phani.kuma 16262 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
16263 
    if self.ex is not None:
16264 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16265 
      self.ex.write(oprot)
16266 
      oprot.writeFieldEnd()
16267 
    oprot.writeFieldStop()
16268 
    oprot.writeStructEnd()
16269 
 
16270 
  def validate(self):
16271 
    return
16272 
 
16273 
 
16274 
  def __repr__(self):
16275 
    L = ['%s=%r' % (key, value)
16276 
      for key, value in self.__dict__.iteritems()]
16277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16278 
 
16279 
  def __eq__(self, other):
16280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16281 
 
16282 
  def __ne__(self, other):
16283 
    return not (self == other)
16284 
 
16285 
class getOrdersNotLocalConnected_args:
16286 
  """
16287 
  Attributes:
16288 
   - providerId
16289 
  """
16290 
 
16291 
  thrift_spec = (
16292 
    None, # 0
16293 
    (1, TType.I64, 'providerId', None, None, ), # 1
16294 
  )
16295 
 
16296 
  def __init__(self, providerId=None,):
16297 
    self.providerId = providerId
16298 
 
16299 
  def read(self, iprot):
16300 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16301 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16302 
      return
16303 
    iprot.readStructBegin()
16304 
    while True:
16305 
      (fname, ftype, fid) = iprot.readFieldBegin()
16306 
      if ftype == TType.STOP:
16307 
        break
16308 
      if fid == 1:
16309 
        if ftype == TType.I64:
16310 
          self.providerId = iprot.readI64();
16311 
        else:
16312 
          iprot.skip(ftype)
16313 
      else:
16314 
        iprot.skip(ftype)
16315 
      iprot.readFieldEnd()
16316 
    iprot.readStructEnd()
16317 
 
16318 
  def write(self, oprot):
16319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16321 
      return
16322 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
16323 
    if self.providerId is not None:
16324 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16325 
      oprot.writeI64(self.providerId)
16326 
      oprot.writeFieldEnd()
16327 
    oprot.writeFieldStop()
16328 
    oprot.writeStructEnd()
16329 
 
16330 
  def validate(self):
16331 
    return
16332 
 
16333 
 
16334 
  def __repr__(self):
16335 
    L = ['%s=%r' % (key, value)
16336 
      for key, value in self.__dict__.iteritems()]
16337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16338 
 
16339 
  def __eq__(self, other):
16340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16341 
 
16342 
  def __ne__(self, other):
16343 
    return not (self == other)
16344 
 
16345 
class getOrdersNotLocalConnected_result:
16346 
  """
16347 
  Attributes:
16348 
   - success
16349 
  """
16350 
 
16351 
  thrift_spec = (
16352 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16353 
  )
16354 
 
16355 
  def __init__(self, success=None,):
16356 
    self.success = success
16357 
 
16358 
  def read(self, iprot):
16359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16361 
      return
16362 
    iprot.readStructBegin()
16363 
    while True:
16364 
      (fname, ftype, fid) = iprot.readFieldBegin()
16365 
      if ftype == TType.STOP:
16366 
        break
16367 
      if fid == 0:
16368 
        if ftype == TType.LIST:
16369 
          self.success = []
6188 rajveer 16370 
          (_etype371, _size368) = iprot.readListBegin()
16371 
          for _i372 in xrange(_size368):
16372 
            _elem373 = Order()
16373 
            _elem373.read(iprot)
16374 
            self.success.append(_elem373)
4910 phani.kuma 16375 
          iprot.readListEnd()
16376 
        else:
16377 
          iprot.skip(ftype)
16378 
      else:
16379 
        iprot.skip(ftype)
16380 
      iprot.readFieldEnd()
16381 
    iprot.readStructEnd()
16382 
 
16383 
  def write(self, oprot):
16384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16386 
      return
16387 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 16388 
    if self.success is not None:
16389 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16390 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16391 
      for iter374 in self.success:
16392 
        iter374.write(oprot)
4581 phani.kuma 16393 
      oprot.writeListEnd()
16394 
      oprot.writeFieldEnd()
4910 phani.kuma 16395 
    oprot.writeFieldStop()
16396 
    oprot.writeStructEnd()
16397 
 
16398 
  def validate(self):
16399 
    return
16400 
 
16401 
 
16402 
  def __repr__(self):
16403 
    L = ['%s=%r' % (key, value)
16404 
      for key, value in self.__dict__.iteritems()]
16405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16406 
 
16407 
  def __eq__(self, other):
16408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16409 
 
16410 
  def __ne__(self, other):
16411 
    return not (self == other)
16412 
 
16413 
class markOrdersAsDestinationCityReached_args:
16414 
  """
16415 
  Attributes:
16416 
   - providerId
16417 
   - destination_city_reached_orders
16418 
  """
16419 
 
16420 
  thrift_spec = (
16421 
    None, # 0
16422 
    (1, TType.I64, 'providerId', None, None, ), # 1
16423 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16424 
  )
16425 
 
16426 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
16427 
    self.providerId = providerId
16428 
    self.destination_city_reached_orders = destination_city_reached_orders
16429 
 
16430 
  def read(self, iprot):
16431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16433 
      return
16434 
    iprot.readStructBegin()
16435 
    while True:
16436 
      (fname, ftype, fid) = iprot.readFieldBegin()
16437 
      if ftype == TType.STOP:
16438 
        break
16439 
      if fid == 1:
16440 
        if ftype == TType.I64:
16441 
          self.providerId = iprot.readI64();
16442 
        else:
16443 
          iprot.skip(ftype)
16444 
      elif fid == 2:
16445 
        if ftype == TType.MAP:
16446 
          self.destination_city_reached_orders = {}
6188 rajveer 16447 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
16448 
          for _i379 in xrange(_size375):
16449 
            _key380 = iprot.readString();
16450 
            _val381 = iprot.readString();
16451 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 16452 
          iprot.readMapEnd()
16453 
        else:
16454 
          iprot.skip(ftype)
16455 
      else:
16456 
        iprot.skip(ftype)
16457 
      iprot.readFieldEnd()
16458 
    iprot.readStructEnd()
16459 
 
16460 
  def write(self, oprot):
16461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16463 
      return
16464 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
16465 
    if self.providerId is not None:
16466 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16467 
      oprot.writeI64(self.providerId)
16468 
      oprot.writeFieldEnd()
16469 
    if self.destination_city_reached_orders is not None:
16470 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
16471 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 16472 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
16473 
        oprot.writeString(kiter382)
16474 
        oprot.writeString(viter383)
4910 phani.kuma 16475 
      oprot.writeMapEnd()
16476 
      oprot.writeFieldEnd()
16477 
    oprot.writeFieldStop()
16478 
    oprot.writeStructEnd()
16479 
 
16480 
  def validate(self):
16481 
    return
16482 
 
16483 
 
16484 
  def __repr__(self):
16485 
    L = ['%s=%r' % (key, value)
16486 
      for key, value in self.__dict__.iteritems()]
16487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16488 
 
16489 
  def __eq__(self, other):
16490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16491 
 
16492 
  def __ne__(self, other):
16493 
    return not (self == other)
16494 
 
16495 
class markOrdersAsDestinationCityReached_result:
16496 
  """
16497 
  Attributes:
16498 
   - ex
16499 
  """
16500 
 
16501 
  thrift_spec = (
16502 
    None, # 0
16503 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16504 
  )
16505 
 
16506 
  def __init__(self, ex=None,):
16507 
    self.ex = ex
16508 
 
16509 
  def read(self, iprot):
16510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16512 
      return
16513 
    iprot.readStructBegin()
16514 
    while True:
16515 
      (fname, ftype, fid) = iprot.readFieldBegin()
16516 
      if ftype == TType.STOP:
16517 
        break
16518 
      if fid == 1:
16519 
        if ftype == TType.STRUCT:
16520 
          self.ex = TransactionServiceException()
16521 
          self.ex.read(iprot)
16522 
        else:
16523 
          iprot.skip(ftype)
16524 
      else:
16525 
        iprot.skip(ftype)
16526 
      iprot.readFieldEnd()
16527 
    iprot.readStructEnd()
16528 
 
16529 
  def write(self, oprot):
16530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16532 
      return
16533 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 16534 
    if self.ex is not None:
3064 chandransh 16535 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16536 
      self.ex.write(oprot)
1627 ankur.sing 16537 
      oprot.writeFieldEnd()
16538 
    oprot.writeFieldStop()
16539 
    oprot.writeStructEnd()
16540 
 
3431 rajveer 16541 
  def validate(self):
16542 
    return
16543 
 
16544 
 
1627 ankur.sing 16545 
  def __repr__(self):
16546 
    L = ['%s=%r' % (key, value)
16547 
      for key, value in self.__dict__.iteritems()]
16548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16549 
 
16550 
  def __eq__(self, other):
16551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16552 
 
16553 
  def __ne__(self, other):
16554 
    return not (self == other)
16555 
 
4910 phani.kuma 16556 
class markOrdersAsFirstDeliveryAttempted_args:
16557 
  """
16558 
  Attributes:
16559 
   - providerId
16560 
   - first_atdl_orders
16561 
  """
16562 
 
16563 
  thrift_spec = (
16564 
    None, # 0
16565 
    (1, TType.I64, 'providerId', None, None, ), # 1
16566 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16567 
  )
16568 
 
16569 
  def __init__(self, providerId=None, first_atdl_orders=None,):
16570 
    self.providerId = providerId
16571 
    self.first_atdl_orders = first_atdl_orders
16572 
 
16573 
  def read(self, iprot):
16574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16576 
      return
16577 
    iprot.readStructBegin()
16578 
    while True:
16579 
      (fname, ftype, fid) = iprot.readFieldBegin()
16580 
      if ftype == TType.STOP:
16581 
        break
16582 
      if fid == 1:
16583 
        if ftype == TType.I64:
16584 
          self.providerId = iprot.readI64();
16585 
        else:
16586 
          iprot.skip(ftype)
16587 
      elif fid == 2:
16588 
        if ftype == TType.MAP:
16589 
          self.first_atdl_orders = {}
6188 rajveer 16590 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
16591 
          for _i388 in xrange(_size384):
16592 
            _key389 = iprot.readString();
16593 
            _val390 = iprot.readString();
16594 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 16595 
          iprot.readMapEnd()
16596 
        else:
16597 
          iprot.skip(ftype)
16598 
      else:
16599 
        iprot.skip(ftype)
16600 
      iprot.readFieldEnd()
16601 
    iprot.readStructEnd()
16602 
 
16603 
  def write(self, oprot):
16604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16606 
      return
16607 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
16608 
    if self.providerId is not None:
16609 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16610 
      oprot.writeI64(self.providerId)
16611 
      oprot.writeFieldEnd()
16612 
    if self.first_atdl_orders is not None:
16613 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
16614 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 16615 
      for kiter391,viter392 in self.first_atdl_orders.items():
16616 
        oprot.writeString(kiter391)
16617 
        oprot.writeString(viter392)
4910 phani.kuma 16618 
      oprot.writeMapEnd()
16619 
      oprot.writeFieldEnd()
16620 
    oprot.writeFieldStop()
16621 
    oprot.writeStructEnd()
16622 
 
16623 
  def validate(self):
16624 
    return
16625 
 
16626 
 
16627 
  def __repr__(self):
16628 
    L = ['%s=%r' % (key, value)
16629 
      for key, value in self.__dict__.iteritems()]
16630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16631 
 
16632 
  def __eq__(self, other):
16633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16634 
 
16635 
  def __ne__(self, other):
16636 
    return not (self == other)
16637 
 
16638 
class markOrdersAsFirstDeliveryAttempted_result:
16639 
  """
16640 
  Attributes:
16641 
   - ex
16642 
  """
16643 
 
16644 
  thrift_spec = (
16645 
    None, # 0
16646 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16647 
  )
16648 
 
16649 
  def __init__(self, ex=None,):
16650 
    self.ex = ex
16651 
 
16652 
  def read(self, iprot):
16653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16655 
      return
16656 
    iprot.readStructBegin()
16657 
    while True:
16658 
      (fname, ftype, fid) = iprot.readFieldBegin()
16659 
      if ftype == TType.STOP:
16660 
        break
16661 
      if fid == 1:
16662 
        if ftype == TType.STRUCT:
16663 
          self.ex = TransactionServiceException()
16664 
          self.ex.read(iprot)
16665 
        else:
16666 
          iprot.skip(ftype)
16667 
      else:
16668 
        iprot.skip(ftype)
16669 
      iprot.readFieldEnd()
16670 
    iprot.readStructEnd()
16671 
 
16672 
  def write(self, oprot):
16673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16675 
      return
16676 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
16677 
    if self.ex is not None:
16678 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16679 
      self.ex.write(oprot)
16680 
      oprot.writeFieldEnd()
16681 
    oprot.writeFieldStop()
16682 
    oprot.writeStructEnd()
16683 
 
16684 
  def validate(self):
16685 
    return
16686 
 
16687 
 
16688 
  def __repr__(self):
16689 
    L = ['%s=%r' % (key, value)
16690 
      for key, value in self.__dict__.iteritems()]
16691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16692 
 
16693 
  def __eq__(self, other):
16694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16695 
 
16696 
  def __ne__(self, other):
16697 
    return not (self == other)
16698 
 
3064 chandransh 16699 
class getUndeliveredOrders_args:
1886 ankur.sing 16700 
  """
16701 
  Attributes:
3064 chandransh 16702 
   - providerId
16703 
   - warehouseId
1886 ankur.sing 16704 
  """
1627 ankur.sing 16705 
 
1886 ankur.sing 16706 
  thrift_spec = (
16707 
    None, # 0
3064 chandransh 16708 
    (1, TType.I64, 'providerId', None, None, ), # 1
16709 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 16710 
  )
16711 
 
3064 chandransh 16712 
  def __init__(self, providerId=None, warehouseId=None,):
16713 
    self.providerId = providerId
16714 
    self.warehouseId = warehouseId
1886 ankur.sing 16715 
 
16716 
  def read(self, iprot):
16717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16719 
      return
16720 
    iprot.readStructBegin()
16721 
    while True:
16722 
      (fname, ftype, fid) = iprot.readFieldBegin()
16723 
      if ftype == TType.STOP:
16724 
        break
16725 
      if fid == 1:
16726 
        if ftype == TType.I64:
3064 chandransh 16727 
          self.providerId = iprot.readI64();
1886 ankur.sing 16728 
        else:
16729 
          iprot.skip(ftype)
3064 chandransh 16730 
      elif fid == 2:
16731 
        if ftype == TType.I64:
16732 
          self.warehouseId = iprot.readI64();
16733 
        else:
16734 
          iprot.skip(ftype)
1886 ankur.sing 16735 
      else:
16736 
        iprot.skip(ftype)
16737 
      iprot.readFieldEnd()
16738 
    iprot.readStructEnd()
16739 
 
16740 
  def write(self, oprot):
16741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16743 
      return
3064 chandransh 16744 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 16745 
    if self.providerId is not None:
3064 chandransh 16746 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16747 
      oprot.writeI64(self.providerId)
1886 ankur.sing 16748 
      oprot.writeFieldEnd()
3431 rajveer 16749 
    if self.warehouseId is not None:
3064 chandransh 16750 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16751 
      oprot.writeI64(self.warehouseId)
16752 
      oprot.writeFieldEnd()
1886 ankur.sing 16753 
    oprot.writeFieldStop()
16754 
    oprot.writeStructEnd()
16755 
 
3431 rajveer 16756 
  def validate(self):
16757 
    return
16758 
 
16759 
 
1886 ankur.sing 16760 
  def __repr__(self):
16761 
    L = ['%s=%r' % (key, value)
16762 
      for key, value in self.__dict__.iteritems()]
16763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16764 
 
16765 
  def __eq__(self, other):
16766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16767 
 
16768 
  def __ne__(self, other):
16769 
    return not (self == other)
16770 
 
3064 chandransh 16771 
class getUndeliveredOrders_result:
1886 ankur.sing 16772 
  """
16773 
  Attributes:
16774 
   - success
16775 
  """
16776 
 
16777 
  thrift_spec = (
16778 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16779 
  )
16780 
 
16781 
  def __init__(self, success=None,):
16782 
    self.success = success
16783 
 
16784 
  def read(self, iprot):
16785 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16786 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16787 
      return
16788 
    iprot.readStructBegin()
16789 
    while True:
16790 
      (fname, ftype, fid) = iprot.readFieldBegin()
16791 
      if ftype == TType.STOP:
16792 
        break
16793 
      if fid == 0:
16794 
        if ftype == TType.LIST:
16795 
          self.success = []
6188 rajveer 16796 
          (_etype396, _size393) = iprot.readListBegin()
16797 
          for _i397 in xrange(_size393):
16798 
            _elem398 = Order()
16799 
            _elem398.read(iprot)
16800 
            self.success.append(_elem398)
1886 ankur.sing 16801 
          iprot.readListEnd()
16802 
        else:
16803 
          iprot.skip(ftype)
16804 
      else:
16805 
        iprot.skip(ftype)
16806 
      iprot.readFieldEnd()
16807 
    iprot.readStructEnd()
16808 
 
16809 
  def write(self, oprot):
16810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16812 
      return
3064 chandransh 16813 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 16814 
    if self.success is not None:
1886 ankur.sing 16815 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16816 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16817 
      for iter399 in self.success:
16818 
        iter399.write(oprot)
1886 ankur.sing 16819 
      oprot.writeListEnd()
16820 
      oprot.writeFieldEnd()
16821 
    oprot.writeFieldStop()
16822 
    oprot.writeStructEnd()
16823 
 
3431 rajveer 16824 
  def validate(self):
16825 
    return
16826 
 
16827 
 
1886 ankur.sing 16828 
  def __repr__(self):
16829 
    L = ['%s=%r' % (key, value)
16830 
      for key, value in self.__dict__.iteritems()]
16831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16832 
 
16833 
  def __eq__(self, other):
16834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16835 
 
16836 
  def __ne__(self, other):
16837 
    return not (self == other)
16838 
 
4783 phani.kuma 16839 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
16840 
 
16841 
  thrift_spec = (
16842 
  )
16843 
 
16844 
  def read(self, iprot):
16845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16847 
      return
16848 
    iprot.readStructBegin()
16849 
    while True:
16850 
      (fname, ftype, fid) = iprot.readFieldBegin()
16851 
      if ftype == TType.STOP:
16852 
        break
16853 
      else:
16854 
        iprot.skip(ftype)
16855 
      iprot.readFieldEnd()
16856 
    iprot.readStructEnd()
16857 
 
16858 
  def write(self, oprot):
16859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16861 
      return
16862 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
16863 
    oprot.writeFieldStop()
16864 
    oprot.writeStructEnd()
16865 
 
16866 
  def validate(self):
16867 
    return
16868 
 
16869 
 
16870 
  def __repr__(self):
16871 
    L = ['%s=%r' % (key, value)
16872 
      for key, value in self.__dict__.iteritems()]
16873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16874 
 
16875 
  def __eq__(self, other):
16876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16877 
 
16878 
  def __ne__(self, other):
16879 
    return not (self == other)
16880 
 
16881 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
16882 
  """
16883 
  Attributes:
16884 
   - success
16885 
  """
16886 
 
16887 
  thrift_spec = (
16888 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16889 
  )
16890 
 
16891 
  def __init__(self, success=None,):
16892 
    self.success = success
16893 
 
16894 
  def read(self, iprot):
16895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16897 
      return
16898 
    iprot.readStructBegin()
16899 
    while True:
16900 
      (fname, ftype, fid) = iprot.readFieldBegin()
16901 
      if ftype == TType.STOP:
16902 
        break
16903 
      if fid == 0:
16904 
        if ftype == TType.LIST:
16905 
          self.success = []
6188 rajveer 16906 
          (_etype403, _size400) = iprot.readListBegin()
16907 
          for _i404 in xrange(_size400):
16908 
            _elem405 = Order()
16909 
            _elem405.read(iprot)
16910 
            self.success.append(_elem405)
4783 phani.kuma 16911 
          iprot.readListEnd()
16912 
        else:
16913 
          iprot.skip(ftype)
16914 
      else:
16915 
        iprot.skip(ftype)
16916 
      iprot.readFieldEnd()
16917 
    iprot.readStructEnd()
16918 
 
16919 
  def write(self, oprot):
16920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16922 
      return
16923 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
16924 
    if self.success is not None:
16925 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16926 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16927 
      for iter406 in self.success:
16928 
        iter406.write(oprot)
4783 phani.kuma 16929 
      oprot.writeListEnd()
16930 
      oprot.writeFieldEnd()
16931 
    oprot.writeFieldStop()
16932 
    oprot.writeStructEnd()
16933 
 
16934 
  def validate(self):
16935 
    return
16936 
 
16937 
 
16938 
  def __repr__(self):
16939 
    L = ['%s=%r' % (key, value)
16940 
      for key, value in self.__dict__.iteritems()]
16941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16942 
 
16943 
  def __eq__(self, other):
16944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16945 
 
16946 
  def __ne__(self, other):
16947 
    return not (self == other)
16948 
 
2536 chandransh 16949 
class toggleDOAFlag_args:
16950 
  """
16951 
  Attributes:
16952 
   - orderId
16953 
  """
1886 ankur.sing 16954 
 
2536 chandransh 16955 
  thrift_spec = (
16956 
    None, # 0
16957 
    (1, TType.I64, 'orderId', None, None, ), # 1
16958 
  )
16959 
 
16960 
  def __init__(self, orderId=None,):
16961 
    self.orderId = orderId
16962 
 
16963 
  def read(self, iprot):
16964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16966 
      return
16967 
    iprot.readStructBegin()
16968 
    while True:
16969 
      (fname, ftype, fid) = iprot.readFieldBegin()
16970 
      if ftype == TType.STOP:
16971 
        break
16972 
      if fid == 1:
16973 
        if ftype == TType.I64:
16974 
          self.orderId = iprot.readI64();
16975 
        else:
16976 
          iprot.skip(ftype)
16977 
      else:
16978 
        iprot.skip(ftype)
16979 
      iprot.readFieldEnd()
16980 
    iprot.readStructEnd()
16981 
 
16982 
  def write(self, oprot):
16983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16985 
      return
16986 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 16987 
    if self.orderId is not None:
2536 chandransh 16988 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16989 
      oprot.writeI64(self.orderId)
16990 
      oprot.writeFieldEnd()
16991 
    oprot.writeFieldStop()
16992 
    oprot.writeStructEnd()
16993 
 
3431 rajveer 16994 
  def validate(self):
16995 
    return
16996 
 
16997 
 
2536 chandransh 16998 
  def __repr__(self):
16999 
    L = ['%s=%r' % (key, value)
17000 
      for key, value in self.__dict__.iteritems()]
17001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17002 
 
17003 
  def __eq__(self, other):
17004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17005 
 
17006 
  def __ne__(self, other):
17007 
    return not (self == other)
17008 
 
17009 
class toggleDOAFlag_result:
17010 
  """
17011 
  Attributes:
17012 
   - success
17013 
   - ex
17014 
  """
17015 
 
17016 
  thrift_spec = (
17017 
    (0, TType.BOOL, 'success', None, None, ), # 0
17018 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17019 
  )
17020 
 
17021 
  def __init__(self, success=None, ex=None,):
17022 
    self.success = success
17023 
    self.ex = ex
17024 
 
17025 
  def read(self, iprot):
17026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17028 
      return
17029 
    iprot.readStructBegin()
17030 
    while True:
17031 
      (fname, ftype, fid) = iprot.readFieldBegin()
17032 
      if ftype == TType.STOP:
17033 
        break
17034 
      if fid == 0:
17035 
        if ftype == TType.BOOL:
17036 
          self.success = iprot.readBool();
17037 
        else:
17038 
          iprot.skip(ftype)
17039 
      elif fid == 1:
17040 
        if ftype == TType.STRUCT:
17041 
          self.ex = TransactionServiceException()
17042 
          self.ex.read(iprot)
17043 
        else:
17044 
          iprot.skip(ftype)
17045 
      else:
17046 
        iprot.skip(ftype)
17047 
      iprot.readFieldEnd()
17048 
    iprot.readStructEnd()
17049 
 
17050 
  def write(self, oprot):
17051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17053 
      return
17054 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 17055 
    if self.success is not None:
2536 chandransh 17056 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17057 
      oprot.writeBool(self.success)
17058 
      oprot.writeFieldEnd()
3431 rajveer 17059 
    if self.ex is not None:
2536 chandransh 17060 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17061 
      self.ex.write(oprot)
17062 
      oprot.writeFieldEnd()
17063 
    oprot.writeFieldStop()
17064 
    oprot.writeStructEnd()
17065 
 
3431 rajveer 17066 
  def validate(self):
17067 
    return
17068 
 
17069 
 
2536 chandransh 17070 
  def __repr__(self):
17071 
    L = ['%s=%r' % (key, value)
17072 
      for key, value in self.__dict__.iteritems()]
17073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17074 
 
17075 
  def __eq__(self, other):
17076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17077 
 
17078 
  def __ne__(self, other):
17079 
    return not (self == other)
17080 
 
4712 rajveer 17081 
class markOrderAsDelivered_args:
17082 
  """
17083 
  Attributes:
17084 
   - orderId
17085 
   - deliveryTimestamp
17086 
   - receiver
17087 
  """
17088 
 
17089 
  thrift_spec = None
17090 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
17091 
    self.orderId = orderId
17092 
    self.deliveryTimestamp = deliveryTimestamp
17093 
    self.receiver = receiver
17094 
 
17095 
  def read(self, iprot):
17096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17098 
      return
17099 
    iprot.readStructBegin()
17100 
    while True:
17101 
      (fname, ftype, fid) = iprot.readFieldBegin()
17102 
      if ftype == TType.STOP:
17103 
        break
17104 
      if fid == 1:
17105 
        if ftype == TType.I64:
17106 
          self.orderId = iprot.readI64();
17107 
        else:
17108 
          iprot.skip(ftype)
17109 
      elif fid == 2:
17110 
        if ftype == TType.I64:
17111 
          self.deliveryTimestamp = iprot.readI64();
17112 
        else:
17113 
          iprot.skip(ftype)
17114 
      elif fid == -1:
17115 
        if ftype == TType.STRING:
17116 
          self.receiver = iprot.readString();
17117 
        else:
17118 
          iprot.skip(ftype)
17119 
      else:
17120 
        iprot.skip(ftype)
17121 
      iprot.readFieldEnd()
17122 
    iprot.readStructEnd()
17123 
 
17124 
  def write(self, oprot):
17125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17127 
      return
17128 
    oprot.writeStructBegin('markOrderAsDelivered_args')
17129 
    if self.receiver is not None:
17130 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
17131 
      oprot.writeString(self.receiver)
17132 
      oprot.writeFieldEnd()
17133 
    if self.orderId is not None:
17134 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17135 
      oprot.writeI64(self.orderId)
17136 
      oprot.writeFieldEnd()
17137 
    if self.deliveryTimestamp is not None:
17138 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
17139 
      oprot.writeI64(self.deliveryTimestamp)
17140 
      oprot.writeFieldEnd()
17141 
    oprot.writeFieldStop()
17142 
    oprot.writeStructEnd()
17143 
 
17144 
  def validate(self):
17145 
    return
17146 
 
17147 
 
17148 
  def __repr__(self):
17149 
    L = ['%s=%r' % (key, value)
17150 
      for key, value in self.__dict__.iteritems()]
17151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17152 
 
17153 
  def __eq__(self, other):
17154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17155 
 
17156 
  def __ne__(self, other):
17157 
    return not (self == other)
17158 
 
17159 
class markOrderAsDelivered_result:
17160 
  """
17161 
  Attributes:
17162 
   - ex
17163 
  """
17164 
 
17165 
  thrift_spec = (
17166 
    None, # 0
17167 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17168 
  )
17169 
 
17170 
  def __init__(self, ex=None,):
17171 
    self.ex = ex
17172 
 
17173 
  def read(self, iprot):
17174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17176 
      return
17177 
    iprot.readStructBegin()
17178 
    while True:
17179 
      (fname, ftype, fid) = iprot.readFieldBegin()
17180 
      if ftype == TType.STOP:
17181 
        break
17182 
      if fid == 1:
17183 
        if ftype == TType.STRUCT:
17184 
          self.ex = TransactionServiceException()
17185 
          self.ex.read(iprot)
17186 
        else:
17187 
          iprot.skip(ftype)
17188 
      else:
17189 
        iprot.skip(ftype)
17190 
      iprot.readFieldEnd()
17191 
    iprot.readStructEnd()
17192 
 
17193 
  def write(self, oprot):
17194 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17195 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17196 
      return
17197 
    oprot.writeStructBegin('markOrderAsDelivered_result')
17198 
    if self.ex is not None:
17199 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17200 
      self.ex.write(oprot)
17201 
      oprot.writeFieldEnd()
17202 
    oprot.writeFieldStop()
17203 
    oprot.writeStructEnd()
17204 
 
17205 
  def validate(self):
17206 
    return
17207 
 
17208 
 
17209 
  def __repr__(self):
17210 
    L = ['%s=%r' % (key, value)
17211 
      for key, value in self.__dict__.iteritems()]
17212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17213 
 
17214 
  def __eq__(self, other):
17215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17216 
 
17217 
  def __ne__(self, other):
17218 
    return not (self == other)
17219 
 
5553 rajveer 17220 
class markOrderAsReceivedAtStore_args:
17221 
  """
17222 
  Attributes:
17223 
   - orderId
17224 
   - deliveryTimestamp
17225 
  """
17226 
 
17227 
  thrift_spec = (
17228 
    None, # 0
17229 
    (1, TType.I64, 'orderId', None, None, ), # 1
17230 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
17231 
  )
17232 
 
17233 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
17234 
    self.orderId = orderId
17235 
    self.deliveryTimestamp = deliveryTimestamp
17236 
 
17237 
  def read(self, iprot):
17238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17240 
      return
17241 
    iprot.readStructBegin()
17242 
    while True:
17243 
      (fname, ftype, fid) = iprot.readFieldBegin()
17244 
      if ftype == TType.STOP:
17245 
        break
17246 
      if fid == 1:
17247 
        if ftype == TType.I64:
17248 
          self.orderId = iprot.readI64();
17249 
        else:
17250 
          iprot.skip(ftype)
17251 
      elif fid == 2:
17252 
        if ftype == TType.I64:
17253 
          self.deliveryTimestamp = iprot.readI64();
17254 
        else:
17255 
          iprot.skip(ftype)
17256 
      else:
17257 
        iprot.skip(ftype)
17258 
      iprot.readFieldEnd()
17259 
    iprot.readStructEnd()
17260 
 
17261 
  def write(self, oprot):
17262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17264 
      return
17265 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
17266 
    if self.orderId is not None:
17267 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17268 
      oprot.writeI64(self.orderId)
17269 
      oprot.writeFieldEnd()
17270 
    if self.deliveryTimestamp is not None:
17271 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
17272 
      oprot.writeI64(self.deliveryTimestamp)
17273 
      oprot.writeFieldEnd()
17274 
    oprot.writeFieldStop()
17275 
    oprot.writeStructEnd()
17276 
 
17277 
  def validate(self):
17278 
    return
17279 
 
17280 
 
17281 
  def __repr__(self):
17282 
    L = ['%s=%r' % (key, value)
17283 
      for key, value in self.__dict__.iteritems()]
17284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17285 
 
17286 
  def __eq__(self, other):
17287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17288 
 
17289 
  def __ne__(self, other):
17290 
    return not (self == other)
17291 
 
17292 
class markOrderAsReceivedAtStore_result:
17293 
  """
17294 
  Attributes:
17295 
   - ex
17296 
  """
17297 
 
17298 
  thrift_spec = (
17299 
    None, # 0
17300 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17301 
  )
17302 
 
17303 
  def __init__(self, ex=None,):
17304 
    self.ex = ex
17305 
 
17306 
  def read(self, iprot):
17307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17309 
      return
17310 
    iprot.readStructBegin()
17311 
    while True:
17312 
      (fname, ftype, fid) = iprot.readFieldBegin()
17313 
      if ftype == TType.STOP:
17314 
        break
17315 
      if fid == 1:
17316 
        if ftype == TType.STRUCT:
17317 
          self.ex = TransactionServiceException()
17318 
          self.ex.read(iprot)
17319 
        else:
17320 
          iprot.skip(ftype)
17321 
      else:
17322 
        iprot.skip(ftype)
17323 
      iprot.readFieldEnd()
17324 
    iprot.readStructEnd()
17325 
 
17326 
  def write(self, oprot):
17327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17329 
      return
17330 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
17331 
    if self.ex is not None:
17332 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17333 
      self.ex.write(oprot)
17334 
      oprot.writeFieldEnd()
17335 
    oprot.writeFieldStop()
17336 
    oprot.writeStructEnd()
17337 
 
17338 
  def validate(self):
17339 
    return
17340 
 
17341 
 
17342 
  def __repr__(self):
17343 
    L = ['%s=%r' % (key, value)
17344 
      for key, value in self.__dict__.iteritems()]
17345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17346 
 
17347 
  def __eq__(self, other):
17348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17349 
 
17350 
  def __ne__(self, other):
17351 
    return not (self == other)
17352 
 
4454 rajveer 17353 
class markOrderDoaRequestReceived_args:
17354 
  """
17355 
  Attributes:
17356 
   - orderId
17357 
  """
17358 
 
17359 
  thrift_spec = (
17360 
    None, # 0
17361 
    (1, TType.I64, 'orderId', None, None, ), # 1
17362 
  )
17363 
 
17364 
  def __init__(self, orderId=None,):
17365 
    self.orderId = orderId
17366 
 
17367 
  def read(self, iprot):
17368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17370 
      return
17371 
    iprot.readStructBegin()
17372 
    while True:
17373 
      (fname, ftype, fid) = iprot.readFieldBegin()
17374 
      if ftype == TType.STOP:
17375 
        break
17376 
      if fid == 1:
17377 
        if ftype == TType.I64:
17378 
          self.orderId = iprot.readI64();
17379 
        else:
17380 
          iprot.skip(ftype)
17381 
      else:
17382 
        iprot.skip(ftype)
17383 
      iprot.readFieldEnd()
17384 
    iprot.readStructEnd()
17385 
 
17386 
  def write(self, oprot):
17387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17389 
      return
17390 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
17391 
    if self.orderId is not None:
17392 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17393 
      oprot.writeI64(self.orderId)
17394 
      oprot.writeFieldEnd()
17395 
    oprot.writeFieldStop()
17396 
    oprot.writeStructEnd()
17397 
 
17398 
  def validate(self):
17399 
    return
17400 
 
17401 
 
17402 
  def __repr__(self):
17403 
    L = ['%s=%r' % (key, value)
17404 
      for key, value in self.__dict__.iteritems()]
17405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17406 
 
17407 
  def __eq__(self, other):
17408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17409 
 
17410 
  def __ne__(self, other):
17411 
    return not (self == other)
17412 
 
17413 
class markOrderDoaRequestReceived_result:
17414 
  """
17415 
  Attributes:
17416 
   - success
17417 
   - ex
17418 
  """
17419 
 
17420 
  thrift_spec = (
17421 
    (0, TType.BOOL, 'success', None, None, ), # 0
17422 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17423 
  )
17424 
 
17425 
  def __init__(self, success=None, ex=None,):
17426 
    self.success = success
17427 
    self.ex = ex
17428 
 
17429 
  def read(self, iprot):
17430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17432 
      return
17433 
    iprot.readStructBegin()
17434 
    while True:
17435 
      (fname, ftype, fid) = iprot.readFieldBegin()
17436 
      if ftype == TType.STOP:
17437 
        break
17438 
      if fid == 0:
17439 
        if ftype == TType.BOOL:
17440 
          self.success = iprot.readBool();
17441 
        else:
17442 
          iprot.skip(ftype)
17443 
      elif fid == 1:
17444 
        if ftype == TType.STRUCT:
17445 
          self.ex = TransactionServiceException()
17446 
          self.ex.read(iprot)
17447 
        else:
17448 
          iprot.skip(ftype)
17449 
      else:
17450 
        iprot.skip(ftype)
17451 
      iprot.readFieldEnd()
17452 
    iprot.readStructEnd()
17453 
 
17454 
  def write(self, oprot):
17455 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17456 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17457 
      return
17458 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
17459 
    if self.success is not None:
17460 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17461 
      oprot.writeBool(self.success)
17462 
      oprot.writeFieldEnd()
17463 
    if self.ex is not None:
17464 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17465 
      self.ex.write(oprot)
17466 
      oprot.writeFieldEnd()
17467 
    oprot.writeFieldStop()
17468 
    oprot.writeStructEnd()
17469 
 
17470 
  def validate(self):
17471 
    return
17472 
 
17473 
 
17474 
  def __repr__(self):
17475 
    L = ['%s=%r' % (key, value)
17476 
      for key, value in self.__dict__.iteritems()]
17477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17478 
 
17479 
  def __eq__(self, other):
17480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17481 
 
17482 
  def __ne__(self, other):
17483 
    return not (self == other)
17484 
 
17485 
class markOrderDoaRequestAuthorized_args:
17486 
  """
17487 
  Attributes:
17488 
   - orderId
17489 
   - isAuthorized
17490 
  """
17491 
 
17492 
  thrift_spec = (
17493 
    None, # 0
17494 
    (1, TType.I64, 'orderId', None, None, ), # 1
17495 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17496 
  )
17497 
 
17498 
  def __init__(self, orderId=None, isAuthorized=None,):
17499 
    self.orderId = orderId
17500 
    self.isAuthorized = isAuthorized
17501 
 
17502 
  def read(self, iprot):
17503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17505 
      return
17506 
    iprot.readStructBegin()
17507 
    while True:
17508 
      (fname, ftype, fid) = iprot.readFieldBegin()
17509 
      if ftype == TType.STOP:
17510 
        break
17511 
      if fid == 1:
17512 
        if ftype == TType.I64:
17513 
          self.orderId = iprot.readI64();
17514 
        else:
17515 
          iprot.skip(ftype)
17516 
      elif fid == 2:
17517 
        if ftype == TType.BOOL:
17518 
          self.isAuthorized = iprot.readBool();
17519 
        else:
17520 
          iprot.skip(ftype)
17521 
      else:
17522 
        iprot.skip(ftype)
17523 
      iprot.readFieldEnd()
17524 
    iprot.readStructEnd()
17525 
 
17526 
  def write(self, oprot):
17527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17529 
      return
17530 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
17531 
    if self.orderId is not None:
17532 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17533 
      oprot.writeI64(self.orderId)
17534 
      oprot.writeFieldEnd()
17535 
    if self.isAuthorized is not None:
17536 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17537 
      oprot.writeBool(self.isAuthorized)
17538 
      oprot.writeFieldEnd()
17539 
    oprot.writeFieldStop()
17540 
    oprot.writeStructEnd()
17541 
 
17542 
  def validate(self):
17543 
    return
17544 
 
17545 
 
17546 
  def __repr__(self):
17547 
    L = ['%s=%r' % (key, value)
17548 
      for key, value in self.__dict__.iteritems()]
17549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17550 
 
17551 
  def __eq__(self, other):
17552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17553 
 
17554 
  def __ne__(self, other):
17555 
    return not (self == other)
17556 
 
17557 
class markOrderDoaRequestAuthorized_result:
17558 
  """
17559 
  Attributes:
17560 
   - success
17561 
   - ex
17562 
  """
17563 
 
17564 
  thrift_spec = (
17565 
    (0, TType.BOOL, 'success', None, None, ), # 0
17566 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17567 
  )
17568 
 
17569 
  def __init__(self, success=None, ex=None,):
17570 
    self.success = success
17571 
    self.ex = ex
17572 
 
17573 
  def read(self, iprot):
17574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17576 
      return
17577 
    iprot.readStructBegin()
17578 
    while True:
17579 
      (fname, ftype, fid) = iprot.readFieldBegin()
17580 
      if ftype == TType.STOP:
17581 
        break
17582 
      if fid == 0:
17583 
        if ftype == TType.BOOL:
17584 
          self.success = iprot.readBool();
17585 
        else:
17586 
          iprot.skip(ftype)
17587 
      elif fid == 1:
17588 
        if ftype == TType.STRUCT:
17589 
          self.ex = TransactionServiceException()
17590 
          self.ex.read(iprot)
17591 
        else:
17592 
          iprot.skip(ftype)
17593 
      else:
17594 
        iprot.skip(ftype)
17595 
      iprot.readFieldEnd()
17596 
    iprot.readStructEnd()
17597 
 
17598 
  def write(self, oprot):
17599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17601 
      return
17602 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
17603 
    if self.success is not None:
17604 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17605 
      oprot.writeBool(self.success)
17606 
      oprot.writeFieldEnd()
17607 
    if self.ex is not None:
17608 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17609 
      self.ex.write(oprot)
17610 
      oprot.writeFieldEnd()
17611 
    oprot.writeFieldStop()
17612 
    oprot.writeStructEnd()
17613 
 
17614 
  def validate(self):
17615 
    return
17616 
 
17617 
 
17618 
  def __repr__(self):
17619 
    L = ['%s=%r' % (key, value)
17620 
      for key, value in self.__dict__.iteritems()]
17621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17622 
 
17623 
  def __eq__(self, other):
17624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17625 
 
17626 
  def __ne__(self, other):
17627 
    return not (self == other)
17628 
 
4488 rajveer 17629 
class markOrderReturnRequestReceived_args:
17630 
  """
17631 
  Attributes:
17632 
   - orderId
17633 
  """
17634 
 
17635 
  thrift_spec = (
17636 
    None, # 0
17637 
    (1, TType.I64, 'orderId', None, None, ), # 1
17638 
  )
17639 
 
17640 
  def __init__(self, orderId=None,):
17641 
    self.orderId = orderId
17642 
 
17643 
  def read(self, iprot):
17644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17646 
      return
17647 
    iprot.readStructBegin()
17648 
    while True:
17649 
      (fname, ftype, fid) = iprot.readFieldBegin()
17650 
      if ftype == TType.STOP:
17651 
        break
17652 
      if fid == 1:
17653 
        if ftype == TType.I64:
17654 
          self.orderId = iprot.readI64();
17655 
        else:
17656 
          iprot.skip(ftype)
17657 
      else:
17658 
        iprot.skip(ftype)
17659 
      iprot.readFieldEnd()
17660 
    iprot.readStructEnd()
17661 
 
17662 
  def write(self, oprot):
17663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17665 
      return
17666 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
17667 
    if self.orderId is not None:
17668 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17669 
      oprot.writeI64(self.orderId)
17670 
      oprot.writeFieldEnd()
17671 
    oprot.writeFieldStop()
17672 
    oprot.writeStructEnd()
17673 
 
17674 
  def validate(self):
17675 
    return
17676 
 
17677 
 
17678 
  def __repr__(self):
17679 
    L = ['%s=%r' % (key, value)
17680 
      for key, value in self.__dict__.iteritems()]
17681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17682 
 
17683 
  def __eq__(self, other):
17684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17685 
 
17686 
  def __ne__(self, other):
17687 
    return not (self == other)
17688 
 
17689 
class markOrderReturnRequestReceived_result:
17690 
  """
17691 
  Attributes:
17692 
   - success
17693 
   - ex
17694 
  """
17695 
 
17696 
  thrift_spec = (
17697 
    (0, TType.BOOL, 'success', None, None, ), # 0
17698 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17699 
  )
17700 
 
17701 
  def __init__(self, success=None, ex=None,):
17702 
    self.success = success
17703 
    self.ex = ex
17704 
 
17705 
  def read(self, iprot):
17706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17708 
      return
17709 
    iprot.readStructBegin()
17710 
    while True:
17711 
      (fname, ftype, fid) = iprot.readFieldBegin()
17712 
      if ftype == TType.STOP:
17713 
        break
17714 
      if fid == 0:
17715 
        if ftype == TType.BOOL:
17716 
          self.success = iprot.readBool();
17717 
        else:
17718 
          iprot.skip(ftype)
17719 
      elif fid == 1:
17720 
        if ftype == TType.STRUCT:
17721 
          self.ex = TransactionServiceException()
17722 
          self.ex.read(iprot)
17723 
        else:
17724 
          iprot.skip(ftype)
17725 
      else:
17726 
        iprot.skip(ftype)
17727 
      iprot.readFieldEnd()
17728 
    iprot.readStructEnd()
17729 
 
17730 
  def write(self, oprot):
17731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17733 
      return
17734 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
17735 
    if self.success is not None:
17736 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17737 
      oprot.writeBool(self.success)
17738 
      oprot.writeFieldEnd()
17739 
    if self.ex is not None:
17740 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17741 
      self.ex.write(oprot)
17742 
      oprot.writeFieldEnd()
17743 
    oprot.writeFieldStop()
17744 
    oprot.writeStructEnd()
17745 
 
17746 
  def validate(self):
17747 
    return
17748 
 
17749 
 
17750 
  def __repr__(self):
17751 
    L = ['%s=%r' % (key, value)
17752 
      for key, value in self.__dict__.iteritems()]
17753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17754 
 
17755 
  def __eq__(self, other):
17756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17757 
 
17758 
  def __ne__(self, other):
17759 
    return not (self == other)
17760 
 
17761 
class markOrderReturnRequestAuthorized_args:
17762 
  """
17763 
  Attributes:
17764 
   - orderId
17765 
   - isAuthorized
17766 
  """
17767 
 
17768 
  thrift_spec = (
17769 
    None, # 0
17770 
    (1, TType.I64, 'orderId', None, None, ), # 1
17771 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17772 
  )
17773 
 
17774 
  def __init__(self, orderId=None, isAuthorized=None,):
17775 
    self.orderId = orderId
17776 
    self.isAuthorized = isAuthorized
17777 
 
17778 
  def read(self, iprot):
17779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17781 
      return
17782 
    iprot.readStructBegin()
17783 
    while True:
17784 
      (fname, ftype, fid) = iprot.readFieldBegin()
17785 
      if ftype == TType.STOP:
17786 
        break
17787 
      if fid == 1:
17788 
        if ftype == TType.I64:
17789 
          self.orderId = iprot.readI64();
17790 
        else:
17791 
          iprot.skip(ftype)
17792 
      elif fid == 2:
17793 
        if ftype == TType.BOOL:
17794 
          self.isAuthorized = iprot.readBool();
17795 
        else:
17796 
          iprot.skip(ftype)
17797 
      else:
17798 
        iprot.skip(ftype)
17799 
      iprot.readFieldEnd()
17800 
    iprot.readStructEnd()
17801 
 
17802 
  def write(self, oprot):
17803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17805 
      return
17806 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
17807 
    if self.orderId is not None:
17808 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17809 
      oprot.writeI64(self.orderId)
17810 
      oprot.writeFieldEnd()
17811 
    if self.isAuthorized is not None:
17812 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17813 
      oprot.writeBool(self.isAuthorized)
17814 
      oprot.writeFieldEnd()
17815 
    oprot.writeFieldStop()
17816 
    oprot.writeStructEnd()
17817 
 
17818 
  def validate(self):
17819 
    return
17820 
 
17821 
 
17822 
  def __repr__(self):
17823 
    L = ['%s=%r' % (key, value)
17824 
      for key, value in self.__dict__.iteritems()]
17825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17826 
 
17827 
  def __eq__(self, other):
17828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17829 
 
17830 
  def __ne__(self, other):
17831 
    return not (self == other)
17832 
 
17833 
class markOrderReturnRequestAuthorized_result:
17834 
  """
17835 
  Attributes:
17836 
   - success
17837 
   - ex
17838 
  """
17839 
 
17840 
  thrift_spec = (
17841 
    (0, TType.BOOL, 'success', None, None, ), # 0
17842 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17843 
  )
17844 
 
17845 
  def __init__(self, success=None, ex=None,):
17846 
    self.success = success
17847 
    self.ex = ex
17848 
 
17849 
  def read(self, iprot):
17850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17852 
      return
17853 
    iprot.readStructBegin()
17854 
    while True:
17855 
      (fname, ftype, fid) = iprot.readFieldBegin()
17856 
      if ftype == TType.STOP:
17857 
        break
17858 
      if fid == 0:
17859 
        if ftype == TType.BOOL:
17860 
          self.success = iprot.readBool();
17861 
        else:
17862 
          iprot.skip(ftype)
17863 
      elif fid == 1:
17864 
        if ftype == TType.STRUCT:
17865 
          self.ex = TransactionServiceException()
17866 
          self.ex.read(iprot)
17867 
        else:
17868 
          iprot.skip(ftype)
17869 
      else:
17870 
        iprot.skip(ftype)
17871 
      iprot.readFieldEnd()
17872 
    iprot.readStructEnd()
17873 
 
17874 
  def write(self, oprot):
17875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17877 
      return
17878 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
17879 
    if self.success is not None:
17880 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17881 
      oprot.writeBool(self.success)
17882 
      oprot.writeFieldEnd()
17883 
    if self.ex is not None:
17884 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17885 
      self.ex.write(oprot)
17886 
      oprot.writeFieldEnd()
17887 
    oprot.writeFieldStop()
17888 
    oprot.writeStructEnd()
17889 
 
17890 
  def validate(self):
17891 
    return
17892 
 
17893 
 
17894 
  def __repr__(self):
17895 
    L = ['%s=%r' % (key, value)
17896 
      for key, value in self.__dict__.iteritems()]
17897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17898 
 
17899 
  def __eq__(self, other):
17900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17901 
 
17902 
  def __ne__(self, other):
17903 
    return not (self == other)
17904 
 
2536 chandransh 17905 
class requestPickupNumber_args:
17906 
  """
17907 
  Attributes:
17908 
   - orderId
4579 rajveer 17909 
   - providerId
2536 chandransh 17910 
  """
17911 
 
17912 
  thrift_spec = (
17913 
    None, # 0
17914 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 17915 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 17916 
  )
17917 
 
4579 rajveer 17918 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 17919 
    self.orderId = orderId
4579 rajveer 17920 
    self.providerId = providerId
2536 chandransh 17921 
 
17922 
  def read(self, iprot):
17923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17925 
      return
17926 
    iprot.readStructBegin()
17927 
    while True:
17928 
      (fname, ftype, fid) = iprot.readFieldBegin()
17929 
      if ftype == TType.STOP:
17930 
        break
17931 
      if fid == 1:
17932 
        if ftype == TType.I64:
17933 
          self.orderId = iprot.readI64();
17934 
        else:
17935 
          iprot.skip(ftype)
4579 rajveer 17936 
      elif fid == 2:
17937 
        if ftype == TType.I64:
17938 
          self.providerId = iprot.readI64();
17939 
        else:
17940 
          iprot.skip(ftype)
2536 chandransh 17941 
      else:
17942 
        iprot.skip(ftype)
17943 
      iprot.readFieldEnd()
17944 
    iprot.readStructEnd()
17945 
 
17946 
  def write(self, oprot):
17947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17949 
      return
17950 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 17951 
    if self.orderId is not None:
2536 chandransh 17952 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17953 
      oprot.writeI64(self.orderId)
17954 
      oprot.writeFieldEnd()
4579 rajveer 17955 
    if self.providerId is not None:
17956 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
17957 
      oprot.writeI64(self.providerId)
17958 
      oprot.writeFieldEnd()
2536 chandransh 17959 
    oprot.writeFieldStop()
17960 
    oprot.writeStructEnd()
17961 
 
3431 rajveer 17962 
  def validate(self):
17963 
    return
17964 
 
17965 
 
2536 chandransh 17966 
  def __repr__(self):
17967 
    L = ['%s=%r' % (key, value)
17968 
      for key, value in self.__dict__.iteritems()]
17969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17970 
 
17971 
  def __eq__(self, other):
17972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17973 
 
17974 
  def __ne__(self, other):
17975 
    return not (self == other)
17976 
 
17977 
class requestPickupNumber_result:
17978 
  """
17979 
  Attributes:
17980 
   - success
17981 
   - ex
17982 
  """
17983 
 
17984 
  thrift_spec = (
17985 
    (0, TType.BOOL, 'success', None, None, ), # 0
17986 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17987 
  )
17988 
 
17989 
  def __init__(self, success=None, ex=None,):
17990 
    self.success = success
17991 
    self.ex = ex
17992 
 
17993 
  def read(self, iprot):
17994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17996 
      return
17997 
    iprot.readStructBegin()
17998 
    while True:
17999 
      (fname, ftype, fid) = iprot.readFieldBegin()
18000 
      if ftype == TType.STOP:
18001 
        break
18002 
      if fid == 0:
18003 
        if ftype == TType.BOOL:
18004 
          self.success = iprot.readBool();
18005 
        else:
18006 
          iprot.skip(ftype)
18007 
      elif fid == 1:
18008 
        if ftype == TType.STRUCT:
18009 
          self.ex = TransactionServiceException()
18010 
          self.ex.read(iprot)
18011 
        else:
18012 
          iprot.skip(ftype)
18013 
      else:
18014 
        iprot.skip(ftype)
18015 
      iprot.readFieldEnd()
18016 
    iprot.readStructEnd()
18017 
 
18018 
  def write(self, oprot):
18019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18021 
      return
18022 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 18023 
    if self.success is not None:
2536 chandransh 18024 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18025 
      oprot.writeBool(self.success)
18026 
      oprot.writeFieldEnd()
3431 rajveer 18027 
    if self.ex is not None:
2536 chandransh 18028 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18029 
      self.ex.write(oprot)
18030 
      oprot.writeFieldEnd()
18031 
    oprot.writeFieldStop()
18032 
    oprot.writeStructEnd()
18033 
 
3431 rajveer 18034 
  def validate(self):
18035 
    return
18036 
 
18037 
 
2536 chandransh 18038 
  def __repr__(self):
18039 
    L = ['%s=%r' % (key, value)
18040 
      for key, value in self.__dict__.iteritems()]
18041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18042 
 
18043 
  def __eq__(self, other):
18044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18045 
 
18046 
  def __ne__(self, other):
18047 
    return not (self == other)
18048 
 
18049 
class authorizePickup_args:
18050 
  """
18051 
  Attributes:
18052 
   - orderId
18053 
   - pickupNumber
4602 rajveer 18054 
   - providerId
2536 chandransh 18055 
  """
18056 
 
18057 
  thrift_spec = (
18058 
    None, # 0
18059 
    (1, TType.I64, 'orderId', None, None, ), # 1
18060 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 18061 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 18062 
  )
18063 
 
4602 rajveer 18064 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 18065 
    self.orderId = orderId
18066 
    self.pickupNumber = pickupNumber
4602 rajveer 18067 
    self.providerId = providerId
2536 chandransh 18068 
 
18069 
  def read(self, iprot):
18070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18072 
      return
18073 
    iprot.readStructBegin()
18074 
    while True:
18075 
      (fname, ftype, fid) = iprot.readFieldBegin()
18076 
      if ftype == TType.STOP:
18077 
        break
18078 
      if fid == 1:
18079 
        if ftype == TType.I64:
18080 
          self.orderId = iprot.readI64();
18081 
        else:
18082 
          iprot.skip(ftype)
18083 
      elif fid == 2:
18084 
        if ftype == TType.STRING:
18085 
          self.pickupNumber = iprot.readString();
18086 
        else:
18087 
          iprot.skip(ftype)
4602 rajveer 18088 
      elif fid == 3:
18089 
        if ftype == TType.I64:
18090 
          self.providerId = iprot.readI64();
18091 
        else:
18092 
          iprot.skip(ftype)
2536 chandransh 18093 
      else:
18094 
        iprot.skip(ftype)
18095 
      iprot.readFieldEnd()
18096 
    iprot.readStructEnd()
18097 
 
18098 
  def write(self, oprot):
18099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18101 
      return
18102 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 18103 
    if self.orderId is not None:
2536 chandransh 18104 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18105 
      oprot.writeI64(self.orderId)
18106 
      oprot.writeFieldEnd()
3431 rajveer 18107 
    if self.pickupNumber is not None:
2536 chandransh 18108 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
18109 
      oprot.writeString(self.pickupNumber)
18110 
      oprot.writeFieldEnd()
4602 rajveer 18111 
    if self.providerId is not None:
18112 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
18113 
      oprot.writeI64(self.providerId)
18114 
      oprot.writeFieldEnd()
2536 chandransh 18115 
    oprot.writeFieldStop()
18116 
    oprot.writeStructEnd()
18117 
 
3431 rajveer 18118 
  def validate(self):
18119 
    return
18120 
 
18121 
 
2536 chandransh 18122 
  def __repr__(self):
18123 
    L = ['%s=%r' % (key, value)
18124 
      for key, value in self.__dict__.iteritems()]
18125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18126 
 
18127 
  def __eq__(self, other):
18128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18129 
 
18130 
  def __ne__(self, other):
18131 
    return not (self == other)
18132 
 
18133 
class authorizePickup_result:
18134 
  """
18135 
  Attributes:
18136 
   - success
18137 
   - ex
18138 
  """
18139 
 
18140 
  thrift_spec = (
18141 
    (0, TType.BOOL, 'success', None, None, ), # 0
18142 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18143 
  )
18144 
 
18145 
  def __init__(self, success=None, ex=None,):
18146 
    self.success = success
18147 
    self.ex = ex
18148 
 
18149 
  def read(self, iprot):
18150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18152 
      return
18153 
    iprot.readStructBegin()
18154 
    while True:
18155 
      (fname, ftype, fid) = iprot.readFieldBegin()
18156 
      if ftype == TType.STOP:
18157 
        break
18158 
      if fid == 0:
18159 
        if ftype == TType.BOOL:
18160 
          self.success = iprot.readBool();
18161 
        else:
18162 
          iprot.skip(ftype)
18163 
      elif fid == 1:
18164 
        if ftype == TType.STRUCT:
18165 
          self.ex = TransactionServiceException()
18166 
          self.ex.read(iprot)
18167 
        else:
18168 
          iprot.skip(ftype)
18169 
      else:
18170 
        iprot.skip(ftype)
18171 
      iprot.readFieldEnd()
18172 
    iprot.readStructEnd()
18173 
 
18174 
  def write(self, oprot):
18175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18177 
      return
18178 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 18179 
    if self.success is not None:
2536 chandransh 18180 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18181 
      oprot.writeBool(self.success)
18182 
      oprot.writeFieldEnd()
3431 rajveer 18183 
    if self.ex is not None:
2536 chandransh 18184 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18185 
      self.ex.write(oprot)
18186 
      oprot.writeFieldEnd()
18187 
    oprot.writeFieldStop()
18188 
    oprot.writeStructEnd()
18189 
 
3431 rajveer 18190 
  def validate(self):
18191 
    return
18192 
 
18193 
 
2536 chandransh 18194 
  def __repr__(self):
18195 
    L = ['%s=%r' % (key, value)
18196 
      for key, value in self.__dict__.iteritems()]
18197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18198 
 
18199 
  def __eq__(self, other):
18200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18201 
 
18202 
  def __ne__(self, other):
18203 
    return not (self == other)
18204 
 
2764 chandransh 18205 
class markDoasAsPickedUp_args:
18206 
  """
18207 
  Attributes:
18208 
   - providerId
18209 
   - pickupDetails
18210 
  """
18211 
 
18212 
  thrift_spec = (
18213 
    None, # 0
18214 
    (1, TType.I64, 'providerId', None, None, ), # 1
18215 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
18216 
  )
18217 
 
18218 
  def __init__(self, providerId=None, pickupDetails=None,):
18219 
    self.providerId = providerId
18220 
    self.pickupDetails = pickupDetails
18221 
 
18222 
  def read(self, iprot):
18223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18225 
      return
18226 
    iprot.readStructBegin()
18227 
    while True:
18228 
      (fname, ftype, fid) = iprot.readFieldBegin()
18229 
      if ftype == TType.STOP:
18230 
        break
18231 
      if fid == 1:
18232 
        if ftype == TType.I64:
18233 
          self.providerId = iprot.readI64();
18234 
        else:
18235 
          iprot.skip(ftype)
18236 
      elif fid == 2:
18237 
        if ftype == TType.MAP:
18238 
          self.pickupDetails = {}
6188 rajveer 18239 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
18240 
          for _i411 in xrange(_size407):
18241 
            _key412 = iprot.readString();
18242 
            _val413 = iprot.readString();
18243 
            self.pickupDetails[_key412] = _val413
2764 chandransh 18244 
          iprot.readMapEnd()
18245 
        else:
18246 
          iprot.skip(ftype)
18247 
      else:
18248 
        iprot.skip(ftype)
18249 
      iprot.readFieldEnd()
18250 
    iprot.readStructEnd()
18251 
 
18252 
  def write(self, oprot):
18253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18255 
      return
18256 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 18257 
    if self.providerId is not None:
2764 chandransh 18258 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18259 
      oprot.writeI64(self.providerId)
18260 
      oprot.writeFieldEnd()
3431 rajveer 18261 
    if self.pickupDetails is not None:
2764 chandransh 18262 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
18263 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 18264 
      for kiter414,viter415 in self.pickupDetails.items():
18265 
        oprot.writeString(kiter414)
18266 
        oprot.writeString(viter415)
2764 chandransh 18267 
      oprot.writeMapEnd()
18268 
      oprot.writeFieldEnd()
18269 
    oprot.writeFieldStop()
18270 
    oprot.writeStructEnd()
18271 
 
3431 rajveer 18272 
  def validate(self):
18273 
    return
18274 
 
18275 
 
2764 chandransh 18276 
  def __repr__(self):
18277 
    L = ['%s=%r' % (key, value)
18278 
      for key, value in self.__dict__.iteritems()]
18279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18280 
 
18281 
  def __eq__(self, other):
18282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18283 
 
18284 
  def __ne__(self, other):
18285 
    return not (self == other)
18286 
 
18287 
class markDoasAsPickedUp_result:
4910 phani.kuma 18288 
 
18289 
  thrift_spec = (
18290 
  )
18291 
 
18292 
  def read(self, iprot):
18293 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18294 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18295 
      return
18296 
    iprot.readStructBegin()
18297 
    while True:
18298 
      (fname, ftype, fid) = iprot.readFieldBegin()
18299 
      if ftype == TType.STOP:
18300 
        break
18301 
      else:
18302 
        iprot.skip(ftype)
18303 
      iprot.readFieldEnd()
18304 
    iprot.readStructEnd()
18305 
 
18306 
  def write(self, oprot):
18307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18309 
      return
18310 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
18311 
    oprot.writeFieldStop()
18312 
    oprot.writeStructEnd()
18313 
 
18314 
  def validate(self):
18315 
    return
18316 
 
18317 
 
18318 
  def __repr__(self):
18319 
    L = ['%s=%r' % (key, value)
18320 
      for key, value in self.__dict__.iteritems()]
18321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18322 
 
18323 
  def __eq__(self, other):
18324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18325 
 
18326 
  def __ne__(self, other):
18327 
    return not (self == other)
18328 
 
18329 
class getDoasNotPickedUp_args:
2764 chandransh 18330 
  """
18331 
  Attributes:
4910 phani.kuma 18332 
   - providerId
18333 
  """
18334 
 
18335 
  thrift_spec = (
18336 
    None, # 0
18337 
    (1, TType.I64, 'providerId', None, None, ), # 1
18338 
  )
18339 
 
18340 
  def __init__(self, providerId=None,):
18341 
    self.providerId = providerId
18342 
 
18343 
  def read(self, iprot):
18344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18346 
      return
18347 
    iprot.readStructBegin()
18348 
    while True:
18349 
      (fname, ftype, fid) = iprot.readFieldBegin()
18350 
      if ftype == TType.STOP:
18351 
        break
18352 
      if fid == 1:
18353 
        if ftype == TType.I64:
18354 
          self.providerId = iprot.readI64();
18355 
        else:
18356 
          iprot.skip(ftype)
18357 
      else:
18358 
        iprot.skip(ftype)
18359 
      iprot.readFieldEnd()
18360 
    iprot.readStructEnd()
18361 
 
18362 
  def write(self, oprot):
18363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18365 
      return
18366 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
18367 
    if self.providerId is not None:
18368 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18369 
      oprot.writeI64(self.providerId)
18370 
      oprot.writeFieldEnd()
18371 
    oprot.writeFieldStop()
18372 
    oprot.writeStructEnd()
18373 
 
18374 
  def validate(self):
18375 
    return
18376 
 
18377 
 
18378 
  def __repr__(self):
18379 
    L = ['%s=%r' % (key, value)
18380 
      for key, value in self.__dict__.iteritems()]
18381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18382 
 
18383 
  def __eq__(self, other):
18384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18385 
 
18386 
  def __ne__(self, other):
18387 
    return not (self == other)
18388 
 
18389 
class getDoasNotPickedUp_result:
18390 
  """
18391 
  Attributes:
2764 chandransh 18392 
   - success
18393 
  """
18394 
 
18395 
  thrift_spec = (
18396 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18397 
  )
18398 
 
18399 
  def __init__(self, success=None,):
18400 
    self.success = success
18401 
 
18402 
  def read(self, iprot):
18403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18405 
      return
18406 
    iprot.readStructBegin()
18407 
    while True:
18408 
      (fname, ftype, fid) = iprot.readFieldBegin()
18409 
      if ftype == TType.STOP:
18410 
        break
18411 
      if fid == 0:
18412 
        if ftype == TType.LIST:
18413 
          self.success = []
6188 rajveer 18414 
          (_etype419, _size416) = iprot.readListBegin()
18415 
          for _i420 in xrange(_size416):
18416 
            _elem421 = Order()
18417 
            _elem421.read(iprot)
18418 
            self.success.append(_elem421)
2764 chandransh 18419 
          iprot.readListEnd()
18420 
        else:
18421 
          iprot.skip(ftype)
18422 
      else:
18423 
        iprot.skip(ftype)
18424 
      iprot.readFieldEnd()
18425 
    iprot.readStructEnd()
18426 
 
18427 
  def write(self, oprot):
18428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18430 
      return
4910 phani.kuma 18431 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 18432 
    if self.success is not None:
2764 chandransh 18433 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18434 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18435 
      for iter422 in self.success:
18436 
        iter422.write(oprot)
2764 chandransh 18437 
      oprot.writeListEnd()
18438 
      oprot.writeFieldEnd()
18439 
    oprot.writeFieldStop()
18440 
    oprot.writeStructEnd()
18441 
 
3431 rajveer 18442 
  def validate(self):
18443 
    return
18444 
 
18445 
 
2764 chandransh 18446 
  def __repr__(self):
18447 
    L = ['%s=%r' % (key, value)
18448 
      for key, value in self.__dict__.iteritems()]
18449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18450 
 
18451 
  def __eq__(self, other):
18452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18453 
 
18454 
  def __ne__(self, other):
18455 
    return not (self == other)
18456 
 
4741 phani.kuma 18457 
class markReturnOrdersAsPickedUp_args:
18458 
  """
18459 
  Attributes:
18460 
   - providerId
18461 
   - pickupDetails
18462 
  """
18463 
 
18464 
  thrift_spec = (
18465 
    None, # 0
18466 
    (1, TType.I64, 'providerId', None, None, ), # 1
18467 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
18468 
  )
18469 
 
18470 
  def __init__(self, providerId=None, pickupDetails=None,):
18471 
    self.providerId = providerId
18472 
    self.pickupDetails = pickupDetails
18473 
 
18474 
  def read(self, iprot):
18475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18477 
      return
18478 
    iprot.readStructBegin()
18479 
    while True:
18480 
      (fname, ftype, fid) = iprot.readFieldBegin()
18481 
      if ftype == TType.STOP:
18482 
        break
18483 
      if fid == 1:
18484 
        if ftype == TType.I64:
18485 
          self.providerId = iprot.readI64();
18486 
        else:
18487 
          iprot.skip(ftype)
18488 
      elif fid == 2:
18489 
        if ftype == TType.MAP:
18490 
          self.pickupDetails = {}
6188 rajveer 18491 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
18492 
          for _i427 in xrange(_size423):
18493 
            _key428 = iprot.readString();
18494 
            _val429 = iprot.readString();
18495 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 18496 
          iprot.readMapEnd()
18497 
        else:
18498 
          iprot.skip(ftype)
18499 
      else:
18500 
        iprot.skip(ftype)
18501 
      iprot.readFieldEnd()
18502 
    iprot.readStructEnd()
18503 
 
18504 
  def write(self, oprot):
18505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18507 
      return
18508 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
18509 
    if self.providerId is not None:
18510 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18511 
      oprot.writeI64(self.providerId)
18512 
      oprot.writeFieldEnd()
18513 
    if self.pickupDetails is not None:
18514 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
18515 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 18516 
      for kiter430,viter431 in self.pickupDetails.items():
18517 
        oprot.writeString(kiter430)
18518 
        oprot.writeString(viter431)
4741 phani.kuma 18519 
      oprot.writeMapEnd()
18520 
      oprot.writeFieldEnd()
18521 
    oprot.writeFieldStop()
18522 
    oprot.writeStructEnd()
18523 
 
18524 
  def validate(self):
18525 
    return
18526 
 
18527 
 
18528 
  def __repr__(self):
18529 
    L = ['%s=%r' % (key, value)
18530 
      for key, value in self.__dict__.iteritems()]
18531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18532 
 
18533 
  def __eq__(self, other):
18534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18535 
 
18536 
  def __ne__(self, other):
18537 
    return not (self == other)
18538 
 
18539 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 18540 
 
18541 
  thrift_spec = (
18542 
  )
18543 
 
18544 
  def read(self, iprot):
18545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18547 
      return
18548 
    iprot.readStructBegin()
18549 
    while True:
18550 
      (fname, ftype, fid) = iprot.readFieldBegin()
18551 
      if ftype == TType.STOP:
18552 
        break
18553 
      else:
18554 
        iprot.skip(ftype)
18555 
      iprot.readFieldEnd()
18556 
    iprot.readStructEnd()
18557 
 
18558 
  def write(self, oprot):
18559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18561 
      return
18562 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
18563 
    oprot.writeFieldStop()
18564 
    oprot.writeStructEnd()
18565 
 
18566 
  def validate(self):
18567 
    return
18568 
 
18569 
 
18570 
  def __repr__(self):
18571 
    L = ['%s=%r' % (key, value)
18572 
      for key, value in self.__dict__.iteritems()]
18573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18574 
 
18575 
  def __eq__(self, other):
18576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18577 
 
18578 
  def __ne__(self, other):
18579 
    return not (self == other)
18580 
 
18581 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 18582 
  """
18583 
  Attributes:
4910 phani.kuma 18584 
   - providerId
18585 
  """
18586 
 
18587 
  thrift_spec = (
18588 
    None, # 0
18589 
    (1, TType.I64, 'providerId', None, None, ), # 1
18590 
  )
18591 
 
18592 
  def __init__(self, providerId=None,):
18593 
    self.providerId = providerId
18594 
 
18595 
  def read(self, iprot):
18596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18598 
      return
18599 
    iprot.readStructBegin()
18600 
    while True:
18601 
      (fname, ftype, fid) = iprot.readFieldBegin()
18602 
      if ftype == TType.STOP:
18603 
        break
18604 
      if fid == 1:
18605 
        if ftype == TType.I64:
18606 
          self.providerId = iprot.readI64();
18607 
        else:
18608 
          iprot.skip(ftype)
18609 
      else:
18610 
        iprot.skip(ftype)
18611 
      iprot.readFieldEnd()
18612 
    iprot.readStructEnd()
18613 
 
18614 
  def write(self, oprot):
18615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18617 
      return
18618 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
18619 
    if self.providerId is not None:
18620 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18621 
      oprot.writeI64(self.providerId)
18622 
      oprot.writeFieldEnd()
18623 
    oprot.writeFieldStop()
18624 
    oprot.writeStructEnd()
18625 
 
18626 
  def validate(self):
18627 
    return
18628 
 
18629 
 
18630 
  def __repr__(self):
18631 
    L = ['%s=%r' % (key, value)
18632 
      for key, value in self.__dict__.iteritems()]
18633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18634 
 
18635 
  def __eq__(self, other):
18636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18637 
 
18638 
  def __ne__(self, other):
18639 
    return not (self == other)
18640 
 
18641 
class getReturnOrdersNotPickedUp_result:
18642 
  """
18643 
  Attributes:
4741 phani.kuma 18644 
   - success
18645 
  """
18646 
 
18647 
  thrift_spec = (
18648 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18649 
  )
18650 
 
18651 
  def __init__(self, success=None,):
18652 
    self.success = success
18653 
 
18654 
  def read(self, iprot):
18655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18657 
      return
18658 
    iprot.readStructBegin()
18659 
    while True:
18660 
      (fname, ftype, fid) = iprot.readFieldBegin()
18661 
      if ftype == TType.STOP:
18662 
        break
18663 
      if fid == 0:
18664 
        if ftype == TType.LIST:
18665 
          self.success = []
6188 rajveer 18666 
          (_etype435, _size432) = iprot.readListBegin()
18667 
          for _i436 in xrange(_size432):
18668 
            _elem437 = Order()
18669 
            _elem437.read(iprot)
18670 
            self.success.append(_elem437)
4741 phani.kuma 18671 
          iprot.readListEnd()
18672 
        else:
18673 
          iprot.skip(ftype)
18674 
      else:
18675 
        iprot.skip(ftype)
18676 
      iprot.readFieldEnd()
18677 
    iprot.readStructEnd()
18678 
 
18679 
  def write(self, oprot):
18680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18682 
      return
4910 phani.kuma 18683 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 18684 
    if self.success is not None:
18685 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18686 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18687 
      for iter438 in self.success:
18688 
        iter438.write(oprot)
4741 phani.kuma 18689 
      oprot.writeListEnd()
18690 
      oprot.writeFieldEnd()
18691 
    oprot.writeFieldStop()
18692 
    oprot.writeStructEnd()
18693 
 
18694 
  def validate(self):
18695 
    return
18696 
 
18697 
 
18698 
  def __repr__(self):
18699 
    L = ['%s=%r' % (key, value)
18700 
      for key, value in self.__dict__.iteritems()]
18701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18702 
 
18703 
  def __eq__(self, other):
18704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18705 
 
18706 
  def __ne__(self, other):
18707 
    return not (self == other)
18708 
 
2616 chandransh 18709 
class receiveReturn_args:
2591 chandransh 18710 
  """
18711 
  Attributes:
18712 
   - orderId
4479 rajveer 18713 
   - receiveCondition
2591 chandransh 18714 
  """
2536 chandransh 18715 
 
2591 chandransh 18716 
  thrift_spec = (
18717 
    None, # 0
18718 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 18719 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 18720 
  )
18721 
 
4479 rajveer 18722 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 18723 
    self.orderId = orderId
4479 rajveer 18724 
    self.receiveCondition = receiveCondition
2591 chandransh 18725 
 
18726 
  def read(self, iprot):
18727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18729 
      return
18730 
    iprot.readStructBegin()
18731 
    while True:
18732 
      (fname, ftype, fid) = iprot.readFieldBegin()
18733 
      if ftype == TType.STOP:
18734 
        break
18735 
      if fid == 1:
18736 
        if ftype == TType.I64:
18737 
          self.orderId = iprot.readI64();
18738 
        else:
18739 
          iprot.skip(ftype)
4479 rajveer 18740 
      elif fid == 2:
18741 
        if ftype == TType.I64:
18742 
          self.receiveCondition = iprot.readI64();
18743 
        else:
18744 
          iprot.skip(ftype)
2591 chandransh 18745 
      else:
18746 
        iprot.skip(ftype)
18747 
      iprot.readFieldEnd()
18748 
    iprot.readStructEnd()
18749 
 
18750 
  def write(self, oprot):
18751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18753 
      return
2616 chandransh 18754 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 18755 
    if self.orderId is not None:
2591 chandransh 18756 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18757 
      oprot.writeI64(self.orderId)
18758 
      oprot.writeFieldEnd()
4479 rajveer 18759 
    if self.receiveCondition is not None:
18760 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
18761 
      oprot.writeI64(self.receiveCondition)
18762 
      oprot.writeFieldEnd()
2591 chandransh 18763 
    oprot.writeFieldStop()
18764 
    oprot.writeStructEnd()
18765 
 
3431 rajveer 18766 
  def validate(self):
18767 
    return
18768 
 
18769 
 
2591 chandransh 18770 
  def __repr__(self):
18771 
    L = ['%s=%r' % (key, value)
18772 
      for key, value in self.__dict__.iteritems()]
18773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18774 
 
18775 
  def __eq__(self, other):
18776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18777 
 
18778 
  def __ne__(self, other):
18779 
    return not (self == other)
18780 
 
2616 chandransh 18781 
class receiveReturn_result:
2591 chandransh 18782 
  """
18783 
  Attributes:
18784 
   - success
18785 
   - ex
18786 
  """
18787 
 
18788 
  thrift_spec = (
18789 
    (0, TType.BOOL, 'success', None, None, ), # 0
18790 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18791 
  )
18792 
 
18793 
  def __init__(self, success=None, ex=None,):
18794 
    self.success = success
18795 
    self.ex = ex
18796 
 
18797 
  def read(self, iprot):
18798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18800 
      return
18801 
    iprot.readStructBegin()
18802 
    while True:
18803 
      (fname, ftype, fid) = iprot.readFieldBegin()
18804 
      if ftype == TType.STOP:
18805 
        break
18806 
      if fid == 0:
18807 
        if ftype == TType.BOOL:
18808 
          self.success = iprot.readBool();
18809 
        else:
18810 
          iprot.skip(ftype)
18811 
      elif fid == 1:
18812 
        if ftype == TType.STRUCT:
18813 
          self.ex = TransactionServiceException()
18814 
          self.ex.read(iprot)
18815 
        else:
18816 
          iprot.skip(ftype)
18817 
      else:
18818 
        iprot.skip(ftype)
18819 
      iprot.readFieldEnd()
18820 
    iprot.readStructEnd()
18821 
 
18822 
  def write(self, oprot):
18823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18825 
      return
2616 chandransh 18826 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 18827 
    if self.success is not None:
2591 chandransh 18828 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18829 
      oprot.writeBool(self.success)
18830 
      oprot.writeFieldEnd()
3431 rajveer 18831 
    if self.ex is not None:
2591 chandransh 18832 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18833 
      self.ex.write(oprot)
18834 
      oprot.writeFieldEnd()
18835 
    oprot.writeFieldStop()
18836 
    oprot.writeStructEnd()
18837 
 
3431 rajveer 18838 
  def validate(self):
18839 
    return
18840 
 
18841 
 
2591 chandransh 18842 
  def __repr__(self):
18843 
    L = ['%s=%r' % (key, value)
18844 
      for key, value in self.__dict__.iteritems()]
18845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18846 
 
18847 
  def __eq__(self, other):
18848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18849 
 
18850 
  def __ne__(self, other):
18851 
    return not (self == other)
18852 
 
18853 
class validateDoa_args:
18854 
  """
18855 
  Attributes:
18856 
   - orderId
18857 
   - isValid
18858 
  """
18859 
 
18860 
  thrift_spec = (
18861 
    None, # 0
18862 
    (1, TType.I64, 'orderId', None, None, ), # 1
18863 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
18864 
  )
18865 
 
18866 
  def __init__(self, orderId=None, isValid=None,):
18867 
    self.orderId = orderId
18868 
    self.isValid = isValid
18869 
 
18870 
  def read(self, iprot):
18871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18873 
      return
18874 
    iprot.readStructBegin()
18875 
    while True:
18876 
      (fname, ftype, fid) = iprot.readFieldBegin()
18877 
      if ftype == TType.STOP:
18878 
        break
18879 
      if fid == 1:
18880 
        if ftype == TType.I64:
18881 
          self.orderId = iprot.readI64();
18882 
        else:
18883 
          iprot.skip(ftype)
18884 
      elif fid == 2:
18885 
        if ftype == TType.BOOL:
18886 
          self.isValid = iprot.readBool();
18887 
        else:
18888 
          iprot.skip(ftype)
18889 
      else:
18890 
        iprot.skip(ftype)
18891 
      iprot.readFieldEnd()
18892 
    iprot.readStructEnd()
18893 
 
18894 
  def write(self, oprot):
18895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18897 
      return
18898 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 18899 
    if self.orderId is not None:
2591 chandransh 18900 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18901 
      oprot.writeI64(self.orderId)
18902 
      oprot.writeFieldEnd()
3431 rajveer 18903 
    if self.isValid is not None:
2591 chandransh 18904 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
18905 
      oprot.writeBool(self.isValid)
18906 
      oprot.writeFieldEnd()
18907 
    oprot.writeFieldStop()
18908 
    oprot.writeStructEnd()
18909 
 
3431 rajveer 18910 
  def validate(self):
18911 
    return
18912 
 
18913 
 
2591 chandransh 18914 
  def __repr__(self):
18915 
    L = ['%s=%r' % (key, value)
18916 
      for key, value in self.__dict__.iteritems()]
18917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18918 
 
18919 
  def __eq__(self, other):
18920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18921 
 
18922 
  def __ne__(self, other):
18923 
    return not (self == other)
18924 
 
18925 
class validateDoa_result:
18926 
  """
18927 
  Attributes:
18928 
   - success
18929 
   - ex
18930 
  """
18931 
 
18932 
  thrift_spec = (
18933 
    (0, TType.BOOL, 'success', None, None, ), # 0
18934 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18935 
  )
18936 
 
18937 
  def __init__(self, success=None, ex=None,):
18938 
    self.success = success
18939 
    self.ex = ex
18940 
 
18941 
  def read(self, iprot):
18942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18944 
      return
18945 
    iprot.readStructBegin()
18946 
    while True:
18947 
      (fname, ftype, fid) = iprot.readFieldBegin()
18948 
      if ftype == TType.STOP:
18949 
        break
18950 
      if fid == 0:
18951 
        if ftype == TType.BOOL:
18952 
          self.success = iprot.readBool();
18953 
        else:
18954 
          iprot.skip(ftype)
18955 
      elif fid == 1:
18956 
        if ftype == TType.STRUCT:
18957 
          self.ex = TransactionServiceException()
18958 
          self.ex.read(iprot)
18959 
        else:
18960 
          iprot.skip(ftype)
18961 
      else:
18962 
        iprot.skip(ftype)
18963 
      iprot.readFieldEnd()
18964 
    iprot.readStructEnd()
18965 
 
18966 
  def write(self, oprot):
18967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18969 
      return
18970 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 18971 
    if self.success is not None:
2591 chandransh 18972 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18973 
      oprot.writeBool(self.success)
18974 
      oprot.writeFieldEnd()
3431 rajveer 18975 
    if self.ex is not None:
2591 chandransh 18976 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18977 
      self.ex.write(oprot)
18978 
      oprot.writeFieldEnd()
18979 
    oprot.writeFieldStop()
18980 
    oprot.writeStructEnd()
18981 
 
3431 rajveer 18982 
  def validate(self):
18983 
    return
18984 
 
18985 
 
2591 chandransh 18986 
  def __repr__(self):
18987 
    L = ['%s=%r' % (key, value)
18988 
      for key, value in self.__dict__.iteritems()]
18989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18990 
 
18991 
  def __eq__(self, other):
18992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18993 
 
18994 
  def __ne__(self, other):
18995 
    return not (self == other)
18996 
 
4495 rajveer 18997 
class validateReturnProduct_args:
18998 
  """
18999 
  Attributes:
19000 
   - orderId
19001 
   - isUsable
19002 
  """
19003 
 
19004 
  thrift_spec = (
19005 
    None, # 0
19006 
    (1, TType.I64, 'orderId', None, None, ), # 1
19007 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
19008 
  )
19009 
 
19010 
  def __init__(self, orderId=None, isUsable=None,):
19011 
    self.orderId = orderId
19012 
    self.isUsable = isUsable
19013 
 
19014 
  def read(self, iprot):
19015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19017 
      return
19018 
    iprot.readStructBegin()
19019 
    while True:
19020 
      (fname, ftype, fid) = iprot.readFieldBegin()
19021 
      if ftype == TType.STOP:
19022 
        break
19023 
      if fid == 1:
19024 
        if ftype == TType.I64:
19025 
          self.orderId = iprot.readI64();
19026 
        else:
19027 
          iprot.skip(ftype)
19028 
      elif fid == 2:
19029 
        if ftype == TType.BOOL:
19030 
          self.isUsable = iprot.readBool();
19031 
        else:
19032 
          iprot.skip(ftype)
19033 
      else:
19034 
        iprot.skip(ftype)
19035 
      iprot.readFieldEnd()
19036 
    iprot.readStructEnd()
19037 
 
19038 
  def write(self, oprot):
19039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19041 
      return
19042 
    oprot.writeStructBegin('validateReturnProduct_args')
19043 
    if self.orderId is not None:
19044 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19045 
      oprot.writeI64(self.orderId)
19046 
      oprot.writeFieldEnd()
19047 
    if self.isUsable is not None:
19048 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
19049 
      oprot.writeBool(self.isUsable)
19050 
      oprot.writeFieldEnd()
19051 
    oprot.writeFieldStop()
19052 
    oprot.writeStructEnd()
19053 
 
19054 
  def validate(self):
19055 
    return
19056 
 
19057 
 
19058 
  def __repr__(self):
19059 
    L = ['%s=%r' % (key, value)
19060 
      for key, value in self.__dict__.iteritems()]
19061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19062 
 
19063 
  def __eq__(self, other):
19064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19065 
 
19066 
  def __ne__(self, other):
19067 
    return not (self == other)
19068 
 
19069 
class validateReturnProduct_result:
19070 
  """
19071 
  Attributes:
19072 
   - success
19073 
   - ex
19074 
  """
19075 
 
19076 
  thrift_spec = (
19077 
    (0, TType.BOOL, 'success', None, None, ), # 0
19078 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19079 
  )
19080 
 
19081 
  def __init__(self, success=None, ex=None,):
19082 
    self.success = success
19083 
    self.ex = ex
19084 
 
19085 
  def read(self, iprot):
19086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19088 
      return
19089 
    iprot.readStructBegin()
19090 
    while True:
19091 
      (fname, ftype, fid) = iprot.readFieldBegin()
19092 
      if ftype == TType.STOP:
19093 
        break
19094 
      if fid == 0:
19095 
        if ftype == TType.BOOL:
19096 
          self.success = iprot.readBool();
19097 
        else:
19098 
          iprot.skip(ftype)
19099 
      elif fid == 1:
19100 
        if ftype == TType.STRUCT:
19101 
          self.ex = TransactionServiceException()
19102 
          self.ex.read(iprot)
19103 
        else:
19104 
          iprot.skip(ftype)
19105 
      else:
19106 
        iprot.skip(ftype)
19107 
      iprot.readFieldEnd()
19108 
    iprot.readStructEnd()
19109 
 
19110 
  def write(self, oprot):
19111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19113 
      return
19114 
    oprot.writeStructBegin('validateReturnProduct_result')
19115 
    if self.success is not None:
19116 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19117 
      oprot.writeBool(self.success)
19118 
      oprot.writeFieldEnd()
19119 
    if self.ex is not None:
19120 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19121 
      self.ex.write(oprot)
19122 
      oprot.writeFieldEnd()
19123 
    oprot.writeFieldStop()
19124 
    oprot.writeStructEnd()
19125 
 
19126 
  def validate(self):
19127 
    return
19128 
 
19129 
 
19130 
  def __repr__(self):
19131 
    L = ['%s=%r' % (key, value)
19132 
      for key, value in self.__dict__.iteritems()]
19133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19134 
 
19135 
  def __eq__(self, other):
19136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19137 
 
19138 
  def __ne__(self, other):
19139 
    return not (self == other)
19140 
 
2616 chandransh 19141 
class reshipOrder_args:
19142 
  """
19143 
  Attributes:
19144 
   - orderId
19145 
  """
2591 chandransh 19146 
 
2616 chandransh 19147 
  thrift_spec = (
19148 
    None, # 0
19149 
    (1, TType.I64, 'orderId', None, None, ), # 1
19150 
  )
19151 
 
19152 
  def __init__(self, orderId=None,):
19153 
    self.orderId = orderId
19154 
 
19155 
  def read(self, iprot):
19156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19158 
      return
19159 
    iprot.readStructBegin()
19160 
    while True:
19161 
      (fname, ftype, fid) = iprot.readFieldBegin()
19162 
      if ftype == TType.STOP:
19163 
        break
19164 
      if fid == 1:
19165 
        if ftype == TType.I64:
19166 
          self.orderId = iprot.readI64();
19167 
        else:
19168 
          iprot.skip(ftype)
19169 
      else:
19170 
        iprot.skip(ftype)
19171 
      iprot.readFieldEnd()
19172 
    iprot.readStructEnd()
19173 
 
19174 
  def write(self, oprot):
19175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19177 
      return
19178 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 19179 
    if self.orderId is not None:
2616 chandransh 19180 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19181 
      oprot.writeI64(self.orderId)
19182 
      oprot.writeFieldEnd()
19183 
    oprot.writeFieldStop()
19184 
    oprot.writeStructEnd()
19185 
 
3431 rajveer 19186 
  def validate(self):
19187 
    return
19188 
 
19189 
 
2616 chandransh 19190 
  def __repr__(self):
19191 
    L = ['%s=%r' % (key, value)
19192 
      for key, value in self.__dict__.iteritems()]
19193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19194 
 
19195 
  def __eq__(self, other):
19196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19197 
 
19198 
  def __ne__(self, other):
19199 
    return not (self == other)
19200 
 
19201 
class reshipOrder_result:
19202 
  """
19203 
  Attributes:
19204 
   - success
19205 
   - ex
19206 
  """
19207 
 
19208 
  thrift_spec = (
19209 
    (0, TType.I64, 'success', None, None, ), # 0
19210 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19211 
  )
19212 
 
19213 
  def __init__(self, success=None, ex=None,):
19214 
    self.success = success
19215 
    self.ex = ex
19216 
 
19217 
  def read(self, iprot):
19218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19220 
      return
19221 
    iprot.readStructBegin()
19222 
    while True:
19223 
      (fname, ftype, fid) = iprot.readFieldBegin()
19224 
      if ftype == TType.STOP:
19225 
        break
19226 
      if fid == 0:
19227 
        if ftype == TType.I64:
19228 
          self.success = iprot.readI64();
19229 
        else:
19230 
          iprot.skip(ftype)
19231 
      elif fid == 1:
19232 
        if ftype == TType.STRUCT:
19233 
          self.ex = TransactionServiceException()
19234 
          self.ex.read(iprot)
19235 
        else:
19236 
          iprot.skip(ftype)
19237 
      else:
19238 
        iprot.skip(ftype)
19239 
      iprot.readFieldEnd()
19240 
    iprot.readStructEnd()
19241 
 
19242 
  def write(self, oprot):
19243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19245 
      return
19246 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 19247 
    if self.success is not None:
2616 chandransh 19248 
      oprot.writeFieldBegin('success', TType.I64, 0)
19249 
      oprot.writeI64(self.success)
19250 
      oprot.writeFieldEnd()
3431 rajveer 19251 
    if self.ex is not None:
2616 chandransh 19252 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19253 
      self.ex.write(oprot)
19254 
      oprot.writeFieldEnd()
19255 
    oprot.writeFieldStop()
19256 
    oprot.writeStructEnd()
19257 
 
3431 rajveer 19258 
  def validate(self):
19259 
    return
19260 
 
19261 
 
2616 chandransh 19262 
  def __repr__(self):
19263 
    L = ['%s=%r' % (key, value)
19264 
      for key, value in self.__dict__.iteritems()]
19265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19266 
 
19267 
  def __eq__(self, other):
19268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19269 
 
19270 
  def __ne__(self, other):
19271 
    return not (self == other)
19272 
 
19273 
class refundOrder_args:
19274 
  """
19275 
  Attributes:
19276 
   - orderId
3226 chandransh 19277 
   - refundedBy
19278 
   - reason
2616 chandransh 19279 
  """
19280 
 
19281 
  thrift_spec = (
19282 
    None, # 0
19283 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 19284 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
19285 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 19286 
  )
19287 
 
3226 chandransh 19288 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 19289 
    self.orderId = orderId
3226 chandransh 19290 
    self.refundedBy = refundedBy
19291 
    self.reason = reason
2616 chandransh 19292 
 
19293 
  def read(self, iprot):
19294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19296 
      return
19297 
    iprot.readStructBegin()
19298 
    while True:
19299 
      (fname, ftype, fid) = iprot.readFieldBegin()
19300 
      if ftype == TType.STOP:
19301 
        break
19302 
      if fid == 1:
19303 
        if ftype == TType.I64:
19304 
          self.orderId = iprot.readI64();
19305 
        else:
19306 
          iprot.skip(ftype)
3226 chandransh 19307 
      elif fid == 2:
19308 
        if ftype == TType.STRING:
19309 
          self.refundedBy = iprot.readString();
19310 
        else:
19311 
          iprot.skip(ftype)
19312 
      elif fid == 3:
19313 
        if ftype == TType.STRING:
19314 
          self.reason = iprot.readString();
19315 
        else:
19316 
          iprot.skip(ftype)
2616 chandransh 19317 
      else:
19318 
        iprot.skip(ftype)
19319 
      iprot.readFieldEnd()
19320 
    iprot.readStructEnd()
19321 
 
19322 
  def write(self, oprot):
19323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19325 
      return
19326 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 19327 
    if self.orderId is not None:
2616 chandransh 19328 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19329 
      oprot.writeI64(self.orderId)
19330 
      oprot.writeFieldEnd()
3431 rajveer 19331 
    if self.refundedBy is not None:
3226 chandransh 19332 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
19333 
      oprot.writeString(self.refundedBy)
19334 
      oprot.writeFieldEnd()
3431 rajveer 19335 
    if self.reason is not None:
3226 chandransh 19336 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
19337 
      oprot.writeString(self.reason)
19338 
      oprot.writeFieldEnd()
2616 chandransh 19339 
    oprot.writeFieldStop()
19340 
    oprot.writeStructEnd()
19341 
 
3431 rajveer 19342 
  def validate(self):
19343 
    return
19344 
 
19345 
 
2616 chandransh 19346 
  def __repr__(self):
19347 
    L = ['%s=%r' % (key, value)
19348 
      for key, value in self.__dict__.iteritems()]
19349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19350 
 
19351 
  def __eq__(self, other):
19352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19353 
 
19354 
  def __ne__(self, other):
19355 
    return not (self == other)
19356 
 
19357 
class refundOrder_result:
19358 
  """
19359 
  Attributes:
19360 
   - success
19361 
   - ex
19362 
  """
19363 
 
19364 
  thrift_spec = (
19365 
    (0, TType.BOOL, 'success', None, None, ), # 0
19366 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19367 
  )
19368 
 
19369 
  def __init__(self, success=None, ex=None,):
19370 
    self.success = success
19371 
    self.ex = ex
19372 
 
19373 
  def read(self, iprot):
19374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19376 
      return
19377 
    iprot.readStructBegin()
19378 
    while True:
19379 
      (fname, ftype, fid) = iprot.readFieldBegin()
19380 
      if ftype == TType.STOP:
19381 
        break
19382 
      if fid == 0:
19383 
        if ftype == TType.BOOL:
19384 
          self.success = iprot.readBool();
19385 
        else:
19386 
          iprot.skip(ftype)
19387 
      elif fid == 1:
19388 
        if ftype == TType.STRUCT:
19389 
          self.ex = TransactionServiceException()
19390 
          self.ex.read(iprot)
19391 
        else:
19392 
          iprot.skip(ftype)
19393 
      else:
19394 
        iprot.skip(ftype)
19395 
      iprot.readFieldEnd()
19396 
    iprot.readStructEnd()
19397 
 
19398 
  def write(self, oprot):
19399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19401 
      return
19402 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 19403 
    if self.success is not None:
2616 chandransh 19404 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19405 
      oprot.writeBool(self.success)
19406 
      oprot.writeFieldEnd()
3431 rajveer 19407 
    if self.ex is not None:
2616 chandransh 19408 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19409 
      self.ex.write(oprot)
19410 
      oprot.writeFieldEnd()
19411 
    oprot.writeFieldStop()
19412 
    oprot.writeStructEnd()
19413 
 
3431 rajveer 19414 
  def validate(self):
19415 
    return
19416 
 
19417 
 
2616 chandransh 19418 
  def __repr__(self):
19419 
    L = ['%s=%r' % (key, value)
19420 
      for key, value in self.__dict__.iteritems()]
19421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19422 
 
19423 
  def __eq__(self, other):
19424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19425 
 
19426 
  def __ne__(self, other):
19427 
    return not (self == other)
19428 
 
2690 chandransh 19429 
class getReturnOrders_args:
19430 
  """
19431 
  Attributes:
19432 
   - warehouseId
19433 
   - fromDate
19434 
   - toDate
19435 
  """
2616 chandransh 19436 
 
2690 chandransh 19437 
  thrift_spec = (
19438 
    None, # 0
19439 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
19440 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19441 
    (3, TType.I64, 'toDate', None, None, ), # 3
19442 
  )
19443 
 
19444 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
19445 
    self.warehouseId = warehouseId
19446 
    self.fromDate = fromDate
19447 
    self.toDate = toDate
19448 
 
19449 
  def read(self, iprot):
19450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19452 
      return
19453 
    iprot.readStructBegin()
19454 
    while True:
19455 
      (fname, ftype, fid) = iprot.readFieldBegin()
19456 
      if ftype == TType.STOP:
19457 
        break
19458 
      if fid == 1:
19459 
        if ftype == TType.I64:
19460 
          self.warehouseId = iprot.readI64();
19461 
        else:
19462 
          iprot.skip(ftype)
19463 
      elif fid == 2:
19464 
        if ftype == TType.I64:
19465 
          self.fromDate = iprot.readI64();
19466 
        else:
19467 
          iprot.skip(ftype)
19468 
      elif fid == 3:
19469 
        if ftype == TType.I64:
19470 
          self.toDate = iprot.readI64();
19471 
        else:
19472 
          iprot.skip(ftype)
19473 
      else:
19474 
        iprot.skip(ftype)
19475 
      iprot.readFieldEnd()
19476 
    iprot.readStructEnd()
19477 
 
19478 
  def write(self, oprot):
19479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19481 
      return
19482 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 19483 
    if self.warehouseId is not None:
2690 chandransh 19484 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
19485 
      oprot.writeI64(self.warehouseId)
19486 
      oprot.writeFieldEnd()
3431 rajveer 19487 
    if self.fromDate is not None:
2690 chandransh 19488 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19489 
      oprot.writeI64(self.fromDate)
19490 
      oprot.writeFieldEnd()
3431 rajveer 19491 
    if self.toDate is not None:
2690 chandransh 19492 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19493 
      oprot.writeI64(self.toDate)
19494 
      oprot.writeFieldEnd()
19495 
    oprot.writeFieldStop()
19496 
    oprot.writeStructEnd()
19497 
 
3431 rajveer 19498 
  def validate(self):
19499 
    return
19500 
 
19501 
 
2690 chandransh 19502 
  def __repr__(self):
19503 
    L = ['%s=%r' % (key, value)
19504 
      for key, value in self.__dict__.iteritems()]
19505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19506 
 
19507 
  def __eq__(self, other):
19508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19509 
 
19510 
  def __ne__(self, other):
19511 
    return not (self == other)
19512 
 
19513 
class getReturnOrders_result:
19514 
  """
19515 
  Attributes:
19516 
   - success
19517 
  """
19518 
 
19519 
  thrift_spec = (
19520 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19521 
  )
19522 
 
19523 
  def __init__(self, success=None,):
19524 
    self.success = success
19525 
 
19526 
  def read(self, iprot):
19527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19529 
      return
19530 
    iprot.readStructBegin()
19531 
    while True:
19532 
      (fname, ftype, fid) = iprot.readFieldBegin()
19533 
      if ftype == TType.STOP:
19534 
        break
19535 
      if fid == 0:
19536 
        if ftype == TType.LIST:
19537 
          self.success = []
6188 rajveer 19538 
          (_etype442, _size439) = iprot.readListBegin()
19539 
          for _i443 in xrange(_size439):
19540 
            _elem444 = ReturnOrder()
19541 
            _elem444.read(iprot)
19542 
            self.success.append(_elem444)
2690 chandransh 19543 
          iprot.readListEnd()
19544 
        else:
19545 
          iprot.skip(ftype)
19546 
      else:
19547 
        iprot.skip(ftype)
19548 
      iprot.readFieldEnd()
19549 
    iprot.readStructEnd()
19550 
 
19551 
  def write(self, oprot):
19552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19554 
      return
19555 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 19556 
    if self.success is not None:
2690 chandransh 19557 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19558 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19559 
      for iter445 in self.success:
19560 
        iter445.write(oprot)
2690 chandransh 19561 
      oprot.writeListEnd()
19562 
      oprot.writeFieldEnd()
19563 
    oprot.writeFieldStop()
19564 
    oprot.writeStructEnd()
19565 
 
3431 rajveer 19566 
  def validate(self):
19567 
    return
19568 
 
19569 
 
2690 chandransh 19570 
  def __repr__(self):
19571 
    L = ['%s=%r' % (key, value)
19572 
      for key, value in self.__dict__.iteritems()]
19573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19574 
 
19575 
  def __eq__(self, other):
19576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19577 
 
19578 
  def __ne__(self, other):
19579 
    return not (self == other)
19580 
 
5481 phani.kuma 19581 
class getAllReturnOrders_args:
19582 
  """
19583 
  Attributes:
19584 
   - onlyNotProcessed
19585 
   - fromDate
19586 
   - toDate
19587 
  """
19588 
 
19589 
  thrift_spec = (
19590 
    None, # 0
19591 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
19592 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19593 
    (3, TType.I64, 'toDate', None, None, ), # 3
19594 
  )
19595 
 
19596 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
19597 
    self.onlyNotProcessed = onlyNotProcessed
19598 
    self.fromDate = fromDate
19599 
    self.toDate = toDate
19600 
 
19601 
  def read(self, iprot):
19602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19604 
      return
19605 
    iprot.readStructBegin()
19606 
    while True:
19607 
      (fname, ftype, fid) = iprot.readFieldBegin()
19608 
      if ftype == TType.STOP:
19609 
        break
19610 
      if fid == 1:
19611 
        if ftype == TType.BOOL:
19612 
          self.onlyNotProcessed = iprot.readBool();
19613 
        else:
19614 
          iprot.skip(ftype)
19615 
      elif fid == 2:
19616 
        if ftype == TType.I64:
19617 
          self.fromDate = iprot.readI64();
19618 
        else:
19619 
          iprot.skip(ftype)
19620 
      elif fid == 3:
19621 
        if ftype == TType.I64:
19622 
          self.toDate = iprot.readI64();
19623 
        else:
19624 
          iprot.skip(ftype)
19625 
      else:
19626 
        iprot.skip(ftype)
19627 
      iprot.readFieldEnd()
19628 
    iprot.readStructEnd()
19629 
 
19630 
  def write(self, oprot):
19631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19633 
      return
19634 
    oprot.writeStructBegin('getAllReturnOrders_args')
19635 
    if self.onlyNotProcessed is not None:
19636 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
19637 
      oprot.writeBool(self.onlyNotProcessed)
19638 
      oprot.writeFieldEnd()
19639 
    if self.fromDate is not None:
19640 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19641 
      oprot.writeI64(self.fromDate)
19642 
      oprot.writeFieldEnd()
19643 
    if self.toDate is not None:
19644 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19645 
      oprot.writeI64(self.toDate)
19646 
      oprot.writeFieldEnd()
19647 
    oprot.writeFieldStop()
19648 
    oprot.writeStructEnd()
19649 
 
19650 
  def validate(self):
19651 
    return
19652 
 
19653 
 
19654 
  def __repr__(self):
19655 
    L = ['%s=%r' % (key, value)
19656 
      for key, value in self.__dict__.iteritems()]
19657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19658 
 
19659 
  def __eq__(self, other):
19660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19661 
 
19662 
  def __ne__(self, other):
19663 
    return not (self == other)
19664 
 
19665 
class getAllReturnOrders_result:
19666 
  """
19667 
  Attributes:
19668 
   - success
19669 
  """
19670 
 
19671 
  thrift_spec = (
19672 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19673 
  )
19674 
 
19675 
  def __init__(self, success=None,):
19676 
    self.success = success
19677 
 
19678 
  def read(self, iprot):
19679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19681 
      return
19682 
    iprot.readStructBegin()
19683 
    while True:
19684 
      (fname, ftype, fid) = iprot.readFieldBegin()
19685 
      if ftype == TType.STOP:
19686 
        break
19687 
      if fid == 0:
19688 
        if ftype == TType.LIST:
19689 
          self.success = []
6188 rajveer 19690 
          (_etype449, _size446) = iprot.readListBegin()
19691 
          for _i450 in xrange(_size446):
19692 
            _elem451 = ReturnOrder()
19693 
            _elem451.read(iprot)
19694 
            self.success.append(_elem451)
5481 phani.kuma 19695 
          iprot.readListEnd()
19696 
        else:
19697 
          iprot.skip(ftype)
19698 
      else:
19699 
        iprot.skip(ftype)
19700 
      iprot.readFieldEnd()
19701 
    iprot.readStructEnd()
19702 
 
19703 
  def write(self, oprot):
19704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19706 
      return
19707 
    oprot.writeStructBegin('getAllReturnOrders_result')
19708 
    if self.success is not None:
19709 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19710 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19711 
      for iter452 in self.success:
19712 
        iter452.write(oprot)
5481 phani.kuma 19713 
      oprot.writeListEnd()
19714 
      oprot.writeFieldEnd()
19715 
    oprot.writeFieldStop()
19716 
    oprot.writeStructEnd()
19717 
 
19718 
  def validate(self):
19719 
    return
19720 
 
19721 
 
19722 
  def __repr__(self):
19723 
    L = ['%s=%r' % (key, value)
19724 
      for key, value in self.__dict__.iteritems()]
19725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19726 
 
19727 
  def __eq__(self, other):
19728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19729 
 
19730 
  def __ne__(self, other):
19731 
    return not (self == other)
19732 
 
2700 chandransh 19733 
class getReturnOrder_args:
19734 
  """
19735 
  Attributes:
19736 
   - id
19737 
  """
19738 
 
19739 
  thrift_spec = (
19740 
    None, # 0
19741 
    (1, TType.I64, 'id', None, None, ), # 1
19742 
  )
19743 
 
19744 
  def __init__(self, id=None,):
19745 
    self.id = id
19746 
 
19747 
  def read(self, iprot):
19748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19750 
      return
19751 
    iprot.readStructBegin()
19752 
    while True:
19753 
      (fname, ftype, fid) = iprot.readFieldBegin()
19754 
      if ftype == TType.STOP:
19755 
        break
19756 
      if fid == 1:
19757 
        if ftype == TType.I64:
19758 
          self.id = iprot.readI64();
19759 
        else:
19760 
          iprot.skip(ftype)
19761 
      else:
19762 
        iprot.skip(ftype)
19763 
      iprot.readFieldEnd()
19764 
    iprot.readStructEnd()
19765 
 
19766 
  def write(self, oprot):
19767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19769 
      return
19770 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 19771 
    if self.id is not None:
2700 chandransh 19772 
      oprot.writeFieldBegin('id', TType.I64, 1)
19773 
      oprot.writeI64(self.id)
19774 
      oprot.writeFieldEnd()
19775 
    oprot.writeFieldStop()
19776 
    oprot.writeStructEnd()
19777 
 
3431 rajveer 19778 
  def validate(self):
19779 
    return
19780 
 
19781 
 
2700 chandransh 19782 
  def __repr__(self):
19783 
    L = ['%s=%r' % (key, value)
19784 
      for key, value in self.__dict__.iteritems()]
19785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19786 
 
19787 
  def __eq__(self, other):
19788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19789 
 
19790 
  def __ne__(self, other):
19791 
    return not (self == other)
19792 
 
19793 
class getReturnOrder_result:
19794 
  """
19795 
  Attributes:
19796 
   - success
19797 
   - ex
19798 
  """
19799 
 
19800 
  thrift_spec = (
19801 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
19802 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19803 
  )
19804 
 
19805 
  def __init__(self, success=None, ex=None,):
19806 
    self.success = success
19807 
    self.ex = ex
19808 
 
19809 
  def read(self, iprot):
19810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19812 
      return
19813 
    iprot.readStructBegin()
19814 
    while True:
19815 
      (fname, ftype, fid) = iprot.readFieldBegin()
19816 
      if ftype == TType.STOP:
19817 
        break
19818 
      if fid == 0:
19819 
        if ftype == TType.STRUCT:
19820 
          self.success = ReturnOrder()
19821 
          self.success.read(iprot)
19822 
        else:
19823 
          iprot.skip(ftype)
19824 
      elif fid == 1:
19825 
        if ftype == TType.STRUCT:
19826 
          self.ex = TransactionServiceException()
19827 
          self.ex.read(iprot)
19828 
        else:
19829 
          iprot.skip(ftype)
19830 
      else:
19831 
        iprot.skip(ftype)
19832 
      iprot.readFieldEnd()
19833 
    iprot.readStructEnd()
19834 
 
19835 
  def write(self, oprot):
19836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19838 
      return
19839 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 19840 
    if self.success is not None:
2700 chandransh 19841 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19842 
      self.success.write(oprot)
19843 
      oprot.writeFieldEnd()
3431 rajveer 19844 
    if self.ex is not None:
2700 chandransh 19845 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19846 
      self.ex.write(oprot)
19847 
      oprot.writeFieldEnd()
19848 
    oprot.writeFieldStop()
19849 
    oprot.writeStructEnd()
19850 
 
3431 rajveer 19851 
  def validate(self):
19852 
    return
19853 
 
19854 
 
2700 chandransh 19855 
  def __repr__(self):
19856 
    L = ['%s=%r' % (key, value)
19857 
      for key, value in self.__dict__.iteritems()]
19858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19859 
 
19860 
  def __eq__(self, other):
19861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19862 
 
19863 
  def __ne__(self, other):
19864 
    return not (self == other)
19865 
 
2690 chandransh 19866 
class processReturn_args:
19867 
  """
19868 
  Attributes:
19869 
   - returnOrderId
19870 
  """
19871 
 
19872 
  thrift_spec = (
19873 
    None, # 0
19874 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
19875 
  )
19876 
 
19877 
  def __init__(self, returnOrderId=None,):
19878 
    self.returnOrderId = returnOrderId
19879 
 
19880 
  def read(self, iprot):
19881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19883 
      return
19884 
    iprot.readStructBegin()
19885 
    while True:
19886 
      (fname, ftype, fid) = iprot.readFieldBegin()
19887 
      if ftype == TType.STOP:
19888 
        break
19889 
      if fid == 1:
19890 
        if ftype == TType.I64:
19891 
          self.returnOrderId = iprot.readI64();
19892 
        else:
19893 
          iprot.skip(ftype)
19894 
      else:
19895 
        iprot.skip(ftype)
19896 
      iprot.readFieldEnd()
19897 
    iprot.readStructEnd()
19898 
 
19899 
  def write(self, oprot):
19900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19902 
      return
19903 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 19904 
    if self.returnOrderId is not None:
2690 chandransh 19905 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
19906 
      oprot.writeI64(self.returnOrderId)
19907 
      oprot.writeFieldEnd()
19908 
    oprot.writeFieldStop()
19909 
    oprot.writeStructEnd()
19910 
 
3431 rajveer 19911 
  def validate(self):
19912 
    return
19913 
 
19914 
 
2690 chandransh 19915 
  def __repr__(self):
19916 
    L = ['%s=%r' % (key, value)
19917 
      for key, value in self.__dict__.iteritems()]
19918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19919 
 
19920 
  def __eq__(self, other):
19921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19922 
 
19923 
  def __ne__(self, other):
19924 
    return not (self == other)
19925 
 
19926 
class processReturn_result:
19927 
  """
19928 
  Attributes:
19929 
   - ex
19930 
  """
19931 
 
19932 
  thrift_spec = (
19933 
    None, # 0
19934 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19935 
  )
19936 
 
19937 
  def __init__(self, ex=None,):
19938 
    self.ex = ex
19939 
 
19940 
  def read(self, iprot):
19941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19943 
      return
19944 
    iprot.readStructBegin()
19945 
    while True:
19946 
      (fname, ftype, fid) = iprot.readFieldBegin()
19947 
      if ftype == TType.STOP:
19948 
        break
19949 
      if fid == 1:
19950 
        if ftype == TType.STRUCT:
19951 
          self.ex = TransactionServiceException()
19952 
          self.ex.read(iprot)
19953 
        else:
19954 
          iprot.skip(ftype)
19955 
      else:
19956 
        iprot.skip(ftype)
19957 
      iprot.readFieldEnd()
19958 
    iprot.readStructEnd()
19959 
 
19960 
  def write(self, oprot):
19961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19963 
      return
19964 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 19965 
    if self.ex is not None:
2690 chandransh 19966 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19967 
      self.ex.write(oprot)
19968 
      oprot.writeFieldEnd()
19969 
    oprot.writeFieldStop()
19970 
    oprot.writeStructEnd()
19971 
 
3431 rajveer 19972 
  def validate(self):
19973 
    return
19974 
 
19975 
 
2690 chandransh 19976 
  def __repr__(self):
19977 
    L = ['%s=%r' % (key, value)
19978 
      for key, value in self.__dict__.iteritems()]
19979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19980 
 
19981 
  def __eq__(self, other):
19982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19983 
 
19984 
  def __ne__(self, other):
19985 
    return not (self == other)
19986 
 
3451 chandransh 19987 
class updateWeight_args:
19988 
  """
19989 
  Attributes:
19990 
   - orderId
19991 
   - weight
19992 
  """
19993 
 
19994 
  thrift_spec = (
19995 
    None, # 0
19996 
    (1, TType.I64, 'orderId', None, None, ), # 1
19997 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
19998 
  )
19999 
 
20000 
  def __init__(self, orderId=None, weight=None,):
20001 
    self.orderId = orderId
20002 
    self.weight = weight
20003 
 
20004 
  def read(self, iprot):
20005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20007 
      return
20008 
    iprot.readStructBegin()
20009 
    while True:
20010 
      (fname, ftype, fid) = iprot.readFieldBegin()
20011 
      if ftype == TType.STOP:
20012 
        break
20013 
      if fid == 1:
20014 
        if ftype == TType.I64:
20015 
          self.orderId = iprot.readI64();
20016 
        else:
20017 
          iprot.skip(ftype)
20018 
      elif fid == 2:
20019 
        if ftype == TType.DOUBLE:
20020 
          self.weight = iprot.readDouble();
20021 
        else:
20022 
          iprot.skip(ftype)
20023 
      else:
20024 
        iprot.skip(ftype)
20025 
      iprot.readFieldEnd()
20026 
    iprot.readStructEnd()
20027 
 
20028 
  def write(self, oprot):
20029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20031 
      return
20032 
    oprot.writeStructBegin('updateWeight_args')
20033 
    if self.orderId is not None:
20034 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20035 
      oprot.writeI64(self.orderId)
20036 
      oprot.writeFieldEnd()
20037 
    if self.weight is not None:
20038 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
20039 
      oprot.writeDouble(self.weight)
20040 
      oprot.writeFieldEnd()
20041 
    oprot.writeFieldStop()
20042 
    oprot.writeStructEnd()
20043 
 
20044 
  def validate(self):
20045 
    return
20046 
 
20047 
 
20048 
  def __repr__(self):
20049 
    L = ['%s=%r' % (key, value)
20050 
      for key, value in self.__dict__.iteritems()]
20051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20052 
 
20053 
  def __eq__(self, other):
20054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20055 
 
20056 
  def __ne__(self, other):
20057 
    return not (self == other)
20058 
 
20059 
class updateWeight_result:
20060 
  """
20061 
  Attributes:
20062 
   - success
20063 
   - ex
20064 
  """
20065 
 
20066 
  thrift_spec = (
20067 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20068 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20069 
  )
20070 
 
20071 
  def __init__(self, success=None, ex=None,):
20072 
    self.success = success
20073 
    self.ex = ex
20074 
 
20075 
  def read(self, iprot):
20076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20078 
      return
20079 
    iprot.readStructBegin()
20080 
    while True:
20081 
      (fname, ftype, fid) = iprot.readFieldBegin()
20082 
      if ftype == TType.STOP:
20083 
        break
20084 
      if fid == 0:
20085 
        if ftype == TType.STRUCT:
20086 
          self.success = Order()
20087 
          self.success.read(iprot)
20088 
        else:
20089 
          iprot.skip(ftype)
20090 
      elif fid == 1:
20091 
        if ftype == TType.STRUCT:
20092 
          self.ex = TransactionServiceException()
20093 
          self.ex.read(iprot)
20094 
        else:
20095 
          iprot.skip(ftype)
20096 
      else:
20097 
        iprot.skip(ftype)
20098 
      iprot.readFieldEnd()
20099 
    iprot.readStructEnd()
20100 
 
20101 
  def write(self, oprot):
20102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20104 
      return
20105 
    oprot.writeStructBegin('updateWeight_result')
20106 
    if self.success is not None:
20107 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20108 
      self.success.write(oprot)
20109 
      oprot.writeFieldEnd()
20110 
    if self.ex is not None:
20111 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20112 
      self.ex.write(oprot)
20113 
      oprot.writeFieldEnd()
20114 
    oprot.writeFieldStop()
20115 
    oprot.writeStructEnd()
20116 
 
20117 
  def validate(self):
20118 
    return
20119 
 
20120 
 
20121 
  def __repr__(self):
20122 
    L = ['%s=%r' % (key, value)
20123 
      for key, value in self.__dict__.iteritems()]
20124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20125 
 
20126 
  def __eq__(self, other):
20127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20128 
 
20129 
  def __ne__(self, other):
20130 
    return not (self == other)
3469 chandransh 20131 
 
20132 
class changeItem_args:
20133 
  """
20134 
  Attributes:
20135 
   - orderId
20136 
   - itemId
20137 
  """
20138 
 
20139 
  thrift_spec = (
20140 
    None, # 0
20141 
    (1, TType.I64, 'orderId', None, None, ), # 1
20142 
    (2, TType.I64, 'itemId', None, None, ), # 2
20143 
  )
20144 
 
20145 
  def __init__(self, orderId=None, itemId=None,):
20146 
    self.orderId = orderId
20147 
    self.itemId = itemId
20148 
 
20149 
  def read(self, iprot):
20150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20152 
      return
20153 
    iprot.readStructBegin()
20154 
    while True:
20155 
      (fname, ftype, fid) = iprot.readFieldBegin()
20156 
      if ftype == TType.STOP:
20157 
        break
20158 
      if fid == 1:
20159 
        if ftype == TType.I64:
20160 
          self.orderId = iprot.readI64();
20161 
        else:
20162 
          iprot.skip(ftype)
20163 
      elif fid == 2:
20164 
        if ftype == TType.I64:
20165 
          self.itemId = iprot.readI64();
20166 
        else:
20167 
          iprot.skip(ftype)
20168 
      else:
20169 
        iprot.skip(ftype)
20170 
      iprot.readFieldEnd()
20171 
    iprot.readStructEnd()
20172 
 
20173 
  def write(self, oprot):
20174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20176 
      return
20177 
    oprot.writeStructBegin('changeItem_args')
20178 
    if self.orderId is not None:
20179 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20180 
      oprot.writeI64(self.orderId)
20181 
      oprot.writeFieldEnd()
20182 
    if self.itemId is not None:
20183 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20184 
      oprot.writeI64(self.itemId)
20185 
      oprot.writeFieldEnd()
20186 
    oprot.writeFieldStop()
20187 
    oprot.writeStructEnd()
20188 
 
20189 
  def validate(self):
20190 
    return
20191 
 
20192 
 
20193 
  def __repr__(self):
20194 
    L = ['%s=%r' % (key, value)
20195 
      for key, value in self.__dict__.iteritems()]
20196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20197 
 
20198 
  def __eq__(self, other):
20199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20200 
 
20201 
  def __ne__(self, other):
20202 
    return not (self == other)
20203 
 
20204 
class changeItem_result:
20205 
  """
20206 
  Attributes:
20207 
   - success
20208 
   - ex
20209 
  """
20210 
 
20211 
  thrift_spec = (
20212 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20213 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20214 
  )
20215 
 
20216 
  def __init__(self, success=None, ex=None,):
20217 
    self.success = success
20218 
    self.ex = ex
20219 
 
20220 
  def read(self, iprot):
20221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20223 
      return
20224 
    iprot.readStructBegin()
20225 
    while True:
20226 
      (fname, ftype, fid) = iprot.readFieldBegin()
20227 
      if ftype == TType.STOP:
20228 
        break
20229 
      if fid == 0:
20230 
        if ftype == TType.STRUCT:
20231 
          self.success = Order()
20232 
          self.success.read(iprot)
20233 
        else:
20234 
          iprot.skip(ftype)
20235 
      elif fid == 1:
20236 
        if ftype == TType.STRUCT:
20237 
          self.ex = TransactionServiceException()
20238 
          self.ex.read(iprot)
20239 
        else:
20240 
          iprot.skip(ftype)
20241 
      else:
20242 
        iprot.skip(ftype)
20243 
      iprot.readFieldEnd()
20244 
    iprot.readStructEnd()
20245 
 
20246 
  def write(self, oprot):
20247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20249 
      return
20250 
    oprot.writeStructBegin('changeItem_result')
20251 
    if self.success is not None:
20252 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20253 
      self.success.write(oprot)
20254 
      oprot.writeFieldEnd()
20255 
    if self.ex is not None:
20256 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20257 
      self.ex.write(oprot)
20258 
      oprot.writeFieldEnd()
20259 
    oprot.writeFieldStop()
20260 
    oprot.writeStructEnd()
20261 
 
20262 
  def validate(self):
20263 
    return
20264 
 
20265 
 
20266 
  def __repr__(self):
20267 
    L = ['%s=%r' % (key, value)
20268 
      for key, value in self.__dict__.iteritems()]
20269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20270 
 
20271 
  def __eq__(self, other):
20272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20273 
 
20274 
  def __ne__(self, other):
20275 
    return not (self == other)
20276 
 
20277 
class shiftToWarehouse_args:
20278 
  """
20279 
  Attributes:
20280 
   - orderId
20281 
   - warehouseId
20282 
  """
20283 
 
20284 
  thrift_spec = (
20285 
    None, # 0
20286 
    (1, TType.I64, 'orderId', None, None, ), # 1
20287 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
20288 
  )
20289 
 
20290 
  def __init__(self, orderId=None, warehouseId=None,):
20291 
    self.orderId = orderId
20292 
    self.warehouseId = warehouseId
20293 
 
20294 
  def read(self, iprot):
20295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20297 
      return
20298 
    iprot.readStructBegin()
20299 
    while True:
20300 
      (fname, ftype, fid) = iprot.readFieldBegin()
20301 
      if ftype == TType.STOP:
20302 
        break
20303 
      if fid == 1:
20304 
        if ftype == TType.I64:
20305 
          self.orderId = iprot.readI64();
20306 
        else:
20307 
          iprot.skip(ftype)
20308 
      elif fid == 2:
20309 
        if ftype == TType.I64:
20310 
          self.warehouseId = iprot.readI64();
20311 
        else:
20312 
          iprot.skip(ftype)
20313 
      else:
20314 
        iprot.skip(ftype)
20315 
      iprot.readFieldEnd()
20316 
    iprot.readStructEnd()
20317 
 
20318 
  def write(self, oprot):
20319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20321 
      return
20322 
    oprot.writeStructBegin('shiftToWarehouse_args')
20323 
    if self.orderId is not None:
20324 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20325 
      oprot.writeI64(self.orderId)
20326 
      oprot.writeFieldEnd()
20327 
    if self.warehouseId is not None:
20328 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
20329 
      oprot.writeI64(self.warehouseId)
20330 
      oprot.writeFieldEnd()
20331 
    oprot.writeFieldStop()
20332 
    oprot.writeStructEnd()
20333 
 
20334 
  def validate(self):
20335 
    return
20336 
 
20337 
 
20338 
  def __repr__(self):
20339 
    L = ['%s=%r' % (key, value)
20340 
      for key, value in self.__dict__.iteritems()]
20341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20342 
 
20343 
  def __eq__(self, other):
20344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20345 
 
20346 
  def __ne__(self, other):
20347 
    return not (self == other)
20348 
 
20349 
class shiftToWarehouse_result:
20350 
  """
20351 
  Attributes:
20352 
   - success
20353 
   - ex
20354 
  """
20355 
 
20356 
  thrift_spec = (
20357 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20358 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20359 
  )
20360 
 
20361 
  def __init__(self, success=None, ex=None,):
20362 
    self.success = success
20363 
    self.ex = ex
20364 
 
20365 
  def read(self, iprot):
20366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20368 
      return
20369 
    iprot.readStructBegin()
20370 
    while True:
20371 
      (fname, ftype, fid) = iprot.readFieldBegin()
20372 
      if ftype == TType.STOP:
20373 
        break
20374 
      if fid == 0:
20375 
        if ftype == TType.STRUCT:
20376 
          self.success = Order()
20377 
          self.success.read(iprot)
20378 
        else:
20379 
          iprot.skip(ftype)
20380 
      elif fid == 1:
20381 
        if ftype == TType.STRUCT:
20382 
          self.ex = TransactionServiceException()
20383 
          self.ex.read(iprot)
20384 
        else:
20385 
          iprot.skip(ftype)
20386 
      else:
20387 
        iprot.skip(ftype)
20388 
      iprot.readFieldEnd()
20389 
    iprot.readStructEnd()
20390 
 
20391 
  def write(self, oprot):
20392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20394 
      return
20395 
    oprot.writeStructBegin('shiftToWarehouse_result')
20396 
    if self.success is not None:
20397 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20398 
      self.success.write(oprot)
20399 
      oprot.writeFieldEnd()
20400 
    if self.ex is not None:
20401 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20402 
      self.ex.write(oprot)
20403 
      oprot.writeFieldEnd()
20404 
    oprot.writeFieldStop()
20405 
    oprot.writeStructEnd()
20406 
 
20407 
  def validate(self):
20408 
    return
20409 
 
20410 
 
20411 
  def __repr__(self):
20412 
    L = ['%s=%r' % (key, value)
20413 
      for key, value in self.__dict__.iteritems()]
20414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20415 
 
20416 
  def __eq__(self, other):
20417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20418 
 
20419 
  def __ne__(self, other):
20420 
    return not (self == other)
3553 chandransh 20421 
 
20422 
class addDelayReason_args:
20423 
  """
20424 
  Attributes:
20425 
   - orderId
20426 
   - delayReason
3986 chandransh 20427 
   - furtherDelay
4647 rajveer 20428 
   - delayReasonText
3553 chandransh 20429 
  """
20430 
 
20431 
  thrift_spec = (
20432 
    None, # 0
20433 
    (1, TType.I64, 'orderId', None, None, ), # 1
20434 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 20435 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 20436 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 20437 
  )
20438 
 
4647 rajveer 20439 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 20440 
    self.orderId = orderId
20441 
    self.delayReason = delayReason
3986 chandransh 20442 
    self.furtherDelay = furtherDelay
4647 rajveer 20443 
    self.delayReasonText = delayReasonText
3553 chandransh 20444 
 
20445 
  def read(self, iprot):
20446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20448 
      return
20449 
    iprot.readStructBegin()
20450 
    while True:
20451 
      (fname, ftype, fid) = iprot.readFieldBegin()
20452 
      if ftype == TType.STOP:
20453 
        break
20454 
      if fid == 1:
20455 
        if ftype == TType.I64:
20456 
          self.orderId = iprot.readI64();
20457 
        else:
20458 
          iprot.skip(ftype)
20459 
      elif fid == 2:
20460 
        if ftype == TType.I32:
20461 
          self.delayReason = iprot.readI32();
20462 
        else:
20463 
          iprot.skip(ftype)
3986 chandransh 20464 
      elif fid == 3:
20465 
        if ftype == TType.I64:
20466 
          self.furtherDelay = iprot.readI64();
20467 
        else:
20468 
          iprot.skip(ftype)
4647 rajveer 20469 
      elif fid == 4:
20470 
        if ftype == TType.STRING:
20471 
          self.delayReasonText = iprot.readString();
20472 
        else:
20473 
          iprot.skip(ftype)
3553 chandransh 20474 
      else:
20475 
        iprot.skip(ftype)
20476 
      iprot.readFieldEnd()
20477 
    iprot.readStructEnd()
20478 
 
20479 
  def write(self, oprot):
20480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20482 
      return
20483 
    oprot.writeStructBegin('addDelayReason_args')
20484 
    if self.orderId is not None:
20485 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20486 
      oprot.writeI64(self.orderId)
20487 
      oprot.writeFieldEnd()
20488 
    if self.delayReason is not None:
20489 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
20490 
      oprot.writeI32(self.delayReason)
20491 
      oprot.writeFieldEnd()
3986 chandransh 20492 
    if self.furtherDelay is not None:
20493 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
20494 
      oprot.writeI64(self.furtherDelay)
20495 
      oprot.writeFieldEnd()
4647 rajveer 20496 
    if self.delayReasonText is not None:
20497 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
20498 
      oprot.writeString(self.delayReasonText)
20499 
      oprot.writeFieldEnd()
3553 chandransh 20500 
    oprot.writeFieldStop()
20501 
    oprot.writeStructEnd()
20502 
 
20503 
  def validate(self):
20504 
    return
20505 
 
20506 
 
20507 
  def __repr__(self):
20508 
    L = ['%s=%r' % (key, value)
20509 
      for key, value in self.__dict__.iteritems()]
20510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20511 
 
20512 
  def __eq__(self, other):
20513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20514 
 
20515 
  def __ne__(self, other):
20516 
    return not (self == other)
20517 
 
20518 
class addDelayReason_result:
20519 
  """
20520 
  Attributes:
20521 
   - success
20522 
   - ex
20523 
  """
20524 
 
20525 
  thrift_spec = (
20526 
    (0, TType.BOOL, 'success', None, None, ), # 0
20527 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20528 
  )
20529 
 
20530 
  def __init__(self, success=None, ex=None,):
20531 
    self.success = success
20532 
    self.ex = ex
20533 
 
20534 
  def read(self, iprot):
20535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20537 
      return
20538 
    iprot.readStructBegin()
20539 
    while True:
20540 
      (fname, ftype, fid) = iprot.readFieldBegin()
20541 
      if ftype == TType.STOP:
20542 
        break
20543 
      if fid == 0:
20544 
        if ftype == TType.BOOL:
20545 
          self.success = iprot.readBool();
20546 
        else:
20547 
          iprot.skip(ftype)
20548 
      elif fid == 1:
20549 
        if ftype == TType.STRUCT:
20550 
          self.ex = TransactionServiceException()
20551 
          self.ex.read(iprot)
20552 
        else:
20553 
          iprot.skip(ftype)
20554 
      else:
20555 
        iprot.skip(ftype)
20556 
      iprot.readFieldEnd()
20557 
    iprot.readStructEnd()
20558 
 
20559 
  def write(self, oprot):
20560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20562 
      return
20563 
    oprot.writeStructBegin('addDelayReason_result')
20564 
    if self.success is not None:
20565 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20566 
      oprot.writeBool(self.success)
20567 
      oprot.writeFieldEnd()
20568 
    if self.ex is not None:
20569 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20570 
      self.ex.write(oprot)
20571 
      oprot.writeFieldEnd()
20572 
    oprot.writeFieldStop()
20573 
    oprot.writeStructEnd()
20574 
 
20575 
  def validate(self):
20576 
    return
20577 
 
20578 
 
20579 
  def __repr__(self):
20580 
    L = ['%s=%r' % (key, value)
20581 
      for key, value in self.__dict__.iteritems()]
20582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20583 
 
20584 
  def __eq__(self, other):
20585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20586 
 
20587 
  def __ne__(self, other):
20588 
    return not (self == other)
3956 chandransh 20589 
 
20590 
class reconcileCodCollection_args:
20591 
  """
20592 
  Attributes:
20593 
   - collectedAmountMap
20594 
   - xferBy
20595 
   - xferTxnId
20596 
   - xferDate
20597 
  """
20598 
 
20599 
  thrift_spec = (
20600 
    None, # 0
20601 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
20602 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
20603 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
20604 
    (4, TType.I64, 'xferDate', None, None, ), # 4
20605 
  )
20606 
 
20607 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
20608 
    self.collectedAmountMap = collectedAmountMap
20609 
    self.xferBy = xferBy
20610 
    self.xferTxnId = xferTxnId
20611 
    self.xferDate = xferDate
20612 
 
20613 
  def read(self, iprot):
20614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20616 
      return
20617 
    iprot.readStructBegin()
20618 
    while True:
20619 
      (fname, ftype, fid) = iprot.readFieldBegin()
20620 
      if ftype == TType.STOP:
20621 
        break
20622 
      if fid == 1:
20623 
        if ftype == TType.MAP:
20624 
          self.collectedAmountMap = {}
6188 rajveer 20625 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
20626 
          for _i457 in xrange(_size453):
20627 
            _key458 = iprot.readString();
20628 
            _val459 = iprot.readDouble();
20629 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 20630 
          iprot.readMapEnd()
20631 
        else:
20632 
          iprot.skip(ftype)
20633 
      elif fid == 2:
20634 
        if ftype == TType.STRING:
20635 
          self.xferBy = iprot.readString();
20636 
        else:
20637 
          iprot.skip(ftype)
20638 
      elif fid == 3:
20639 
        if ftype == TType.STRING:
20640 
          self.xferTxnId = iprot.readString();
20641 
        else:
20642 
          iprot.skip(ftype)
20643 
      elif fid == 4:
20644 
        if ftype == TType.I64:
20645 
          self.xferDate = iprot.readI64();
20646 
        else:
20647 
          iprot.skip(ftype)
20648 
      else:
20649 
        iprot.skip(ftype)
20650 
      iprot.readFieldEnd()
20651 
    iprot.readStructEnd()
20652 
 
20653 
  def write(self, oprot):
20654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20656 
      return
20657 
    oprot.writeStructBegin('reconcileCodCollection_args')
20658 
    if self.collectedAmountMap is not None:
20659 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
20660 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 20661 
      for kiter460,viter461 in self.collectedAmountMap.items():
20662 
        oprot.writeString(kiter460)
20663 
        oprot.writeDouble(viter461)
3956 chandransh 20664 
      oprot.writeMapEnd()
20665 
      oprot.writeFieldEnd()
20666 
    if self.xferBy is not None:
20667 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
20668 
      oprot.writeString(self.xferBy)
20669 
      oprot.writeFieldEnd()
20670 
    if self.xferTxnId is not None:
20671 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
20672 
      oprot.writeString(self.xferTxnId)
20673 
      oprot.writeFieldEnd()
20674 
    if self.xferDate is not None:
20675 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
20676 
      oprot.writeI64(self.xferDate)
20677 
      oprot.writeFieldEnd()
20678 
    oprot.writeFieldStop()
20679 
    oprot.writeStructEnd()
20680 
 
20681 
  def validate(self):
20682 
    return
20683 
 
20684 
 
20685 
  def __repr__(self):
20686 
    L = ['%s=%r' % (key, value)
20687 
      for key, value in self.__dict__.iteritems()]
20688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20689 
 
20690 
  def __eq__(self, other):
20691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20692 
 
20693 
  def __ne__(self, other):
20694 
    return not (self == other)
20695 
 
20696 
class reconcileCodCollection_result:
20697 
  """
20698 
  Attributes:
20699 
   - success
20700 
   - ex
20701 
  """
20702 
 
20703 
  thrift_spec = (
20704 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
20705 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20706 
  )
20707 
 
20708 
  def __init__(self, success=None, ex=None,):
20709 
    self.success = success
20710 
    self.ex = ex
20711 
 
20712 
  def read(self, iprot):
20713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20715 
      return
20716 
    iprot.readStructBegin()
20717 
    while True:
20718 
      (fname, ftype, fid) = iprot.readFieldBegin()
20719 
      if ftype == TType.STOP:
20720 
        break
20721 
      if fid == 0:
20722 
        if ftype == TType.MAP:
20723 
          self.success = {}
6188 rajveer 20724 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20725 
          for _i466 in xrange(_size462):
20726 
            _key467 = iprot.readString();
20727 
            _val468 = iprot.readString();
20728 
            self.success[_key467] = _val468
3956 chandransh 20729 
          iprot.readMapEnd()
20730 
        else:
20731 
          iprot.skip(ftype)
20732 
      elif fid == 1:
20733 
        if ftype == TType.STRUCT:
20734 
          self.ex = TransactionServiceException()
20735 
          self.ex.read(iprot)
20736 
        else:
20737 
          iprot.skip(ftype)
20738 
      else:
20739 
        iprot.skip(ftype)
20740 
      iprot.readFieldEnd()
20741 
    iprot.readStructEnd()
20742 
 
20743 
  def write(self, oprot):
20744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20746 
      return
20747 
    oprot.writeStructBegin('reconcileCodCollection_result')
20748 
    if self.success is not None:
20749 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20750 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 20751 
      for kiter469,viter470 in self.success.items():
20752 
        oprot.writeString(kiter469)
20753 
        oprot.writeString(viter470)
3956 chandransh 20754 
      oprot.writeMapEnd()
20755 
      oprot.writeFieldEnd()
20756 
    if self.ex is not None:
20757 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20758 
      self.ex.write(oprot)
20759 
      oprot.writeFieldEnd()
20760 
    oprot.writeFieldStop()
20761 
    oprot.writeStructEnd()
20762 
 
20763 
  def validate(self):
20764 
    return
20765 
 
20766 
 
20767 
  def __repr__(self):
20768 
    L = ['%s=%r' % (key, value)
20769 
      for key, value in self.__dict__.iteritems()]
20770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20771 
 
20772 
  def __eq__(self, other):
20773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20774 
 
20775 
  def __ne__(self, other):
20776 
    return not (self == other)
4008 mandeep.dh 20777 
 
20778 
class getTransactionsRequiringExtraProcessing_args:
20779 
  """
20780 
  Attributes:
20781 
   - category
20782 
  """
20783 
 
20784 
  thrift_spec = (
20785 
    None, # 0
20786 
    (1, TType.I32, 'category', None, None, ), # 1
20787 
  )
20788 
 
20789 
  def __init__(self, category=None,):
20790 
    self.category = category
20791 
 
20792 
  def read(self, iprot):
20793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20795 
      return
20796 
    iprot.readStructBegin()
20797 
    while True:
20798 
      (fname, ftype, fid) = iprot.readFieldBegin()
20799 
      if ftype == TType.STOP:
20800 
        break
20801 
      if fid == 1:
20802 
        if ftype == TType.I32:
20803 
          self.category = iprot.readI32();
20804 
        else:
20805 
          iprot.skip(ftype)
20806 
      else:
20807 
        iprot.skip(ftype)
20808 
      iprot.readFieldEnd()
20809 
    iprot.readStructEnd()
20810 
 
20811 
  def write(self, oprot):
20812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20814 
      return
20815 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
20816 
    if self.category is not None:
20817 
      oprot.writeFieldBegin('category', TType.I32, 1)
20818 
      oprot.writeI32(self.category)
20819 
      oprot.writeFieldEnd()
20820 
    oprot.writeFieldStop()
20821 
    oprot.writeStructEnd()
20822 
 
20823 
  def validate(self):
20824 
    return
20825 
 
20826 
 
20827 
  def __repr__(self):
20828 
    L = ['%s=%r' % (key, value)
20829 
      for key, value in self.__dict__.iteritems()]
20830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20831 
 
20832 
  def __eq__(self, other):
20833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20834 
 
20835 
  def __ne__(self, other):
20836 
    return not (self == other)
20837 
 
20838 
class getTransactionsRequiringExtraProcessing_result:
20839 
  """
20840 
  Attributes:
20841 
   - success
20842 
  """
20843 
 
20844 
  thrift_spec = (
20845 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
20846 
  )
20847 
 
20848 
  def __init__(self, success=None,):
20849 
    self.success = success
20850 
 
20851 
  def read(self, iprot):
20852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20854 
      return
20855 
    iprot.readStructBegin()
20856 
    while True:
20857 
      (fname, ftype, fid) = iprot.readFieldBegin()
20858 
      if ftype == TType.STOP:
20859 
        break
20860 
      if fid == 0:
20861 
        if ftype == TType.LIST:
20862 
          self.success = []
6188 rajveer 20863 
          (_etype474, _size471) = iprot.readListBegin()
20864 
          for _i475 in xrange(_size471):
20865 
            _elem476 = iprot.readI64();
20866 
            self.success.append(_elem476)
4008 mandeep.dh 20867 
          iprot.readListEnd()
20868 
        else:
20869 
          iprot.skip(ftype)
20870 
      else:
20871 
        iprot.skip(ftype)
20872 
      iprot.readFieldEnd()
20873 
    iprot.readStructEnd()
20874 
 
20875 
  def write(self, oprot):
20876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20878 
      return
20879 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
20880 
    if self.success is not None:
20881 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20882 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 20883 
      for iter477 in self.success:
20884 
        oprot.writeI64(iter477)
4008 mandeep.dh 20885 
      oprot.writeListEnd()
20886 
      oprot.writeFieldEnd()
20887 
    oprot.writeFieldStop()
20888 
    oprot.writeStructEnd()
20889 
 
20890 
  def validate(self):
20891 
    return
20892 
 
20893 
 
20894 
  def __repr__(self):
20895 
    L = ['%s=%r' % (key, value)
20896 
      for key, value in self.__dict__.iteritems()]
20897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20898 
 
20899 
  def __eq__(self, other):
20900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20901 
 
20902 
  def __ne__(self, other):
20903 
    return not (self == other)
20904 
 
20905 
class markTransactionAsProcessed_args:
20906 
  """
20907 
  Attributes:
20908 
   - transactionId
20909 
   - category
20910 
  """
20911 
 
20912 
  thrift_spec = (
20913 
    None, # 0
20914 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20915 
    (2, TType.I32, 'category', None, None, ), # 2
20916 
  )
20917 
 
20918 
  def __init__(self, transactionId=None, category=None,):
20919 
    self.transactionId = transactionId
20920 
    self.category = category
20921 
 
20922 
  def read(self, iprot):
20923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20925 
      return
20926 
    iprot.readStructBegin()
20927 
    while True:
20928 
      (fname, ftype, fid) = iprot.readFieldBegin()
20929 
      if ftype == TType.STOP:
20930 
        break
20931 
      if fid == 1:
20932 
        if ftype == TType.I64:
20933 
          self.transactionId = iprot.readI64();
20934 
        else:
20935 
          iprot.skip(ftype)
20936 
      elif fid == 2:
20937 
        if ftype == TType.I32:
20938 
          self.category = iprot.readI32();
20939 
        else:
20940 
          iprot.skip(ftype)
20941 
      else:
20942 
        iprot.skip(ftype)
20943 
      iprot.readFieldEnd()
20944 
    iprot.readStructEnd()
20945 
 
20946 
  def write(self, oprot):
20947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20949 
      return
20950 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
20951 
    if self.transactionId is not None:
20952 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20953 
      oprot.writeI64(self.transactionId)
20954 
      oprot.writeFieldEnd()
20955 
    if self.category is not None:
20956 
      oprot.writeFieldBegin('category', TType.I32, 2)
20957 
      oprot.writeI32(self.category)
20958 
      oprot.writeFieldEnd()
20959 
    oprot.writeFieldStop()
20960 
    oprot.writeStructEnd()
20961 
 
20962 
  def validate(self):
20963 
    return
20964 
 
20965 
 
20966 
  def __repr__(self):
20967 
    L = ['%s=%r' % (key, value)
20968 
      for key, value in self.__dict__.iteritems()]
20969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20970 
 
20971 
  def __eq__(self, other):
20972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20973 
 
20974 
  def __ne__(self, other):
20975 
    return not (self == other)
20976 
 
20977 
class markTransactionAsProcessed_result:
20978 
 
20979 
  thrift_spec = (
20980 
  )
20981 
 
20982 
  def read(self, iprot):
20983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20985 
      return
20986 
    iprot.readStructBegin()
20987 
    while True:
20988 
      (fname, ftype, fid) = iprot.readFieldBegin()
20989 
      if ftype == TType.STOP:
20990 
        break
20991 
      else:
20992 
        iprot.skip(ftype)
20993 
      iprot.readFieldEnd()
20994 
    iprot.readStructEnd()
20995 
 
20996 
  def write(self, oprot):
20997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20999 
      return
21000 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
21001 
    oprot.writeFieldStop()
21002 
    oprot.writeStructEnd()
21003 
 
21004 
  def validate(self):
21005 
    return
21006 
 
21007 
 
21008 
  def __repr__(self):
21009 
    L = ['%s=%r' % (key, value)
21010 
      for key, value in self.__dict__.iteritems()]
21011 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21012 
 
21013 
  def __eq__(self, other):
21014 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21015 
 
21016 
  def __ne__(self, other):
21017 
    return not (self == other)
4018 chandransh 21018 
 
21019 
class getItemWiseRiskyOrdersCount_args:
21020 
 
21021 
  thrift_spec = (
21022 
  )
21023 
 
21024 
  def read(self, iprot):
21025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21027 
      return
21028 
    iprot.readStructBegin()
21029 
    while True:
21030 
      (fname, ftype, fid) = iprot.readFieldBegin()
21031 
      if ftype == TType.STOP:
21032 
        break
21033 
      else:
21034 
        iprot.skip(ftype)
21035 
      iprot.readFieldEnd()
21036 
    iprot.readStructEnd()
21037 
 
21038 
  def write(self, oprot):
21039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21041 
      return
21042 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
21043 
    oprot.writeFieldStop()
21044 
    oprot.writeStructEnd()
21045 
 
21046 
  def validate(self):
21047 
    return
21048 
 
21049 
 
21050 
  def __repr__(self):
21051 
    L = ['%s=%r' % (key, value)
21052 
      for key, value in self.__dict__.iteritems()]
21053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21054 
 
21055 
  def __eq__(self, other):
21056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21057 
 
21058 
  def __ne__(self, other):
21059 
    return not (self == other)
21060 
 
21061 
class getItemWiseRiskyOrdersCount_result:
21062 
  """
21063 
  Attributes:
21064 
   - success
21065 
  """
21066 
 
21067 
  thrift_spec = (
21068 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
21069 
  )
21070 
 
21071 
  def __init__(self, success=None,):
21072 
    self.success = success
21073 
 
21074 
  def read(self, iprot):
21075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21077 
      return
21078 
    iprot.readStructBegin()
21079 
    while True:
21080 
      (fname, ftype, fid) = iprot.readFieldBegin()
21081 
      if ftype == TType.STOP:
21082 
        break
21083 
      if fid == 0:
21084 
        if ftype == TType.MAP:
21085 
          self.success = {}
6188 rajveer 21086 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
21087 
          for _i482 in xrange(_size478):
21088 
            _key483 = iprot.readI64();
21089 
            _val484 = iprot.readI64();
21090 
            self.success[_key483] = _val484
4018 chandransh 21091 
          iprot.readMapEnd()
21092 
        else:
21093 
          iprot.skip(ftype)
21094 
      else:
21095 
        iprot.skip(ftype)
21096 
      iprot.readFieldEnd()
21097 
    iprot.readStructEnd()
21098 
 
21099 
  def write(self, oprot):
21100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21102 
      return
21103 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
21104 
    if self.success is not None:
21105 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21106 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 21107 
      for kiter485,viter486 in self.success.items():
21108 
        oprot.writeI64(kiter485)
21109 
        oprot.writeI64(viter486)
4018 chandransh 21110 
      oprot.writeMapEnd()
21111 
      oprot.writeFieldEnd()
21112 
    oprot.writeFieldStop()
21113 
    oprot.writeStructEnd()
21114 
 
21115 
  def validate(self):
21116 
    return
21117 
 
21118 
 
21119 
  def __repr__(self):
21120 
    L = ['%s=%r' % (key, value)
21121 
      for key, value in self.__dict__.iteritems()]
21122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21123 
 
21124 
  def __eq__(self, other):
21125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21126 
 
21127 
  def __ne__(self, other):
21128 
    return not (self == other)
4247 rajveer 21129 
 
4295 varun.gupt 21130 
class getOrdersForItemIds_args:
21131 
  """
21132 
  Attributes:
21133 
   - itemIds
21134 
  """
21135 
 
21136 
  thrift_spec = (
21137 
    None, # 0
21138 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
21139 
  )
21140 
 
21141 
  def __init__(self, itemIds=None,):
21142 
    self.itemIds = itemIds
21143 
 
21144 
  def read(self, iprot):
21145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21147 
      return
21148 
    iprot.readStructBegin()
21149 
    while True:
21150 
      (fname, ftype, fid) = iprot.readFieldBegin()
21151 
      if ftype == TType.STOP:
21152 
        break
21153 
      if fid == 1:
21154 
        if ftype == TType.LIST:
21155 
          self.itemIds = []
6188 rajveer 21156 
          (_etype490, _size487) = iprot.readListBegin()
21157 
          for _i491 in xrange(_size487):
21158 
            _elem492 = iprot.readI64();
21159 
            self.itemIds.append(_elem492)
4295 varun.gupt 21160 
          iprot.readListEnd()
21161 
        else:
21162 
          iprot.skip(ftype)
21163 
      else:
21164 
        iprot.skip(ftype)
21165 
      iprot.readFieldEnd()
21166 
    iprot.readStructEnd()
21167 
 
21168 
  def write(self, oprot):
21169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21171 
      return
21172 
    oprot.writeStructBegin('getOrdersForItemIds_args')
21173 
    if self.itemIds is not None:
21174 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
21175 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 21176 
      for iter493 in self.itemIds:
21177 
        oprot.writeI64(iter493)
4295 varun.gupt 21178 
      oprot.writeListEnd()
21179 
      oprot.writeFieldEnd()
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 getOrdersForItemIds_result:
21199 
  """
21200 
  Attributes:
21201 
   - success
21202 
  """
21203 
 
21204 
  thrift_spec = (
21205 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21206 
  )
21207 
 
21208 
  def __init__(self, success=None,):
21209 
    self.success = success
21210 
 
21211 
  def read(self, iprot):
21212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21214 
      return
21215 
    iprot.readStructBegin()
21216 
    while True:
21217 
      (fname, ftype, fid) = iprot.readFieldBegin()
21218 
      if ftype == TType.STOP:
21219 
        break
21220 
      if fid == 0:
21221 
        if ftype == TType.LIST:
21222 
          self.success = []
6188 rajveer 21223 
          (_etype497, _size494) = iprot.readListBegin()
21224 
          for _i498 in xrange(_size494):
21225 
            _elem499 = Order()
21226 
            _elem499.read(iprot)
21227 
            self.success.append(_elem499)
4295 varun.gupt 21228 
          iprot.readListEnd()
21229 
        else:
21230 
          iprot.skip(ftype)
21231 
      else:
21232 
        iprot.skip(ftype)
21233 
      iprot.readFieldEnd()
21234 
    iprot.readStructEnd()
21235 
 
21236 
  def write(self, oprot):
21237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21239 
      return
21240 
    oprot.writeStructBegin('getOrdersForItemIds_result')
21241 
    if self.success is not None:
21242 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21243 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 21244 
      for iter500 in self.success:
21245 
        iter500.write(oprot)
4295 varun.gupt 21246 
      oprot.writeListEnd()
21247 
      oprot.writeFieldEnd()
21248 
    oprot.writeFieldStop()
21249 
    oprot.writeStructEnd()
21250 
 
21251 
  def validate(self):
21252 
    return
21253 
 
21254 
 
21255 
  def __repr__(self):
21256 
    L = ['%s=%r' % (key, value)
21257 
      for key, value in self.__dict__.iteritems()]
21258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21259 
 
21260 
  def __eq__(self, other):
21261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21262 
 
21263 
  def __ne__(self, other):
21264 
    return not (self == other)
21265 
 
4247 rajveer 21266 
class markOrderCancellationRequestReceived_args:
21267 
  """
21268 
  Attributes:
21269 
   - orderId
21270 
  """
21271 
 
21272 
  thrift_spec = (
21273 
    None, # 0
21274 
    (1, TType.I64, 'orderId', None, None, ), # 1
21275 
  )
21276 
 
21277 
  def __init__(self, orderId=None,):
21278 
    self.orderId = orderId
21279 
 
21280 
  def read(self, iprot):
21281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21283 
      return
21284 
    iprot.readStructBegin()
21285 
    while True:
21286 
      (fname, ftype, fid) = iprot.readFieldBegin()
21287 
      if ftype == TType.STOP:
21288 
        break
21289 
      if fid == 1:
21290 
        if ftype == TType.I64:
21291 
          self.orderId = iprot.readI64();
21292 
        else:
21293 
          iprot.skip(ftype)
21294 
      else:
21295 
        iprot.skip(ftype)
21296 
      iprot.readFieldEnd()
21297 
    iprot.readStructEnd()
21298 
 
21299 
  def write(self, oprot):
21300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21302 
      return
21303 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
21304 
    if self.orderId is not None:
21305 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21306 
      oprot.writeI64(self.orderId)
21307 
      oprot.writeFieldEnd()
21308 
    oprot.writeFieldStop()
21309 
    oprot.writeStructEnd()
21310 
 
21311 
  def validate(self):
21312 
    return
21313 
 
21314 
 
21315 
  def __repr__(self):
21316 
    L = ['%s=%r' % (key, value)
21317 
      for key, value in self.__dict__.iteritems()]
21318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21319 
 
21320 
  def __eq__(self, other):
21321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21322 
 
21323 
  def __ne__(self, other):
21324 
    return not (self == other)
21325 
 
21326 
class markOrderCancellationRequestReceived_result:
21327 
  """
21328 
  Attributes:
21329 
   - ex
21330 
  """
21331 
 
21332 
  thrift_spec = (
21333 
    None, # 0
21334 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21335 
  )
21336 
 
21337 
  def __init__(self, ex=None,):
21338 
    self.ex = ex
21339 
 
21340 
  def read(self, iprot):
21341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21343 
      return
21344 
    iprot.readStructBegin()
21345 
    while True:
21346 
      (fname, ftype, fid) = iprot.readFieldBegin()
21347 
      if ftype == TType.STOP:
21348 
        break
21349 
      if fid == 1:
21350 
        if ftype == TType.STRUCT:
21351 
          self.ex = TransactionServiceException()
21352 
          self.ex.read(iprot)
21353 
        else:
21354 
          iprot.skip(ftype)
21355 
      else:
21356 
        iprot.skip(ftype)
21357 
      iprot.readFieldEnd()
21358 
    iprot.readStructEnd()
21359 
 
21360 
  def write(self, oprot):
21361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21363 
      return
21364 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
21365 
    if self.ex is not None:
21366 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21367 
      self.ex.write(oprot)
21368 
      oprot.writeFieldEnd()
21369 
    oprot.writeFieldStop()
21370 
    oprot.writeStructEnd()
21371 
 
21372 
  def validate(self):
21373 
    return
21374 
 
21375 
 
21376 
  def __repr__(self):
21377 
    L = ['%s=%r' % (key, value)
21378 
      for key, value in self.__dict__.iteritems()]
21379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21380 
 
21381 
  def __eq__(self, other):
21382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21383 
 
21384 
  def __ne__(self, other):
21385 
    return not (self == other)
21386 
 
21387 
class markOrderCancellationRequestConfirmed_args:
21388 
  """
21389 
  Attributes:
21390 
   - orderId
21391 
  """
21392 
 
21393 
  thrift_spec = (
21394 
    None, # 0
21395 
    (1, TType.I64, 'orderId', None, None, ), # 1
21396 
  )
21397 
 
21398 
  def __init__(self, orderId=None,):
21399 
    self.orderId = orderId
21400 
 
21401 
  def read(self, iprot):
21402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21404 
      return
21405 
    iprot.readStructBegin()
21406 
    while True:
21407 
      (fname, ftype, fid) = iprot.readFieldBegin()
21408 
      if ftype == TType.STOP:
21409 
        break
21410 
      if fid == 1:
21411 
        if ftype == TType.I64:
21412 
          self.orderId = iprot.readI64();
21413 
        else:
21414 
          iprot.skip(ftype)
21415 
      else:
21416 
        iprot.skip(ftype)
21417 
      iprot.readFieldEnd()
21418 
    iprot.readStructEnd()
21419 
 
21420 
  def write(self, oprot):
21421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21423 
      return
21424 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
21425 
    if self.orderId is not None:
21426 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21427 
      oprot.writeI64(self.orderId)
21428 
      oprot.writeFieldEnd()
21429 
    oprot.writeFieldStop()
21430 
    oprot.writeStructEnd()
21431 
 
21432 
  def validate(self):
21433 
    return
21434 
 
21435 
 
21436 
  def __repr__(self):
21437 
    L = ['%s=%r' % (key, value)
21438 
      for key, value in self.__dict__.iteritems()]
21439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21440 
 
21441 
  def __eq__(self, other):
21442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21443 
 
21444 
  def __ne__(self, other):
21445 
    return not (self == other)
21446 
 
21447 
class markOrderCancellationRequestConfirmed_result:
21448 
  """
21449 
  Attributes:
21450 
   - ex
21451 
  """
21452 
 
21453 
  thrift_spec = (
21454 
    None, # 0
21455 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21456 
  )
21457 
 
21458 
  def __init__(self, ex=None,):
21459 
    self.ex = ex
21460 
 
21461 
  def read(self, iprot):
21462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21464 
      return
21465 
    iprot.readStructBegin()
21466 
    while True:
21467 
      (fname, ftype, fid) = iprot.readFieldBegin()
21468 
      if ftype == TType.STOP:
21469 
        break
21470 
      if fid == 1:
21471 
        if ftype == TType.STRUCT:
21472 
          self.ex = TransactionServiceException()
21473 
          self.ex.read(iprot)
21474 
        else:
21475 
          iprot.skip(ftype)
21476 
      else:
21477 
        iprot.skip(ftype)
21478 
      iprot.readFieldEnd()
21479 
    iprot.readStructEnd()
21480 
 
21481 
  def write(self, oprot):
21482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21484 
      return
21485 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
21486 
    if self.ex is not None:
21487 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21488 
      self.ex.write(oprot)
21489 
      oprot.writeFieldEnd()
21490 
    oprot.writeFieldStop()
21491 
    oprot.writeStructEnd()
21492 
 
21493 
  def validate(self):
21494 
    return
21495 
 
21496 
 
21497 
  def __repr__(self):
21498 
    L = ['%s=%r' % (key, value)
21499 
      for key, value in self.__dict__.iteritems()]
21500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21501 
 
21502 
  def __eq__(self, other):
21503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21504 
 
21505 
  def __ne__(self, other):
21506 
    return not (self == other)
21507 
 
21508 
class markOrderCancellationRequestDenied_args:
21509 
  """
21510 
  Attributes:
21511 
   - orderId
21512 
  """
21513 
 
21514 
  thrift_spec = (
21515 
    None, # 0
21516 
    (1, TType.I64, 'orderId', None, None, ), # 1
21517 
  )
21518 
 
21519 
  def __init__(self, orderId=None,):
21520 
    self.orderId = orderId
21521 
 
21522 
  def read(self, iprot):
21523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21525 
      return
21526 
    iprot.readStructBegin()
21527 
    while True:
21528 
      (fname, ftype, fid) = iprot.readFieldBegin()
21529 
      if ftype == TType.STOP:
21530 
        break
21531 
      if fid == 1:
21532 
        if ftype == TType.I64:
21533 
          self.orderId = iprot.readI64();
21534 
        else:
21535 
          iprot.skip(ftype)
21536 
      else:
21537 
        iprot.skip(ftype)
21538 
      iprot.readFieldEnd()
21539 
    iprot.readStructEnd()
21540 
 
21541 
  def write(self, oprot):
21542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21544 
      return
21545 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
21546 
    if self.orderId is not None:
21547 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21548 
      oprot.writeI64(self.orderId)
21549 
      oprot.writeFieldEnd()
21550 
    oprot.writeFieldStop()
21551 
    oprot.writeStructEnd()
21552 
 
21553 
  def validate(self):
21554 
    return
21555 
 
21556 
 
21557 
  def __repr__(self):
21558 
    L = ['%s=%r' % (key, value)
21559 
      for key, value in self.__dict__.iteritems()]
21560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21561 
 
21562 
  def __eq__(self, other):
21563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21564 
 
21565 
  def __ne__(self, other):
21566 
    return not (self == other)
21567 
 
21568 
class markOrderCancellationRequestDenied_result:
21569 
  """
21570 
  Attributes:
21571 
   - ex
21572 
  """
21573 
 
21574 
  thrift_spec = (
21575 
    None, # 0
21576 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21577 
  )
21578 
 
21579 
  def __init__(self, ex=None,):
21580 
    self.ex = ex
21581 
 
21582 
  def read(self, iprot):
21583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21585 
      return
21586 
    iprot.readStructBegin()
21587 
    while True:
21588 
      (fname, ftype, fid) = iprot.readFieldBegin()
21589 
      if ftype == TType.STOP:
21590 
        break
21591 
      if fid == 1:
21592 
        if ftype == TType.STRUCT:
21593 
          self.ex = TransactionServiceException()
21594 
          self.ex.read(iprot)
21595 
        else:
21596 
          iprot.skip(ftype)
21597 
      else:
21598 
        iprot.skip(ftype)
21599 
      iprot.readFieldEnd()
21600 
    iprot.readStructEnd()
21601 
 
21602 
  def write(self, oprot):
21603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21605 
      return
21606 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
21607 
    if self.ex is not None:
21608 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21609 
      self.ex.write(oprot)
21610 
      oprot.writeFieldEnd()
21611 
    oprot.writeFieldStop()
21612 
    oprot.writeStructEnd()
21613 
 
21614 
  def validate(self):
21615 
    return
21616 
 
21617 
 
21618 
  def __repr__(self):
21619 
    L = ['%s=%r' % (key, value)
21620 
      for key, value in self.__dict__.iteritems()]
21621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21622 
 
21623 
  def __eq__(self, other):
21624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21625 
 
21626 
  def __ne__(self, other):
21627 
    return not (self == other)
21628 
 
4258 rajveer 21629 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 21630 
  """
21631 
  Attributes:
4258 rajveer 21632 
   - transactionId
4247 rajveer 21633 
  """
21634 
 
21635 
  thrift_spec = (
21636 
    None, # 0
4258 rajveer 21637 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 21638 
  )
21639 
 
4258 rajveer 21640 
  def __init__(self, transactionId=None,):
21641 
    self.transactionId = transactionId
4247 rajveer 21642 
 
21643 
  def read(self, iprot):
21644 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21645 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21646 
      return
21647 
    iprot.readStructBegin()
21648 
    while True:
21649 
      (fname, ftype, fid) = iprot.readFieldBegin()
21650 
      if ftype == TType.STOP:
21651 
        break
21652 
      if fid == 1:
21653 
        if ftype == TType.I64:
4258 rajveer 21654 
          self.transactionId = iprot.readI64();
4247 rajveer 21655 
        else:
21656 
          iprot.skip(ftype)
21657 
      else:
21658 
        iprot.skip(ftype)
21659 
      iprot.readFieldEnd()
21660 
    iprot.readStructEnd()
21661 
 
21662 
  def write(self, oprot):
21663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21665 
      return
4258 rajveer 21666 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
21667 
    if self.transactionId is not None:
21668 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21669 
      oprot.writeI64(self.transactionId)
4247 rajveer 21670 
      oprot.writeFieldEnd()
21671 
    oprot.writeFieldStop()
21672 
    oprot.writeStructEnd()
21673 
 
21674 
  def validate(self):
21675 
    return
21676 
 
21677 
 
21678 
  def __repr__(self):
21679 
    L = ['%s=%r' % (key, value)
21680 
      for key, value in self.__dict__.iteritems()]
21681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21682 
 
21683 
  def __eq__(self, other):
21684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21685 
 
21686 
  def __ne__(self, other):
21687 
    return not (self == other)
21688 
 
4258 rajveer 21689 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 21690 
  """
21691 
  Attributes:
21692 
   - ex
21693 
  """
21694 
 
21695 
  thrift_spec = (
21696 
    None, # 0
21697 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21698 
  )
21699 
 
21700 
  def __init__(self, ex=None,):
21701 
    self.ex = ex
21702 
 
21703 
  def read(self, iprot):
21704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21706 
      return
21707 
    iprot.readStructBegin()
21708 
    while True:
21709 
      (fname, ftype, fid) = iprot.readFieldBegin()
21710 
      if ftype == TType.STOP:
21711 
        break
21712 
      if fid == 1:
21713 
        if ftype == TType.STRUCT:
21714 
          self.ex = TransactionServiceException()
21715 
          self.ex.read(iprot)
21716 
        else:
21717 
          iprot.skip(ftype)
21718 
      else:
21719 
        iprot.skip(ftype)
21720 
      iprot.readFieldEnd()
21721 
    iprot.readStructEnd()
21722 
 
21723 
  def write(self, oprot):
21724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21726 
      return
4258 rajveer 21727 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 21728 
    if self.ex is not None:
21729 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21730 
      self.ex.write(oprot)
21731 
      oprot.writeFieldEnd()
21732 
    oprot.writeFieldStop()
21733 
    oprot.writeStructEnd()
21734 
 
21735 
  def validate(self):
21736 
    return
21737 
 
21738 
 
21739 
  def __repr__(self):
21740 
    L = ['%s=%r' % (key, value)
21741 
      for key, value in self.__dict__.iteritems()]
21742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21743 
 
21744 
  def __eq__(self, other):
21745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21746 
 
21747 
  def __ne__(self, other):
21748 
    return not (self == other)
4259 anupam.sin 21749 
 
21750 
class refundTransaction_args:
21751 
  """
21752 
  Attributes:
21753 
   - transactionId
21754 
   - refundedBy
21755 
   - reason
21756 
  """
21757 
 
21758 
  thrift_spec = (
21759 
    None, # 0
21760 
    (1, TType.I64, 'transactionId', None, None, ), # 1
21761 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
21762 
    (3, TType.STRING, 'reason', None, None, ), # 3
21763 
  )
21764 
 
21765 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
21766 
    self.transactionId = transactionId
21767 
    self.refundedBy = refundedBy
21768 
    self.reason = reason
21769 
 
21770 
  def read(self, iprot):
21771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21773 
      return
21774 
    iprot.readStructBegin()
21775 
    while True:
21776 
      (fname, ftype, fid) = iprot.readFieldBegin()
21777 
      if ftype == TType.STOP:
21778 
        break
21779 
      if fid == 1:
21780 
        if ftype == TType.I64:
21781 
          self.transactionId = iprot.readI64();
21782 
        else:
21783 
          iprot.skip(ftype)
21784 
      elif fid == 2:
21785 
        if ftype == TType.STRING:
21786 
          self.refundedBy = iprot.readString();
21787 
        else:
21788 
          iprot.skip(ftype)
21789 
      elif fid == 3:
21790 
        if ftype == TType.STRING:
21791 
          self.reason = iprot.readString();
21792 
        else:
21793 
          iprot.skip(ftype)
21794 
      else:
21795 
        iprot.skip(ftype)
21796 
      iprot.readFieldEnd()
21797 
    iprot.readStructEnd()
21798 
 
21799 
  def write(self, oprot):
21800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21802 
      return
21803 
    oprot.writeStructBegin('refundTransaction_args')
21804 
    if self.transactionId is not None:
21805 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21806 
      oprot.writeI64(self.transactionId)
21807 
      oprot.writeFieldEnd()
21808 
    if self.refundedBy is not None:
21809 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
21810 
      oprot.writeString(self.refundedBy)
21811 
      oprot.writeFieldEnd()
21812 
    if self.reason is not None:
21813 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
21814 
      oprot.writeString(self.reason)
21815 
      oprot.writeFieldEnd()
21816 
    oprot.writeFieldStop()
21817 
    oprot.writeStructEnd()
21818 
 
21819 
  def validate(self):
21820 
    return
21821 
 
21822 
 
21823 
  def __repr__(self):
21824 
    L = ['%s=%r' % (key, value)
21825 
      for key, value in self.__dict__.iteritems()]
21826 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21827 
 
21828 
  def __eq__(self, other):
21829 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21830 
 
21831 
  def __ne__(self, other):
21832 
    return not (self == other)
21833 
 
21834 
class refundTransaction_result:
21835 
  """
21836 
  Attributes:
21837 
   - ex
21838 
  """
21839 
 
21840 
  thrift_spec = (
21841 
    None, # 0
21842 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21843 
  )
21844 
 
21845 
  def __init__(self, ex=None,):
21846 
    self.ex = ex
21847 
 
21848 
  def read(self, iprot):
21849 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21850 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21851 
      return
21852 
    iprot.readStructBegin()
21853 
    while True:
21854 
      (fname, ftype, fid) = iprot.readFieldBegin()
21855 
      if ftype == TType.STOP:
21856 
        break
21857 
      if fid == 1:
21858 
        if ftype == TType.STRUCT:
21859 
          self.ex = TransactionServiceException()
21860 
          self.ex.read(iprot)
21861 
        else:
21862 
          iprot.skip(ftype)
21863 
      else:
21864 
        iprot.skip(ftype)
21865 
      iprot.readFieldEnd()
21866 
    iprot.readStructEnd()
21867 
 
21868 
  def write(self, oprot):
21869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21871 
      return
21872 
    oprot.writeStructBegin('refundTransaction_result')
21873 
    if self.ex is not None:
21874 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21875 
      self.ex.write(oprot)
21876 
      oprot.writeFieldEnd()
21877 
    oprot.writeFieldStop()
21878 
    oprot.writeStructEnd()
21879 
 
21880 
  def validate(self):
21881 
    return
21882 
 
21883 
 
21884 
  def __repr__(self):
21885 
    L = ['%s=%r' % (key, value)
21886 
      for key, value in self.__dict__.iteritems()]
21887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21888 
 
21889 
  def __eq__(self, other):
21890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21891 
 
21892 
  def __ne__(self, other):
21893 
    return not (self == other)
4285 rajveer 21894 
 
4324 mandeep.dh 21895 
class updateShipmentAddress_args:
21896 
  """
21897 
  Attributes:
21898 
   - orderId
21899 
   - addressId
21900 
  """
21901 
 
21902 
  thrift_spec = (
21903 
    None, # 0
21904 
    (1, TType.I64, 'orderId', None, None, ), # 1
21905 
    (2, TType.I64, 'addressId', None, None, ), # 2
21906 
  )
21907 
 
21908 
  def __init__(self, orderId=None, addressId=None,):
21909 
    self.orderId = orderId
21910 
    self.addressId = addressId
21911 
 
21912 
  def read(self, iprot):
21913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21915 
      return
21916 
    iprot.readStructBegin()
21917 
    while True:
21918 
      (fname, ftype, fid) = iprot.readFieldBegin()
21919 
      if ftype == TType.STOP:
21920 
        break
21921 
      if fid == 1:
21922 
        if ftype == TType.I64:
21923 
          self.orderId = iprot.readI64();
21924 
        else:
21925 
          iprot.skip(ftype)
21926 
      elif fid == 2:
21927 
        if ftype == TType.I64:
21928 
          self.addressId = iprot.readI64();
21929 
        else:
21930 
          iprot.skip(ftype)
21931 
      else:
21932 
        iprot.skip(ftype)
21933 
      iprot.readFieldEnd()
21934 
    iprot.readStructEnd()
21935 
 
21936 
  def write(self, oprot):
21937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21939 
      return
21940 
    oprot.writeStructBegin('updateShipmentAddress_args')
21941 
    if self.orderId is not None:
21942 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21943 
      oprot.writeI64(self.orderId)
21944 
      oprot.writeFieldEnd()
21945 
    if self.addressId is not None:
21946 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
21947 
      oprot.writeI64(self.addressId)
21948 
      oprot.writeFieldEnd()
21949 
    oprot.writeFieldStop()
21950 
    oprot.writeStructEnd()
21951 
 
21952 
  def validate(self):
21953 
    return
21954 
 
21955 
 
21956 
  def __repr__(self):
21957 
    L = ['%s=%r' % (key, value)
21958 
      for key, value in self.__dict__.iteritems()]
21959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21960 
 
21961 
  def __eq__(self, other):
21962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21963 
 
21964 
  def __ne__(self, other):
21965 
    return not (self == other)
21966 
 
21967 
class updateShipmentAddress_result:
21968 
  """
21969 
  Attributes:
21970 
   - ex
21971 
  """
21972 
 
21973 
  thrift_spec = (
21974 
    None, # 0
21975 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21976 
  )
21977 
 
21978 
  def __init__(self, ex=None,):
21979 
    self.ex = ex
21980 
 
21981 
  def read(self, iprot):
21982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21984 
      return
21985 
    iprot.readStructBegin()
21986 
    while True:
21987 
      (fname, ftype, fid) = iprot.readFieldBegin()
21988 
      if ftype == TType.STOP:
21989 
        break
21990 
      if fid == 1:
21991 
        if ftype == TType.STRUCT:
21992 
          self.ex = TransactionServiceException()
21993 
          self.ex.read(iprot)
21994 
        else:
21995 
          iprot.skip(ftype)
21996 
      else:
21997 
        iprot.skip(ftype)
21998 
      iprot.readFieldEnd()
21999 
    iprot.readStructEnd()
22000 
 
22001 
  def write(self, oprot):
22002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22004 
      return
22005 
    oprot.writeStructBegin('updateShipmentAddress_result')
22006 
    if self.ex is not None:
22007 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22008 
      self.ex.write(oprot)
22009 
      oprot.writeFieldEnd()
22010 
    oprot.writeFieldStop()
22011 
    oprot.writeStructEnd()
22012 
 
22013 
  def validate(self):
22014 
    return
22015 
 
22016 
 
22017 
  def __repr__(self):
22018 
    L = ['%s=%r' % (key, value)
22019 
      for key, value in self.__dict__.iteritems()]
22020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22021 
 
22022 
  def __eq__(self, other):
22023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22024 
 
22025 
  def __ne__(self, other):
22026 
    return not (self == other)
22027 
 
4285 rajveer 22028 
class acceptOrdersForItemId_args:
22029 
  """
22030 
  Attributes:
22031 
   - itemId
22032 
   - inventory
22033 
  """
22034 
 
22035 
  thrift_spec = (
22036 
    None, # 0
22037 
    (1, TType.I64, 'itemId', None, None, ), # 1
22038 
    (2, TType.I64, 'inventory', None, None, ), # 2
22039 
  )
22040 
 
22041 
  def __init__(self, itemId=None, inventory=None,):
22042 
    self.itemId = itemId
22043 
    self.inventory = inventory
22044 
 
22045 
  def read(self, iprot):
22046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22048 
      return
22049 
    iprot.readStructBegin()
22050 
    while True:
22051 
      (fname, ftype, fid) = iprot.readFieldBegin()
22052 
      if ftype == TType.STOP:
22053 
        break
22054 
      if fid == 1:
22055 
        if ftype == TType.I64:
22056 
          self.itemId = iprot.readI64();
22057 
        else:
22058 
          iprot.skip(ftype)
22059 
      elif fid == 2:
22060 
        if ftype == TType.I64:
22061 
          self.inventory = iprot.readI64();
22062 
        else:
22063 
          iprot.skip(ftype)
22064 
      else:
22065 
        iprot.skip(ftype)
22066 
      iprot.readFieldEnd()
22067 
    iprot.readStructEnd()
22068 
 
22069 
  def write(self, oprot):
22070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22072 
      return
22073 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
22074 
    if self.itemId is not None:
22075 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
22076 
      oprot.writeI64(self.itemId)
22077 
      oprot.writeFieldEnd()
22078 
    if self.inventory is not None:
22079 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
22080 
      oprot.writeI64(self.inventory)
22081 
      oprot.writeFieldEnd()
22082 
    oprot.writeFieldStop()
22083 
    oprot.writeStructEnd()
22084 
 
22085 
  def validate(self):
22086 
    return
22087 
 
22088 
 
22089 
  def __repr__(self):
22090 
    L = ['%s=%r' % (key, value)
22091 
      for key, value in self.__dict__.iteritems()]
22092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22093 
 
22094 
  def __eq__(self, other):
22095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22096 
 
22097 
  def __ne__(self, other):
22098 
    return not (self == other)
22099 
 
22100 
class acceptOrdersForItemId_result:
22101 
  """
22102 
  Attributes:
22103 
   - success
22104 
   - ex
22105 
  """
22106 
 
22107 
  thrift_spec = (
22108 
    (0, TType.BOOL, 'success', None, None, ), # 0
22109 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22110 
  )
22111 
 
22112 
  def __init__(self, success=None, ex=None,):
22113 
    self.success = success
22114 
    self.ex = ex
22115 
 
22116 
  def read(self, iprot):
22117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22119 
      return
22120 
    iprot.readStructBegin()
22121 
    while True:
22122 
      (fname, ftype, fid) = iprot.readFieldBegin()
22123 
      if ftype == TType.STOP:
22124 
        break
22125 
      if fid == 0:
22126 
        if ftype == TType.BOOL:
22127 
          self.success = iprot.readBool();
22128 
        else:
22129 
          iprot.skip(ftype)
22130 
      elif fid == 1:
22131 
        if ftype == TType.STRUCT:
22132 
          self.ex = TransactionServiceException()
22133 
          self.ex.read(iprot)
22134 
        else:
22135 
          iprot.skip(ftype)
22136 
      else:
22137 
        iprot.skip(ftype)
22138 
      iprot.readFieldEnd()
22139 
    iprot.readStructEnd()
22140 
 
22141 
  def write(self, oprot):
22142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22144 
      return
22145 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
22146 
    if self.success is not None:
22147 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22148 
      oprot.writeBool(self.success)
22149 
      oprot.writeFieldEnd()
22150 
    if self.ex is not None:
22151 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22152 
      self.ex.write(oprot)
22153 
      oprot.writeFieldEnd()
22154 
    oprot.writeFieldStop()
22155 
    oprot.writeStructEnd()
22156 
 
22157 
  def validate(self):
22158 
    return
22159 
 
22160 
 
22161 
  def __repr__(self):
22162 
    L = ['%s=%r' % (key, value)
22163 
      for key, value in self.__dict__.iteritems()]
22164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22165 
 
22166 
  def __eq__(self, other):
22167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22168 
 
22169 
  def __ne__(self, other):
22170 
    return not (self == other)
4303 rajveer 22171 
 
22172 
class markOrdersAsPORaised_args:
22173 
  """
22174 
  Attributes:
22175 
   - vendorId
22176 
   - itemId
22177 
   - quantity
22178 
   - estimate
4369 rajveer 22179 
   - isReminder
4303 rajveer 22180 
  """
22181 
 
22182 
  thrift_spec = (
22183 
    None, # 0
22184 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22185 
    (2, TType.I64, 'itemId', None, None, ), # 2
22186 
    (3, TType.I64, 'quantity', None, None, ), # 3
22187 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22188 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22189 
  )
22190 
 
4369 rajveer 22191 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22192 
    self.vendorId = vendorId
22193 
    self.itemId = itemId
22194 
    self.quantity = quantity
22195 
    self.estimate = estimate
4369 rajveer 22196 
    self.isReminder = isReminder
4303 rajveer 22197 
 
22198 
  def read(self, iprot):
22199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22201 
      return
22202 
    iprot.readStructBegin()
22203 
    while True:
22204 
      (fname, ftype, fid) = iprot.readFieldBegin()
22205 
      if ftype == TType.STOP:
22206 
        break
22207 
      if fid == 1:
22208 
        if ftype == TType.I64:
22209 
          self.vendorId = iprot.readI64();
22210 
        else:
22211 
          iprot.skip(ftype)
22212 
      elif fid == 2:
22213 
        if ftype == TType.I64:
22214 
          self.itemId = iprot.readI64();
22215 
        else:
22216 
          iprot.skip(ftype)
22217 
      elif fid == 3:
22218 
        if ftype == TType.I64:
22219 
          self.quantity = iprot.readI64();
22220 
        else:
22221 
          iprot.skip(ftype)
22222 
      elif fid == 4:
22223 
        if ftype == TType.I64:
22224 
          self.estimate = iprot.readI64();
22225 
        else:
22226 
          iprot.skip(ftype)
4369 rajveer 22227 
      elif fid == 5:
22228 
        if ftype == TType.BOOL:
22229 
          self.isReminder = iprot.readBool();
22230 
        else:
22231 
          iprot.skip(ftype)
4303 rajveer 22232 
      else:
22233 
        iprot.skip(ftype)
22234 
      iprot.readFieldEnd()
22235 
    iprot.readStructEnd()
22236 
 
22237 
  def write(self, oprot):
22238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22240 
      return
22241 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
22242 
    if self.vendorId is not None:
22243 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22244 
      oprot.writeI64(self.vendorId)
22245 
      oprot.writeFieldEnd()
22246 
    if self.itemId is not None:
22247 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22248 
      oprot.writeI64(self.itemId)
22249 
      oprot.writeFieldEnd()
22250 
    if self.quantity is not None:
22251 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22252 
      oprot.writeI64(self.quantity)
22253 
      oprot.writeFieldEnd()
22254 
    if self.estimate is not None:
22255 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22256 
      oprot.writeI64(self.estimate)
22257 
      oprot.writeFieldEnd()
4369 rajveer 22258 
    if self.isReminder is not None:
22259 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22260 
      oprot.writeBool(self.isReminder)
22261 
      oprot.writeFieldEnd()
4303 rajveer 22262 
    oprot.writeFieldStop()
22263 
    oprot.writeStructEnd()
22264 
 
22265 
  def validate(self):
22266 
    return
22267 
 
22268 
 
22269 
  def __repr__(self):
22270 
    L = ['%s=%r' % (key, value)
22271 
      for key, value in self.__dict__.iteritems()]
22272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22273 
 
22274 
  def __eq__(self, other):
22275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22276 
 
22277 
  def __ne__(self, other):
22278 
    return not (self == other)
22279 
 
22280 
class markOrdersAsPORaised_result:
22281 
  """
22282 
  Attributes:
22283 
   - ex
22284 
  """
22285 
 
22286 
  thrift_spec = (
22287 
    None, # 0
22288 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22289 
  )
22290 
 
22291 
  def __init__(self, ex=None,):
22292 
    self.ex = ex
22293 
 
22294 
  def read(self, iprot):
22295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22297 
      return
22298 
    iprot.readStructBegin()
22299 
    while True:
22300 
      (fname, ftype, fid) = iprot.readFieldBegin()
22301 
      if ftype == TType.STOP:
22302 
        break
22303 
      if fid == 1:
22304 
        if ftype == TType.STRUCT:
22305 
          self.ex = TransactionServiceException()
22306 
          self.ex.read(iprot)
22307 
        else:
22308 
          iprot.skip(ftype)
22309 
      else:
22310 
        iprot.skip(ftype)
22311 
      iprot.readFieldEnd()
22312 
    iprot.readStructEnd()
22313 
 
22314 
  def write(self, oprot):
22315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22317 
      return
22318 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
22319 
    if self.ex is not None:
22320 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22321 
      self.ex.write(oprot)
22322 
      oprot.writeFieldEnd()
22323 
    oprot.writeFieldStop()
22324 
    oprot.writeStructEnd()
22325 
 
22326 
  def validate(self):
22327 
    return
22328 
 
22329 
 
22330 
  def __repr__(self):
22331 
    L = ['%s=%r' % (key, value)
22332 
      for key, value in self.__dict__.iteritems()]
22333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22334 
 
22335 
  def __eq__(self, other):
22336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22337 
 
22338 
  def __ne__(self, other):
22339 
    return not (self == other)
22340 
 
22341 
class markOrdersAsReversalInitiated_args:
22342 
  """
22343 
  Attributes:
22344 
   - vendorId
22345 
   - itemId
22346 
   - quantity
22347 
   - estimate
4369 rajveer 22348 
   - isReminder
4303 rajveer 22349 
  """
22350 
 
22351 
  thrift_spec = (
22352 
    None, # 0
22353 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22354 
    (2, TType.I64, 'itemId', None, None, ), # 2
22355 
    (3, TType.I64, 'quantity', None, None, ), # 3
22356 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22357 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22358 
  )
22359 
 
4369 rajveer 22360 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22361 
    self.vendorId = vendorId
22362 
    self.itemId = itemId
22363 
    self.quantity = quantity
22364 
    self.estimate = estimate
4369 rajveer 22365 
    self.isReminder = isReminder
4303 rajveer 22366 
 
22367 
  def read(self, iprot):
22368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22370 
      return
22371 
    iprot.readStructBegin()
22372 
    while True:
22373 
      (fname, ftype, fid) = iprot.readFieldBegin()
22374 
      if ftype == TType.STOP:
22375 
        break
22376 
      if fid == 1:
22377 
        if ftype == TType.I64:
22378 
          self.vendorId = iprot.readI64();
22379 
        else:
22380 
          iprot.skip(ftype)
22381 
      elif fid == 2:
22382 
        if ftype == TType.I64:
22383 
          self.itemId = iprot.readI64();
22384 
        else:
22385 
          iprot.skip(ftype)
22386 
      elif fid == 3:
22387 
        if ftype == TType.I64:
22388 
          self.quantity = iprot.readI64();
22389 
        else:
22390 
          iprot.skip(ftype)
22391 
      elif fid == 4:
22392 
        if ftype == TType.I64:
22393 
          self.estimate = iprot.readI64();
22394 
        else:
22395 
          iprot.skip(ftype)
4369 rajveer 22396 
      elif fid == 5:
22397 
        if ftype == TType.BOOL:
22398 
          self.isReminder = iprot.readBool();
22399 
        else:
22400 
          iprot.skip(ftype)
4303 rajveer 22401 
      else:
22402 
        iprot.skip(ftype)
22403 
      iprot.readFieldEnd()
22404 
    iprot.readStructEnd()
22405 
 
22406 
  def write(self, oprot):
22407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22409 
      return
22410 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
22411 
    if self.vendorId is not None:
22412 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22413 
      oprot.writeI64(self.vendorId)
22414 
      oprot.writeFieldEnd()
22415 
    if self.itemId is not None:
22416 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22417 
      oprot.writeI64(self.itemId)
22418 
      oprot.writeFieldEnd()
22419 
    if self.quantity is not None:
22420 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22421 
      oprot.writeI64(self.quantity)
22422 
      oprot.writeFieldEnd()
22423 
    if self.estimate is not None:
22424 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22425 
      oprot.writeI64(self.estimate)
22426 
      oprot.writeFieldEnd()
4369 rajveer 22427 
    if self.isReminder is not None:
22428 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22429 
      oprot.writeBool(self.isReminder)
22430 
      oprot.writeFieldEnd()
4303 rajveer 22431 
    oprot.writeFieldStop()
22432 
    oprot.writeStructEnd()
22433 
 
22434 
  def validate(self):
22435 
    return
22436 
 
22437 
 
22438 
  def __repr__(self):
22439 
    L = ['%s=%r' % (key, value)
22440 
      for key, value in self.__dict__.iteritems()]
22441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22442 
 
22443 
  def __eq__(self, other):
22444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22445 
 
22446 
  def __ne__(self, other):
22447 
    return not (self == other)
22448 
 
22449 
class markOrdersAsReversalInitiated_result:
22450 
  """
22451 
  Attributes:
22452 
   - ex
22453 
  """
22454 
 
22455 
  thrift_spec = (
22456 
    None, # 0
22457 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22458 
  )
22459 
 
22460 
  def __init__(self, ex=None,):
22461 
    self.ex = ex
22462 
 
22463 
  def read(self, iprot):
22464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22466 
      return
22467 
    iprot.readStructBegin()
22468 
    while True:
22469 
      (fname, ftype, fid) = iprot.readFieldBegin()
22470 
      if ftype == TType.STOP:
22471 
        break
22472 
      if fid == 1:
22473 
        if ftype == TType.STRUCT:
22474 
          self.ex = TransactionServiceException()
22475 
          self.ex.read(iprot)
22476 
        else:
22477 
          iprot.skip(ftype)
22478 
      else:
22479 
        iprot.skip(ftype)
22480 
      iprot.readFieldEnd()
22481 
    iprot.readStructEnd()
22482 
 
22483 
  def write(self, oprot):
22484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22486 
      return
22487 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
22488 
    if self.ex is not None:
22489 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22490 
      self.ex.write(oprot)
22491 
      oprot.writeFieldEnd()
22492 
    oprot.writeFieldStop()
22493 
    oprot.writeStructEnd()
22494 
 
22495 
  def validate(self):
22496 
    return
22497 
 
22498 
 
22499 
  def __repr__(self):
22500 
    L = ['%s=%r' % (key, value)
22501 
      for key, value in self.__dict__.iteritems()]
22502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22503 
 
22504 
  def __eq__(self, other):
22505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22506 
 
22507 
  def __ne__(self, other):
22508 
    return not (self == other)
22509 
 
22510 
class markOrdersAsNotAvailabke_args:
22511 
  """
22512 
  Attributes:
22513 
   - vendorId
22514 
   - itemId
22515 
   - quantity
22516 
   - estimate
4369 rajveer 22517 
   - isReminder
4303 rajveer 22518 
  """
22519 
 
22520 
  thrift_spec = (
22521 
    None, # 0
22522 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22523 
    (2, TType.I64, 'itemId', None, None, ), # 2
22524 
    (3, TType.I64, 'quantity', None, None, ), # 3
22525 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22526 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22527 
  )
22528 
 
4369 rajveer 22529 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22530 
    self.vendorId = vendorId
22531 
    self.itemId = itemId
22532 
    self.quantity = quantity
22533 
    self.estimate = estimate
4369 rajveer 22534 
    self.isReminder = isReminder
4303 rajveer 22535 
 
22536 
  def read(self, iprot):
22537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22539 
      return
22540 
    iprot.readStructBegin()
22541 
    while True:
22542 
      (fname, ftype, fid) = iprot.readFieldBegin()
22543 
      if ftype == TType.STOP:
22544 
        break
22545 
      if fid == 1:
22546 
        if ftype == TType.I64:
22547 
          self.vendorId = iprot.readI64();
22548 
        else:
22549 
          iprot.skip(ftype)
22550 
      elif fid == 2:
22551 
        if ftype == TType.I64:
22552 
          self.itemId = iprot.readI64();
22553 
        else:
22554 
          iprot.skip(ftype)
22555 
      elif fid == 3:
22556 
        if ftype == TType.I64:
22557 
          self.quantity = iprot.readI64();
22558 
        else:
22559 
          iprot.skip(ftype)
22560 
      elif fid == 4:
22561 
        if ftype == TType.I64:
22562 
          self.estimate = iprot.readI64();
22563 
        else:
22564 
          iprot.skip(ftype)
4369 rajveer 22565 
      elif fid == 5:
22566 
        if ftype == TType.BOOL:
22567 
          self.isReminder = iprot.readBool();
22568 
        else:
22569 
          iprot.skip(ftype)
4303 rajveer 22570 
      else:
22571 
        iprot.skip(ftype)
22572 
      iprot.readFieldEnd()
22573 
    iprot.readStructEnd()
22574 
 
22575 
  def write(self, oprot):
22576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22578 
      return
22579 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
22580 
    if self.vendorId is not None:
22581 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22582 
      oprot.writeI64(self.vendorId)
22583 
      oprot.writeFieldEnd()
22584 
    if self.itemId is not None:
22585 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22586 
      oprot.writeI64(self.itemId)
22587 
      oprot.writeFieldEnd()
22588 
    if self.quantity is not None:
22589 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22590 
      oprot.writeI64(self.quantity)
22591 
      oprot.writeFieldEnd()
22592 
    if self.estimate is not None:
22593 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22594 
      oprot.writeI64(self.estimate)
22595 
      oprot.writeFieldEnd()
4369 rajveer 22596 
    if self.isReminder is not None:
22597 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22598 
      oprot.writeBool(self.isReminder)
22599 
      oprot.writeFieldEnd()
4303 rajveer 22600 
    oprot.writeFieldStop()
22601 
    oprot.writeStructEnd()
22602 
 
22603 
  def validate(self):
22604 
    return
22605 
 
22606 
 
22607 
  def __repr__(self):
22608 
    L = ['%s=%r' % (key, value)
22609 
      for key, value in self.__dict__.iteritems()]
22610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22611 
 
22612 
  def __eq__(self, other):
22613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22614 
 
22615 
  def __ne__(self, other):
22616 
    return not (self == other)
22617 
 
22618 
class markOrdersAsNotAvailabke_result:
22619 
  """
22620 
  Attributes:
22621 
   - ex
22622 
  """
22623 
 
22624 
  thrift_spec = (
22625 
    None, # 0
22626 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22627 
  )
22628 
 
22629 
  def __init__(self, ex=None,):
22630 
    self.ex = ex
22631 
 
22632 
  def read(self, iprot):
22633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22635 
      return
22636 
    iprot.readStructBegin()
22637 
    while True:
22638 
      (fname, ftype, fid) = iprot.readFieldBegin()
22639 
      if ftype == TType.STOP:
22640 
        break
22641 
      if fid == 1:
22642 
        if ftype == TType.STRUCT:
22643 
          self.ex = TransactionServiceException()
22644 
          self.ex.read(iprot)
22645 
        else:
22646 
          iprot.skip(ftype)
22647 
      else:
22648 
        iprot.skip(ftype)
22649 
      iprot.readFieldEnd()
22650 
    iprot.readStructEnd()
22651 
 
22652 
  def write(self, oprot):
22653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22655 
      return
22656 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
22657 
    if self.ex is not None:
22658 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22659 
      self.ex.write(oprot)
22660 
      oprot.writeFieldEnd()
22661 
    oprot.writeFieldStop()
22662 
    oprot.writeStructEnd()
22663 
 
22664 
  def validate(self):
22665 
    return
22666 
 
22667 
 
22668 
  def __repr__(self):
22669 
    L = ['%s=%r' % (key, value)
22670 
      for key, value in self.__dict__.iteritems()]
22671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22672 
 
22673 
  def __eq__(self, other):
22674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22675 
 
22676 
  def __ne__(self, other):
22677 
    return not (self == other)
4369 rajveer 22678 
 
22679 
class markOrdersAsTimeout_args:
22680 
  """
22681 
  Attributes:
22682 
   - vendorId
22683 
  """
22684 
 
22685 
  thrift_spec = (
22686 
    None, # 0
22687 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22688 
  )
22689 
 
22690 
  def __init__(self, vendorId=None,):
22691 
    self.vendorId = vendorId
22692 
 
22693 
  def read(self, iprot):
22694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22696 
      return
22697 
    iprot.readStructBegin()
22698 
    while True:
22699 
      (fname, ftype, fid) = iprot.readFieldBegin()
22700 
      if ftype == TType.STOP:
22701 
        break
22702 
      if fid == 1:
22703 
        if ftype == TType.I64:
22704 
          self.vendorId = iprot.readI64();
22705 
        else:
22706 
          iprot.skip(ftype)
22707 
      else:
22708 
        iprot.skip(ftype)
22709 
      iprot.readFieldEnd()
22710 
    iprot.readStructEnd()
22711 
 
22712 
  def write(self, oprot):
22713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22715 
      return
22716 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
22717 
    if self.vendorId is not None:
22718 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22719 
      oprot.writeI64(self.vendorId)
22720 
      oprot.writeFieldEnd()
22721 
    oprot.writeFieldStop()
22722 
    oprot.writeStructEnd()
22723 
 
22724 
  def validate(self):
22725 
    return
22726 
 
22727 
 
22728 
  def __repr__(self):
22729 
    L = ['%s=%r' % (key, value)
22730 
      for key, value in self.__dict__.iteritems()]
22731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22732 
 
22733 
  def __eq__(self, other):
22734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22735 
 
22736 
  def __ne__(self, other):
22737 
    return not (self == other)
22738 
 
22739 
class markOrdersAsTimeout_result:
22740 
  """
22741 
  Attributes:
22742 
   - success
22743 
   - ex
22744 
  """
22745 
 
22746 
  thrift_spec = (
22747 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
22748 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22749 
  )
22750 
 
22751 
  def __init__(self, success=None, ex=None,):
22752 
    self.success = success
22753 
    self.ex = ex
22754 
 
22755 
  def read(self, iprot):
22756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22758 
      return
22759 
    iprot.readStructBegin()
22760 
    while True:
22761 
      (fname, ftype, fid) = iprot.readFieldBegin()
22762 
      if ftype == TType.STOP:
22763 
        break
22764 
      if fid == 0:
22765 
        if ftype == TType.MAP:
22766 
          self.success = {}
6188 rajveer 22767 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
22768 
          for _i505 in xrange(_size501):
22769 
            _key506 = iprot.readI32();
22770 
            _val507 = TimeoutSummary()
22771 
            _val507.read(iprot)
22772 
            self.success[_key506] = _val507
4369 rajveer 22773 
          iprot.readMapEnd()
22774 
        else:
22775 
          iprot.skip(ftype)
22776 
      elif fid == 1:
22777 
        if ftype == TType.STRUCT:
22778 
          self.ex = TransactionServiceException()
22779 
          self.ex.read(iprot)
22780 
        else:
22781 
          iprot.skip(ftype)
22782 
      else:
22783 
        iprot.skip(ftype)
22784 
      iprot.readFieldEnd()
22785 
    iprot.readStructEnd()
22786 
 
22787 
  def write(self, oprot):
22788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22790 
      return
22791 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
22792 
    if self.success is not None:
22793 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22794 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 22795 
      for kiter508,viter509 in self.success.items():
22796 
        oprot.writeI32(kiter508)
22797 
        viter509.write(oprot)
4369 rajveer 22798 
      oprot.writeMapEnd()
22799 
      oprot.writeFieldEnd()
22800 
    if self.ex is not None:
22801 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22802 
      self.ex.write(oprot)
22803 
      oprot.writeFieldEnd()
22804 
    oprot.writeFieldStop()
22805 
    oprot.writeStructEnd()
22806 
 
22807 
  def validate(self):
22808 
    return
22809 
 
22810 
 
22811 
  def __repr__(self):
22812 
    L = ['%s=%r' % (key, value)
22813 
      for key, value in self.__dict__.iteritems()]
22814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22815 
 
22816 
  def __eq__(self, other):
22817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22818 
 
22819 
  def __ne__(self, other):
22820 
    return not (self == other)
4386 anupam.sin 22821 
 
4662 rajveer 22822 
class markOrderAsLostInTransit_args:
22823 
  """
22824 
  Attributes:
22825 
   - orderId
22826 
  """
22827 
 
22828 
  thrift_spec = (
22829 
    None, # 0
22830 
    (1, TType.I64, 'orderId', None, None, ), # 1
22831 
  )
22832 
 
22833 
  def __init__(self, orderId=None,):
22834 
    self.orderId = orderId
22835 
 
22836 
  def read(self, iprot):
22837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22839 
      return
22840 
    iprot.readStructBegin()
22841 
    while True:
22842 
      (fname, ftype, fid) = iprot.readFieldBegin()
22843 
      if ftype == TType.STOP:
22844 
        break
22845 
      if fid == 1:
22846 
        if ftype == TType.I64:
22847 
          self.orderId = iprot.readI64();
22848 
        else:
22849 
          iprot.skip(ftype)
22850 
      else:
22851 
        iprot.skip(ftype)
22852 
      iprot.readFieldEnd()
22853 
    iprot.readStructEnd()
22854 
 
22855 
  def write(self, oprot):
22856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22858 
      return
22859 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
22860 
    if self.orderId is not None:
22861 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22862 
      oprot.writeI64(self.orderId)
22863 
      oprot.writeFieldEnd()
22864 
    oprot.writeFieldStop()
22865 
    oprot.writeStructEnd()
22866 
 
22867 
  def validate(self):
22868 
    return
22869 
 
22870 
 
22871 
  def __repr__(self):
22872 
    L = ['%s=%r' % (key, value)
22873 
      for key, value in self.__dict__.iteritems()]
22874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22875 
 
22876 
  def __eq__(self, other):
22877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22878 
 
22879 
  def __ne__(self, other):
22880 
    return not (self == other)
22881 
 
22882 
class markOrderAsLostInTransit_result:
22883 
  """
22884 
  Attributes:
22885 
   - success
22886 
   - ex
22887 
  """
22888 
 
22889 
  thrift_spec = (
22890 
    (0, TType.BOOL, 'success', None, None, ), # 0
22891 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22892 
  )
22893 
 
22894 
  def __init__(self, success=None, ex=None,):
22895 
    self.success = success
22896 
    self.ex = ex
22897 
 
22898 
  def read(self, iprot):
22899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22901 
      return
22902 
    iprot.readStructBegin()
22903 
    while True:
22904 
      (fname, ftype, fid) = iprot.readFieldBegin()
22905 
      if ftype == TType.STOP:
22906 
        break
22907 
      if fid == 0:
22908 
        if ftype == TType.BOOL:
22909 
          self.success = iprot.readBool();
22910 
        else:
22911 
          iprot.skip(ftype)
22912 
      elif fid == 1:
22913 
        if ftype == TType.STRUCT:
22914 
          self.ex = TransactionServiceException()
22915 
          self.ex.read(iprot)
22916 
        else:
22917 
          iprot.skip(ftype)
22918 
      else:
22919 
        iprot.skip(ftype)
22920 
      iprot.readFieldEnd()
22921 
    iprot.readStructEnd()
22922 
 
22923 
  def write(self, oprot):
22924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22926 
      return
22927 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
22928 
    if self.success is not None:
22929 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22930 
      oprot.writeBool(self.success)
22931 
      oprot.writeFieldEnd()
22932 
    if self.ex is not None:
22933 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22934 
      self.ex.write(oprot)
22935 
      oprot.writeFieldEnd()
22936 
    oprot.writeFieldStop()
22937 
    oprot.writeStructEnd()
22938 
 
22939 
  def validate(self):
22940 
    return
22941 
 
22942 
 
22943 
  def __repr__(self):
22944 
    L = ['%s=%r' % (key, value)
22945 
      for key, value in self.__dict__.iteritems()]
22946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22947 
 
22948 
  def __eq__(self, other):
22949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22950 
 
22951 
  def __ne__(self, other):
22952 
    return not (self == other)
22953 
 
4386 anupam.sin 22954 
class getOrderForAwb_args:
22955 
  """
22956 
  Attributes:
22957 
   - awb
22958 
  """
22959 
 
22960 
  thrift_spec = (
22961 
    None, # 0
22962 
    (1, TType.STRING, 'awb', None, None, ), # 1
22963 
  )
22964 
 
22965 
  def __init__(self, awb=None,):
22966 
    self.awb = awb
22967 
 
22968 
  def read(self, iprot):
22969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22971 
      return
22972 
    iprot.readStructBegin()
22973 
    while True:
22974 
      (fname, ftype, fid) = iprot.readFieldBegin()
22975 
      if ftype == TType.STOP:
22976 
        break
22977 
      if fid == 1:
22978 
        if ftype == TType.STRING:
22979 
          self.awb = iprot.readString();
22980 
        else:
22981 
          iprot.skip(ftype)
22982 
      else:
22983 
        iprot.skip(ftype)
22984 
      iprot.readFieldEnd()
22985 
    iprot.readStructEnd()
22986 
 
22987 
  def write(self, oprot):
22988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22990 
      return
22991 
    oprot.writeStructBegin('getOrderForAwb_args')
22992 
    if self.awb is not None:
22993 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
22994 
      oprot.writeString(self.awb)
22995 
      oprot.writeFieldEnd()
22996 
    oprot.writeFieldStop()
22997 
    oprot.writeStructEnd()
22998 
 
22999 
  def validate(self):
23000 
    return
23001 
 
23002 
 
23003 
  def __repr__(self):
23004 
    L = ['%s=%r' % (key, value)
23005 
      for key, value in self.__dict__.iteritems()]
23006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23007 
 
23008 
  def __eq__(self, other):
23009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23010 
 
23011 
  def __ne__(self, other):
23012 
    return not (self == other)
23013 
 
23014 
class getOrderForAwb_result:
23015 
  """
23016 
  Attributes:
23017 
   - success
23018 
   - ex
23019 
  """
23020 
 
23021 
  thrift_spec = (
23022 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
23023 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23024 
  )
23025 
 
23026 
  def __init__(self, success=None, ex=None,):
23027 
    self.success = success
23028 
    self.ex = ex
23029 
 
23030 
  def read(self, iprot):
23031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23033 
      return
23034 
    iprot.readStructBegin()
23035 
    while True:
23036 
      (fname, ftype, fid) = iprot.readFieldBegin()
23037 
      if ftype == TType.STOP:
23038 
        break
23039 
      if fid == 0:
23040 
        if ftype == TType.STRUCT:
23041 
          self.success = Order()
23042 
          self.success.read(iprot)
23043 
        else:
23044 
          iprot.skip(ftype)
23045 
      elif fid == 1:
23046 
        if ftype == TType.STRUCT:
23047 
          self.ex = TransactionServiceException()
23048 
          self.ex.read(iprot)
23049 
        else:
23050 
          iprot.skip(ftype)
23051 
      else:
23052 
        iprot.skip(ftype)
23053 
      iprot.readFieldEnd()
23054 
    iprot.readStructEnd()
23055 
 
23056 
  def write(self, oprot):
23057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23059 
      return
23060 
    oprot.writeStructBegin('getOrderForAwb_result')
23061 
    if self.success is not None:
23062 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23063 
      self.success.write(oprot)
23064 
      oprot.writeFieldEnd()
23065 
    if self.ex is not None:
23066 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23067 
      self.ex.write(oprot)
23068 
      oprot.writeFieldEnd()
23069 
    oprot.writeFieldStop()
23070 
    oprot.writeStructEnd()
23071 
 
23072 
  def validate(self):
23073 
    return
23074 
 
23075 
 
23076 
  def __repr__(self):
23077 
    L = ['%s=%r' % (key, value)
23078 
      for key, value in self.__dict__.iteritems()]
23079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23080 
 
23081 
  def __eq__(self, other):
23082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23083 
 
23084 
  def __ne__(self, other):
23085 
    return not (self == other)
4506 phani.kuma 23086 
 
23087 
class getOrdersForProviderForStatus_args:
23088 
  """
23089 
  Attributes:
23090 
   - logistics_provider_id
4910 phani.kuma 23091 
   - order_status_list
4506 phani.kuma 23092 
  """
23093 
 
23094 
  thrift_spec = (
23095 
    None, # 0
23096 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 23097 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 23098 
  )
23099 
 
4910 phani.kuma 23100 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 23101 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 23102 
    self.order_status_list = order_status_list
4506 phani.kuma 23103 
 
23104 
  def read(self, iprot):
23105 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23106 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23107 
      return
23108 
    iprot.readStructBegin()
23109 
    while True:
23110 
      (fname, ftype, fid) = iprot.readFieldBegin()
23111 
      if ftype == TType.STOP:
23112 
        break
23113 
      if fid == 1:
23114 
        if ftype == TType.I64:
23115 
          self.logistics_provider_id = iprot.readI64();
23116 
        else:
23117 
          iprot.skip(ftype)
23118 
      elif fid == 2:
4910 phani.kuma 23119 
        if ftype == TType.LIST:
23120 
          self.order_status_list = []
6188 rajveer 23121 
          (_etype513, _size510) = iprot.readListBegin()
23122 
          for _i514 in xrange(_size510):
23123 
            _elem515 = iprot.readI32();
23124 
            self.order_status_list.append(_elem515)
4910 phani.kuma 23125 
          iprot.readListEnd()
4506 phani.kuma 23126 
        else:
23127 
          iprot.skip(ftype)
23128 
      else:
23129 
        iprot.skip(ftype)
23130 
      iprot.readFieldEnd()
23131 
    iprot.readStructEnd()
23132 
 
23133 
  def write(self, oprot):
23134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23136 
      return
23137 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
23138 
    if self.logistics_provider_id is not None:
23139 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
23140 
      oprot.writeI64(self.logistics_provider_id)
23141 
      oprot.writeFieldEnd()
4910 phani.kuma 23142 
    if self.order_status_list is not None:
23143 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
23144 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 23145 
      for iter516 in self.order_status_list:
23146 
        oprot.writeI32(iter516)
4910 phani.kuma 23147 
      oprot.writeListEnd()
4506 phani.kuma 23148 
      oprot.writeFieldEnd()
23149 
    oprot.writeFieldStop()
23150 
    oprot.writeStructEnd()
23151 
 
23152 
  def validate(self):
23153 
    return
23154 
 
23155 
 
23156 
  def __repr__(self):
23157 
    L = ['%s=%r' % (key, value)
23158 
      for key, value in self.__dict__.iteritems()]
23159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23160 
 
23161 
  def __eq__(self, other):
23162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23163 
 
23164 
  def __ne__(self, other):
23165 
    return not (self == other)
23166 
 
23167 
class getOrdersForProviderForStatus_result:
23168 
  """
23169 
  Attributes:
23170 
   - success
23171 
   - ex
23172 
  """
23173 
 
23174 
  thrift_spec = (
23175 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23176 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23177 
  )
23178 
 
23179 
  def __init__(self, success=None, ex=None,):
23180 
    self.success = success
23181 
    self.ex = ex
23182 
 
23183 
  def read(self, iprot):
23184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23186 
      return
23187 
    iprot.readStructBegin()
23188 
    while True:
23189 
      (fname, ftype, fid) = iprot.readFieldBegin()
23190 
      if ftype == TType.STOP:
23191 
        break
23192 
      if fid == 0:
23193 
        if ftype == TType.LIST:
23194 
          self.success = []
6188 rajveer 23195 
          (_etype520, _size517) = iprot.readListBegin()
23196 
          for _i521 in xrange(_size517):
23197 
            _elem522 = Order()
23198 
            _elem522.read(iprot)
23199 
            self.success.append(_elem522)
4506 phani.kuma 23200 
          iprot.readListEnd()
23201 
        else:
23202 
          iprot.skip(ftype)
23203 
      elif fid == 1:
23204 
        if ftype == TType.STRUCT:
23205 
          self.ex = TransactionServiceException()
23206 
          self.ex.read(iprot)
23207 
        else:
23208 
          iprot.skip(ftype)
23209 
      else:
23210 
        iprot.skip(ftype)
23211 
      iprot.readFieldEnd()
23212 
    iprot.readStructEnd()
23213 
 
23214 
  def write(self, oprot):
23215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23217 
      return
23218 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
23219 
    if self.success is not None:
23220 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23221 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23222 
      for iter523 in self.success:
23223 
        iter523.write(oprot)
4506 phani.kuma 23224 
      oprot.writeListEnd()
23225 
      oprot.writeFieldEnd()
23226 
    if self.ex is not None:
23227 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23228 
      self.ex.write(oprot)
23229 
      oprot.writeFieldEnd()
23230 
    oprot.writeFieldStop()
23231 
    oprot.writeStructEnd()
23232 
 
23233 
  def validate(self):
23234 
    return
23235 
 
23236 
 
23237 
  def __repr__(self):
23238 
    L = ['%s=%r' % (key, value)
23239 
      for key, value in self.__dict__.iteritems()]
23240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23241 
 
23242 
  def __eq__(self, other):
23243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23244 
 
23245 
  def __ne__(self, other):
23246 
    return not (self == other)
4600 varun.gupt 23247 
 
23248 
class getBilledOrdersForVendor_args:
23249 
  """
23250 
  Attributes:
23251 
   - vendorId
23252 
   - billingDateFrom
23253 
   - billingDateTo
23254 
  """
23255 
 
23256 
  thrift_spec = (
23257 
    None, # 0
23258 
    (1, TType.I64, 'vendorId', None, None, ), # 1
23259 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
23260 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
23261 
  )
23262 
 
23263 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
23264 
    self.vendorId = vendorId
23265 
    self.billingDateFrom = billingDateFrom
23266 
    self.billingDateTo = billingDateTo
23267 
 
23268 
  def read(self, iprot):
23269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23271 
      return
23272 
    iprot.readStructBegin()
23273 
    while True:
23274 
      (fname, ftype, fid) = iprot.readFieldBegin()
23275 
      if ftype == TType.STOP:
23276 
        break
23277 
      if fid == 1:
23278 
        if ftype == TType.I64:
23279 
          self.vendorId = iprot.readI64();
23280 
        else:
23281 
          iprot.skip(ftype)
23282 
      elif fid == 2:
23283 
        if ftype == TType.I64:
23284 
          self.billingDateFrom = iprot.readI64();
23285 
        else:
23286 
          iprot.skip(ftype)
23287 
      elif fid == 3:
23288 
        if ftype == TType.I64:
23289 
          self.billingDateTo = iprot.readI64();
23290 
        else:
23291 
          iprot.skip(ftype)
23292 
      else:
23293 
        iprot.skip(ftype)
23294 
      iprot.readFieldEnd()
23295 
    iprot.readStructEnd()
23296 
 
23297 
  def write(self, oprot):
23298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23300 
      return
23301 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
23302 
    if self.vendorId is not None:
23303 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23304 
      oprot.writeI64(self.vendorId)
23305 
      oprot.writeFieldEnd()
23306 
    if self.billingDateFrom is not None:
23307 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
23308 
      oprot.writeI64(self.billingDateFrom)
23309 
      oprot.writeFieldEnd()
23310 
    if self.billingDateTo is not None:
23311 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
23312 
      oprot.writeI64(self.billingDateTo)
23313 
      oprot.writeFieldEnd()
23314 
    oprot.writeFieldStop()
23315 
    oprot.writeStructEnd()
23316 
 
23317 
  def validate(self):
23318 
    return
23319 
 
23320 
 
23321 
  def __repr__(self):
23322 
    L = ['%s=%r' % (key, value)
23323 
      for key, value in self.__dict__.iteritems()]
23324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23325 
 
23326 
  def __eq__(self, other):
23327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23328 
 
23329 
  def __ne__(self, other):
23330 
    return not (self == other)
23331 
 
23332 
class getBilledOrdersForVendor_result:
23333 
  """
23334 
  Attributes:
23335 
   - success
23336 
   - ex
23337 
  """
23338 
 
23339 
  thrift_spec = (
23340 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23341 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23342 
  )
23343 
 
23344 
  def __init__(self, success=None, ex=None,):
23345 
    self.success = success
23346 
    self.ex = ex
23347 
 
23348 
  def read(self, iprot):
23349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23351 
      return
23352 
    iprot.readStructBegin()
23353 
    while True:
23354 
      (fname, ftype, fid) = iprot.readFieldBegin()
23355 
      if ftype == TType.STOP:
23356 
        break
23357 
      if fid == 0:
23358 
        if ftype == TType.LIST:
23359 
          self.success = []
6188 rajveer 23360 
          (_etype527, _size524) = iprot.readListBegin()
23361 
          for _i528 in xrange(_size524):
23362 
            _elem529 = Order()
23363 
            _elem529.read(iprot)
23364 
            self.success.append(_elem529)
4600 varun.gupt 23365 
          iprot.readListEnd()
23366 
        else:
23367 
          iprot.skip(ftype)
23368 
      elif fid == 1:
23369 
        if ftype == TType.STRUCT:
23370 
          self.ex = TransactionServiceException()
23371 
          self.ex.read(iprot)
23372 
        else:
23373 
          iprot.skip(ftype)
23374 
      else:
23375 
        iprot.skip(ftype)
23376 
      iprot.readFieldEnd()
23377 
    iprot.readStructEnd()
23378 
 
23379 
  def write(self, oprot):
23380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23382 
      return
23383 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
23384 
    if self.success is not None:
23385 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23386 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23387 
      for iter530 in self.success:
23388 
        iter530.write(oprot)
4600 varun.gupt 23389 
      oprot.writeListEnd()
23390 
      oprot.writeFieldEnd()
23391 
    if self.ex is not None:
23392 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23393 
      self.ex.write(oprot)
23394 
      oprot.writeFieldEnd()
23395 
    oprot.writeFieldStop()
23396 
    oprot.writeStructEnd()
23397 
 
23398 
  def validate(self):
23399 
    return
23400 
 
23401 
 
23402 
  def __repr__(self):
23403 
    L = ['%s=%r' % (key, value)
23404 
      for key, value in self.__dict__.iteritems()]
23405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23406 
 
23407 
  def __eq__(self, other):
23408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23409 
 
23410 
  def __ne__(self, other):
23411 
    return not (self == other)
23412 
 
4607 rajveer 23413 
class getSlippedSippingDateOrders_args:
23414 
 
23415 
  thrift_spec = (
23416 
  )
23417 
 
23418 
  def read(self, iprot):
23419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23421 
      return
23422 
    iprot.readStructBegin()
23423 
    while True:
23424 
      (fname, ftype, fid) = iprot.readFieldBegin()
23425 
      if ftype == TType.STOP:
23426 
        break
23427 
      else:
23428 
        iprot.skip(ftype)
23429 
      iprot.readFieldEnd()
23430 
    iprot.readStructEnd()
23431 
 
23432 
  def write(self, oprot):
23433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23435 
      return
23436 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
23437 
    oprot.writeFieldStop()
23438 
    oprot.writeStructEnd()
23439 
 
23440 
  def validate(self):
23441 
    return
23442 
 
23443 
 
23444 
  def __repr__(self):
23445 
    L = ['%s=%r' % (key, value)
23446 
      for key, value in self.__dict__.iteritems()]
23447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23448 
 
23449 
  def __eq__(self, other):
23450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23451 
 
23452 
  def __ne__(self, other):
23453 
    return not (self == other)
23454 
 
23455 
class getSlippedSippingDateOrders_result:
23456 
  """
23457 
  Attributes:
23458 
   - success
23459 
   - ex
23460 
  """
23461 
 
23462 
  thrift_spec = (
23463 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23464 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23465 
  )
23466 
 
23467 
  def __init__(self, success=None, ex=None,):
23468 
    self.success = success
23469 
    self.ex = ex
23470 
 
23471 
  def read(self, iprot):
23472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23474 
      return
23475 
    iprot.readStructBegin()
23476 
    while True:
23477 
      (fname, ftype, fid) = iprot.readFieldBegin()
23478 
      if ftype == TType.STOP:
23479 
        break
23480 
      if fid == 0:
23481 
        if ftype == TType.LIST:
23482 
          self.success = []
6188 rajveer 23483 
          (_etype534, _size531) = iprot.readListBegin()
23484 
          for _i535 in xrange(_size531):
23485 
            _elem536 = Order()
23486 
            _elem536.read(iprot)
23487 
            self.success.append(_elem536)
4607 rajveer 23488 
          iprot.readListEnd()
23489 
        else:
23490 
          iprot.skip(ftype)
23491 
      elif fid == 1:
23492 
        if ftype == TType.STRUCT:
23493 
          self.ex = TransactionServiceException()
23494 
          self.ex.read(iprot)
23495 
        else:
23496 
          iprot.skip(ftype)
23497 
      else:
23498 
        iprot.skip(ftype)
23499 
      iprot.readFieldEnd()
23500 
    iprot.readStructEnd()
23501 
 
23502 
  def write(self, oprot):
23503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23505 
      return
23506 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
23507 
    if self.success is not None:
23508 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23509 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23510 
      for iter537 in self.success:
23511 
        iter537.write(oprot)
4607 rajveer 23512 
      oprot.writeListEnd()
23513 
      oprot.writeFieldEnd()
23514 
    if self.ex is not None:
23515 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23516 
      self.ex.write(oprot)
23517 
      oprot.writeFieldEnd()
23518 
    oprot.writeFieldStop()
23519 
    oprot.writeStructEnd()
23520 
 
23521 
  def validate(self):
23522 
    return
23523 
 
23524 
 
23525 
  def __repr__(self):
23526 
    L = ['%s=%r' % (key, value)
23527 
      for key, value in self.__dict__.iteritems()]
23528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23529 
 
23530 
  def __eq__(self, other):
23531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23532 
 
23533 
  def __ne__(self, other):
23534 
    return not (self == other)
23535 
 
4709 rajveer 23536 
class getCancelledOrders_args:
23537 
  """
23538 
  Attributes:
23539 
   - cancelDateFrom
23540 
   - cancelDateTo
23541 
  """
23542 
 
23543 
  thrift_spec = (
23544 
    None, # 0
23545 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
23546 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
23547 
  )
23548 
 
23549 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
23550 
    self.cancelDateFrom = cancelDateFrom
23551 
    self.cancelDateTo = cancelDateTo
23552 
 
23553 
  def read(self, iprot):
23554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23556 
      return
23557 
    iprot.readStructBegin()
23558 
    while True:
23559 
      (fname, ftype, fid) = iprot.readFieldBegin()
23560 
      if ftype == TType.STOP:
23561 
        break
23562 
      if fid == 1:
23563 
        if ftype == TType.I64:
23564 
          self.cancelDateFrom = iprot.readI64();
23565 
        else:
23566 
          iprot.skip(ftype)
23567 
      elif fid == 2:
23568 
        if ftype == TType.I64:
23569 
          self.cancelDateTo = iprot.readI64();
23570 
        else:
23571 
          iprot.skip(ftype)
23572 
      else:
23573 
        iprot.skip(ftype)
23574 
      iprot.readFieldEnd()
23575 
    iprot.readStructEnd()
23576 
 
23577 
  def write(self, oprot):
23578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23580 
      return
23581 
    oprot.writeStructBegin('getCancelledOrders_args')
23582 
    if self.cancelDateFrom is not None:
23583 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
23584 
      oprot.writeI64(self.cancelDateFrom)
23585 
      oprot.writeFieldEnd()
23586 
    if self.cancelDateTo is not None:
23587 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
23588 
      oprot.writeI64(self.cancelDateTo)
23589 
      oprot.writeFieldEnd()
23590 
    oprot.writeFieldStop()
23591 
    oprot.writeStructEnd()
23592 
 
23593 
  def validate(self):
23594 
    return
23595 
 
23596 
 
23597 
  def __repr__(self):
23598 
    L = ['%s=%r' % (key, value)
23599 
      for key, value in self.__dict__.iteritems()]
23600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23601 
 
23602 
  def __eq__(self, other):
23603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23604 
 
23605 
  def __ne__(self, other):
23606 
    return not (self == other)
23607 
 
23608 
class getCancelledOrders_result:
23609 
  """
23610 
  Attributes:
23611 
   - success
23612 
   - ex
23613 
  """
23614 
 
23615 
  thrift_spec = (
23616 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23617 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23618 
  )
23619 
 
23620 
  def __init__(self, success=None, ex=None,):
23621 
    self.success = success
23622 
    self.ex = ex
23623 
 
23624 
  def read(self, iprot):
23625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23627 
      return
23628 
    iprot.readStructBegin()
23629 
    while True:
23630 
      (fname, ftype, fid) = iprot.readFieldBegin()
23631 
      if ftype == TType.STOP:
23632 
        break
23633 
      if fid == 0:
23634 
        if ftype == TType.LIST:
23635 
          self.success = []
6188 rajveer 23636 
          (_etype541, _size538) = iprot.readListBegin()
23637 
          for _i542 in xrange(_size538):
23638 
            _elem543 = Order()
23639 
            _elem543.read(iprot)
23640 
            self.success.append(_elem543)
4709 rajveer 23641 
          iprot.readListEnd()
23642 
        else:
23643 
          iprot.skip(ftype)
23644 
      elif fid == 1:
23645 
        if ftype == TType.STRUCT:
23646 
          self.ex = TransactionServiceException()
23647 
          self.ex.read(iprot)
23648 
        else:
23649 
          iprot.skip(ftype)
23650 
      else:
23651 
        iprot.skip(ftype)
23652 
      iprot.readFieldEnd()
23653 
    iprot.readStructEnd()
23654 
 
23655 
  def write(self, oprot):
23656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23658 
      return
23659 
    oprot.writeStructBegin('getCancelledOrders_result')
23660 
    if self.success is not None:
23661 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23662 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23663 
      for iter544 in self.success:
23664 
        iter544.write(oprot)
4709 rajveer 23665 
      oprot.writeListEnd()
23666 
      oprot.writeFieldEnd()
23667 
    if self.ex is not None:
23668 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23669 
      self.ex.write(oprot)
23670 
      oprot.writeFieldEnd()
23671 
    oprot.writeFieldStop()
23672 
    oprot.writeStructEnd()
23673 
 
23674 
  def validate(self):
23675 
    return
23676 
 
23677 
 
23678 
  def __repr__(self):
23679 
    L = ['%s=%r' % (key, value)
23680 
      for key, value in self.__dict__.iteritems()]
23681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23682 
 
23683 
  def __eq__(self, other):
23684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23685 
 
23686 
  def __ne__(self, other):
23687 
    return not (self == other)
23688 
 
4600 varun.gupt 23689 
class saveBluedartSettlements_args:
23690 
  """
23691 
  Attributes:
23692 
   - mapAWBAndAmount
23693 
  """
23694 
 
23695 
  thrift_spec = (
23696 
    None, # 0
23697 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
23698 
  )
23699 
 
23700 
  def __init__(self, mapAWBAndAmount=None,):
23701 
    self.mapAWBAndAmount = mapAWBAndAmount
23702 
 
23703 
  def read(self, iprot):
23704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23706 
      return
23707 
    iprot.readStructBegin()
23708 
    while True:
23709 
      (fname, ftype, fid) = iprot.readFieldBegin()
23710 
      if ftype == TType.STOP:
23711 
        break
23712 
      if fid == 1:
23713 
        if ftype == TType.MAP:
23714 
          self.mapAWBAndAmount = {}
6188 rajveer 23715 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
23716 
          for _i549 in xrange(_size545):
23717 
            _key550 = iprot.readI64();
23718 
            _val551 = iprot.readDouble();
23719 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 23720 
          iprot.readMapEnd()
23721 
        else:
23722 
          iprot.skip(ftype)
23723 
      else:
23724 
        iprot.skip(ftype)
23725 
      iprot.readFieldEnd()
23726 
    iprot.readStructEnd()
23727 
 
23728 
  def write(self, oprot):
23729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23731 
      return
23732 
    oprot.writeStructBegin('saveBluedartSettlements_args')
23733 
    if self.mapAWBAndAmount is not None:
23734 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
23735 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 23736 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
23737 
        oprot.writeI64(kiter552)
23738 
        oprot.writeDouble(viter553)
4600 varun.gupt 23739 
      oprot.writeMapEnd()
23740 
      oprot.writeFieldEnd()
23741 
    oprot.writeFieldStop()
23742 
    oprot.writeStructEnd()
23743 
 
23744 
  def validate(self):
23745 
    return
23746 
 
23747 
 
23748 
  def __repr__(self):
23749 
    L = ['%s=%r' % (key, value)
23750 
      for key, value in self.__dict__.iteritems()]
23751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23752 
 
23753 
  def __eq__(self, other):
23754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23755 
 
23756 
  def __ne__(self, other):
23757 
    return not (self == other)
23758 
 
23759 
class saveBluedartSettlements_result:
23760 
  """
23761 
  Attributes:
23762 
   - ex
23763 
  """
23764 
 
23765 
  thrift_spec = (
23766 
    None, # 0
23767 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23768 
  )
23769 
 
23770 
  def __init__(self, ex=None,):
23771 
    self.ex = ex
23772 
 
23773 
  def read(self, iprot):
23774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23776 
      return
23777 
    iprot.readStructBegin()
23778 
    while True:
23779 
      (fname, ftype, fid) = iprot.readFieldBegin()
23780 
      if ftype == TType.STOP:
23781 
        break
23782 
      if fid == 1:
23783 
        if ftype == TType.STRUCT:
23784 
          self.ex = TransactionServiceException()
23785 
          self.ex.read(iprot)
23786 
        else:
23787 
          iprot.skip(ftype)
23788 
      else:
23789 
        iprot.skip(ftype)
23790 
      iprot.readFieldEnd()
23791 
    iprot.readStructEnd()
23792 
 
23793 
  def write(self, oprot):
23794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23796 
      return
23797 
    oprot.writeStructBegin('saveBluedartSettlements_result')
23798 
    if self.ex is not None:
23799 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23800 
      self.ex.write(oprot)
23801 
      oprot.writeFieldEnd()
23802 
    oprot.writeFieldStop()
23803 
    oprot.writeStructEnd()
23804 
 
23805 
  def validate(self):
23806 
    return
23807 
 
23808 
 
23809 
  def __repr__(self):
23810 
    L = ['%s=%r' % (key, value)
23811 
      for key, value in self.__dict__.iteritems()]
23812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23813 
 
23814 
  def __eq__(self, other):
23815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23816 
 
23817 
  def __ne__(self, other):
23818 
    return not (self == other)
23819 
 
23820 
class savePaymentSettlements_args:
23821 
  """
23822 
  Attributes:
23823 
   - settlementDate
23824 
   - paymentGatewayId
4905 varun.gupt 23825 
   - referenceId
4600 varun.gupt 23826 
   - serviceTax
23827 
   - otherCharges
23828 
   - netCollection
23829 
  """
23830 
 
23831 
  thrift_spec = (
23832 
    None, # 0
23833 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
23834 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 23835 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 23836 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
23837 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
23838 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
23839 
  )
23840 
 
4905 varun.gupt 23841 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 23842 
    self.settlementDate = settlementDate
23843 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 23844 
    self.referenceId = referenceId
4600 varun.gupt 23845 
    self.serviceTax = serviceTax
23846 
    self.otherCharges = otherCharges
23847 
    self.netCollection = netCollection
23848 
 
23849 
  def read(self, iprot):
23850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23852 
      return
23853 
    iprot.readStructBegin()
23854 
    while True:
23855 
      (fname, ftype, fid) = iprot.readFieldBegin()
23856 
      if ftype == TType.STOP:
23857 
        break
23858 
      if fid == 1:
23859 
        if ftype == TType.I64:
23860 
          self.settlementDate = iprot.readI64();
23861 
        else:
23862 
          iprot.skip(ftype)
23863 
      elif fid == 2:
23864 
        if ftype == TType.I64:
23865 
          self.paymentGatewayId = iprot.readI64();
23866 
        else:
23867 
          iprot.skip(ftype)
23868 
      elif fid == 3:
23869 
        if ftype == TType.I64:
4905 varun.gupt 23870 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23871 
        else:
23872 
          iprot.skip(ftype)
23873 
      elif fid == 4:
23874 
        if ftype == TType.DOUBLE:
23875 
          self.serviceTax = iprot.readDouble();
23876 
        else:
23877 
          iprot.skip(ftype)
23878 
      elif fid == 5:
23879 
        if ftype == TType.DOUBLE:
23880 
          self.otherCharges = iprot.readDouble();
23881 
        else:
23882 
          iprot.skip(ftype)
23883 
      elif fid == 6:
23884 
        if ftype == TType.DOUBLE:
23885 
          self.netCollection = iprot.readDouble();
23886 
        else:
23887 
          iprot.skip(ftype)
23888 
      else:
23889 
        iprot.skip(ftype)
23890 
      iprot.readFieldEnd()
23891 
    iprot.readStructEnd()
23892 
 
23893 
  def write(self, oprot):
23894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23896 
      return
23897 
    oprot.writeStructBegin('savePaymentSettlements_args')
23898 
    if self.settlementDate is not None:
23899 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
23900 
      oprot.writeI64(self.settlementDate)
23901 
      oprot.writeFieldEnd()
23902 
    if self.paymentGatewayId is not None:
23903 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
23904 
      oprot.writeI64(self.paymentGatewayId)
23905 
      oprot.writeFieldEnd()
4905 varun.gupt 23906 
    if self.referenceId is not None:
23907 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
23908 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23909 
      oprot.writeFieldEnd()
23910 
    if self.serviceTax is not None:
23911 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
23912 
      oprot.writeDouble(self.serviceTax)
23913 
      oprot.writeFieldEnd()
23914 
    if self.otherCharges is not None:
23915 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
23916 
      oprot.writeDouble(self.otherCharges)
23917 
      oprot.writeFieldEnd()
23918 
    if self.netCollection is not None:
23919 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
23920 
      oprot.writeDouble(self.netCollection)
23921 
      oprot.writeFieldEnd()
23922 
    oprot.writeFieldStop()
23923 
    oprot.writeStructEnd()
23924 
 
23925 
  def validate(self):
23926 
    return
23927 
 
23928 
 
23929 
  def __repr__(self):
23930 
    L = ['%s=%r' % (key, value)
23931 
      for key, value in self.__dict__.iteritems()]
23932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23933 
 
23934 
  def __eq__(self, other):
23935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23936 
 
23937 
  def __ne__(self, other):
23938 
    return not (self == other)
23939 
 
23940 
class savePaymentSettlements_result:
23941 
  """
23942 
  Attributes:
23943 
   - ex
23944 
  """
23945 
 
23946 
  thrift_spec = (
23947 
    None, # 0
23948 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23949 
  )
23950 
 
23951 
  def __init__(self, ex=None,):
23952 
    self.ex = ex
23953 
 
23954 
  def read(self, iprot):
23955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23957 
      return
23958 
    iprot.readStructBegin()
23959 
    while True:
23960 
      (fname, ftype, fid) = iprot.readFieldBegin()
23961 
      if ftype == TType.STOP:
23962 
        break
23963 
      if fid == 1:
23964 
        if ftype == TType.STRUCT:
23965 
          self.ex = TransactionServiceException()
23966 
          self.ex.read(iprot)
23967 
        else:
23968 
          iprot.skip(ftype)
23969 
      else:
23970 
        iprot.skip(ftype)
23971 
      iprot.readFieldEnd()
23972 
    iprot.readStructEnd()
23973 
 
23974 
  def write(self, oprot):
23975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23977 
      return
23978 
    oprot.writeStructBegin('savePaymentSettlements_result')
23979 
    if self.ex is not None:
23980 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23981 
      self.ex.write(oprot)
23982 
      oprot.writeFieldEnd()
23983 
    oprot.writeFieldStop()
23984 
    oprot.writeStructEnd()
23985 
 
23986 
  def validate(self):
23987 
    return
23988 
 
23989 
 
23990 
  def __repr__(self):
23991 
    L = ['%s=%r' % (key, value)
23992 
      for key, value in self.__dict__.iteritems()]
23993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23994 
 
23995 
  def __eq__(self, other):
23996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23997 
 
23998 
  def __ne__(self, other):
23999 
    return not (self == other)
24000 
 
24001 
class saveEBSSettlementSummary_args:
24002 
  """
24003 
  Attributes:
24004 
   - settlementId
24005 
   - settlementDate
24006 
   - transactionDateFrom
24007 
   - transactionDateTo
24008 
   - amount
24009 
  """
24010 
 
24011 
  thrift_spec = (
24012 
    None, # 0
24013 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24014 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
24015 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
24016 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
24017 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
24018 
  )
24019 
 
24020 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
24021 
    self.settlementId = settlementId
24022 
    self.settlementDate = settlementDate
24023 
    self.transactionDateFrom = transactionDateFrom
24024 
    self.transactionDateTo = transactionDateTo
24025 
    self.amount = amount
24026 
 
24027 
  def read(self, iprot):
24028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24030 
      return
24031 
    iprot.readStructBegin()
24032 
    while True:
24033 
      (fname, ftype, fid) = iprot.readFieldBegin()
24034 
      if ftype == TType.STOP:
24035 
        break
24036 
      if fid == 1:
24037 
        if ftype == TType.I64:
24038 
          self.settlementId = iprot.readI64();
24039 
        else:
24040 
          iprot.skip(ftype)
24041 
      elif fid == 2:
24042 
        if ftype == TType.I64:
24043 
          self.settlementDate = iprot.readI64();
24044 
        else:
24045 
          iprot.skip(ftype)
24046 
      elif fid == 3:
24047 
        if ftype == TType.I64:
24048 
          self.transactionDateFrom = iprot.readI64();
24049 
        else:
24050 
          iprot.skip(ftype)
24051 
      elif fid == 4:
24052 
        if ftype == TType.I64:
24053 
          self.transactionDateTo = iprot.readI64();
24054 
        else:
24055 
          iprot.skip(ftype)
24056 
      elif fid == 5:
24057 
        if ftype == TType.DOUBLE:
24058 
          self.amount = iprot.readDouble();
24059 
        else:
24060 
          iprot.skip(ftype)
24061 
      else:
24062 
        iprot.skip(ftype)
24063 
      iprot.readFieldEnd()
24064 
    iprot.readStructEnd()
24065 
 
24066 
  def write(self, oprot):
24067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24069 
      return
24070 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
24071 
    if self.settlementId is not None:
24072 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24073 
      oprot.writeI64(self.settlementId)
24074 
      oprot.writeFieldEnd()
24075 
    if self.settlementDate is not None:
24076 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
24077 
      oprot.writeI64(self.settlementDate)
24078 
      oprot.writeFieldEnd()
24079 
    if self.transactionDateFrom is not None:
24080 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
24081 
      oprot.writeI64(self.transactionDateFrom)
24082 
      oprot.writeFieldEnd()
24083 
    if self.transactionDateTo is not None:
24084 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
24085 
      oprot.writeI64(self.transactionDateTo)
24086 
      oprot.writeFieldEnd()
24087 
    if self.amount is not None:
24088 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
24089 
      oprot.writeDouble(self.amount)
24090 
      oprot.writeFieldEnd()
24091 
    oprot.writeFieldStop()
24092 
    oprot.writeStructEnd()
24093 
 
24094 
  def validate(self):
24095 
    return
24096 
 
24097 
 
24098 
  def __repr__(self):
24099 
    L = ['%s=%r' % (key, value)
24100 
      for key, value in self.__dict__.iteritems()]
24101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24102 
 
24103 
  def __eq__(self, other):
24104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24105 
 
24106 
  def __ne__(self, other):
24107 
    return not (self == other)
24108 
 
24109 
class saveEBSSettlementSummary_result:
24110 
  """
24111 
  Attributes:
24112 
   - ex
24113 
  """
24114 
 
24115 
  thrift_spec = (
24116 
    None, # 0
24117 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24118 
  )
24119 
 
24120 
  def __init__(self, ex=None,):
24121 
    self.ex = ex
24122 
 
24123 
  def read(self, iprot):
24124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24126 
      return
24127 
    iprot.readStructBegin()
24128 
    while True:
24129 
      (fname, ftype, fid) = iprot.readFieldBegin()
24130 
      if ftype == TType.STOP:
24131 
        break
24132 
      if fid == 1:
24133 
        if ftype == TType.STRUCT:
24134 
          self.ex = TransactionServiceException()
24135 
          self.ex.read(iprot)
24136 
        else:
24137 
          iprot.skip(ftype)
24138 
      else:
24139 
        iprot.skip(ftype)
24140 
      iprot.readFieldEnd()
24141 
    iprot.readStructEnd()
24142 
 
24143 
  def write(self, oprot):
24144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24146 
      return
24147 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
24148 
    if self.ex is not None:
24149 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24150 
      self.ex.write(oprot)
24151 
      oprot.writeFieldEnd()
24152 
    oprot.writeFieldStop()
24153 
    oprot.writeStructEnd()
24154 
 
24155 
  def validate(self):
24156 
    return
24157 
 
24158 
 
24159 
  def __repr__(self):
24160 
    L = ['%s=%r' % (key, value)
24161 
      for key, value in self.__dict__.iteritems()]
24162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24163 
 
24164 
  def __eq__(self, other):
24165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24166 
 
24167 
  def __ne__(self, other):
24168 
    return not (self == other)
24169 
 
5386 phani.kuma 24170 
class getSettlementForPrepaid_args:
4600 varun.gupt 24171 
  """
24172 
  Attributes:
5189 varun.gupt 24173 
   - referenceId
24174 
   - isRefund
4600 varun.gupt 24175 
  """
24176 
 
24177 
  thrift_spec = (
24178 
    None, # 0
5189 varun.gupt 24179 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 24180 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 24181 
  )
24182 
 
5386 phani.kuma 24183 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 24184 
    self.referenceId = referenceId
24185 
    self.isRefund = isRefund
4600 varun.gupt 24186 
 
24187 
  def read(self, iprot):
24188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24190 
      return
24191 
    iprot.readStructBegin()
24192 
    while True:
24193 
      (fname, ftype, fid) = iprot.readFieldBegin()
24194 
      if ftype == TType.STOP:
24195 
        break
24196 
      if fid == 1:
24197 
        if ftype == TType.I64:
5189 varun.gupt 24198 
          self.referenceId = iprot.readI64();
4600 varun.gupt 24199 
        else:
24200 
          iprot.skip(ftype)
5189 varun.gupt 24201 
      elif fid == 2:
24202 
        if ftype == TType.BOOL:
24203 
          self.isRefund = iprot.readBool();
24204 
        else:
24205 
          iprot.skip(ftype)
4600 varun.gupt 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
5386 phani.kuma 24215 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 24216 
    if self.referenceId is not None:
24217 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
24218 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 24219 
      oprot.writeFieldEnd()
5386 phani.kuma 24220 
    if self.isRefund is not None:
24221 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
24222 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 24223 
      oprot.writeFieldEnd()
5386 phani.kuma 24224 
    oprot.writeFieldStop()
24225 
    oprot.writeStructEnd()
24226 
 
24227 
  def validate(self):
24228 
    return
24229 
 
24230 
 
24231 
  def __repr__(self):
24232 
    L = ['%s=%r' % (key, value)
24233 
      for key, value in self.__dict__.iteritems()]
24234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24235 
 
24236 
  def __eq__(self, other):
24237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24238 
 
24239 
  def __ne__(self, other):
24240 
    return not (self == other)
24241 
 
24242 
class getSettlementForPrepaid_result:
24243 
  """
24244 
  Attributes:
24245 
   - success
24246 
   - ex
24247 
  """
24248 
 
24249 
  thrift_spec = (
24250 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
24251 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24252 
  )
24253 
 
24254 
  def __init__(self, success=None, ex=None,):
24255 
    self.success = success
24256 
    self.ex = ex
24257 
 
24258 
  def read(self, iprot):
24259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24261 
      return
24262 
    iprot.readStructBegin()
24263 
    while True:
24264 
      (fname, ftype, fid) = iprot.readFieldBegin()
24265 
      if ftype == TType.STOP:
24266 
        break
24267 
      if fid == 0:
24268 
        if ftype == TType.STRUCT:
24269 
          self.success = PaymentSettlement()
24270 
          self.success.read(iprot)
24271 
        else:
24272 
          iprot.skip(ftype)
24273 
      elif fid == 1:
24274 
        if ftype == TType.STRUCT:
24275 
          self.ex = TransactionServiceException()
24276 
          self.ex.read(iprot)
24277 
        else:
24278 
          iprot.skip(ftype)
24279 
      else:
24280 
        iprot.skip(ftype)
24281 
      iprot.readFieldEnd()
24282 
    iprot.readStructEnd()
24283 
 
24284 
  def write(self, oprot):
24285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24287 
      return
24288 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
24289 
    if self.success is not None:
24290 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24291 
      self.success.write(oprot)
24292 
      oprot.writeFieldEnd()
24293 
    if self.ex is not None:
24294 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24295 
      self.ex.write(oprot)
24296 
      oprot.writeFieldEnd()
24297 
    oprot.writeFieldStop()
24298 
    oprot.writeStructEnd()
24299 
 
24300 
  def validate(self):
24301 
    return
24302 
 
24303 
 
24304 
  def __repr__(self):
24305 
    L = ['%s=%r' % (key, value)
24306 
      for key, value in self.__dict__.iteritems()]
24307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24308 
 
24309 
  def __eq__(self, other):
24310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24311 
 
24312 
  def __ne__(self, other):
24313 
    return not (self == other)
24314 
 
24315 
class getSettlementForCod_args:
24316 
  """
24317 
  Attributes:
24318 
   - orderId
24319 
   - isRefund
24320 
  """
24321 
 
24322 
  thrift_spec = (
24323 
    None, # 0
24324 
    (1, TType.I64, 'orderId', None, None, ), # 1
24325 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
24326 
  )
24327 
 
24328 
  def __init__(self, orderId=None, isRefund=None,):
24329 
    self.orderId = orderId
24330 
    self.isRefund = isRefund
24331 
 
24332 
  def read(self, iprot):
24333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24335 
      return
24336 
    iprot.readStructBegin()
24337 
    while True:
24338 
      (fname, ftype, fid) = iprot.readFieldBegin()
24339 
      if ftype == TType.STOP:
24340 
        break
24341 
      if fid == 1:
24342 
        if ftype == TType.I64:
24343 
          self.orderId = iprot.readI64();
24344 
        else:
24345 
          iprot.skip(ftype)
24346 
      elif fid == 2:
24347 
        if ftype == TType.BOOL:
24348 
          self.isRefund = iprot.readBool();
24349 
        else:
24350 
          iprot.skip(ftype)
24351 
      else:
24352 
        iprot.skip(ftype)
24353 
      iprot.readFieldEnd()
24354 
    iprot.readStructEnd()
24355 
 
24356 
  def write(self, oprot):
24357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24359 
      return
24360 
    oprot.writeStructBegin('getSettlementForCod_args')
24361 
    if self.orderId is not None:
24362 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24363 
      oprot.writeI64(self.orderId)
24364 
      oprot.writeFieldEnd()
5189 varun.gupt 24365 
    if self.isRefund is not None:
5386 phani.kuma 24366 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 24367 
      oprot.writeBool(self.isRefund)
24368 
      oprot.writeFieldEnd()
4600 varun.gupt 24369 
    oprot.writeFieldStop()
24370 
    oprot.writeStructEnd()
24371 
 
24372 
  def validate(self):
24373 
    return
24374 
 
24375 
 
24376 
  def __repr__(self):
24377 
    L = ['%s=%r' % (key, value)
24378 
      for key, value in self.__dict__.iteritems()]
24379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24380 
 
24381 
  def __eq__(self, other):
24382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24383 
 
24384 
  def __ne__(self, other):
24385 
    return not (self == other)
24386 
 
5386 phani.kuma 24387 
class getSettlementForCod_result:
4600 varun.gupt 24388 
  """
24389 
  Attributes:
24390 
   - success
24391 
   - ex
24392 
  """
24393 
 
24394 
  thrift_spec = (
24395 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
24396 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24397 
  )
24398 
 
24399 
  def __init__(self, success=None, ex=None,):
24400 
    self.success = success
24401 
    self.ex = ex
24402 
 
24403 
  def read(self, iprot):
24404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24406 
      return
24407 
    iprot.readStructBegin()
24408 
    while True:
24409 
      (fname, ftype, fid) = iprot.readFieldBegin()
24410 
      if ftype == TType.STOP:
24411 
        break
24412 
      if fid == 0:
24413 
        if ftype == TType.STRUCT:
24414 
          self.success = PaymentSettlement()
24415 
          self.success.read(iprot)
24416 
        else:
24417 
          iprot.skip(ftype)
24418 
      elif fid == 1:
24419 
        if ftype == TType.STRUCT:
24420 
          self.ex = TransactionServiceException()
24421 
          self.ex.read(iprot)
24422 
        else:
24423 
          iprot.skip(ftype)
24424 
      else:
24425 
        iprot.skip(ftype)
24426 
      iprot.readFieldEnd()
24427 
    iprot.readStructEnd()
24428 
 
24429 
  def write(self, oprot):
24430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24432 
      return
5386 phani.kuma 24433 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 24434 
    if self.success is not None:
24435 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24436 
      self.success.write(oprot)
24437 
      oprot.writeFieldEnd()
24438 
    if self.ex is not None:
24439 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24440 
      self.ex.write(oprot)
24441 
      oprot.writeFieldEnd()
24442 
    oprot.writeFieldStop()
24443 
    oprot.writeStructEnd()
24444 
 
24445 
  def validate(self):
24446 
    return
24447 
 
24448 
 
24449 
  def __repr__(self):
24450 
    L = ['%s=%r' % (key, value)
24451 
      for key, value in self.__dict__.iteritems()]
24452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24453 
 
24454 
  def __eq__(self, other):
24455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24456 
 
24457 
  def __ne__(self, other):
24458 
    return not (self == other)
24459 
 
24460 
class getEBSSettlementSummaries_args:
24461 
 
24462 
  thrift_spec = (
24463 
  )
24464 
 
24465 
  def read(self, iprot):
24466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24468 
      return
24469 
    iprot.readStructBegin()
24470 
    while True:
24471 
      (fname, ftype, fid) = iprot.readFieldBegin()
24472 
      if ftype == TType.STOP:
24473 
        break
24474 
      else:
24475 
        iprot.skip(ftype)
24476 
      iprot.readFieldEnd()
24477 
    iprot.readStructEnd()
24478 
 
24479 
  def write(self, oprot):
24480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24482 
      return
24483 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
24484 
    oprot.writeFieldStop()
24485 
    oprot.writeStructEnd()
24486 
 
24487 
  def validate(self):
24488 
    return
24489 
 
24490 
 
24491 
  def __repr__(self):
24492 
    L = ['%s=%r' % (key, value)
24493 
      for key, value in self.__dict__.iteritems()]
24494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24495 
 
24496 
  def __eq__(self, other):
24497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24498 
 
24499 
  def __ne__(self, other):
24500 
    return not (self == other)
24501 
 
24502 
class getEBSSettlementSummaries_result:
24503 
  """
24504 
  Attributes:
24505 
   - success
24506 
   - ex
24507 
  """
24508 
 
24509 
  thrift_spec = (
24510 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
24511 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24512 
  )
24513 
 
24514 
  def __init__(self, success=None, ex=None,):
24515 
    self.success = success
24516 
    self.ex = ex
24517 
 
24518 
  def read(self, iprot):
24519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24521 
      return
24522 
    iprot.readStructBegin()
24523 
    while True:
24524 
      (fname, ftype, fid) = iprot.readFieldBegin()
24525 
      if ftype == TType.STOP:
24526 
        break
24527 
      if fid == 0:
24528 
        if ftype == TType.MAP:
24529 
          self.success = {}
6188 rajveer 24530 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
24531 
          for _i558 in xrange(_size554):
24532 
            _key559 = iprot.readI64();
24533 
            _val560 = iprot.readString();
24534 
            self.success[_key559] = _val560
4600 varun.gupt 24535 
          iprot.readMapEnd()
24536 
        else:
24537 
          iprot.skip(ftype)
24538 
      elif fid == 1:
24539 
        if ftype == TType.STRUCT:
24540 
          self.ex = TransactionServiceException()
24541 
          self.ex.read(iprot)
24542 
        else:
24543 
          iprot.skip(ftype)
24544 
      else:
24545 
        iprot.skip(ftype)
24546 
      iprot.readFieldEnd()
24547 
    iprot.readStructEnd()
24548 
 
24549 
  def write(self, oprot):
24550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24552 
      return
24553 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
24554 
    if self.success is not None:
24555 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24556 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 24557 
      for kiter561,viter562 in self.success.items():
24558 
        oprot.writeI64(kiter561)
24559 
        oprot.writeString(viter562)
4600 varun.gupt 24560 
      oprot.writeMapEnd()
24561 
      oprot.writeFieldEnd()
24562 
    if self.ex is not None:
24563 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24564 
      self.ex.write(oprot)
24565 
      oprot.writeFieldEnd()
24566 
    oprot.writeFieldStop()
24567 
    oprot.writeStructEnd()
24568 
 
24569 
  def validate(self):
24570 
    return
24571 
 
24572 
 
24573 
  def __repr__(self):
24574 
    L = ['%s=%r' % (key, value)
24575 
      for key, value in self.__dict__.iteritems()]
24576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24577 
 
24578 
  def __eq__(self, other):
24579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24580 
 
24581 
  def __ne__(self, other):
24582 
    return not (self == other)
24583 
 
24584 
class markEBSSettlementUploaded_args:
24585 
  """
24586 
  Attributes:
24587 
   - settlementId
24588 
  """
24589 
 
24590 
  thrift_spec = (
24591 
    None, # 0
24592 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24593 
  )
24594 
 
24595 
  def __init__(self, settlementId=None,):
24596 
    self.settlementId = settlementId
24597 
 
24598 
  def read(self, iprot):
24599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24601 
      return
24602 
    iprot.readStructBegin()
24603 
    while True:
24604 
      (fname, ftype, fid) = iprot.readFieldBegin()
24605 
      if ftype == TType.STOP:
24606 
        break
24607 
      if fid == 1:
24608 
        if ftype == TType.I64:
24609 
          self.settlementId = iprot.readI64();
24610 
        else:
24611 
          iprot.skip(ftype)
24612 
      else:
24613 
        iprot.skip(ftype)
24614 
      iprot.readFieldEnd()
24615 
    iprot.readStructEnd()
24616 
 
24617 
  def write(self, oprot):
24618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24620 
      return
24621 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
24622 
    if self.settlementId is not None:
24623 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24624 
      oprot.writeI64(self.settlementId)
24625 
      oprot.writeFieldEnd()
24626 
    oprot.writeFieldStop()
24627 
    oprot.writeStructEnd()
24628 
 
24629 
  def validate(self):
24630 
    return
24631 
 
24632 
 
24633 
  def __repr__(self):
24634 
    L = ['%s=%r' % (key, value)
24635 
      for key, value in self.__dict__.iteritems()]
24636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24637 
 
24638 
  def __eq__(self, other):
24639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24640 
 
24641 
  def __ne__(self, other):
24642 
    return not (self == other)
24643 
 
24644 
class markEBSSettlementUploaded_result:
24645 
  """
24646 
  Attributes:
24647 
   - ex
24648 
  """
24649 
 
24650 
  thrift_spec = (
24651 
    None, # 0
24652 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24653 
  )
24654 
 
24655 
  def __init__(self, ex=None,):
24656 
    self.ex = ex
24657 
 
24658 
  def read(self, iprot):
24659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24661 
      return
24662 
    iprot.readStructBegin()
24663 
    while True:
24664 
      (fname, ftype, fid) = iprot.readFieldBegin()
24665 
      if ftype == TType.STOP:
24666 
        break
24667 
      if fid == 1:
24668 
        if ftype == TType.STRUCT:
24669 
          self.ex = TransactionServiceException()
24670 
          self.ex.read(iprot)
24671 
        else:
24672 
          iprot.skip(ftype)
24673 
      else:
24674 
        iprot.skip(ftype)
24675 
      iprot.readFieldEnd()
24676 
    iprot.readStructEnd()
24677 
 
24678 
  def write(self, oprot):
24679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24681 
      return
24682 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
24683 
    if self.ex is not None:
24684 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24685 
      self.ex.write(oprot)
24686 
      oprot.writeFieldEnd()
24687 
    oprot.writeFieldStop()
24688 
    oprot.writeStructEnd()
24689 
 
24690 
  def validate(self):
24691 
    return
24692 
 
24693 
 
24694 
  def __repr__(self):
24695 
    L = ['%s=%r' % (key, value)
24696 
      for key, value in self.__dict__.iteritems()]
24697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24698 
 
24699 
  def __eq__(self, other):
24700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24701 
 
24702 
  def __ne__(self, other):
24703 
    return not (self == other)
24704 
 
24705 
class getEBSSettlementDate_args:
24706 
  """
24707 
  Attributes:
24708 
   - settlementId
24709 
  """
24710 
 
24711 
  thrift_spec = (
24712 
    None, # 0
24713 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24714 
  )
24715 
 
24716 
  def __init__(self, settlementId=None,):
24717 
    self.settlementId = settlementId
24718 
 
24719 
  def read(self, iprot):
24720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24722 
      return
24723 
    iprot.readStructBegin()
24724 
    while True:
24725 
      (fname, ftype, fid) = iprot.readFieldBegin()
24726 
      if ftype == TType.STOP:
24727 
        break
24728 
      if fid == 1:
24729 
        if ftype == TType.I64:
24730 
          self.settlementId = iprot.readI64();
24731 
        else:
24732 
          iprot.skip(ftype)
24733 
      else:
24734 
        iprot.skip(ftype)
24735 
      iprot.readFieldEnd()
24736 
    iprot.readStructEnd()
24737 
 
24738 
  def write(self, oprot):
24739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24741 
      return
24742 
    oprot.writeStructBegin('getEBSSettlementDate_args')
24743 
    if self.settlementId is not None:
24744 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24745 
      oprot.writeI64(self.settlementId)
24746 
      oprot.writeFieldEnd()
24747 
    oprot.writeFieldStop()
24748 
    oprot.writeStructEnd()
24749 
 
24750 
  def validate(self):
24751 
    return
24752 
 
24753 
 
24754 
  def __repr__(self):
24755 
    L = ['%s=%r' % (key, value)
24756 
      for key, value in self.__dict__.iteritems()]
24757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24758 
 
24759 
  def __eq__(self, other):
24760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24761 
 
24762 
  def __ne__(self, other):
24763 
    return not (self == other)
24764 
 
24765 
class getEBSSettlementDate_result:
24766 
  """
24767 
  Attributes:
24768 
   - success
24769 
   - ex
24770 
  """
24771 
 
24772 
  thrift_spec = (
24773 
    (0, TType.I64, 'success', None, None, ), # 0
24774 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24775 
  )
24776 
 
24777 
  def __init__(self, success=None, ex=None,):
24778 
    self.success = success
24779 
    self.ex = ex
24780 
 
24781 
  def read(self, iprot):
24782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24784 
      return
24785 
    iprot.readStructBegin()
24786 
    while True:
24787 
      (fname, ftype, fid) = iprot.readFieldBegin()
24788 
      if ftype == TType.STOP:
24789 
        break
24790 
      if fid == 0:
24791 
        if ftype == TType.I64:
24792 
          self.success = iprot.readI64();
24793 
        else:
24794 
          iprot.skip(ftype)
24795 
      elif fid == 1:
24796 
        if ftype == TType.STRUCT:
24797 
          self.ex = TransactionServiceException()
24798 
          self.ex.read(iprot)
24799 
        else:
24800 
          iprot.skip(ftype)
24801 
      else:
24802 
        iprot.skip(ftype)
24803 
      iprot.readFieldEnd()
24804 
    iprot.readStructEnd()
24805 
 
24806 
  def write(self, oprot):
24807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24809 
      return
24810 
    oprot.writeStructBegin('getEBSSettlementDate_result')
24811 
    if self.success is not None:
24812 
      oprot.writeFieldBegin('success', TType.I64, 0)
24813 
      oprot.writeI64(self.success)
24814 
      oprot.writeFieldEnd()
24815 
    if self.ex is not None:
24816 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24817 
      self.ex.write(oprot)
24818 
      oprot.writeFieldEnd()
24819 
    oprot.writeFieldStop()
24820 
    oprot.writeStructEnd()
24821 
 
24822 
  def validate(self):
24823 
    return
24824 
 
24825 
 
24826 
  def __repr__(self):
24827 
    L = ['%s=%r' % (key, value)
24828 
      for key, value in self.__dict__.iteritems()]
24829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24830 
 
24831 
  def __eq__(self, other):
24832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24833 
 
24834 
  def __ne__(self, other):
24835 
    return not (self == other)
4715 varun.gupt 24836 
 
24837 
class getSettlementsByDate_args:
24838 
  """
24839 
  Attributes:
24840 
   - settlementDateFrom
24841 
   - settlementDateTo
24842 
   - isRefund
24843 
  """
24844 
 
24845 
  thrift_spec = (
24846 
    None, # 0
24847 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
24848 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
24849 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
24850 
  )
24851 
 
24852 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
24853 
    self.settlementDateFrom = settlementDateFrom
24854 
    self.settlementDateTo = settlementDateTo
24855 
    self.isRefund = isRefund
24856 
 
24857 
  def read(self, iprot):
24858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24860 
      return
24861 
    iprot.readStructBegin()
24862 
    while True:
24863 
      (fname, ftype, fid) = iprot.readFieldBegin()
24864 
      if ftype == TType.STOP:
24865 
        break
24866 
      if fid == 1:
24867 
        if ftype == TType.I64:
24868 
          self.settlementDateFrom = iprot.readI64();
24869 
        else:
24870 
          iprot.skip(ftype)
24871 
      elif fid == 2:
24872 
        if ftype == TType.I64:
24873 
          self.settlementDateTo = iprot.readI64();
24874 
        else:
24875 
          iprot.skip(ftype)
24876 
      elif fid == 3:
24877 
        if ftype == TType.BOOL:
24878 
          self.isRefund = iprot.readBool();
24879 
        else:
24880 
          iprot.skip(ftype)
24881 
      else:
24882 
        iprot.skip(ftype)
24883 
      iprot.readFieldEnd()
24884 
    iprot.readStructEnd()
24885 
 
24886 
  def write(self, oprot):
24887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24889 
      return
24890 
    oprot.writeStructBegin('getSettlementsByDate_args')
24891 
    if self.settlementDateFrom is not None:
24892 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
24893 
      oprot.writeI64(self.settlementDateFrom)
24894 
      oprot.writeFieldEnd()
24895 
    if self.settlementDateTo is not None:
24896 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
24897 
      oprot.writeI64(self.settlementDateTo)
24898 
      oprot.writeFieldEnd()
24899 
    if self.isRefund is not None:
24900 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
24901 
      oprot.writeBool(self.isRefund)
24902 
      oprot.writeFieldEnd()
24903 
    oprot.writeFieldStop()
24904 
    oprot.writeStructEnd()
24905 
 
24906 
  def validate(self):
24907 
    return
24908 
 
24909 
 
24910 
  def __repr__(self):
24911 
    L = ['%s=%r' % (key, value)
24912 
      for key, value in self.__dict__.iteritems()]
24913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24914 
 
24915 
  def __eq__(self, other):
24916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24917 
 
24918 
  def __ne__(self, other):
24919 
    return not (self == other)
24920 
 
24921 
class getSettlementsByDate_result:
24922 
  """
24923 
  Attributes:
24924 
   - success
24925 
   - ex
24926 
  """
24927 
 
24928 
  thrift_spec = (
24929 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
24930 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24931 
  )
24932 
 
24933 
  def __init__(self, success=None, ex=None,):
24934 
    self.success = success
24935 
    self.ex = ex
24936 
 
24937 
  def read(self, iprot):
24938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24940 
      return
24941 
    iprot.readStructBegin()
24942 
    while True:
24943 
      (fname, ftype, fid) = iprot.readFieldBegin()
24944 
      if ftype == TType.STOP:
24945 
        break
24946 
      if fid == 0:
24947 
        if ftype == TType.LIST:
24948 
          self.success = []
6188 rajveer 24949 
          (_etype566, _size563) = iprot.readListBegin()
24950 
          for _i567 in xrange(_size563):
24951 
            _elem568 = PaymentSettlement()
24952 
            _elem568.read(iprot)
24953 
            self.success.append(_elem568)
4715 varun.gupt 24954 
          iprot.readListEnd()
24955 
        else:
24956 
          iprot.skip(ftype)
24957 
      elif fid == 1:
24958 
        if ftype == TType.STRUCT:
24959 
          self.ex = TransactionServiceException()
24960 
          self.ex.read(iprot)
24961 
        else:
24962 
          iprot.skip(ftype)
24963 
      else:
24964 
        iprot.skip(ftype)
24965 
      iprot.readFieldEnd()
24966 
    iprot.readStructEnd()
24967 
 
24968 
  def write(self, oprot):
24969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24971 
      return
24972 
    oprot.writeStructBegin('getSettlementsByDate_result')
24973 
    if self.success is not None:
24974 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24975 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24976 
      for iter569 in self.success:
24977 
        iter569.write(oprot)
4715 varun.gupt 24978 
      oprot.writeListEnd()
24979 
      oprot.writeFieldEnd()
24980 
    if self.ex is not None:
24981 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24982 
      self.ex.write(oprot)
24983 
      oprot.writeFieldEnd()
24984 
    oprot.writeFieldStop()
24985 
    oprot.writeStructEnd()
24986 
 
24987 
  def validate(self):
24988 
    return
24989 
 
24990 
 
24991 
  def __repr__(self):
24992 
    L = ['%s=%r' % (key, value)
24993 
      for key, value in self.__dict__.iteritems()]
24994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24995 
 
24996 
  def __eq__(self, other):
24997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24998 
 
24999 
  def __ne__(self, other):
25000 
    return not (self == other)
25001 
 
25002 
class getReshippedOrderIds_args:
25003 
  """
25004 
  Attributes:
25005 
   - orderIds
25006 
  """
25007 
 
25008 
  thrift_spec = (
25009 
    None, # 0
25010 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
25011 
  )
25012 
 
25013 
  def __init__(self, orderIds=None,):
25014 
    self.orderIds = orderIds
25015 
 
25016 
  def read(self, iprot):
25017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25019 
      return
25020 
    iprot.readStructBegin()
25021 
    while True:
25022 
      (fname, ftype, fid) = iprot.readFieldBegin()
25023 
      if ftype == TType.STOP:
25024 
        break
25025 
      if fid == 1:
25026 
        if ftype == TType.LIST:
25027 
          self.orderIds = []
6188 rajveer 25028 
          (_etype573, _size570) = iprot.readListBegin()
25029 
          for _i574 in xrange(_size570):
25030 
            _elem575 = iprot.readI64();
25031 
            self.orderIds.append(_elem575)
4715 varun.gupt 25032 
          iprot.readListEnd()
25033 
        else:
25034 
          iprot.skip(ftype)
25035 
      else:
25036 
        iprot.skip(ftype)
25037 
      iprot.readFieldEnd()
25038 
    iprot.readStructEnd()
25039 
 
25040 
  def write(self, oprot):
25041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25043 
      return
25044 
    oprot.writeStructBegin('getReshippedOrderIds_args')
25045 
    if self.orderIds is not None:
25046 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
25047 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 25048 
      for iter576 in self.orderIds:
25049 
        oprot.writeI64(iter576)
4715 varun.gupt 25050 
      oprot.writeListEnd()
25051 
      oprot.writeFieldEnd()
25052 
    oprot.writeFieldStop()
25053 
    oprot.writeStructEnd()
25054 
 
25055 
  def validate(self):
25056 
    return
25057 
 
25058 
 
25059 
  def __repr__(self):
25060 
    L = ['%s=%r' % (key, value)
25061 
      for key, value in self.__dict__.iteritems()]
25062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25063 
 
25064 
  def __eq__(self, other):
25065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25066 
 
25067 
  def __ne__(self, other):
25068 
    return not (self == other)
25069 
 
25070 
class getReshippedOrderIds_result:
25071 
  """
25072 
  Attributes:
25073 
   - success
25074 
   - ex
25075 
  """
25076 
 
25077 
  thrift_spec = (
25078 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
25079 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25080 
  )
25081 
 
25082 
  def __init__(self, success=None, ex=None,):
25083 
    self.success = success
25084 
    self.ex = ex
25085 
 
25086 
  def read(self, iprot):
25087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25089 
      return
25090 
    iprot.readStructBegin()
25091 
    while True:
25092 
      (fname, ftype, fid) = iprot.readFieldBegin()
25093 
      if ftype == TType.STOP:
25094 
        break
25095 
      if fid == 0:
25096 
        if ftype == TType.LIST:
25097 
          self.success = []
6188 rajveer 25098 
          (_etype580, _size577) = iprot.readListBegin()
25099 
          for _i581 in xrange(_size577):
25100 
            _elem582 = iprot.readI64();
25101 
            self.success.append(_elem582)
4715 varun.gupt 25102 
          iprot.readListEnd()
25103 
        else:
25104 
          iprot.skip(ftype)
25105 
      elif fid == 1:
25106 
        if ftype == TType.STRUCT:
25107 
          self.ex = TransactionServiceException()
25108 
          self.ex.read(iprot)
25109 
        else:
25110 
          iprot.skip(ftype)
25111 
      else:
25112 
        iprot.skip(ftype)
25113 
      iprot.readFieldEnd()
25114 
    iprot.readStructEnd()
25115 
 
25116 
  def write(self, oprot):
25117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25119 
      return
25120 
    oprot.writeStructBegin('getReshippedOrderIds_result')
25121 
    if self.success is not None:
25122 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25123 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25124 
      for iter583 in self.success:
25125 
        oprot.writeI64(iter583)
4715 varun.gupt 25126 
      oprot.writeListEnd()
25127 
      oprot.writeFieldEnd()
25128 
    if self.ex is not None:
25129 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25130 
      self.ex.write(oprot)
25131 
      oprot.writeFieldEnd()
25132 
    oprot.writeFieldStop()
25133 
    oprot.writeStructEnd()
25134 
 
25135 
  def validate(self):
25136 
    return
25137 
 
25138 
 
25139 
  def __repr__(self):
25140 
    L = ['%s=%r' % (key, value)
25141 
      for key, value in self.__dict__.iteritems()]
25142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25143 
 
25144 
  def __eq__(self, other):
25145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25146 
 
25147 
  def __ne__(self, other):
25148 
    return not (self == other)
4757 mandeep.dh 25149 
 
5481 phani.kuma 25150 
class getBilledOrders_args:
4875 varun.gupt 25151 
  """
25152 
  Attributes:
25153 
   - vendorId
5481 phani.kuma 25154 
   - onlyVendorNotPaid
25155 
   - billingDateFrom
25156 
   - billingDateTo
4875 varun.gupt 25157 
  """
25158 
 
25159 
  thrift_spec = (
25160 
    None, # 0
25161 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 25162 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
25163 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
25164 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 25165 
  )
25166 
 
5481 phani.kuma 25167 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 25168 
    self.vendorId = vendorId
5481 phani.kuma 25169 
    self.onlyVendorNotPaid = onlyVendorNotPaid
25170 
    self.billingDateFrom = billingDateFrom
25171 
    self.billingDateTo = billingDateTo
4875 varun.gupt 25172 
 
25173 
  def read(self, iprot):
25174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25176 
      return
25177 
    iprot.readStructBegin()
25178 
    while True:
25179 
      (fname, ftype, fid) = iprot.readFieldBegin()
25180 
      if ftype == TType.STOP:
25181 
        break
25182 
      if fid == 1:
25183 
        if ftype == TType.I64:
25184 
          self.vendorId = iprot.readI64();
25185 
        else:
25186 
          iprot.skip(ftype)
5481 phani.kuma 25187 
      elif fid == 2:
25188 
        if ftype == TType.BOOL:
25189 
          self.onlyVendorNotPaid = iprot.readBool();
25190 
        else:
25191 
          iprot.skip(ftype)
25192 
      elif fid == 3:
25193 
        if ftype == TType.I64:
25194 
          self.billingDateFrom = iprot.readI64();
25195 
        else:
25196 
          iprot.skip(ftype)
25197 
      elif fid == 4:
25198 
        if ftype == TType.I64:
25199 
          self.billingDateTo = iprot.readI64();
25200 
        else:
25201 
          iprot.skip(ftype)
4875 varun.gupt 25202 
      else:
25203 
        iprot.skip(ftype)
25204 
      iprot.readFieldEnd()
25205 
    iprot.readStructEnd()
25206 
 
25207 
  def write(self, oprot):
25208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25210 
      return
5481 phani.kuma 25211 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 25212 
    if self.vendorId is not None:
25213 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
25214 
      oprot.writeI64(self.vendorId)
25215 
      oprot.writeFieldEnd()
5481 phani.kuma 25216 
    if self.onlyVendorNotPaid is not None:
25217 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
25218 
      oprot.writeBool(self.onlyVendorNotPaid)
25219 
      oprot.writeFieldEnd()
25220 
    if self.billingDateFrom is not None:
25221 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
25222 
      oprot.writeI64(self.billingDateFrom)
25223 
      oprot.writeFieldEnd()
25224 
    if self.billingDateTo is not None:
25225 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
25226 
      oprot.writeI64(self.billingDateTo)
25227 
      oprot.writeFieldEnd()
4875 varun.gupt 25228 
    oprot.writeFieldStop()
25229 
    oprot.writeStructEnd()
25230 
 
25231 
  def validate(self):
25232 
    return
25233 
 
25234 
 
25235 
  def __repr__(self):
25236 
    L = ['%s=%r' % (key, value)
25237 
      for key, value in self.__dict__.iteritems()]
25238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25239 
 
25240 
  def __eq__(self, other):
25241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25242 
 
25243 
  def __ne__(self, other):
25244 
    return not (self == other)
25245 
 
5481 phani.kuma 25246 
class getBilledOrders_result:
4875 varun.gupt 25247 
  """
25248 
  Attributes:
25249 
   - success
25250 
   - ex
25251 
  """
25252 
 
25253 
  thrift_spec = (
25254 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25255 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25256 
  )
25257 
 
25258 
  def __init__(self, success=None, ex=None,):
25259 
    self.success = success
25260 
    self.ex = ex
25261 
 
25262 
  def read(self, iprot):
25263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25265 
      return
25266 
    iprot.readStructBegin()
25267 
    while True:
25268 
      (fname, ftype, fid) = iprot.readFieldBegin()
25269 
      if ftype == TType.STOP:
25270 
        break
25271 
      if fid == 0:
25272 
        if ftype == TType.LIST:
25273 
          self.success = []
6188 rajveer 25274 
          (_etype587, _size584) = iprot.readListBegin()
25275 
          for _i588 in xrange(_size584):
25276 
            _elem589 = Order()
25277 
            _elem589.read(iprot)
25278 
            self.success.append(_elem589)
4875 varun.gupt 25279 
          iprot.readListEnd()
25280 
        else:
25281 
          iprot.skip(ftype)
25282 
      elif fid == 1:
25283 
        if ftype == TType.STRUCT:
25284 
          self.ex = TransactionServiceException()
25285 
          self.ex.read(iprot)
25286 
        else:
25287 
          iprot.skip(ftype)
25288 
      else:
25289 
        iprot.skip(ftype)
25290 
      iprot.readFieldEnd()
25291 
    iprot.readStructEnd()
25292 
 
25293 
  def write(self, oprot):
25294 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25295 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25296 
      return
5481 phani.kuma 25297 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 25298 
    if self.success is not None:
25299 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25300 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25301 
      for iter590 in self.success:
25302 
        iter590.write(oprot)
4875 varun.gupt 25303 
      oprot.writeListEnd()
25304 
      oprot.writeFieldEnd()
25305 
    if self.ex is not None:
25306 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25307 
      self.ex.write(oprot)
25308 
      oprot.writeFieldEnd()
25309 
    oprot.writeFieldStop()
25310 
    oprot.writeStructEnd()
25311 
 
25312 
  def validate(self):
25313 
    return
25314 
 
25315 
 
25316 
  def __repr__(self):
25317 
    L = ['%s=%r' % (key, value)
25318 
      for key, value in self.__dict__.iteritems()]
25319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25320 
 
25321 
  def __eq__(self, other):
25322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25323 
 
25324 
  def __ne__(self, other):
25325 
    return not (self == other)
5031 varun.gupt 25326 
 
25327 
class getStatusDistributionOfOrders_args:
25328 
  """
25329 
  Attributes:
25330 
   - startDate
25331 
   - endDate
25332 
  """
25333 
 
25334 
  thrift_spec = (
25335 
    None, # 0
25336 
    (1, TType.I64, 'startDate', None, None, ), # 1
25337 
    (2, TType.I64, 'endDate', None, None, ), # 2
25338 
  )
25339 
 
25340 
  def __init__(self, startDate=None, endDate=None,):
25341 
    self.startDate = startDate
25342 
    self.endDate = endDate
25343 
 
25344 
  def read(self, iprot):
25345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25347 
      return
25348 
    iprot.readStructBegin()
25349 
    while True:
25350 
      (fname, ftype, fid) = iprot.readFieldBegin()
25351 
      if ftype == TType.STOP:
25352 
        break
25353 
      if fid == 1:
25354 
        if ftype == TType.I64:
25355 
          self.startDate = iprot.readI64();
25356 
        else:
25357 
          iprot.skip(ftype)
25358 
      elif fid == 2:
25359 
        if ftype == TType.I64:
25360 
          self.endDate = iprot.readI64();
25361 
        else:
25362 
          iprot.skip(ftype)
25363 
      else:
25364 
        iprot.skip(ftype)
25365 
      iprot.readFieldEnd()
25366 
    iprot.readStructEnd()
25367 
 
25368 
  def write(self, oprot):
25369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25371 
      return
25372 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
25373 
    if self.startDate is not None:
25374 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
25375 
      oprot.writeI64(self.startDate)
25376 
      oprot.writeFieldEnd()
25377 
    if self.endDate is not None:
25378 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
25379 
      oprot.writeI64(self.endDate)
25380 
      oprot.writeFieldEnd()
25381 
    oprot.writeFieldStop()
25382 
    oprot.writeStructEnd()
25383 
 
25384 
  def validate(self):
25385 
    return
25386 
 
25387 
 
25388 
  def __repr__(self):
25389 
    L = ['%s=%r' % (key, value)
25390 
      for key, value in self.__dict__.iteritems()]
25391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25392 
 
25393 
  def __eq__(self, other):
25394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25395 
 
25396 
  def __ne__(self, other):
25397 
    return not (self == other)
25398 
 
25399 
class getStatusDistributionOfOrders_result:
25400 
  """
25401 
  Attributes:
25402 
   - success
25403 
   - ex
25404 
  """
25405 
 
25406 
  thrift_spec = (
25407 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
25408 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25409 
  )
25410 
 
25411 
  def __init__(self, success=None, ex=None,):
25412 
    self.success = success
25413 
    self.ex = ex
25414 
 
25415 
  def read(self, iprot):
25416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25418 
      return
25419 
    iprot.readStructBegin()
25420 
    while True:
25421 
      (fname, ftype, fid) = iprot.readFieldBegin()
25422 
      if ftype == TType.STOP:
25423 
        break
25424 
      if fid == 0:
25425 
        if ftype == TType.MAP:
25426 
          self.success = {}
6188 rajveer 25427 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
25428 
          for _i595 in xrange(_size591):
25429 
            _key596 = iprot.readI64();
25430 
            _val597 = iprot.readI64();
25431 
            self.success[_key596] = _val597
5031 varun.gupt 25432 
          iprot.readMapEnd()
25433 
        else:
25434 
          iprot.skip(ftype)
25435 
      elif fid == 1:
25436 
        if ftype == TType.STRUCT:
25437 
          self.ex = TransactionServiceException()
25438 
          self.ex.read(iprot)
25439 
        else:
25440 
          iprot.skip(ftype)
25441 
      else:
25442 
        iprot.skip(ftype)
25443 
      iprot.readFieldEnd()
25444 
    iprot.readStructEnd()
25445 
 
25446 
  def write(self, oprot):
25447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25449 
      return
25450 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
25451 
    if self.success is not None:
25452 
      oprot.writeFieldBegin('success', TType.MAP, 0)
25453 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 25454 
      for kiter598,viter599 in self.success.items():
25455 
        oprot.writeI64(kiter598)
25456 
        oprot.writeI64(viter599)
5031 varun.gupt 25457 
      oprot.writeMapEnd()
25458 
      oprot.writeFieldEnd()
25459 
    if self.ex is not None:
25460 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25461 
      self.ex.write(oprot)
25462 
      oprot.writeFieldEnd()
25463 
    oprot.writeFieldStop()
25464 
    oprot.writeStructEnd()
25465 
 
25466 
  def validate(self):
25467 
    return
25468 
 
25469 
 
25470 
  def __repr__(self):
25471 
    L = ['%s=%r' % (key, value)
25472 
      for key, value in self.__dict__.iteritems()]
25473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25474 
 
25475 
  def __eq__(self, other):
25476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25477 
 
25478 
  def __ne__(self, other):
25479 
    return not (self == other)
5067 varun.gupt 25480 
 
25481 
class getOrderIdsForStatus_args:
25482 
  """
25483 
  Attributes:
25484 
   - status
25485 
   - startDatetime
25486 
   - endDatetime
25487 
  """
25488 
 
25489 
  thrift_spec = (
25490 
    None, # 0
25491 
    (1, TType.I64, 'status', None, None, ), # 1
25492 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
25493 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
25494 
  )
25495 
 
25496 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
25497 
    self.status = status
25498 
    self.startDatetime = startDatetime
25499 
    self.endDatetime = endDatetime
25500 
 
25501 
  def read(self, iprot):
25502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25504 
      return
25505 
    iprot.readStructBegin()
25506 
    while True:
25507 
      (fname, ftype, fid) = iprot.readFieldBegin()
25508 
      if ftype == TType.STOP:
25509 
        break
25510 
      if fid == 1:
25511 
        if ftype == TType.I64:
25512 
          self.status = iprot.readI64();
25513 
        else:
25514 
          iprot.skip(ftype)
25515 
      elif fid == 2:
25516 
        if ftype == TType.I64:
25517 
          self.startDatetime = iprot.readI64();
25518 
        else:
25519 
          iprot.skip(ftype)
25520 
      elif fid == 3:
25521 
        if ftype == TType.I64:
25522 
          self.endDatetime = iprot.readI64();
25523 
        else:
25524 
          iprot.skip(ftype)
25525 
      else:
25526 
        iprot.skip(ftype)
25527 
      iprot.readFieldEnd()
25528 
    iprot.readStructEnd()
25529 
 
25530 
  def write(self, oprot):
25531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25533 
      return
25534 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
25535 
    if self.status is not None:
25536 
      oprot.writeFieldBegin('status', TType.I64, 1)
25537 
      oprot.writeI64(self.status)
25538 
      oprot.writeFieldEnd()
25539 
    if self.startDatetime is not None:
25540 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
25541 
      oprot.writeI64(self.startDatetime)
25542 
      oprot.writeFieldEnd()
25543 
    if self.endDatetime is not None:
25544 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
25545 
      oprot.writeI64(self.endDatetime)
25546 
      oprot.writeFieldEnd()
25547 
    oprot.writeFieldStop()
25548 
    oprot.writeStructEnd()
25549 
 
25550 
  def validate(self):
25551 
    return
25552 
 
25553 
 
25554 
  def __repr__(self):
25555 
    L = ['%s=%r' % (key, value)
25556 
      for key, value in self.__dict__.iteritems()]
25557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25558 
 
25559 
  def __eq__(self, other):
25560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25561 
 
25562 
  def __ne__(self, other):
25563 
    return not (self == other)
25564 
 
25565 
class getOrderIdsForStatus_result:
25566 
  """
25567 
  Attributes:
25568 
   - success
25569 
   - ex
25570 
  """
25571 
 
25572 
  thrift_spec = (
25573 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
25574 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25575 
  )
25576 
 
25577 
  def __init__(self, success=None, ex=None,):
25578 
    self.success = success
25579 
    self.ex = ex
25580 
 
25581 
  def read(self, iprot):
25582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25584 
      return
25585 
    iprot.readStructBegin()
25586 
    while True:
25587 
      (fname, ftype, fid) = iprot.readFieldBegin()
25588 
      if ftype == TType.STOP:
25589 
        break
25590 
      if fid == 0:
25591 
        if ftype == TType.LIST:
25592 
          self.success = []
6188 rajveer 25593 
          (_etype603, _size600) = iprot.readListBegin()
25594 
          for _i604 in xrange(_size600):
25595 
            _elem605 = iprot.readI64();
25596 
            self.success.append(_elem605)
5067 varun.gupt 25597 
          iprot.readListEnd()
25598 
        else:
25599 
          iprot.skip(ftype)
25600 
      elif fid == 1:
25601 
        if ftype == TType.STRUCT:
25602 
          self.ex = TransactionServiceException()
25603 
          self.ex.read(iprot)
25604 
        else:
25605 
          iprot.skip(ftype)
25606 
      else:
25607 
        iprot.skip(ftype)
25608 
      iprot.readFieldEnd()
25609 
    iprot.readStructEnd()
25610 
 
25611 
  def write(self, oprot):
25612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25614 
      return
25615 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
25616 
    if self.success is not None:
25617 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25618 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25619 
      for iter606 in self.success:
25620 
        oprot.writeI64(iter606)
5067 varun.gupt 25621 
      oprot.writeListEnd()
25622 
      oprot.writeFieldEnd()
25623 
    if self.ex is not None:
25624 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25625 
      self.ex.write(oprot)
25626 
      oprot.writeFieldEnd()
25627 
    oprot.writeFieldStop()
25628 
    oprot.writeStructEnd()
25629 
 
25630 
  def validate(self):
25631 
    return
25632 
 
25633 
 
25634 
  def __repr__(self):
25635 
    L = ['%s=%r' % (key, value)
25636 
      for key, value in self.__dict__.iteritems()]
25637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25638 
 
25639 
  def __eq__(self, other):
25640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25641 
 
25642 
  def __ne__(self, other):
25643 
    return not (self == other)
5099 varun.gupt 25644 
 
5348 anupam.sin 25645 
class updateCODAgent_args:
25646 
  """
25647 
  Attributes:
25648 
   - agent
25649 
   - orderId
25650 
  """
25651 
 
25652 
  thrift_spec = (
25653 
    None, # 0
25654 
    (1, TType.STRING, 'agent', None, None, ), # 1
25655 
    (2, TType.I64, 'orderId', None, None, ), # 2
25656 
  )
25657 
 
25658 
  def __init__(self, agent=None, orderId=None,):
25659 
    self.agent = agent
25660 
    self.orderId = orderId
25661 
 
25662 
  def read(self, iprot):
25663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25665 
      return
25666 
    iprot.readStructBegin()
25667 
    while True:
25668 
      (fname, ftype, fid) = iprot.readFieldBegin()
25669 
      if ftype == TType.STOP:
25670 
        break
25671 
      if fid == 1:
25672 
        if ftype == TType.STRING:
25673 
          self.agent = iprot.readString();
25674 
        else:
25675 
          iprot.skip(ftype)
25676 
      elif fid == 2:
25677 
        if ftype == TType.I64:
25678 
          self.orderId = iprot.readI64();
25679 
        else:
25680 
          iprot.skip(ftype)
25681 
      else:
25682 
        iprot.skip(ftype)
25683 
      iprot.readFieldEnd()
25684 
    iprot.readStructEnd()
25685 
 
25686 
  def write(self, oprot):
25687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25689 
      return
25690 
    oprot.writeStructBegin('updateCODAgent_args')
25691 
    if self.agent is not None:
25692 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
25693 
      oprot.writeString(self.agent)
25694 
      oprot.writeFieldEnd()
25695 
    if self.orderId is not None:
25696 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
25697 
      oprot.writeI64(self.orderId)
25698 
      oprot.writeFieldEnd()
25699 
    oprot.writeFieldStop()
25700 
    oprot.writeStructEnd()
25701 
 
25702 
  def validate(self):
25703 
    return
25704 
 
25705 
 
25706 
  def __repr__(self):
25707 
    L = ['%s=%r' % (key, value)
25708 
      for key, value in self.__dict__.iteritems()]
25709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25710 
 
25711 
  def __eq__(self, other):
25712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25713 
 
25714 
  def __ne__(self, other):
25715 
    return not (self == other)
25716 
 
25717 
class updateCODAgent_result:
25718 
  """
25719 
  Attributes:
25720 
   - ex
25721 
  """
25722 
 
25723 
  thrift_spec = (
25724 
    None, # 0
25725 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25726 
  )
25727 
 
25728 
  def __init__(self, ex=None,):
25729 
    self.ex = ex
25730 
 
25731 
  def read(self, iprot):
25732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25734 
      return
25735 
    iprot.readStructBegin()
25736 
    while True:
25737 
      (fname, ftype, fid) = iprot.readFieldBegin()
25738 
      if ftype == TType.STOP:
25739 
        break
25740 
      if fid == 1:
25741 
        if ftype == TType.STRUCT:
25742 
          self.ex = TransactionServiceException()
25743 
          self.ex.read(iprot)
25744 
        else:
25745 
          iprot.skip(ftype)
25746 
      else:
25747 
        iprot.skip(ftype)
25748 
      iprot.readFieldEnd()
25749 
    iprot.readStructEnd()
25750 
 
25751 
  def write(self, oprot):
25752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25754 
      return
25755 
    oprot.writeStructBegin('updateCODAgent_result')
25756 
    if self.ex is not None:
25757 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25758 
      self.ex.write(oprot)
25759 
      oprot.writeFieldEnd()
25760 
    oprot.writeFieldStop()
25761 
    oprot.writeStructEnd()
25762 
 
25763 
  def validate(self):
25764 
    return
25765 
 
25766 
 
25767 
  def __repr__(self):
25768 
    L = ['%s=%r' % (key, value)
25769 
      for key, value in self.__dict__.iteritems()]
25770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25771 
 
25772 
  def __eq__(self, other):
25773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25774 
 
25775 
  def __ne__(self, other):
25776 
    return not (self == other)
25777 
 
5099 varun.gupt 25778 
class updateOrderAsPaidToVendor_args:
25779 
  """
25780 
  Attributes:
25781 
   - orderId
25782 
  """
25783 
 
25784 
  thrift_spec = (
25785 
    None, # 0
25786 
    (1, TType.I64, 'orderId', None, None, ), # 1
25787 
  )
25788 
 
25789 
  def __init__(self, orderId=None,):
25790 
    self.orderId = orderId
25791 
 
25792 
  def read(self, iprot):
25793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25795 
      return
25796 
    iprot.readStructBegin()
25797 
    while True:
25798 
      (fname, ftype, fid) = iprot.readFieldBegin()
25799 
      if ftype == TType.STOP:
25800 
        break
25801 
      if fid == 1:
25802 
        if ftype == TType.I64:
25803 
          self.orderId = iprot.readI64();
25804 
        else:
25805 
          iprot.skip(ftype)
25806 
      else:
25807 
        iprot.skip(ftype)
25808 
      iprot.readFieldEnd()
25809 
    iprot.readStructEnd()
25810 
 
25811 
  def write(self, oprot):
25812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25814 
      return
25815 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
25816 
    if self.orderId is not None:
25817 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25818 
      oprot.writeI64(self.orderId)
25819 
      oprot.writeFieldEnd()
25820 
    oprot.writeFieldStop()
25821 
    oprot.writeStructEnd()
25822 
 
25823 
  def validate(self):
25824 
    return
25825 
 
25826 
 
25827 
  def __repr__(self):
25828 
    L = ['%s=%r' % (key, value)
25829 
      for key, value in self.__dict__.iteritems()]
25830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25831 
 
25832 
  def __eq__(self, other):
25833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25834 
 
25835 
  def __ne__(self, other):
25836 
    return not (self == other)
25837 
 
25838 
class updateOrderAsPaidToVendor_result:
25839 
  """
25840 
  Attributes:
25841 
   - ex
25842 
  """
25843 
 
25844 
  thrift_spec = (
25845 
    None, # 0
25846 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25847 
  )
25848 
 
25849 
  def __init__(self, ex=None,):
25850 
    self.ex = ex
25851 
 
25852 
  def read(self, iprot):
25853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25855 
      return
25856 
    iprot.readStructBegin()
25857 
    while True:
25858 
      (fname, ftype, fid) = iprot.readFieldBegin()
25859 
      if ftype == TType.STOP:
25860 
        break
25861 
      if fid == 1:
25862 
        if ftype == TType.STRUCT:
25863 
          self.ex = TransactionServiceException()
25864 
          self.ex.read(iprot)
25865 
        else:
25866 
          iprot.skip(ftype)
25867 
      else:
25868 
        iprot.skip(ftype)
25869 
      iprot.readFieldEnd()
25870 
    iprot.readStructEnd()
25871 
 
25872 
  def write(self, oprot):
25873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25875 
      return
25876 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
25877 
    if self.ex is not None:
25878 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25879 
      self.ex.write(oprot)
25880 
      oprot.writeFieldEnd()
25881 
    oprot.writeFieldStop()
25882 
    oprot.writeStructEnd()
25883 
 
25884 
  def validate(self):
25885 
    return
25886 
 
25887 
 
25888 
  def __repr__(self):
25889 
    L = ['%s=%r' % (key, value)
25890 
      for key, value in self.__dict__.iteritems()]
25891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25892 
 
25893 
  def __eq__(self, other):
25894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25895 
 
25896 
  def __ne__(self, other):
25897 
    return not (self == other)
5208 varun.gupt 25898 
 
5386 phani.kuma 25899 
class updateOrderOnlyAsPaidToVendor_args:
25900 
  """
25901 
  Attributes:
25902 
   - orderId
25903 
  """
25904 
 
25905 
  thrift_spec = (
25906 
    None, # 0
25907 
    (1, TType.I64, 'orderId', None, None, ), # 1
25908 
  )
25909 
 
25910 
  def __init__(self, orderId=None,):
25911 
    self.orderId = orderId
25912 
 
25913 
  def read(self, iprot):
25914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25916 
      return
25917 
    iprot.readStructBegin()
25918 
    while True:
25919 
      (fname, ftype, fid) = iprot.readFieldBegin()
25920 
      if ftype == TType.STOP:
25921 
        break
25922 
      if fid == 1:
25923 
        if ftype == TType.I64:
25924 
          self.orderId = iprot.readI64();
25925 
        else:
25926 
          iprot.skip(ftype)
25927 
      else:
25928 
        iprot.skip(ftype)
25929 
      iprot.readFieldEnd()
25930 
    iprot.readStructEnd()
25931 
 
25932 
  def write(self, oprot):
25933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25935 
      return
25936 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
25937 
    if self.orderId is not None:
25938 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25939 
      oprot.writeI64(self.orderId)
25940 
      oprot.writeFieldEnd()
25941 
    oprot.writeFieldStop()
25942 
    oprot.writeStructEnd()
25943 
 
25944 
  def validate(self):
25945 
    return
25946 
 
25947 
 
25948 
  def __repr__(self):
25949 
    L = ['%s=%r' % (key, value)
25950 
      for key, value in self.__dict__.iteritems()]
25951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25952 
 
25953 
  def __eq__(self, other):
25954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25955 
 
25956 
  def __ne__(self, other):
25957 
    return not (self == other)
25958 
 
25959 
class updateOrderOnlyAsPaidToVendor_result:
25960 
  """
25961 
  Attributes:
25962 
   - ex
25963 
  """
25964 
 
25965 
  thrift_spec = (
25966 
    None, # 0
25967 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25968 
  )
25969 
 
25970 
  def __init__(self, ex=None,):
25971 
    self.ex = ex
25972 
 
25973 
  def read(self, iprot):
25974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25976 
      return
25977 
    iprot.readStructBegin()
25978 
    while True:
25979 
      (fname, ftype, fid) = iprot.readFieldBegin()
25980 
      if ftype == TType.STOP:
25981 
        break
25982 
      if fid == 1:
25983 
        if ftype == TType.STRUCT:
25984 
          self.ex = TransactionServiceException()
25985 
          self.ex.read(iprot)
25986 
        else:
25987 
          iprot.skip(ftype)
25988 
      else:
25989 
        iprot.skip(ftype)
25990 
      iprot.readFieldEnd()
25991 
    iprot.readStructEnd()
25992 
 
25993 
  def write(self, oprot):
25994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25996 
      return
25997 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
25998 
    if self.ex is not None:
25999 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26000 
      self.ex.write(oprot)
26001 
      oprot.writeFieldEnd()
26002 
    oprot.writeFieldStop()
26003 
    oprot.writeStructEnd()
26004 
 
26005 
  def validate(self):
26006 
    return
26007 
 
26008 
 
26009 
  def __repr__(self):
26010 
    L = ['%s=%r' % (key, value)
26011 
      for key, value in self.__dict__.iteritems()]
26012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26013 
 
26014 
  def __eq__(self, other):
26015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26016 
 
26017 
  def __ne__(self, other):
26018 
    return not (self == other)
26019 
 
5208 varun.gupt 26020 
class getRefundedOrdersMarkedPaid_args:
26021 
 
26022 
  thrift_spec = (
26023 
  )
26024 
 
26025 
  def read(self, iprot):
26026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26028 
      return
26029 
    iprot.readStructBegin()
26030 
    while True:
26031 
      (fname, ftype, fid) = iprot.readFieldBegin()
26032 
      if ftype == TType.STOP:
26033 
        break
26034 
      else:
26035 
        iprot.skip(ftype)
26036 
      iprot.readFieldEnd()
26037 
    iprot.readStructEnd()
26038 
 
26039 
  def write(self, oprot):
26040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26042 
      return
26043 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
26044 
    oprot.writeFieldStop()
26045 
    oprot.writeStructEnd()
26046 
 
26047 
  def validate(self):
26048 
    return
26049 
 
26050 
 
26051 
  def __repr__(self):
26052 
    L = ['%s=%r' % (key, value)
26053 
      for key, value in self.__dict__.iteritems()]
26054 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26055 
 
26056 
  def __eq__(self, other):
26057 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26058 
 
26059 
  def __ne__(self, other):
26060 
    return not (self == other)
26061 
 
26062 
class getRefundedOrdersMarkedPaid_result:
26063 
  """
26064 
  Attributes:
26065 
   - success
26066 
   - ex
26067 
  """
26068 
 
26069 
  thrift_spec = (
26070 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26071 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26072 
  )
26073 
 
26074 
  def __init__(self, success=None, ex=None,):
26075 
    self.success = success
26076 
    self.ex = ex
26077 
 
26078 
  def read(self, iprot):
26079 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26080 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26081 
      return
26082 
    iprot.readStructBegin()
26083 
    while True:
26084 
      (fname, ftype, fid) = iprot.readFieldBegin()
26085 
      if ftype == TType.STOP:
26086 
        break
26087 
      if fid == 0:
26088 
        if ftype == TType.LIST:
26089 
          self.success = []
6188 rajveer 26090 
          (_etype610, _size607) = iprot.readListBegin()
26091 
          for _i611 in xrange(_size607):
26092 
            _elem612 = Order()
26093 
            _elem612.read(iprot)
26094 
            self.success.append(_elem612)
5208 varun.gupt 26095 
          iprot.readListEnd()
26096 
        else:
26097 
          iprot.skip(ftype)
26098 
      elif fid == 1:
26099 
        if ftype == TType.STRUCT:
26100 
          self.ex = TransactionServiceException()
26101 
          self.ex.read(iprot)
26102 
        else:
26103 
          iprot.skip(ftype)
26104 
      else:
26105 
        iprot.skip(ftype)
26106 
      iprot.readFieldEnd()
26107 
    iprot.readStructEnd()
26108 
 
26109 
  def write(self, oprot):
26110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26112 
      return
26113 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
26114 
    if self.success is not None:
26115 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26116 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26117 
      for iter613 in self.success:
26118 
        iter613.write(oprot)
5208 varun.gupt 26119 
      oprot.writeListEnd()
26120 
      oprot.writeFieldEnd()
26121 
    if self.ex is not None:
26122 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26123 
      self.ex.write(oprot)
26124 
      oprot.writeFieldEnd()
26125 
    oprot.writeFieldStop()
26126 
    oprot.writeStructEnd()
26127 
 
26128 
  def validate(self):
26129 
    return
26130 
 
26131 
 
26132 
  def __repr__(self):
26133 
    L = ['%s=%r' % (key, value)
26134 
      for key, value in self.__dict__.iteritems()]
26135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26136 
 
26137 
  def __eq__(self, other):
26138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26139 
 
26140 
  def __ne__(self, other):
26141 
    return not (self == other)
5447 anupam.sin 26142 
 
26143 
class getAllVerificationAgents_args:
26144 
  """
26145 
  Attributes:
26146 
   - minOrderId
26147 
   - maxOrderId
26148 
  """
26149 
 
26150 
  thrift_spec = (
26151 
    None, # 0
26152 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
26153 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
26154 
  )
26155 
 
26156 
  def __init__(self, minOrderId=None, maxOrderId=None,):
26157 
    self.minOrderId = minOrderId
26158 
    self.maxOrderId = maxOrderId
26159 
 
26160 
  def read(self, iprot):
26161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26163 
      return
26164 
    iprot.readStructBegin()
26165 
    while True:
26166 
      (fname, ftype, fid) = iprot.readFieldBegin()
26167 
      if ftype == TType.STOP:
26168 
        break
26169 
      if fid == 1:
26170 
        if ftype == TType.I64:
26171 
          self.minOrderId = iprot.readI64();
26172 
        else:
26173 
          iprot.skip(ftype)
26174 
      elif fid == 2:
26175 
        if ftype == TType.I64:
26176 
          self.maxOrderId = iprot.readI64();
26177 
        else:
26178 
          iprot.skip(ftype)
26179 
      else:
26180 
        iprot.skip(ftype)
26181 
      iprot.readFieldEnd()
26182 
    iprot.readStructEnd()
26183 
 
26184 
  def write(self, oprot):
26185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26187 
      return
26188 
    oprot.writeStructBegin('getAllVerificationAgents_args')
26189 
    if self.minOrderId is not None:
26190 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
26191 
      oprot.writeI64(self.minOrderId)
26192 
      oprot.writeFieldEnd()
26193 
    if self.maxOrderId is not None:
26194 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
26195 
      oprot.writeI64(self.maxOrderId)
26196 
      oprot.writeFieldEnd()
26197 
    oprot.writeFieldStop()
26198 
    oprot.writeStructEnd()
26199 
 
26200 
  def validate(self):
26201 
    return
26202 
 
26203 
 
26204 
  def __repr__(self):
26205 
    L = ['%s=%r' % (key, value)
26206 
      for key, value in self.__dict__.iteritems()]
26207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26208 
 
26209 
  def __eq__(self, other):
26210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26211 
 
26212 
  def __ne__(self, other):
26213 
    return not (self == other)
26214 
 
26215 
class getAllVerificationAgents_result:
26216 
  """
26217 
  Attributes:
26218 
   - success
26219 
  """
26220 
 
26221 
  thrift_spec = (
26222 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
26223 
  )
26224 
 
26225 
  def __init__(self, success=None,):
26226 
    self.success = success
26227 
 
26228 
  def read(self, iprot):
26229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26231 
      return
26232 
    iprot.readStructBegin()
26233 
    while True:
26234 
      (fname, ftype, fid) = iprot.readFieldBegin()
26235 
      if ftype == TType.STOP:
26236 
        break
26237 
      if fid == 0:
26238 
        if ftype == TType.LIST:
26239 
          self.success = []
6188 rajveer 26240 
          (_etype617, _size614) = iprot.readListBegin()
26241 
          for _i618 in xrange(_size614):
26242 
            _elem619 = CODVerificationAgent()
26243 
            _elem619.read(iprot)
26244 
            self.success.append(_elem619)
5447 anupam.sin 26245 
          iprot.readListEnd()
26246 
        else:
26247 
          iprot.skip(ftype)
26248 
      else:
26249 
        iprot.skip(ftype)
26250 
      iprot.readFieldEnd()
26251 
    iprot.readStructEnd()
26252 
 
26253 
  def write(self, oprot):
26254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26256 
      return
26257 
    oprot.writeStructBegin('getAllVerificationAgents_result')
26258 
    if self.success is not None:
26259 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26260 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26261 
      for iter620 in self.success:
26262 
        iter620.write(oprot)
5447 anupam.sin 26263 
      oprot.writeListEnd()
26264 
      oprot.writeFieldEnd()
26265 
    oprot.writeFieldStop()
26266 
    oprot.writeStructEnd()
26267 
 
26268 
  def validate(self):
26269 
    return
26270 
 
26271 
 
26272 
  def __repr__(self):
26273 
    L = ['%s=%r' % (key, value)
26274 
      for key, value in self.__dict__.iteritems()]
26275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26276 
 
26277 
  def __eq__(self, other):
26278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26279 
 
26280 
  def __ne__(self, other):
26281 
    return not (self == other)
5527 anupam.sin 26282 
 
26283 
class getAllAttributesForOrderId_args:
26284 
  """
26285 
  Attributes:
26286 
   - orderId
26287 
  """
26288 
 
26289 
  thrift_spec = (
26290 
    None, # 0
26291 
    (1, TType.I64, 'orderId', None, None, ), # 1
26292 
  )
26293 
 
26294 
  def __init__(self, orderId=None,):
26295 
    self.orderId = orderId
26296 
 
26297 
  def read(self, iprot):
26298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26300 
      return
26301 
    iprot.readStructBegin()
26302 
    while True:
26303 
      (fname, ftype, fid) = iprot.readFieldBegin()
26304 
      if ftype == TType.STOP:
26305 
        break
26306 
      if fid == 1:
26307 
        if ftype == TType.I64:
26308 
          self.orderId = iprot.readI64();
26309 
        else:
26310 
          iprot.skip(ftype)
26311 
      else:
26312 
        iprot.skip(ftype)
26313 
      iprot.readFieldEnd()
26314 
    iprot.readStructEnd()
26315 
 
26316 
  def write(self, oprot):
26317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26319 
      return
26320 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
26321 
    if self.orderId is not None:
26322 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26323 
      oprot.writeI64(self.orderId)
26324 
      oprot.writeFieldEnd()
26325 
    oprot.writeFieldStop()
26326 
    oprot.writeStructEnd()
26327 
 
26328 
  def validate(self):
26329 
    return
26330 
 
26331 
 
26332 
  def __repr__(self):
26333 
    L = ['%s=%r' % (key, value)
26334 
      for key, value in self.__dict__.iteritems()]
26335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26336 
 
26337 
  def __eq__(self, other):
26338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26339 
 
26340 
  def __ne__(self, other):
26341 
    return not (self == other)
26342 
 
26343 
class getAllAttributesForOrderId_result:
26344 
  """
26345 
  Attributes:
26346 
   - success
26347 
  """
26348 
 
26349 
  thrift_spec = (
26350 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
26351 
  )
26352 
 
26353 
  def __init__(self, success=None,):
26354 
    self.success = success
26355 
 
26356 
  def read(self, iprot):
26357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26359 
      return
26360 
    iprot.readStructBegin()
26361 
    while True:
26362 
      (fname, ftype, fid) = iprot.readFieldBegin()
26363 
      if ftype == TType.STOP:
26364 
        break
26365 
      if fid == 0:
26366 
        if ftype == TType.LIST:
26367 
          self.success = []
6188 rajveer 26368 
          (_etype624, _size621) = iprot.readListBegin()
26369 
          for _i625 in xrange(_size621):
26370 
            _elem626 = Attribute()
26371 
            _elem626.read(iprot)
26372 
            self.success.append(_elem626)
5527 anupam.sin 26373 
          iprot.readListEnd()
26374 
        else:
26375 
          iprot.skip(ftype)
26376 
      else:
26377 
        iprot.skip(ftype)
26378 
      iprot.readFieldEnd()
26379 
    iprot.readStructEnd()
26380 
 
26381 
  def write(self, oprot):
26382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26384 
      return
26385 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
26386 
    if self.success is not None:
26387 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26388 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26389 
      for iter627 in self.success:
26390 
        iter627.write(oprot)
5527 anupam.sin 26391 
      oprot.writeListEnd()
26392 
      oprot.writeFieldEnd()
26393 
    oprot.writeFieldStop()
26394 
    oprot.writeStructEnd()
26395 
 
26396 
  def validate(self):
26397 
    return
26398 
 
26399 
 
26400 
  def __repr__(self):
26401 
    L = ['%s=%r' % (key, value)
26402 
      for key, value in self.__dict__.iteritems()]
26403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26404 
 
26405 
  def __eq__(self, other):
26406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26407 
 
26408 
  def __ne__(self, other):
26409 
    return not (self == other)
26410 
 
5676 rajveer 26411 
class setOrderAttributes_args:
26412 
  """
26413 
  Attributes:
26414 
   - orderId
26415 
   - attributes
26416 
  """
26417 
 
26418 
  thrift_spec = None
26419 
  def __init__(self, orderId=None, attributes=None,):
26420 
    self.orderId = orderId
26421 
    self.attributes = attributes
26422 
 
26423 
  def read(self, iprot):
26424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26426 
      return
26427 
    iprot.readStructBegin()
26428 
    while True:
26429 
      (fname, ftype, fid) = iprot.readFieldBegin()
26430 
      if ftype == TType.STOP:
26431 
        break
26432 
      if fid == 1:
26433 
        if ftype == TType.I64:
26434 
          self.orderId = iprot.readI64();
26435 
        else:
26436 
          iprot.skip(ftype)
26437 
      elif fid == -1:
26438 
        if ftype == TType.LIST:
26439 
          self.attributes = []
6188 rajveer 26440 
          (_etype631, _size628) = iprot.readListBegin()
26441 
          for _i632 in xrange(_size628):
26442 
            _elem633 = Attribute()
26443 
            _elem633.read(iprot)
26444 
            self.attributes.append(_elem633)
5676 rajveer 26445 
          iprot.readListEnd()
26446 
        else:
26447 
          iprot.skip(ftype)
26448 
      else:
26449 
        iprot.skip(ftype)
26450 
      iprot.readFieldEnd()
26451 
    iprot.readStructEnd()
26452 
 
26453 
  def write(self, oprot):
26454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26456 
      return
26457 
    oprot.writeStructBegin('setOrderAttributes_args')
26458 
    if self.attributes is not None:
26459 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
26460 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 26461 
      for iter634 in self.attributes:
26462 
        iter634.write(oprot)
5676 rajveer 26463 
      oprot.writeListEnd()
26464 
      oprot.writeFieldEnd()
26465 
    if self.orderId is not None:
26466 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26467 
      oprot.writeI64(self.orderId)
26468 
      oprot.writeFieldEnd()
26469 
    oprot.writeFieldStop()
26470 
    oprot.writeStructEnd()
26471 
 
26472 
  def validate(self):
26473 
    return
26474 
 
26475 
 
26476 
  def __repr__(self):
26477 
    L = ['%s=%r' % (key, value)
26478 
      for key, value in self.__dict__.iteritems()]
26479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26480 
 
26481 
  def __eq__(self, other):
26482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26483 
 
26484 
  def __ne__(self, other):
26485 
    return not (self == other)
26486 
 
26487 
class setOrderAttributes_result:
26488 
 
26489 
  thrift_spec = (
26490 
  )
26491 
 
26492 
  def read(self, iprot):
26493 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26494 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26495 
      return
26496 
    iprot.readStructBegin()
26497 
    while True:
26498 
      (fname, ftype, fid) = iprot.readFieldBegin()
26499 
      if ftype == TType.STOP:
26500 
        break
26501 
      else:
26502 
        iprot.skip(ftype)
26503 
      iprot.readFieldEnd()
26504 
    iprot.readStructEnd()
26505 
 
26506 
  def write(self, oprot):
26507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26509 
      return
26510 
    oprot.writeStructBegin('setOrderAttributes_result')
26511 
    oprot.writeFieldStop()
26512 
    oprot.writeStructEnd()
26513 
 
26514 
  def validate(self):
26515 
    return
26516 
 
26517 
 
26518 
  def __repr__(self):
26519 
    L = ['%s=%r' % (key, value)
26520 
      for key, value in self.__dict__.iteritems()]
26521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26522 
 
26523 
  def __eq__(self, other):
26524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26525 
 
26526 
  def __ne__(self, other):
26527 
    return not (self == other)
26528 
 
5527 anupam.sin 26529 
class setOrderAttributeForTransaction_args:
26530 
  """
26531 
  Attributes:
26532 
   - transactionId
26533 
   - attribute
26534 
  """
26535 
 
26536 
  thrift_spec = None
26537 
  def __init__(self, transactionId=None, attribute=None,):
26538 
    self.transactionId = transactionId
26539 
    self.attribute = attribute
26540 
 
26541 
  def read(self, iprot):
26542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26544 
      return
26545 
    iprot.readStructBegin()
26546 
    while True:
26547 
      (fname, ftype, fid) = iprot.readFieldBegin()
26548 
      if ftype == TType.STOP:
26549 
        break
26550 
      if fid == 1:
26551 
        if ftype == TType.I64:
26552 
          self.transactionId = iprot.readI64();
26553 
        else:
26554 
          iprot.skip(ftype)
26555 
      elif fid == -1:
26556 
        if ftype == TType.STRUCT:
26557 
          self.attribute = Attribute()
26558 
          self.attribute.read(iprot)
26559 
        else:
26560 
          iprot.skip(ftype)
26561 
      else:
26562 
        iprot.skip(ftype)
26563 
      iprot.readFieldEnd()
26564 
    iprot.readStructEnd()
26565 
 
26566 
  def write(self, oprot):
26567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26569 
      return
26570 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
26571 
    if self.attribute is not None:
26572 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
26573 
      self.attribute.write(oprot)
26574 
      oprot.writeFieldEnd()
26575 
    if self.transactionId is not None:
26576 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
26577 
      oprot.writeI64(self.transactionId)
26578 
      oprot.writeFieldEnd()
26579 
    oprot.writeFieldStop()
26580 
    oprot.writeStructEnd()
26581 
 
26582 
  def validate(self):
26583 
    return
26584 
 
26585 
 
26586 
  def __repr__(self):
26587 
    L = ['%s=%r' % (key, value)
26588 
      for key, value in self.__dict__.iteritems()]
26589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26590 
 
26591 
  def __eq__(self, other):
26592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26593 
 
26594 
  def __ne__(self, other):
26595 
    return not (self == other)
26596 
 
26597 
class setOrderAttributeForTransaction_result:
26598 
 
26599 
  thrift_spec = (
26600 
  )
26601 
 
26602 
  def read(self, iprot):
26603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26605 
      return
26606 
    iprot.readStructBegin()
26607 
    while True:
26608 
      (fname, ftype, fid) = iprot.readFieldBegin()
26609 
      if ftype == TType.STOP:
26610 
        break
26611 
      else:
26612 
        iprot.skip(ftype)
26613 
      iprot.readFieldEnd()
26614 
    iprot.readStructEnd()
26615 
 
26616 
  def write(self, oprot):
26617 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26618 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26619 
      return
26620 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
26621 
    oprot.writeFieldStop()
26622 
    oprot.writeStructEnd()
26623 
 
26624 
  def validate(self):
26625 
    return
26626 
 
26627 
 
26628 
  def __repr__(self):
26629 
    L = ['%s=%r' % (key, value)
26630 
      for key, value in self.__dict__.iteritems()]
26631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26632 
 
26633 
  def __eq__(self, other):
26634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26635 
 
26636 
  def __ne__(self, other):
26637 
    return not (self == other)
5553 rajveer 26638 
 
26639 
class getReceivePendingOrders_args:
26640 
  """
26641 
  Attributes:
26642 
   - storeId
26643 
  """
26644 
 
26645 
  thrift_spec = (
26646 
    None, # 0
26647 
    (1, TType.I64, 'storeId', None, None, ), # 1
26648 
  )
26649 
 
26650 
  def __init__(self, storeId=None,):
26651 
    self.storeId = storeId
26652 
 
26653 
  def read(self, iprot):
26654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26656 
      return
26657 
    iprot.readStructBegin()
26658 
    while True:
26659 
      (fname, ftype, fid) = iprot.readFieldBegin()
26660 
      if ftype == TType.STOP:
26661 
        break
26662 
      if fid == 1:
26663 
        if ftype == TType.I64:
26664 
          self.storeId = iprot.readI64();
26665 
        else:
26666 
          iprot.skip(ftype)
26667 
      else:
26668 
        iprot.skip(ftype)
26669 
      iprot.readFieldEnd()
26670 
    iprot.readStructEnd()
26671 
 
26672 
  def write(self, oprot):
26673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26675 
      return
26676 
    oprot.writeStructBegin('getReceivePendingOrders_args')
26677 
    if self.storeId is not None:
26678 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26679 
      oprot.writeI64(self.storeId)
26680 
      oprot.writeFieldEnd()
26681 
    oprot.writeFieldStop()
26682 
    oprot.writeStructEnd()
26683 
 
26684 
  def validate(self):
26685 
    return
26686 
 
26687 
 
26688 
  def __repr__(self):
26689 
    L = ['%s=%r' % (key, value)
26690 
      for key, value in self.__dict__.iteritems()]
26691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26692 
 
26693 
  def __eq__(self, other):
26694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26695 
 
26696 
  def __ne__(self, other):
26697 
    return not (self == other)
26698 
 
26699 
class getReceivePendingOrders_result:
26700 
  """
26701 
  Attributes:
26702 
   - success
26703 
  """
26704 
 
26705 
  thrift_spec = (
26706 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26707 
  )
26708 
 
26709 
  def __init__(self, success=None,):
26710 
    self.success = success
26711 
 
26712 
  def read(self, iprot):
26713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26715 
      return
26716 
    iprot.readStructBegin()
26717 
    while True:
26718 
      (fname, ftype, fid) = iprot.readFieldBegin()
26719 
      if ftype == TType.STOP:
26720 
        break
26721 
      if fid == 0:
26722 
        if ftype == TType.LIST:
26723 
          self.success = []
6188 rajveer 26724 
          (_etype638, _size635) = iprot.readListBegin()
26725 
          for _i639 in xrange(_size635):
26726 
            _elem640 = Order()
26727 
            _elem640.read(iprot)
26728 
            self.success.append(_elem640)
5553 rajveer 26729 
          iprot.readListEnd()
26730 
        else:
26731 
          iprot.skip(ftype)
26732 
      else:
26733 
        iprot.skip(ftype)
26734 
      iprot.readFieldEnd()
26735 
    iprot.readStructEnd()
26736 
 
26737 
  def write(self, oprot):
26738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26740 
      return
26741 
    oprot.writeStructBegin('getReceivePendingOrders_result')
26742 
    if self.success is not None:
26743 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26744 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26745 
      for iter641 in self.success:
26746 
        iter641.write(oprot)
5553 rajveer 26747 
      oprot.writeListEnd()
26748 
      oprot.writeFieldEnd()
26749 
    oprot.writeFieldStop()
26750 
    oprot.writeStructEnd()
26751 
 
26752 
  def validate(self):
26753 
    return
26754 
 
26755 
 
26756 
  def __repr__(self):
26757 
    L = ['%s=%r' % (key, value)
26758 
      for key, value in self.__dict__.iteritems()]
26759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26760 
 
26761 
  def __eq__(self, other):
26762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26763 
 
26764 
  def __ne__(self, other):
26765 
    return not (self == other)
26766 
 
26767 
class getReceivedAtStoreOrders_args:
26768 
  """
26769 
  Attributes:
26770 
   - storeId
26771 
  """
26772 
 
26773 
  thrift_spec = (
26774 
    None, # 0
26775 
    (1, TType.I64, 'storeId', None, None, ), # 1
26776 
  )
26777 
 
26778 
  def __init__(self, storeId=None,):
26779 
    self.storeId = storeId
26780 
 
26781 
  def read(self, iprot):
26782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26784 
      return
26785 
    iprot.readStructBegin()
26786 
    while True:
26787 
      (fname, ftype, fid) = iprot.readFieldBegin()
26788 
      if ftype == TType.STOP:
26789 
        break
26790 
      if fid == 1:
26791 
        if ftype == TType.I64:
26792 
          self.storeId = iprot.readI64();
26793 
        else:
26794 
          iprot.skip(ftype)
26795 
      else:
26796 
        iprot.skip(ftype)
26797 
      iprot.readFieldEnd()
26798 
    iprot.readStructEnd()
26799 
 
26800 
  def write(self, oprot):
26801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26803 
      return
26804 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
26805 
    if self.storeId is not None:
26806 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26807 
      oprot.writeI64(self.storeId)
26808 
      oprot.writeFieldEnd()
26809 
    oprot.writeFieldStop()
26810 
    oprot.writeStructEnd()
26811 
 
26812 
  def validate(self):
26813 
    return
26814 
 
26815 
 
26816 
  def __repr__(self):
26817 
    L = ['%s=%r' % (key, value)
26818 
      for key, value in self.__dict__.iteritems()]
26819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26820 
 
26821 
  def __eq__(self, other):
26822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26823 
 
26824 
  def __ne__(self, other):
26825 
    return not (self == other)
26826 
 
26827 
class getReceivedAtStoreOrders_result:
26828 
  """
26829 
  Attributes:
26830 
   - success
26831 
  """
26832 
 
26833 
  thrift_spec = (
26834 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26835 
  )
26836 
 
26837 
  def __init__(self, success=None,):
26838 
    self.success = success
26839 
 
26840 
  def read(self, iprot):
26841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26843 
      return
26844 
    iprot.readStructBegin()
26845 
    while True:
26846 
      (fname, ftype, fid) = iprot.readFieldBegin()
26847 
      if ftype == TType.STOP:
26848 
        break
26849 
      if fid == 0:
26850 
        if ftype == TType.LIST:
26851 
          self.success = []
6188 rajveer 26852 
          (_etype645, _size642) = iprot.readListBegin()
26853 
          for _i646 in xrange(_size642):
26854 
            _elem647 = Order()
26855 
            _elem647.read(iprot)
26856 
            self.success.append(_elem647)
5553 rajveer 26857 
          iprot.readListEnd()
26858 
        else:
26859 
          iprot.skip(ftype)
26860 
      else:
26861 
        iprot.skip(ftype)
26862 
      iprot.readFieldEnd()
26863 
    iprot.readStructEnd()
26864 
 
26865 
  def write(self, oprot):
26866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26868 
      return
26869 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
26870 
    if self.success is not None:
26871 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26872 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26873 
      for iter648 in self.success:
26874 
        iter648.write(oprot)
5553 rajveer 26875 
      oprot.writeListEnd()
26876 
      oprot.writeFieldEnd()
26877 
    oprot.writeFieldStop()
26878 
    oprot.writeStructEnd()
26879 
 
26880 
  def validate(self):
26881 
    return
26882 
 
26883 
 
26884 
  def __repr__(self):
26885 
    L = ['%s=%r' % (key, value)
26886 
      for key, value in self.__dict__.iteritems()]
26887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26888 
 
26889 
  def __eq__(self, other):
26890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26891 
 
26892 
  def __ne__(self, other):
26893 
    return not (self == other)
5593 mandeep.dh 26894 
 
5713 rajveer 26895 
class getOrdersCollectionAtStore_args:
26896 
  """
26897 
  Attributes:
26898 
   - storeId
26899 
   - fromDate
26900 
   - toDate
26901 
   - onlyCod
26902 
  """
26903 
 
26904 
  thrift_spec = (
26905 
    None, # 0
26906 
    (1, TType.I64, 'storeId', None, None, ), # 1
26907 
    (2, TType.I64, 'fromDate', None, None, ), # 2
26908 
    (3, TType.I64, 'toDate', None, None, ), # 3
26909 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
26910 
  )
26911 
 
26912 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
26913 
    self.storeId = storeId
26914 
    self.fromDate = fromDate
26915 
    self.toDate = toDate
26916 
    self.onlyCod = onlyCod
26917 
 
26918 
  def read(self, iprot):
26919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26921 
      return
26922 
    iprot.readStructBegin()
26923 
    while True:
26924 
      (fname, ftype, fid) = iprot.readFieldBegin()
26925 
      if ftype == TType.STOP:
26926 
        break
26927 
      if fid == 1:
26928 
        if ftype == TType.I64:
26929 
          self.storeId = iprot.readI64();
26930 
        else:
26931 
          iprot.skip(ftype)
26932 
      elif fid == 2:
26933 
        if ftype == TType.I64:
26934 
          self.fromDate = iprot.readI64();
26935 
        else:
26936 
          iprot.skip(ftype)
26937 
      elif fid == 3:
26938 
        if ftype == TType.I64:
26939 
          self.toDate = iprot.readI64();
26940 
        else:
26941 
          iprot.skip(ftype)
26942 
      elif fid == 4:
26943 
        if ftype == TType.BOOL:
26944 
          self.onlyCod = iprot.readBool();
26945 
        else:
26946 
          iprot.skip(ftype)
26947 
      else:
26948 
        iprot.skip(ftype)
26949 
      iprot.readFieldEnd()
26950 
    iprot.readStructEnd()
26951 
 
26952 
  def write(self, oprot):
26953 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26954 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26955 
      return
26956 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
26957 
    if self.storeId is not None:
26958 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26959 
      oprot.writeI64(self.storeId)
26960 
      oprot.writeFieldEnd()
26961 
    if self.fromDate is not None:
26962 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
26963 
      oprot.writeI64(self.fromDate)
26964 
      oprot.writeFieldEnd()
26965 
    if self.toDate is not None:
26966 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
26967 
      oprot.writeI64(self.toDate)
26968 
      oprot.writeFieldEnd()
26969 
    if self.onlyCod is not None:
26970 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
26971 
      oprot.writeBool(self.onlyCod)
26972 
      oprot.writeFieldEnd()
26973 
    oprot.writeFieldStop()
26974 
    oprot.writeStructEnd()
26975 
 
26976 
  def validate(self):
26977 
    return
26978 
 
26979 
 
26980 
  def __repr__(self):
26981 
    L = ['%s=%r' % (key, value)
26982 
      for key, value in self.__dict__.iteritems()]
26983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26984 
 
26985 
  def __eq__(self, other):
26986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26987 
 
26988 
  def __ne__(self, other):
26989 
    return not (self == other)
26990 
 
26991 
class getOrdersCollectionAtStore_result:
26992 
  """
26993 
  Attributes:
26994 
   - success
26995 
  """
26996 
 
26997 
  thrift_spec = (
26998 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26999 
  )
27000 
 
27001 
  def __init__(self, success=None,):
27002 
    self.success = success
27003 
 
27004 
  def read(self, iprot):
27005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27007 
      return
27008 
    iprot.readStructBegin()
27009 
    while True:
27010 
      (fname, ftype, fid) = iprot.readFieldBegin()
27011 
      if ftype == TType.STOP:
27012 
        break
27013 
      if fid == 0:
27014 
        if ftype == TType.LIST:
27015 
          self.success = []
6188 rajveer 27016 
          (_etype652, _size649) = iprot.readListBegin()
27017 
          for _i653 in xrange(_size649):
27018 
            _elem654 = Order()
27019 
            _elem654.read(iprot)
27020 
            self.success.append(_elem654)
5713 rajveer 27021 
          iprot.readListEnd()
27022 
        else:
27023 
          iprot.skip(ftype)
27024 
      else:
27025 
        iprot.skip(ftype)
27026 
      iprot.readFieldEnd()
27027 
    iprot.readStructEnd()
27028 
 
27029 
  def write(self, oprot):
27030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27032 
      return
27033 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
27034 
    if self.success is not None:
27035 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27036 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27037 
      for iter655 in self.success:
27038 
        iter655.write(oprot)
5713 rajveer 27039 
      oprot.writeListEnd()
27040 
      oprot.writeFieldEnd()
27041 
    oprot.writeFieldStop()
27042 
    oprot.writeStructEnd()
27043 
 
27044 
  def validate(self):
27045 
    return
27046 
 
27047 
 
27048 
  def __repr__(self):
27049 
    L = ['%s=%r' % (key, value)
27050 
      for key, value in self.__dict__.iteritems()]
27051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27052 
 
27053 
  def __eq__(self, other):
27054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27055 
 
27056 
  def __ne__(self, other):
27057 
    return not (self == other)
27058 
 
5833 rajveer 27059 
class getOrderAttributeValue_args:
27060 
  """
27061 
  Attributes:
27062 
   - orderId
27063 
   - attributeName
27064 
  """
27065 
 
27066 
  thrift_spec = None
27067 
  def __init__(self, orderId=None, attributeName=None,):
27068 
    self.orderId = orderId
27069 
    self.attributeName = attributeName
27070 
 
27071 
  def read(self, iprot):
27072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27074 
      return
27075 
    iprot.readStructBegin()
27076 
    while True:
27077 
      (fname, ftype, fid) = iprot.readFieldBegin()
27078 
      if ftype == TType.STOP:
27079 
        break
27080 
      if fid == 1:
27081 
        if ftype == TType.I64:
27082 
          self.orderId = iprot.readI64();
27083 
        else:
27084 
          iprot.skip(ftype)
27085 
      elif fid == -1:
27086 
        if ftype == TType.STRING:
27087 
          self.attributeName = iprot.readString();
27088 
        else:
27089 
          iprot.skip(ftype)
27090 
      else:
27091 
        iprot.skip(ftype)
27092 
      iprot.readFieldEnd()
27093 
    iprot.readStructEnd()
27094 
 
27095 
  def write(self, oprot):
27096 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27097 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27098 
      return
27099 
    oprot.writeStructBegin('getOrderAttributeValue_args')
27100 
    if self.attributeName is not None:
27101 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
27102 
      oprot.writeString(self.attributeName)
27103 
      oprot.writeFieldEnd()
27104 
    if self.orderId is not None:
27105 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27106 
      oprot.writeI64(self.orderId)
27107 
      oprot.writeFieldEnd()
27108 
    oprot.writeFieldStop()
27109 
    oprot.writeStructEnd()
27110 
 
27111 
  def validate(self):
27112 
    return
27113 
 
27114 
 
27115 
  def __repr__(self):
27116 
    L = ['%s=%r' % (key, value)
27117 
      for key, value in self.__dict__.iteritems()]
27118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27119 
 
27120 
  def __eq__(self, other):
27121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27122 
 
27123 
  def __ne__(self, other):
27124 
    return not (self == other)
27125 
 
27126 
class getOrderAttributeValue_result:
27127 
  """
27128 
  Attributes:
27129 
   - success
27130 
  """
27131 
 
27132 
  thrift_spec = (
27133 
    (0, TType.STRING, 'success', None, None, ), # 0
27134 
  )
27135 
 
27136 
  def __init__(self, success=None,):
27137 
    self.success = success
27138 
 
27139 
  def read(self, iprot):
27140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27142 
      return
27143 
    iprot.readStructBegin()
27144 
    while True:
27145 
      (fname, ftype, fid) = iprot.readFieldBegin()
27146 
      if ftype == TType.STOP:
27147 
        break
27148 
      if fid == 0:
27149 
        if ftype == TType.STRING:
27150 
          self.success = iprot.readString();
27151 
        else:
27152 
          iprot.skip(ftype)
27153 
      else:
27154 
        iprot.skip(ftype)
27155 
      iprot.readFieldEnd()
27156 
    iprot.readStructEnd()
27157 
 
27158 
  def write(self, oprot):
27159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27161 
      return
27162 
    oprot.writeStructBegin('getOrderAttributeValue_result')
27163 
    if self.success is not None:
27164 
      oprot.writeFieldBegin('success', TType.STRING, 0)
27165 
      oprot.writeString(self.success)
27166 
      oprot.writeFieldEnd()
27167 
    oprot.writeFieldStop()
27168 
    oprot.writeStructEnd()
27169 
 
27170 
  def validate(self):
27171 
    return
27172 
 
27173 
 
27174 
  def __repr__(self):
27175 
    L = ['%s=%r' % (key, value)
27176 
      for key, value in self.__dict__.iteritems()]
27177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27178 
 
27179 
  def __eq__(self, other):
27180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27181 
 
27182 
  def __ne__(self, other):
27183 
    return not (self == other)
27184 
 
6019 rajveer 27185 
class changeJacketNumber_args:
27186 
  """
27187 
  Attributes:
27188 
   - orderId
27189 
   - jacketNumber
27190 
  """
27191 
 
27192 
  thrift_spec = (
27193 
    None, # 0
27194 
    (1, TType.I64, 'orderId', None, None, ), # 1
27195 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
27196 
  )
27197 
 
27198 
  def __init__(self, orderId=None, jacketNumber=None,):
27199 
    self.orderId = orderId
27200 
    self.jacketNumber = jacketNumber
27201 
 
27202 
  def read(self, iprot):
27203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27205 
      return
27206 
    iprot.readStructBegin()
27207 
    while True:
27208 
      (fname, ftype, fid) = iprot.readFieldBegin()
27209 
      if ftype == TType.STOP:
27210 
        break
27211 
      if fid == 1:
27212 
        if ftype == TType.I64:
27213 
          self.orderId = iprot.readI64();
27214 
        else:
27215 
          iprot.skip(ftype)
27216 
      elif fid == 2:
27217 
        if ftype == TType.I64:
27218 
          self.jacketNumber = iprot.readI64();
27219 
        else:
27220 
          iprot.skip(ftype)
27221 
      else:
27222 
        iprot.skip(ftype)
27223 
      iprot.readFieldEnd()
27224 
    iprot.readStructEnd()
27225 
 
27226 
  def write(self, oprot):
27227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27229 
      return
27230 
    oprot.writeStructBegin('changeJacketNumber_args')
27231 
    if self.orderId is not None:
27232 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27233 
      oprot.writeI64(self.orderId)
27234 
      oprot.writeFieldEnd()
27235 
    if self.jacketNumber is not None:
27236 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
27237 
      oprot.writeI64(self.jacketNumber)
27238 
      oprot.writeFieldEnd()
27239 
    oprot.writeFieldStop()
27240 
    oprot.writeStructEnd()
27241 
 
27242 
  def validate(self):
27243 
    return
27244 
 
27245 
 
27246 
  def __repr__(self):
27247 
    L = ['%s=%r' % (key, value)
27248 
      for key, value in self.__dict__.iteritems()]
27249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27250 
 
27251 
  def __eq__(self, other):
27252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27253 
 
27254 
  def __ne__(self, other):
27255 
    return not (self == other)
27256 
 
27257 
class changeJacketNumber_result:
27258 
  """
27259 
  Attributes:
27260 
   - success
27261 
  """
27262 
 
27263 
  thrift_spec = (
27264 
    (0, TType.BOOL, 'success', None, None, ), # 0
27265 
  )
27266 
 
27267 
  def __init__(self, success=None,):
27268 
    self.success = success
27269 
 
27270 
  def read(self, iprot):
27271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27273 
      return
27274 
    iprot.readStructBegin()
27275 
    while True:
27276 
      (fname, ftype, fid) = iprot.readFieldBegin()
27277 
      if ftype == TType.STOP:
27278 
        break
27279 
      if fid == 0:
27280 
        if ftype == TType.BOOL:
27281 
          self.success = iprot.readBool();
27282 
        else:
27283 
          iprot.skip(ftype)
27284 
      else:
27285 
        iprot.skip(ftype)
27286 
      iprot.readFieldEnd()
27287 
    iprot.readStructEnd()
27288 
 
27289 
  def write(self, oprot):
27290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27292 
      return
27293 
    oprot.writeStructBegin('changeJacketNumber_result')
27294 
    if self.success is not None:
27295 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27296 
      oprot.writeBool(self.success)
27297 
      oprot.writeFieldEnd()
27298 
    oprot.writeFieldStop()
27299 
    oprot.writeStructEnd()
27300 
 
27301 
  def validate(self):
27302 
    return
27303 
 
27304 
 
27305 
  def __repr__(self):
27306 
    L = ['%s=%r' % (key, value)
27307 
      for key, value in self.__dict__.iteritems()]
27308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27309 
 
27310 
  def __eq__(self, other):
27311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27312 
 
27313 
  def __ne__(self, other):
27314 
    return not (self == other)
27315 
 
27316 
class markOrderAsRtoInTransit_args:
27317 
  """
27318 
  Attributes:
27319 
   - orderId
27320 
  """
27321 
 
27322 
  thrift_spec = (
27323 
    None, # 0
27324 
    (1, TType.I64, 'orderId', None, None, ), # 1
27325 
  )
27326 
 
27327 
  def __init__(self, orderId=None,):
27328 
    self.orderId = orderId
27329 
 
27330 
  def read(self, iprot):
27331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27333 
      return
27334 
    iprot.readStructBegin()
27335 
    while True:
27336 
      (fname, ftype, fid) = iprot.readFieldBegin()
27337 
      if ftype == TType.STOP:
27338 
        break
27339 
      if fid == 1:
27340 
        if ftype == TType.I64:
27341 
          self.orderId = iprot.readI64();
27342 
        else:
27343 
          iprot.skip(ftype)
27344 
      else:
27345 
        iprot.skip(ftype)
27346 
      iprot.readFieldEnd()
27347 
    iprot.readStructEnd()
27348 
 
27349 
  def write(self, oprot):
27350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27352 
      return
27353 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
27354 
    if self.orderId is not None:
27355 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27356 
      oprot.writeI64(self.orderId)
27357 
      oprot.writeFieldEnd()
27358 
    oprot.writeFieldStop()
27359 
    oprot.writeStructEnd()
27360 
 
27361 
  def validate(self):
27362 
    return
27363 
 
27364 
 
27365 
  def __repr__(self):
27366 
    L = ['%s=%r' % (key, value)
27367 
      for key, value in self.__dict__.iteritems()]
27368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27369 
 
27370 
  def __eq__(self, other):
27371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27372 
 
27373 
  def __ne__(self, other):
27374 
    return not (self == other)
27375 
 
27376 
class markOrderAsRtoInTransit_result:
27377 
  """
27378 
  Attributes:
27379 
   - success
27380 
  """
27381 
 
27382 
  thrift_spec = (
27383 
    (0, TType.BOOL, 'success', None, None, ), # 0
27384 
  )
27385 
 
27386 
  def __init__(self, success=None,):
27387 
    self.success = success
27388 
 
27389 
  def read(self, iprot):
27390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27392 
      return
27393 
    iprot.readStructBegin()
27394 
    while True:
27395 
      (fname, ftype, fid) = iprot.readFieldBegin()
27396 
      if ftype == TType.STOP:
27397 
        break
27398 
      if fid == 0:
27399 
        if ftype == TType.BOOL:
27400 
          self.success = iprot.readBool();
27401 
        else:
27402 
          iprot.skip(ftype)
27403 
      else:
27404 
        iprot.skip(ftype)
27405 
      iprot.readFieldEnd()
27406 
    iprot.readStructEnd()
27407 
 
27408 
  def write(self, oprot):
27409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27411 
      return
27412 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
27413 
    if self.success is not None:
27414 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27415 
      oprot.writeBool(self.success)
27416 
      oprot.writeFieldEnd()
27417 
    oprot.writeFieldStop()
27418 
    oprot.writeStructEnd()
27419 
 
27420 
  def validate(self):
27421 
    return
27422 
 
27423 
 
27424 
  def __repr__(self):
27425 
    L = ['%s=%r' % (key, value)
27426 
      for key, value in self.__dict__.iteritems()]
27427 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27428 
 
27429 
  def __eq__(self, other):
27430 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27431 
 
27432 
  def __ne__(self, other):
27433 
    return not (self == other)
27434 
 
5593 mandeep.dh 27435 
class acceptOrderForItem_args:
27436 
  """
27437 
  Attributes:
27438 
   - itemId
27439 
   - quantity
27440 
   - fulfilmentWarehouseId
27441 
   - billingWarehouseId
27442 
  """
27443 
 
27444 
  thrift_spec = (
27445 
    None, # 0
27446 
    (1, TType.I64, 'itemId', None, None, ), # 1
27447 
    (2, TType.I64, 'quantity', None, None, ), # 2
27448 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
27449 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
27450 
  )
27451 
 
27452 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
27453 
    self.itemId = itemId
27454 
    self.quantity = quantity
27455 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
27456 
    self.billingWarehouseId = billingWarehouseId
27457 
 
27458 
  def read(self, iprot):
27459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27461 
      return
27462 
    iprot.readStructBegin()
27463 
    while True:
27464 
      (fname, ftype, fid) = iprot.readFieldBegin()
27465 
      if ftype == TType.STOP:
27466 
        break
27467 
      if fid == 1:
27468 
        if ftype == TType.I64:
27469 
          self.itemId = iprot.readI64();
27470 
        else:
27471 
          iprot.skip(ftype)
27472 
      elif fid == 2:
27473 
        if ftype == TType.I64:
27474 
          self.quantity = iprot.readI64();
27475 
        else:
27476 
          iprot.skip(ftype)
27477 
      elif fid == 3:
27478 
        if ftype == TType.I64:
27479 
          self.fulfilmentWarehouseId = iprot.readI64();
27480 
        else:
27481 
          iprot.skip(ftype)
27482 
      elif fid == 4:
27483 
        if ftype == TType.I64:
27484 
          self.billingWarehouseId = iprot.readI64();
27485 
        else:
27486 
          iprot.skip(ftype)
27487 
      else:
27488 
        iprot.skip(ftype)
27489 
      iprot.readFieldEnd()
27490 
    iprot.readStructEnd()
27491 
 
27492 
  def write(self, oprot):
27493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27495 
      return
27496 
    oprot.writeStructBegin('acceptOrderForItem_args')
27497 
    if self.itemId is not None:
27498 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
27499 
      oprot.writeI64(self.itemId)
27500 
      oprot.writeFieldEnd()
27501 
    if self.quantity is not None:
27502 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
27503 
      oprot.writeI64(self.quantity)
27504 
      oprot.writeFieldEnd()
27505 
    if self.fulfilmentWarehouseId is not None:
27506 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
27507 
      oprot.writeI64(self.fulfilmentWarehouseId)
27508 
      oprot.writeFieldEnd()
27509 
    if self.billingWarehouseId is not None:
27510 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
27511 
      oprot.writeI64(self.billingWarehouseId)
27512 
      oprot.writeFieldEnd()
27513 
    oprot.writeFieldStop()
27514 
    oprot.writeStructEnd()
27515 
 
27516 
  def validate(self):
27517 
    return
27518 
 
27519 
 
27520 
  def __repr__(self):
27521 
    L = ['%s=%r' % (key, value)
27522 
      for key, value in self.__dict__.iteritems()]
27523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27524 
 
27525 
  def __eq__(self, other):
27526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27527 
 
27528 
  def __ne__(self, other):
27529 
    return not (self == other)
27530 
 
27531 
class acceptOrderForItem_result:
27532 
 
27533 
  thrift_spec = (
27534 
  )
27535 
 
27536 
  def read(self, iprot):
27537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27539 
      return
27540 
    iprot.readStructBegin()
27541 
    while True:
27542 
      (fname, ftype, fid) = iprot.readFieldBegin()
27543 
      if ftype == TType.STOP:
27544 
        break
27545 
      else:
27546 
        iprot.skip(ftype)
27547 
      iprot.readFieldEnd()
27548 
    iprot.readStructEnd()
27549 
 
27550 
  def write(self, oprot):
27551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27553 
      return
27554 
    oprot.writeStructBegin('acceptOrderForItem_result')
27555 
    oprot.writeFieldStop()
27556 
    oprot.writeStructEnd()
27557 
 
27558 
  def validate(self):
27559 
    return
27560 
 
27561 
 
27562 
  def __repr__(self):
27563 
    L = ['%s=%r' % (key, value)
27564 
      for key, value in self.__dict__.iteritems()]
27565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27566 
 
27567 
  def __eq__(self, other):
27568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27569 
 
27570 
  def __ne__(self, other):
27571 
    return not (self == other)
6000 mandeep.dh 27572 
 
27573 
class createRechargeOrder_args:
27574 
  """
27575 
  Attributes:
27576 
   - rechargeOrder
27577 
  """
27578 
 
27579 
  thrift_spec = (
27580 
    None, # 0
27581 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
27582 
  )
27583 
 
27584 
  def __init__(self, rechargeOrder=None,):
27585 
    self.rechargeOrder = rechargeOrder
27586 
 
27587 
  def read(self, iprot):
27588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27590 
      return
27591 
    iprot.readStructBegin()
27592 
    while True:
27593 
      (fname, ftype, fid) = iprot.readFieldBegin()
27594 
      if ftype == TType.STOP:
27595 
        break
27596 
      if fid == 1:
27597 
        if ftype == TType.STRUCT:
27598 
          self.rechargeOrder = RechargeOrder()
27599 
          self.rechargeOrder.read(iprot)
27600 
        else:
27601 
          iprot.skip(ftype)
27602 
      else:
27603 
        iprot.skip(ftype)
27604 
      iprot.readFieldEnd()
27605 
    iprot.readStructEnd()
27606 
 
27607 
  def write(self, oprot):
27608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27610 
      return
27611 
    oprot.writeStructBegin('createRechargeOrder_args')
27612 
    if self.rechargeOrder is not None:
27613 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
27614 
      self.rechargeOrder.write(oprot)
27615 
      oprot.writeFieldEnd()
27616 
    oprot.writeFieldStop()
27617 
    oprot.writeStructEnd()
27618 
 
27619 
  def validate(self):
27620 
    return
27621 
 
27622 
 
27623 
  def __repr__(self):
27624 
    L = ['%s=%r' % (key, value)
27625 
      for key, value in self.__dict__.iteritems()]
27626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27627 
 
27628 
  def __eq__(self, other):
27629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27630 
 
27631 
  def __ne__(self, other):
27632 
    return not (self == other)
27633 
 
27634 
class createRechargeOrder_result:
27635 
  """
27636 
  Attributes:
27637 
   - success
27638 
   - ex
27639 
  """
27640 
 
27641 
  thrift_spec = (
27642 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27643 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27644 
  )
27645 
 
27646 
  def __init__(self, success=None, ex=None,):
27647 
    self.success = success
27648 
    self.ex = ex
27649 
 
27650 
  def read(self, iprot):
27651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27653 
      return
27654 
    iprot.readStructBegin()
27655 
    while True:
27656 
      (fname, ftype, fid) = iprot.readFieldBegin()
27657 
      if ftype == TType.STOP:
27658 
        break
27659 
      if fid == 0:
27660 
        if ftype == TType.STRUCT:
27661 
          self.success = RechargeOrder()
27662 
          self.success.read(iprot)
27663 
        else:
27664 
          iprot.skip(ftype)
27665 
      elif fid == 1:
27666 
        if ftype == TType.STRUCT:
27667 
          self.ex = TransactionServiceException()
27668 
          self.ex.read(iprot)
27669 
        else:
27670 
          iprot.skip(ftype)
27671 
      else:
27672 
        iprot.skip(ftype)
27673 
      iprot.readFieldEnd()
27674 
    iprot.readStructEnd()
27675 
 
27676 
  def write(self, oprot):
27677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27679 
      return
27680 
    oprot.writeStructBegin('createRechargeOrder_result')
27681 
    if self.success is not None:
27682 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27683 
      self.success.write(oprot)
27684 
      oprot.writeFieldEnd()
27685 
    if self.ex is not None:
27686 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27687 
      self.ex.write(oprot)
27688 
      oprot.writeFieldEnd()
27689 
    oprot.writeFieldStop()
27690 
    oprot.writeStructEnd()
27691 
 
27692 
  def validate(self):
27693 
    return
27694 
 
27695 
 
27696 
  def __repr__(self):
27697 
    L = ['%s=%r' % (key, value)
27698 
      for key, value in self.__dict__.iteritems()]
27699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27700 
 
27701 
  def __eq__(self, other):
27702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27703 
 
27704 
  def __ne__(self, other):
27705 
    return not (self == other)
27706 
 
6031 rajveer 27707 
class getRechargeOrder_args:
27708 
  """
27709 
  Attributes:
27710 
   - rechargeRrderId
27711 
  """
27712 
 
27713 
  thrift_spec = (
27714 
    None, # 0
27715 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
27716 
  )
27717 
 
27718 
  def __init__(self, rechargeRrderId=None,):
27719 
    self.rechargeRrderId = rechargeRrderId
27720 
 
27721 
  def read(self, iprot):
27722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27724 
      return
27725 
    iprot.readStructBegin()
27726 
    while True:
27727 
      (fname, ftype, fid) = iprot.readFieldBegin()
27728 
      if ftype == TType.STOP:
27729 
        break
27730 
      if fid == 1:
27731 
        if ftype == TType.I64:
27732 
          self.rechargeRrderId = iprot.readI64();
27733 
        else:
27734 
          iprot.skip(ftype)
27735 
      else:
27736 
        iprot.skip(ftype)
27737 
      iprot.readFieldEnd()
27738 
    iprot.readStructEnd()
27739 
 
27740 
  def write(self, oprot):
27741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27743 
      return
27744 
    oprot.writeStructBegin('getRechargeOrder_args')
27745 
    if self.rechargeRrderId is not None:
27746 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
27747 
      oprot.writeI64(self.rechargeRrderId)
27748 
      oprot.writeFieldEnd()
27749 
    oprot.writeFieldStop()
27750 
    oprot.writeStructEnd()
27751 
 
27752 
  def validate(self):
27753 
    return
27754 
 
27755 
 
27756 
  def __repr__(self):
27757 
    L = ['%s=%r' % (key, value)
27758 
      for key, value in self.__dict__.iteritems()]
27759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27760 
 
27761 
  def __eq__(self, other):
27762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27763 
 
27764 
  def __ne__(self, other):
27765 
    return not (self == other)
27766 
 
27767 
class getRechargeOrder_result:
27768 
  """
27769 
  Attributes:
27770 
   - success
27771 
   - ex
27772 
  """
27773 
 
27774 
  thrift_spec = (
27775 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27776 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27777 
  )
27778 
 
27779 
  def __init__(self, success=None, ex=None,):
27780 
    self.success = success
27781 
    self.ex = ex
27782 
 
27783 
  def read(self, iprot):
27784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27786 
      return
27787 
    iprot.readStructBegin()
27788 
    while True:
27789 
      (fname, ftype, fid) = iprot.readFieldBegin()
27790 
      if ftype == TType.STOP:
27791 
        break
27792 
      if fid == 0:
27793 
        if ftype == TType.STRUCT:
27794 
          self.success = RechargeOrder()
27795 
          self.success.read(iprot)
27796 
        else:
27797 
          iprot.skip(ftype)
27798 
      elif fid == 1:
27799 
        if ftype == TType.STRUCT:
27800 
          self.ex = TransactionServiceException()
27801 
          self.ex.read(iprot)
27802 
        else:
27803 
          iprot.skip(ftype)
27804 
      else:
27805 
        iprot.skip(ftype)
27806 
      iprot.readFieldEnd()
27807 
    iprot.readStructEnd()
27808 
 
27809 
  def write(self, oprot):
27810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27812 
      return
27813 
    oprot.writeStructBegin('getRechargeOrder_result')
27814 
    if self.success is not None:
27815 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27816 
      self.success.write(oprot)
27817 
      oprot.writeFieldEnd()
27818 
    if self.ex is not None:
27819 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27820 
      self.ex.write(oprot)
27821 
      oprot.writeFieldEnd()
27822 
    oprot.writeFieldStop()
27823 
    oprot.writeStructEnd()
27824 
 
27825 
  def validate(self):
27826 
    return
27827 
 
27828 
 
27829 
  def __repr__(self):
27830 
    L = ['%s=%r' % (key, value)
27831 
      for key, value in self.__dict__.iteritems()]
27832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27833 
 
27834 
  def __eq__(self, other):
27835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27836 
 
27837 
  def __ne__(self, other):
27838 
    return not (self == other)
27839 
 
27840 
class getRechargeOrders_args:
27841 
  """
27842 
  Attributes:
27843 
   - userId
27844 
  """
27845 
 
27846 
  thrift_spec = (
27847 
    None, # 0
27848 
    (1, TType.I64, 'userId', None, None, ), # 1
27849 
  )
27850 
 
27851 
  def __init__(self, userId=None,):
27852 
    self.userId = userId
27853 
 
27854 
  def read(self, iprot):
27855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27857 
      return
27858 
    iprot.readStructBegin()
27859 
    while True:
27860 
      (fname, ftype, fid) = iprot.readFieldBegin()
27861 
      if ftype == TType.STOP:
27862 
        break
27863 
      if fid == 1:
27864 
        if ftype == TType.I64:
27865 
          self.userId = iprot.readI64();
27866 
        else:
27867 
          iprot.skip(ftype)
27868 
      else:
27869 
        iprot.skip(ftype)
27870 
      iprot.readFieldEnd()
27871 
    iprot.readStructEnd()
27872 
 
27873 
  def write(self, oprot):
27874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27876 
      return
27877 
    oprot.writeStructBegin('getRechargeOrders_args')
27878 
    if self.userId is not None:
27879 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27880 
      oprot.writeI64(self.userId)
27881 
      oprot.writeFieldEnd()
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 getRechargeOrders_result:
27901 
  """
27902 
  Attributes:
27903 
   - success
27904 
  """
27905 
 
27906 
  thrift_spec = (
27907 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), 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.LIST:
27924 
          self.success = []
6188 rajveer 27925 
          (_etype659, _size656) = iprot.readListBegin()
27926 
          for _i660 in xrange(_size656):
27927 
            _elem661 = RechargeOrder()
27928 
            _elem661.read(iprot)
27929 
            self.success.append(_elem661)
6031 rajveer 27930 
          iprot.readListEnd()
27931 
        else:
27932 
          iprot.skip(ftype)
27933 
      else:
27934 
        iprot.skip(ftype)
27935 
      iprot.readFieldEnd()
27936 
    iprot.readStructEnd()
27937 
 
27938 
  def write(self, oprot):
27939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27941 
      return
27942 
    oprot.writeStructBegin('getRechargeOrders_result')
27943 
    if self.success is not None:
27944 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27945 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27946 
      for iter662 in self.success:
27947 
        iter662.write(oprot)
6031 rajveer 27948 
      oprot.writeListEnd()
27949 
      oprot.writeFieldEnd()
27950 
    oprot.writeFieldStop()
27951 
    oprot.writeStructEnd()
27952 
 
27953 
  def validate(self):
27954 
    return
27955 
 
27956 
 
27957 
  def __repr__(self):
27958 
    L = ['%s=%r' % (key, value)
27959 
      for key, value in self.__dict__.iteritems()]
27960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27961 
 
27962 
  def __eq__(self, other):
27963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27964 
 
27965 
  def __ne__(self, other):
27966 
    return not (self == other)
27967 
 
6000 mandeep.dh 27968 
class updateRechargeOrderStatus_args:
27969 
  """
27970 
  Attributes:
27971 
   - rechargeOrderId
27972 
   - rechargeOrderStatus
27973 
  """
27974 
 
27975 
  thrift_spec = (
27976 
    None, # 0
27977 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
27978 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
27979 
  )
27980 
 
27981 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
27982 
    self.rechargeOrderId = rechargeOrderId
27983 
    self.rechargeOrderStatus = rechargeOrderStatus
27984 
 
27985 
  def read(self, iprot):
27986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27988 
      return
27989 
    iprot.readStructBegin()
27990 
    while True:
27991 
      (fname, ftype, fid) = iprot.readFieldBegin()
27992 
      if ftype == TType.STOP:
27993 
        break
27994 
      if fid == 1:
27995 
        if ftype == TType.I64:
27996 
          self.rechargeOrderId = iprot.readI64();
27997 
        else:
27998 
          iprot.skip(ftype)
27999 
      elif fid == 2:
28000 
        if ftype == TType.I32:
28001 
          self.rechargeOrderStatus = iprot.readI32();
28002 
        else:
28003 
          iprot.skip(ftype)
28004 
      else:
28005 
        iprot.skip(ftype)
28006 
      iprot.readFieldEnd()
28007 
    iprot.readStructEnd()
28008 
 
28009 
  def write(self, oprot):
28010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28012 
      return
28013 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
28014 
    if self.rechargeOrderId is not None:
28015 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
28016 
      oprot.writeI64(self.rechargeOrderId)
28017 
      oprot.writeFieldEnd()
28018 
    if self.rechargeOrderStatus is not None:
28019 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
28020 
      oprot.writeI32(self.rechargeOrderStatus)
28021 
      oprot.writeFieldEnd()
28022 
    oprot.writeFieldStop()
28023 
    oprot.writeStructEnd()
28024 
 
28025 
  def validate(self):
28026 
    return
28027 
 
28028 
 
28029 
  def __repr__(self):
28030 
    L = ['%s=%r' % (key, value)
28031 
      for key, value in self.__dict__.iteritems()]
28032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28033 
 
28034 
  def __eq__(self, other):
28035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28036 
 
28037 
  def __ne__(self, other):
28038 
    return not (self == other)
28039 
 
28040 
class updateRechargeOrderStatus_result:
28041 
  """
28042 
  Attributes:
6031 rajveer 28043 
   - success
6000 mandeep.dh 28044 
   - ex
28045 
  """
28046 
 
28047 
  thrift_spec = (
6031 rajveer 28048 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 28049 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28050 
  )
28051 
 
6031 rajveer 28052 
  def __init__(self, success=None, ex=None,):
28053 
    self.success = success
6000 mandeep.dh 28054 
    self.ex = ex
28055 
 
28056 
  def read(self, iprot):
28057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28059 
      return
28060 
    iprot.readStructBegin()
28061 
    while True:
28062 
      (fname, ftype, fid) = iprot.readFieldBegin()
28063 
      if ftype == TType.STOP:
28064 
        break
6031 rajveer 28065 
      if fid == 0:
28066 
        if ftype == TType.BOOL:
28067 
          self.success = iprot.readBool();
28068 
        else:
28069 
          iprot.skip(ftype)
28070 
      elif fid == 1:
6000 mandeep.dh 28071 
        if ftype == TType.STRUCT:
28072 
          self.ex = TransactionServiceException()
28073 
          self.ex.read(iprot)
28074 
        else:
28075 
          iprot.skip(ftype)
28076 
      else:
28077 
        iprot.skip(ftype)
28078 
      iprot.readFieldEnd()
28079 
    iprot.readStructEnd()
28080 
 
28081 
  def write(self, oprot):
28082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28084 
      return
28085 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 28086 
    if self.success is not None:
28087 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28088 
      oprot.writeBool(self.success)
28089 
      oprot.writeFieldEnd()
6000 mandeep.dh 28090 
    if self.ex is not None:
28091 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28092 
      self.ex.write(oprot)
28093 
      oprot.writeFieldEnd()
28094 
    oprot.writeFieldStop()
28095 
    oprot.writeStructEnd()
28096 
 
28097 
  def validate(self):
28098 
    return
28099 
 
28100 
 
28101 
  def __repr__(self):
28102 
    L = ['%s=%r' % (key, value)
28103 
      for key, value in self.__dict__.iteritems()]
28104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28105 
 
28106 
  def __eq__(self, other):
28107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28108 
 
28109 
  def __ne__(self, other):
28110 
    return not (self == other)
28111 
 
28112 
class activateRechargeTxn_args:
28113 
  """
28114 
  Attributes:
6031 rajveer 28115 
   - rechargeOrderId
6000 mandeep.dh 28116 
  """
28117 
 
28118 
  thrift_spec = (
28119 
    None, # 0
6031 rajveer 28120 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 28121 
  )
28122 
 
6031 rajveer 28123 
  def __init__(self, rechargeOrderId=None,):
28124 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 28125 
 
28126 
  def read(self, iprot):
28127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28129 
      return
28130 
    iprot.readStructBegin()
28131 
    while True:
28132 
      (fname, ftype, fid) = iprot.readFieldBegin()
28133 
      if ftype == TType.STOP:
28134 
        break
28135 
      if fid == 1:
6031 rajveer 28136 
        if ftype == TType.I64:
28137 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 28138 
        else:
28139 
          iprot.skip(ftype)
28140 
      else:
28141 
        iprot.skip(ftype)
28142 
      iprot.readFieldEnd()
28143 
    iprot.readStructEnd()
28144 
 
28145 
  def write(self, oprot):
28146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28148 
      return
28149 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 28150 
    if self.rechargeOrderId is not None:
28151 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
28152 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 28153 
      oprot.writeFieldEnd()
28154 
    oprot.writeFieldStop()
28155 
    oprot.writeStructEnd()
28156 
 
28157 
  def validate(self):
28158 
    return
28159 
 
28160 
 
28161 
  def __repr__(self):
28162 
    L = ['%s=%r' % (key, value)
28163 
      for key, value in self.__dict__.iteritems()]
28164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28165 
 
28166 
  def __eq__(self, other):
28167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28168 
 
28169 
  def __ne__(self, other):
28170 
    return not (self == other)
28171 
 
28172 
class activateRechargeTxn_result:
28173 
  """
28174 
  Attributes:
28175 
   - success
28176 
   - ex
28177 
  """
28178 
 
28179 
  thrift_spec = (
6031 rajveer 28180 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 28181 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28182 
  )
28183 
 
28184 
  def __init__(self, success=None, ex=None,):
28185 
    self.success = success
28186 
    self.ex = ex
28187 
 
28188 
  def read(self, iprot):
28189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28191 
      return
28192 
    iprot.readStructBegin()
28193 
    while True:
28194 
      (fname, ftype, fid) = iprot.readFieldBegin()
28195 
      if ftype == TType.STOP:
28196 
        break
28197 
      if fid == 0:
6031 rajveer 28198 
        if ftype == TType.BOOL:
28199 
          self.success = iprot.readBool();
6000 mandeep.dh 28200 
        else:
28201 
          iprot.skip(ftype)
28202 
      elif fid == 1:
28203 
        if ftype == TType.STRUCT:
28204 
          self.ex = TransactionServiceException()
28205 
          self.ex.read(iprot)
28206 
        else:
28207 
          iprot.skip(ftype)
28208 
      else:
28209 
        iprot.skip(ftype)
28210 
      iprot.readFieldEnd()
28211 
    iprot.readStructEnd()
28212 
 
28213 
  def write(self, oprot):
28214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28216 
      return
28217 
    oprot.writeStructBegin('activateRechargeTxn_result')
28218 
    if self.success is not None:
6031 rajveer 28219 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28220 
      oprot.writeBool(self.success)
6000 mandeep.dh 28221 
      oprot.writeFieldEnd()
28222 
    if self.ex is not None:
28223 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28224 
      self.ex.write(oprot)
28225 
      oprot.writeFieldEnd()
28226 
    oprot.writeFieldStop()
28227 
    oprot.writeStructEnd()
28228 
 
28229 
  def validate(self):
28230 
    return
28231 
 
28232 
 
28233 
  def __repr__(self):
28234 
    L = ['%s=%r' % (key, value)
28235 
      for key, value in self.__dict__.iteritems()]
28236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28237 
 
28238 
  def __eq__(self, other):
28239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28240 
 
28241 
  def __ne__(self, other):
28242 
    return not (self == other)
28243 
 
6031 rajveer 28244 
class getUserWallet_args:
6000 mandeep.dh 28245 
  """
28246 
  Attributes:
6031 rajveer 28247 
   - userId
6000 mandeep.dh 28248 
  """
28249 
 
28250 
  thrift_spec = (
28251 
    None, # 0
6031 rajveer 28252 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 28253 
  )
28254 
 
6031 rajveer 28255 
  def __init__(self, userId=None,):
28256 
    self.userId = userId
6000 mandeep.dh 28257 
 
28258 
  def read(self, iprot):
28259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28261 
      return
28262 
    iprot.readStructBegin()
28263 
    while True:
28264 
      (fname, ftype, fid) = iprot.readFieldBegin()
28265 
      if ftype == TType.STOP:
28266 
        break
28267 
      if fid == 1:
28268 
        if ftype == TType.I64:
6031 rajveer 28269 
          self.userId = iprot.readI64();
6000 mandeep.dh 28270 
        else:
28271 
          iprot.skip(ftype)
28272 
      else:
28273 
        iprot.skip(ftype)
28274 
      iprot.readFieldEnd()
28275 
    iprot.readStructEnd()
28276 
 
28277 
  def write(self, oprot):
28278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28280 
      return
6031 rajveer 28281 
    oprot.writeStructBegin('getUserWallet_args')
28282 
    if self.userId is not None:
28283 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28284 
      oprot.writeI64(self.userId)
6000 mandeep.dh 28285 
      oprot.writeFieldEnd()
28286 
    oprot.writeFieldStop()
28287 
    oprot.writeStructEnd()
28288 
 
28289 
  def validate(self):
28290 
    return
28291 
 
28292 
 
28293 
  def __repr__(self):
28294 
    L = ['%s=%r' % (key, value)
28295 
      for key, value in self.__dict__.iteritems()]
28296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28297 
 
28298 
  def __eq__(self, other):
28299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28300 
 
28301 
  def __ne__(self, other):
28302 
    return not (self == other)
28303 
 
6031 rajveer 28304 
class getUserWallet_result:
6000 mandeep.dh 28305 
  """
28306 
  Attributes:
28307 
   - success
28308 
  """
28309 
 
28310 
  thrift_spec = (
6031 rajveer 28311 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 28312 
  )
28313 
 
28314 
  def __init__(self, success=None,):
28315 
    self.success = success
28316 
 
28317 
  def read(self, iprot):
28318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28320 
      return
28321 
    iprot.readStructBegin()
28322 
    while True:
28323 
      (fname, ftype, fid) = iprot.readFieldBegin()
28324 
      if ftype == TType.STOP:
28325 
        break
28326 
      if fid == 0:
6031 rajveer 28327 
        if ftype == TType.STRUCT:
28328 
          self.success = UserWallet()
28329 
          self.success.read(iprot)
6000 mandeep.dh 28330 
        else:
28331 
          iprot.skip(ftype)
28332 
      else:
28333 
        iprot.skip(ftype)
28334 
      iprot.readFieldEnd()
28335 
    iprot.readStructEnd()
28336 
 
28337 
  def write(self, oprot):
28338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28340 
      return
6031 rajveer 28341 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 28342 
    if self.success is not None:
6031 rajveer 28343 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28344 
      self.success.write(oprot)
6000 mandeep.dh 28345 
      oprot.writeFieldEnd()
28346 
    oprot.writeFieldStop()
28347 
    oprot.writeStructEnd()
28348 
 
28349 
  def validate(self):
28350 
    return
28351 
 
28352 
 
28353 
  def __repr__(self):
28354 
    L = ['%s=%r' % (key, value)
28355 
      for key, value in self.__dict__.iteritems()]
28356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28357 
 
28358 
  def __eq__(self, other):
28359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28360 
 
28361 
  def __ne__(self, other):
28362 
    return not (self == other)
28363 
 
6031 rajveer 28364 
class getUserWalletHistory_args:
6000 mandeep.dh 28365 
  """
28366 
  Attributes:
6031 rajveer 28367 
   - userId
6000 mandeep.dh 28368 
  """
28369 
 
28370 
  thrift_spec = (
28371 
    None, # 0
6031 rajveer 28372 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 28373 
  )
28374 
 
6031 rajveer 28375 
  def __init__(self, userId=None,):
28376 
    self.userId = userId
6000 mandeep.dh 28377 
 
28378 
  def read(self, iprot):
28379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28381 
      return
28382 
    iprot.readStructBegin()
28383 
    while True:
28384 
      (fname, ftype, fid) = iprot.readFieldBegin()
28385 
      if ftype == TType.STOP:
28386 
        break
28387 
      if fid == 1:
28388 
        if ftype == TType.I64:
6031 rajveer 28389 
          self.userId = iprot.readI64();
6000 mandeep.dh 28390 
        else:
28391 
          iprot.skip(ftype)
28392 
      else:
28393 
        iprot.skip(ftype)
28394 
      iprot.readFieldEnd()
28395 
    iprot.readStructEnd()
28396 
 
28397 
  def write(self, oprot):
28398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28400 
      return
6031 rajveer 28401 
    oprot.writeStructBegin('getUserWalletHistory_args')
28402 
    if self.userId is not None:
28403 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28404 
      oprot.writeI64(self.userId)
6000 mandeep.dh 28405 
      oprot.writeFieldEnd()
28406 
    oprot.writeFieldStop()
28407 
    oprot.writeStructEnd()
28408 
 
28409 
  def validate(self):
28410 
    return
28411 
 
28412 
 
28413 
  def __repr__(self):
28414 
    L = ['%s=%r' % (key, value)
28415 
      for key, value in self.__dict__.iteritems()]
28416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28417 
 
28418 
  def __eq__(self, other):
28419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28420 
 
28421 
  def __ne__(self, other):
28422 
    return not (self == other)
28423 
 
6031 rajveer 28424 
class getUserWalletHistory_result:
6000 mandeep.dh 28425 
  """
28426 
  Attributes:
28427 
   - success
28428 
  """
28429 
 
28430 
  thrift_spec = (
6031 rajveer 28431 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 28432 
  )
28433 
 
28434 
  def __init__(self, success=None,):
28435 
    self.success = success
28436 
 
28437 
  def read(self, iprot):
28438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28440 
      return
28441 
    iprot.readStructBegin()
28442 
    while True:
28443 
      (fname, ftype, fid) = iprot.readFieldBegin()
28444 
      if ftype == TType.STOP:
28445 
        break
28446 
      if fid == 0:
28447 
        if ftype == TType.LIST:
28448 
          self.success = []
6188 rajveer 28449 
          (_etype666, _size663) = iprot.readListBegin()
28450 
          for _i667 in xrange(_size663):
28451 
            _elem668 = UserWalletHistory()
28452 
            _elem668.read(iprot)
28453 
            self.success.append(_elem668)
6000 mandeep.dh 28454 
          iprot.readListEnd()
28455 
        else:
28456 
          iprot.skip(ftype)
28457 
      else:
28458 
        iprot.skip(ftype)
28459 
      iprot.readFieldEnd()
28460 
    iprot.readStructEnd()
28461 
 
28462 
  def write(self, oprot):
28463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28465 
      return
6031 rajveer 28466 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 28467 
    if self.success is not None:
28468 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28469 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28470 
      for iter669 in self.success:
28471 
        iter669.write(oprot)
6000 mandeep.dh 28472 
      oprot.writeListEnd()
28473 
      oprot.writeFieldEnd()
28474 
    oprot.writeFieldStop()
28475 
    oprot.writeStructEnd()
28476 
 
28477 
  def validate(self):
28478 
    return
28479 
 
28480 
 
28481 
  def __repr__(self):
28482 
    L = ['%s=%r' % (key, value)
28483 
      for key, value in self.__dict__.iteritems()]
28484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28485 
 
28486 
  def __eq__(self, other):
28487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28488 
 
28489 
  def __ne__(self, other):
28490 
    return not (self == other)
6048 rajveer 28491 
 
6050 anupam.sin 28492 
class getRechargeOrdersForTransaction_args:
28493 
  """
28494 
  Attributes:
28495 
   - txnId
28496 
  """
28497 
 
28498 
  thrift_spec = (
28499 
    None, # 0
28500 
    (1, TType.I64, 'txnId', None, None, ), # 1
28501 
  )
28502 
 
28503 
  def __init__(self, txnId=None,):
28504 
    self.txnId = txnId
28505 
 
28506 
  def read(self, iprot):
28507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28509 
      return
28510 
    iprot.readStructBegin()
28511 
    while True:
28512 
      (fname, ftype, fid) = iprot.readFieldBegin()
28513 
      if ftype == TType.STOP:
28514 
        break
28515 
      if fid == 1:
28516 
        if ftype == TType.I64:
28517 
          self.txnId = iprot.readI64();
28518 
        else:
28519 
          iprot.skip(ftype)
28520 
      else:
28521 
        iprot.skip(ftype)
28522 
      iprot.readFieldEnd()
28523 
    iprot.readStructEnd()
28524 
 
28525 
  def write(self, oprot):
28526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28528 
      return
28529 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
28530 
    if self.txnId is not None:
28531 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
28532 
      oprot.writeI64(self.txnId)
28533 
      oprot.writeFieldEnd()
28534 
    oprot.writeFieldStop()
28535 
    oprot.writeStructEnd()
28536 
 
28537 
  def validate(self):
28538 
    return
28539 
 
28540 
 
28541 
  def __repr__(self):
28542 
    L = ['%s=%r' % (key, value)
28543 
      for key, value in self.__dict__.iteritems()]
28544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28545 
 
28546 
  def __eq__(self, other):
28547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28548 
 
28549 
  def __ne__(self, other):
28550 
    return not (self == other)
28551 
 
28552 
class getRechargeOrdersForTransaction_result:
28553 
  """
28554 
  Attributes:
28555 
   - success
28556 
   - ex
28557 
  """
28558 
 
28559 
  thrift_spec = (
28560 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
28561 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28562 
  )
28563 
 
28564 
  def __init__(self, success=None, ex=None,):
28565 
    self.success = success
28566 
    self.ex = ex
28567 
 
28568 
  def read(self, iprot):
28569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28571 
      return
28572 
    iprot.readStructBegin()
28573 
    while True:
28574 
      (fname, ftype, fid) = iprot.readFieldBegin()
28575 
      if ftype == TType.STOP:
28576 
        break
28577 
      if fid == 0:
28578 
        if ftype == TType.STRUCT:
28579 
          self.success = RechargeOrder()
28580 
          self.success.read(iprot)
28581 
        else:
28582 
          iprot.skip(ftype)
28583 
      elif fid == 1:
28584 
        if ftype == TType.STRUCT:
28585 
          self.ex = TransactionServiceException()
28586 
          self.ex.read(iprot)
28587 
        else:
28588 
          iprot.skip(ftype)
28589 
      else:
28590 
        iprot.skip(ftype)
28591 
      iprot.readFieldEnd()
28592 
    iprot.readStructEnd()
28593 
 
28594 
  def write(self, oprot):
28595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28597 
      return
28598 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
28599 
    if self.success is not None:
28600 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28601 
      self.success.write(oprot)
28602 
      oprot.writeFieldEnd()
28603 
    if self.ex is not None:
28604 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28605 
      self.ex.write(oprot)
28606 
      oprot.writeFieldEnd()
28607 
    oprot.writeFieldStop()
28608 
    oprot.writeStructEnd()
28609 
 
28610 
  def validate(self):
28611 
    return
28612 
 
28613 
 
28614 
  def __repr__(self):
28615 
    L = ['%s=%r' % (key, value)
28616 
      for key, value in self.__dict__.iteritems()]
28617 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28618 
 
28619 
  def __eq__(self, other):
28620 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28621 
 
28622 
  def __ne__(self, other):
28623 
    return not (self == other)
28624 
 
6048 rajveer 28625 
class getServiceProviders_args:
28626 
  """
28627 
  Attributes:
28628 
   - rechargeType
6206 rajveer 28629 
   - onlyActive
6048 rajveer 28630 
  """
28631 
 
28632 
  thrift_spec = (
28633 
    None, # 0
28634 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 28635 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 28636 
  )
28637 
 
6206 rajveer 28638 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 28639 
    self.rechargeType = rechargeType
6206 rajveer 28640 
    self.onlyActive = onlyActive
6048 rajveer 28641 
 
28642 
  def read(self, iprot):
28643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28645 
      return
28646 
    iprot.readStructBegin()
28647 
    while True:
28648 
      (fname, ftype, fid) = iprot.readFieldBegin()
28649 
      if ftype == TType.STOP:
28650 
        break
28651 
      if fid == 1:
28652 
        if ftype == TType.I32:
28653 
          self.rechargeType = iprot.readI32();
28654 
        else:
28655 
          iprot.skip(ftype)
6206 rajveer 28656 
      elif fid == 2:
28657 
        if ftype == TType.BOOL:
28658 
          self.onlyActive = iprot.readBool();
28659 
        else:
28660 
          iprot.skip(ftype)
6048 rajveer 28661 
      else:
28662 
        iprot.skip(ftype)
28663 
      iprot.readFieldEnd()
28664 
    iprot.readStructEnd()
28665 
 
28666 
  def write(self, oprot):
28667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28669 
      return
28670 
    oprot.writeStructBegin('getServiceProviders_args')
28671 
    if self.rechargeType is not None:
28672 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28673 
      oprot.writeI32(self.rechargeType)
28674 
      oprot.writeFieldEnd()
6206 rajveer 28675 
    if self.onlyActive is not None:
28676 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
28677 
      oprot.writeBool(self.onlyActive)
28678 
      oprot.writeFieldEnd()
6048 rajveer 28679 
    oprot.writeFieldStop()
28680 
    oprot.writeStructEnd()
28681 
 
28682 
  def validate(self):
28683 
    return
28684 
 
28685 
 
28686 
  def __repr__(self):
28687 
    L = ['%s=%r' % (key, value)
28688 
      for key, value in self.__dict__.iteritems()]
28689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28690 
 
28691 
  def __eq__(self, other):
28692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28693 
 
28694 
  def __ne__(self, other):
28695 
    return not (self == other)
28696 
 
28697 
class getServiceProviders_result:
28698 
  """
28699 
  Attributes:
28700 
   - success
28701 
  """
28702 
 
28703 
  thrift_spec = (
28704 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
28705 
  )
28706 
 
28707 
  def __init__(self, success=None,):
28708 
    self.success = success
28709 
 
28710 
  def read(self, iprot):
28711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28713 
      return
28714 
    iprot.readStructBegin()
28715 
    while True:
28716 
      (fname, ftype, fid) = iprot.readFieldBegin()
28717 
      if ftype == TType.STOP:
28718 
        break
28719 
      if fid == 0:
28720 
        if ftype == TType.MAP:
28721 
          self.success = {}
6188 rajveer 28722 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
28723 
          for _i674 in xrange(_size670):
28724 
            _key675 = iprot.readI64();
28725 
            _val676 = iprot.readString();
28726 
            self.success[_key675] = _val676
6048 rajveer 28727 
          iprot.readMapEnd()
28728 
        else:
28729 
          iprot.skip(ftype)
28730 
      else:
28731 
        iprot.skip(ftype)
28732 
      iprot.readFieldEnd()
28733 
    iprot.readStructEnd()
28734 
 
28735 
  def write(self, oprot):
28736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28738 
      return
28739 
    oprot.writeStructBegin('getServiceProviders_result')
28740 
    if self.success is not None:
28741 
      oprot.writeFieldBegin('success', TType.MAP, 0)
28742 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 28743 
      for kiter677,viter678 in self.success.items():
28744 
        oprot.writeI64(kiter677)
28745 
        oprot.writeString(viter678)
6048 rajveer 28746 
      oprot.writeMapEnd()
28747 
      oprot.writeFieldEnd()
28748 
    oprot.writeFieldStop()
28749 
    oprot.writeStructEnd()
28750 
 
28751 
  def validate(self):
28752 
    return
28753 
 
28754 
 
28755 
  def __repr__(self):
28756 
    L = ['%s=%r' % (key, value)
28757 
      for key, value in self.__dict__.iteritems()]
28758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28759 
 
28760 
  def __eq__(self, other):
28761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28762 
 
28763 
  def __ne__(self, other):
28764 
    return not (self == other)
28765 
 
28766 
class getServiceProviderForDevice_args:
28767 
  """
28768 
  Attributes:
6049 rajveer 28769 
   - rechargeType
6048 rajveer 28770 
   - deviceNumber
28771 
  """
28772 
 
28773 
  thrift_spec = (
28774 
    None, # 0
6049 rajveer 28775 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28776 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 28777 
  )
28778 
 
6049 rajveer 28779 
  def __init__(self, rechargeType=None, deviceNumber=None,):
28780 
    self.rechargeType = rechargeType
6048 rajveer 28781 
    self.deviceNumber = deviceNumber
28782 
 
28783 
  def read(self, iprot):
28784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28786 
      return
28787 
    iprot.readStructBegin()
28788 
    while True:
28789 
      (fname, ftype, fid) = iprot.readFieldBegin()
28790 
      if ftype == TType.STOP:
28791 
        break
28792 
      if fid == 1:
6049 rajveer 28793 
        if ftype == TType.I32:
28794 
          self.rechargeType = iprot.readI32();
28795 
        else:
28796 
          iprot.skip(ftype)
28797 
      elif fid == 2:
6048 rajveer 28798 
        if ftype == TType.STRING:
28799 
          self.deviceNumber = iprot.readString();
28800 
        else:
28801 
          iprot.skip(ftype)
28802 
      else:
28803 
        iprot.skip(ftype)
28804 
      iprot.readFieldEnd()
28805 
    iprot.readStructEnd()
28806 
 
28807 
  def write(self, oprot):
28808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28810 
      return
28811 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 28812 
    if self.rechargeType is not None:
28813 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28814 
      oprot.writeI32(self.rechargeType)
28815 
      oprot.writeFieldEnd()
6048 rajveer 28816 
    if self.deviceNumber is not None:
6049 rajveer 28817 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 28818 
      oprot.writeString(self.deviceNumber)
28819 
      oprot.writeFieldEnd()
28820 
    oprot.writeFieldStop()
28821 
    oprot.writeStructEnd()
28822 
 
28823 
  def validate(self):
28824 
    return
28825 
 
28826 
 
28827 
  def __repr__(self):
28828 
    L = ['%s=%r' % (key, value)
28829 
      for key, value in self.__dict__.iteritems()]
28830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28831 
 
28832 
  def __eq__(self, other):
28833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28834 
 
28835 
  def __ne__(self, other):
28836 
    return not (self == other)
28837 
 
28838 
class getServiceProviderForDevice_result:
28839 
  """
28840 
  Attributes:
28841 
   - success
28842 
  """
28843 
 
28844 
  thrift_spec = (
6289 anupam.sin 28845 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 28846 
  )
28847 
 
28848 
  def __init__(self, success=None,):
28849 
    self.success = success
28850 
 
28851 
  def read(self, iprot):
28852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28854 
      return
28855 
    iprot.readStructBegin()
28856 
    while True:
28857 
      (fname, ftype, fid) = iprot.readFieldBegin()
28858 
      if ftype == TType.STOP:
28859 
        break
28860 
      if fid == 0:
6289 anupam.sin 28861 
        if ftype == TType.STRUCT:
28862 
          self.success = DeviceNumberInfo()
28863 
          self.success.read(iprot)
6048 rajveer 28864 
        else:
28865 
          iprot.skip(ftype)
28866 
      else:
28867 
        iprot.skip(ftype)
28868 
      iprot.readFieldEnd()
28869 
    iprot.readStructEnd()
28870 
 
28871 
  def write(self, oprot):
28872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28874 
      return
28875 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
28876 
    if self.success is not None:
6289 anupam.sin 28877 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28878 
      self.success.write(oprot)
6048 rajveer 28879 
      oprot.writeFieldEnd()
28880 
    oprot.writeFieldStop()
28881 
    oprot.writeStructEnd()
28882 
 
28883 
  def validate(self):
28884 
    return
28885 
 
28886 
 
28887 
  def __repr__(self):
28888 
    L = ['%s=%r' % (key, value)
28889 
      for key, value in self.__dict__.iteritems()]
28890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28891 
 
28892 
  def __eq__(self, other):
28893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28894 
 
28895 
  def __ne__(self, other):
28896 
    return not (self == other)
6094 rajveer 28897 
 
6269 rajveer 28898 
class validateRecharge_args:
28899 
  """
28900 
  Attributes:
28901 
   - rechargeType
28902 
   - deviceNumber
6307 anupam.sin 28903 
   - userSelectedProviderId
6591 anupam.sin 28904 
   - clientAddress
6269 rajveer 28905 
  """
28906 
 
28907 
  thrift_spec = (
28908 
    None, # 0
28909 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28910 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 28911 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6591 anupam.sin 28912 
    (4, TType.STRING, 'clientAddress', None, None, ), # 4
6269 rajveer 28913 
  )
28914 
 
6591 anupam.sin 28915 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None, clientAddress=None,):
6269 rajveer 28916 
    self.rechargeType = rechargeType
28917 
    self.deviceNumber = deviceNumber
6307 anupam.sin 28918 
    self.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 28919 
    self.clientAddress = clientAddress
6269 rajveer 28920 
 
28921 
  def read(self, iprot):
28922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28924 
      return
28925 
    iprot.readStructBegin()
28926 
    while True:
28927 
      (fname, ftype, fid) = iprot.readFieldBegin()
28928 
      if ftype == TType.STOP:
28929 
        break
28930 
      if fid == 1:
28931 
        if ftype == TType.I32:
28932 
          self.rechargeType = iprot.readI32();
28933 
        else:
28934 
          iprot.skip(ftype)
28935 
      elif fid == 2:
28936 
        if ftype == TType.STRING:
28937 
          self.deviceNumber = iprot.readString();
28938 
        else:
28939 
          iprot.skip(ftype)
6307 anupam.sin 28940 
      elif fid == 3:
28941 
        if ftype == TType.I64:
28942 
          self.userSelectedProviderId = iprot.readI64();
28943 
        else:
28944 
          iprot.skip(ftype)
6591 anupam.sin 28945 
      elif fid == 4:
28946 
        if ftype == TType.STRING:
28947 
          self.clientAddress = iprot.readString();
28948 
        else:
28949 
          iprot.skip(ftype)
6269 rajveer 28950 
      else:
28951 
        iprot.skip(ftype)
28952 
      iprot.readFieldEnd()
28953 
    iprot.readStructEnd()
28954 
 
28955 
  def write(self, oprot):
28956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28958 
      return
28959 
    oprot.writeStructBegin('validateRecharge_args')
28960 
    if self.rechargeType is not None:
28961 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28962 
      oprot.writeI32(self.rechargeType)
28963 
      oprot.writeFieldEnd()
28964 
    if self.deviceNumber is not None:
28965 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
28966 
      oprot.writeString(self.deviceNumber)
28967 
      oprot.writeFieldEnd()
6307 anupam.sin 28968 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 28969 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 28970 
      oprot.writeI64(self.userSelectedProviderId)
28971 
      oprot.writeFieldEnd()
6591 anupam.sin 28972 
    if self.clientAddress is not None:
28973 
      oprot.writeFieldBegin('clientAddress', TType.STRING, 4)
28974 
      oprot.writeString(self.clientAddress)
28975 
      oprot.writeFieldEnd()
6269 rajveer 28976 
    oprot.writeFieldStop()
28977 
    oprot.writeStructEnd()
28978 
 
28979 
  def validate(self):
28980 
    return
28981 
 
28982 
 
28983 
  def __repr__(self):
28984 
    L = ['%s=%r' % (key, value)
28985 
      for key, value in self.__dict__.iteritems()]
28986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28987 
 
28988 
  def __eq__(self, other):
28989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28990 
 
28991 
  def __ne__(self, other):
28992 
    return not (self == other)
28993 
 
28994 
class validateRecharge_result:
28995 
  """
28996 
  Attributes:
28997 
   - success
28998 
  """
28999 
 
29000 
  thrift_spec = (
29001 
    (0, TType.STRING, 'success', None, None, ), # 0
29002 
  )
29003 
 
29004 
  def __init__(self, success=None,):
29005 
    self.success = success
29006 
 
29007 
  def read(self, iprot):
29008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29010 
      return
29011 
    iprot.readStructBegin()
29012 
    while True:
29013 
      (fname, ftype, fid) = iprot.readFieldBegin()
29014 
      if ftype == TType.STOP:
29015 
        break
29016 
      if fid == 0:
29017 
        if ftype == TType.STRING:
29018 
          self.success = iprot.readString();
29019 
        else:
29020 
          iprot.skip(ftype)
29021 
      else:
29022 
        iprot.skip(ftype)
29023 
      iprot.readFieldEnd()
29024 
    iprot.readStructEnd()
29025 
 
29026 
  def write(self, oprot):
29027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29029 
      return
29030 
    oprot.writeStructBegin('validateRecharge_result')
29031 
    if self.success is not None:
29032 
      oprot.writeFieldBegin('success', TType.STRING, 0)
29033 
      oprot.writeString(self.success)
29034 
      oprot.writeFieldEnd()
29035 
    oprot.writeFieldStop()
29036 
    oprot.writeStructEnd()
29037 
 
29038 
  def validate(self):
29039 
    return
29040 
 
29041 
 
29042 
  def __repr__(self):
29043 
    L = ['%s=%r' % (key, value)
29044 
      for key, value in self.__dict__.iteritems()]
29045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29046 
 
29047 
  def __eq__(self, other):
29048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29049 
 
29050 
  def __ne__(self, other):
29051 
    return not (self == other)
29052 
 
6094 rajveer 29053 
class getRechargeOrdersForDevice_args:
29054 
  """
29055 
  Attributes:
29056 
   - deviceNumber
29057 
  """
29058 
 
29059 
  thrift_spec = (
29060 
    None, # 0
29061 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
29062 
  )
29063 
 
29064 
  def __init__(self, deviceNumber=None,):
29065 
    self.deviceNumber = deviceNumber
29066 
 
29067 
  def read(self, iprot):
29068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29070 
      return
29071 
    iprot.readStructBegin()
29072 
    while True:
29073 
      (fname, ftype, fid) = iprot.readFieldBegin()
29074 
      if ftype == TType.STOP:
29075 
        break
29076 
      if fid == 1:
29077 
        if ftype == TType.STRING:
29078 
          self.deviceNumber = iprot.readString();
29079 
        else:
29080 
          iprot.skip(ftype)
29081 
      else:
29082 
        iprot.skip(ftype)
29083 
      iprot.readFieldEnd()
29084 
    iprot.readStructEnd()
29085 
 
29086 
  def write(self, oprot):
29087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29089 
      return
29090 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
29091 
    if self.deviceNumber is not None:
29092 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
29093 
      oprot.writeString(self.deviceNumber)
29094 
      oprot.writeFieldEnd()
29095 
    oprot.writeFieldStop()
29096 
    oprot.writeStructEnd()
29097 
 
29098 
  def validate(self):
29099 
    return
29100 
 
29101 
 
29102 
  def __repr__(self):
29103 
    L = ['%s=%r' % (key, value)
29104 
      for key, value in self.__dict__.iteritems()]
29105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29106 
 
29107 
  def __eq__(self, other):
29108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29109 
 
29110 
  def __ne__(self, other):
29111 
    return not (self == other)
29112 
 
29113 
class getRechargeOrdersForDevice_result:
29114 
  """
29115 
  Attributes:
29116 
   - success
29117 
  """
29118 
 
29119 
  thrift_spec = (
29120 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
29121 
  )
29122 
 
29123 
  def __init__(self, success=None,):
29124 
    self.success = success
29125 
 
29126 
  def read(self, iprot):
29127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29129 
      return
29130 
    iprot.readStructBegin()
29131 
    while True:
29132 
      (fname, ftype, fid) = iprot.readFieldBegin()
29133 
      if ftype == TType.STOP:
29134 
        break
29135 
      if fid == 0:
29136 
        if ftype == TType.LIST:
29137 
          self.success = []
6188 rajveer 29138 
          (_etype682, _size679) = iprot.readListBegin()
29139 
          for _i683 in xrange(_size679):
29140 
            _elem684 = RechargeOrder()
29141 
            _elem684.read(iprot)
29142 
            self.success.append(_elem684)
6094 rajveer 29143 
          iprot.readListEnd()
29144 
        else:
29145 
          iprot.skip(ftype)
29146 
      else:
29147 
        iprot.skip(ftype)
29148 
      iprot.readFieldEnd()
29149 
    iprot.readStructEnd()
29150 
 
29151 
  def write(self, oprot):
29152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29154 
      return
29155 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
29156 
    if self.success is not None:
29157 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29158 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29159 
      for iter685 in self.success:
29160 
        iter685.write(oprot)
6094 rajveer 29161 
      oprot.writeListEnd()
29162 
      oprot.writeFieldEnd()
29163 
    oprot.writeFieldStop()
29164 
    oprot.writeStructEnd()
29165 
 
29166 
  def validate(self):
29167 
    return
29168 
 
29169 
 
29170 
  def __repr__(self):
29171 
    L = ['%s=%r' % (key, value)
29172 
      for key, value in self.__dict__.iteritems()]
29173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29174 
 
29175 
  def __eq__(self, other):
29176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29177 
 
29178 
  def __ne__(self, other):
29179 
    return not (self == other)
29180 
 
29181 
class addAmountToWallet_args:
29182 
  """
29183 
  Attributes:
29184 
   - userId
29185 
   - orderId
29186 
   - amount
29187 
  """
29188 
 
29189 
  thrift_spec = (
29190 
    None, # 0
29191 
    (1, TType.I64, 'userId', None, None, ), # 1
29192 
    (2, TType.I64, 'orderId', None, None, ), # 2
29193 
    (3, TType.I64, 'amount', None, None, ), # 3
29194 
  )
29195 
 
29196 
  def __init__(self, userId=None, orderId=None, amount=None,):
29197 
    self.userId = userId
29198 
    self.orderId = orderId
29199 
    self.amount = amount
29200 
 
29201 
  def read(self, iprot):
29202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29204 
      return
29205 
    iprot.readStructBegin()
29206 
    while True:
29207 
      (fname, ftype, fid) = iprot.readFieldBegin()
29208 
      if ftype == TType.STOP:
29209 
        break
29210 
      if fid == 1:
29211 
        if ftype == TType.I64:
29212 
          self.userId = iprot.readI64();
29213 
        else:
29214 
          iprot.skip(ftype)
29215 
      elif fid == 2:
29216 
        if ftype == TType.I64:
29217 
          self.orderId = iprot.readI64();
29218 
        else:
29219 
          iprot.skip(ftype)
29220 
      elif fid == 3:
29221 
        if ftype == TType.I64:
29222 
          self.amount = iprot.readI64();
29223 
        else:
29224 
          iprot.skip(ftype)
29225 
      else:
29226 
        iprot.skip(ftype)
29227 
      iprot.readFieldEnd()
29228 
    iprot.readStructEnd()
29229 
 
29230 
  def write(self, oprot):
29231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29233 
      return
29234 
    oprot.writeStructBegin('addAmountToWallet_args')
29235 
    if self.userId is not None:
29236 
      oprot.writeFieldBegin('userId', TType.I64, 1)
29237 
      oprot.writeI64(self.userId)
29238 
      oprot.writeFieldEnd()
29239 
    if self.orderId is not None:
29240 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
29241 
      oprot.writeI64(self.orderId)
29242 
      oprot.writeFieldEnd()
29243 
    if self.amount is not None:
29244 
      oprot.writeFieldBegin('amount', TType.I64, 3)
29245 
      oprot.writeI64(self.amount)
29246 
      oprot.writeFieldEnd()
29247 
    oprot.writeFieldStop()
29248 
    oprot.writeStructEnd()
29249 
 
29250 
  def validate(self):
29251 
    return
29252 
 
29253 
 
29254 
  def __repr__(self):
29255 
    L = ['%s=%r' % (key, value)
29256 
      for key, value in self.__dict__.iteritems()]
29257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29258 
 
29259 
  def __eq__(self, other):
29260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29261 
 
29262 
  def __ne__(self, other):
29263 
    return not (self == other)
29264 
 
29265 
class addAmountToWallet_result:
29266 
 
29267 
  thrift_spec = (
29268 
  )
29269 
 
29270 
  def read(self, iprot):
29271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29273 
      return
29274 
    iprot.readStructBegin()
29275 
    while True:
29276 
      (fname, ftype, fid) = iprot.readFieldBegin()
29277 
      if ftype == TType.STOP:
29278 
        break
29279 
      else:
29280 
        iprot.skip(ftype)
29281 
      iprot.readFieldEnd()
29282 
    iprot.readStructEnd()
29283 
 
29284 
  def write(self, oprot):
29285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29287 
      return
29288 
    oprot.writeStructBegin('addAmountToWallet_result')
29289 
    oprot.writeFieldStop()
29290 
    oprot.writeStructEnd()
29291 
 
29292 
  def validate(self):
29293 
    return
29294 
 
29295 
 
29296 
  def __repr__(self):
29297 
    L = ['%s=%r' % (key, value)
29298 
      for key, value in self.__dict__.iteritems()]
29299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29300 
 
29301 
  def __eq__(self, other):
29302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29303 
 
29304 
  def __ne__(self, other):
29305 
    return not (self == other)
6154 rajveer 29306 
 
6188 rajveer 29307 
class getRechargeStatistics_args:
29308 
 
29309 
  thrift_spec = (
29310 
  )
29311 
 
29312 
  def read(self, iprot):
29313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29315 
      return
29316 
    iprot.readStructBegin()
29317 
    while True:
29318 
      (fname, ftype, fid) = iprot.readFieldBegin()
29319 
      if ftype == TType.STOP:
29320 
        break
29321 
      else:
29322 
        iprot.skip(ftype)
29323 
      iprot.readFieldEnd()
29324 
    iprot.readStructEnd()
29325 
 
29326 
  def write(self, oprot):
29327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29329 
      return
29330 
    oprot.writeStructBegin('getRechargeStatistics_args')
29331 
    oprot.writeFieldStop()
29332 
    oprot.writeStructEnd()
29333 
 
29334 
  def validate(self):
29335 
    return
29336 
 
29337 
 
29338 
  def __repr__(self):
29339 
    L = ['%s=%r' % (key, value)
29340 
      for key, value in self.__dict__.iteritems()]
29341 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29342 
 
29343 
  def __eq__(self, other):
29344 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29345 
 
29346 
  def __ne__(self, other):
29347 
    return not (self == other)
29348 
 
29349 
class getRechargeStatistics_result:
29350 
  """
29351 
  Attributes:
29352 
   - success
29353 
  """
29354 
 
29355 
  thrift_spec = (
29356 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
29357 
  )
29358 
 
29359 
  def __init__(self, success=None,):
29360 
    self.success = success
29361 
 
29362 
  def read(self, iprot):
29363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29365 
      return
29366 
    iprot.readStructBegin()
29367 
    while True:
29368 
      (fname, ftype, fid) = iprot.readFieldBegin()
29369 
      if ftype == TType.STOP:
29370 
        break
29371 
      if fid == 0:
29372 
        if ftype == TType.STRUCT:
29373 
          self.success = RechargeStatistics()
29374 
          self.success.read(iprot)
29375 
        else:
29376 
          iprot.skip(ftype)
29377 
      else:
29378 
        iprot.skip(ftype)
29379 
      iprot.readFieldEnd()
29380 
    iprot.readStructEnd()
29381 
 
29382 
  def write(self, oprot):
29383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29385 
      return
29386 
    oprot.writeStructBegin('getRechargeStatistics_result')
29387 
    if self.success is not None:
29388 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29389 
      self.success.write(oprot)
29390 
      oprot.writeFieldEnd()
29391 
    oprot.writeFieldStop()
29392 
    oprot.writeStructEnd()
29393 
 
29394 
  def validate(self):
29395 
    return
29396 
 
29397 
 
29398 
  def __repr__(self):
29399 
    L = ['%s=%r' % (key, value)
29400 
      for key, value in self.__dict__.iteritems()]
29401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29402 
 
29403 
  def __eq__(self, other):
29404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29405 
 
29406 
  def __ne__(self, other):
29407 
    return not (self == other)
29408 
 
6154 rajveer 29409 
class getRechargeOrdersForStatus_args:
29410 
  """
29411 
  Attributes:
29412 
   - status
29413 
  """
29414 
 
29415 
  thrift_spec = (
29416 
    None, # 0
29417 
    (1, TType.I64, 'status', None, None, ), # 1
29418 
  )
29419 
 
29420 
  def __init__(self, status=None,):
29421 
    self.status = status
29422 
 
29423 
  def read(self, iprot):
29424 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29425 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29426 
      return
29427 
    iprot.readStructBegin()
29428 
    while True:
29429 
      (fname, ftype, fid) = iprot.readFieldBegin()
29430 
      if ftype == TType.STOP:
29431 
        break
29432 
      if fid == 1:
29433 
        if ftype == TType.I64:
29434 
          self.status = iprot.readI64();
29435 
        else:
29436 
          iprot.skip(ftype)
29437 
      else:
29438 
        iprot.skip(ftype)
29439 
      iprot.readFieldEnd()
29440 
    iprot.readStructEnd()
29441 
 
29442 
  def write(self, oprot):
29443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29445 
      return
29446 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
29447 
    if self.status is not None:
29448 
      oprot.writeFieldBegin('status', TType.I64, 1)
29449 
      oprot.writeI64(self.status)
29450 
      oprot.writeFieldEnd()
29451 
    oprot.writeFieldStop()
29452 
    oprot.writeStructEnd()
29453 
 
29454 
  def validate(self):
29455 
    return
29456 
 
29457 
 
29458 
  def __repr__(self):
29459 
    L = ['%s=%r' % (key, value)
29460 
      for key, value in self.__dict__.iteritems()]
29461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29462 
 
29463 
  def __eq__(self, other):
29464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29465 
 
29466 
  def __ne__(self, other):
29467 
    return not (self == other)
29468 
 
29469 
class getRechargeOrdersForStatus_result:
29470 
  """
29471 
  Attributes:
29472 
   - success
29473 
  """
29474 
 
29475 
  thrift_spec = (
29476 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
29477 
  )
29478 
 
29479 
  def __init__(self, success=None,):
29480 
    self.success = success
29481 
 
29482 
  def read(self, iprot):
29483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29485 
      return
29486 
    iprot.readStructBegin()
29487 
    while True:
29488 
      (fname, ftype, fid) = iprot.readFieldBegin()
29489 
      if ftype == TType.STOP:
29490 
        break
29491 
      if fid == 0:
29492 
        if ftype == TType.LIST:
29493 
          self.success = []
6188 rajveer 29494 
          (_etype689, _size686) = iprot.readListBegin()
29495 
          for _i690 in xrange(_size686):
29496 
            _elem691 = RechargeOrder()
29497 
            _elem691.read(iprot)
29498 
            self.success.append(_elem691)
6154 rajveer 29499 
          iprot.readListEnd()
29500 
        else:
29501 
          iprot.skip(ftype)
29502 
      else:
29503 
        iprot.skip(ftype)
29504 
      iprot.readFieldEnd()
29505 
    iprot.readStructEnd()
29506 
 
29507 
  def write(self, oprot):
29508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29510 
      return
29511 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
29512 
    if self.success is not None:
29513 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29514 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29515 
      for iter692 in self.success:
29516 
        iter692.write(oprot)
6154 rajveer 29517 
      oprot.writeListEnd()
29518 
      oprot.writeFieldEnd()
29519 
    oprot.writeFieldStop()
29520 
    oprot.writeStructEnd()
29521 
 
29522 
  def validate(self):
29523 
    return
29524 
 
29525 
 
29526 
  def __repr__(self):
29527 
    L = ['%s=%r' % (key, value)
29528 
      for key, value in self.__dict__.iteritems()]
29529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29530 
 
29531 
  def __eq__(self, other):
29532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29533 
 
29534 
  def __ne__(self, other):
29535 
    return not (self == other)
6159 rajveer 29536 
 
29537 
class getPlansForOperator_args:
29538 
  """
29539 
  Attributes:
29540 
   - operatorId
29541 
  """
29542 
 
29543 
  thrift_spec = (
29544 
    None, # 0
29545 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29546 
  )
29547 
 
29548 
  def __init__(self, operatorId=None,):
29549 
    self.operatorId = operatorId
29550 
 
29551 
  def read(self, iprot):
29552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29554 
      return
29555 
    iprot.readStructBegin()
29556 
    while True:
29557 
      (fname, ftype, fid) = iprot.readFieldBegin()
29558 
      if ftype == TType.STOP:
29559 
        break
29560 
      if fid == 1:
29561 
        if ftype == TType.I64:
29562 
          self.operatorId = iprot.readI64();
29563 
        else:
29564 
          iprot.skip(ftype)
29565 
      else:
29566 
        iprot.skip(ftype)
29567 
      iprot.readFieldEnd()
29568 
    iprot.readStructEnd()
29569 
 
29570 
  def write(self, oprot):
29571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29573 
      return
29574 
    oprot.writeStructBegin('getPlansForOperator_args')
29575 
    if self.operatorId is not None:
29576 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29577 
      oprot.writeI64(self.operatorId)
29578 
      oprot.writeFieldEnd()
29579 
    oprot.writeFieldStop()
29580 
    oprot.writeStructEnd()
29581 
 
29582 
  def validate(self):
29583 
    return
29584 
 
29585 
 
29586 
  def __repr__(self):
29587 
    L = ['%s=%r' % (key, value)
29588 
      for key, value in self.__dict__.iteritems()]
29589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29590 
 
29591 
  def __eq__(self, other):
29592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29593 
 
29594 
  def __ne__(self, other):
29595 
    return not (self == other)
29596 
 
29597 
class getPlansForOperator_result:
29598 
  """
29599 
  Attributes:
29600 
   - success
29601 
  """
29602 
 
29603 
  thrift_spec = (
29604 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
29605 
  )
29606 
 
29607 
  def __init__(self, success=None,):
29608 
    self.success = success
29609 
 
29610 
  def read(self, iprot):
29611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29613 
      return
29614 
    iprot.readStructBegin()
29615 
    while True:
29616 
      (fname, ftype, fid) = iprot.readFieldBegin()
29617 
      if ftype == TType.STOP:
29618 
        break
29619 
      if fid == 0:
29620 
        if ftype == TType.LIST:
29621 
          self.success = []
6188 rajveer 29622 
          (_etype696, _size693) = iprot.readListBegin()
29623 
          for _i697 in xrange(_size693):
29624 
            _elem698 = RechargePlan()
29625 
            _elem698.read(iprot)
29626 
            self.success.append(_elem698)
6159 rajveer 29627 
          iprot.readListEnd()
29628 
        else:
29629 
          iprot.skip(ftype)
29630 
      else:
29631 
        iprot.skip(ftype)
29632 
      iprot.readFieldEnd()
29633 
    iprot.readStructEnd()
29634 
 
29635 
  def write(self, oprot):
29636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29638 
      return
29639 
    oprot.writeStructBegin('getPlansForOperator_result')
29640 
    if self.success is not None:
29641 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29642 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29643 
      for iter699 in self.success:
29644 
        iter699.write(oprot)
6159 rajveer 29645 
      oprot.writeListEnd()
29646 
      oprot.writeFieldEnd()
29647 
    oprot.writeFieldStop()
29648 
    oprot.writeStructEnd()
29649 
 
29650 
  def validate(self):
29651 
    return
29652 
 
29653 
 
29654 
  def __repr__(self):
29655 
    L = ['%s=%r' % (key, value)
29656 
      for key, value in self.__dict__.iteritems()]
29657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29658 
 
29659 
  def __eq__(self, other):
29660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29661 
 
29662 
  def __ne__(self, other):
29663 
    return not (self == other)
6289 anupam.sin 29664 
 
29665 
class getRechargeDenominations_args:
29666 
  """
29667 
  Attributes:
29668 
   - operatorId
6307 anupam.sin 29669 
   - circleCode
6289 anupam.sin 29670 
   - denominationType
29671 
  """
29672 
 
29673 
  thrift_spec = (
29674 
    None, # 0
29675 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 29676 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 29677 
    (3, TType.I32, 'denominationType', None, None, ), # 3
29678 
  )
29679 
 
6307 anupam.sin 29680 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 29681 
    self.operatorId = operatorId
6307 anupam.sin 29682 
    self.circleCode = circleCode
6289 anupam.sin 29683 
    self.denominationType = denominationType
29684 
 
29685 
  def read(self, iprot):
29686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29688 
      return
29689 
    iprot.readStructBegin()
29690 
    while True:
29691 
      (fname, ftype, fid) = iprot.readFieldBegin()
29692 
      if ftype == TType.STOP:
29693 
        break
29694 
      if fid == 1:
29695 
        if ftype == TType.I64:
29696 
          self.operatorId = iprot.readI64();
29697 
        else:
29698 
          iprot.skip(ftype)
29699 
      elif fid == 2:
29700 
        if ftype == TType.STRING:
6307 anupam.sin 29701 
          self.circleCode = iprot.readString();
6289 anupam.sin 29702 
        else:
29703 
          iprot.skip(ftype)
29704 
      elif fid == 3:
29705 
        if ftype == TType.I32:
29706 
          self.denominationType = iprot.readI32();
29707 
        else:
29708 
          iprot.skip(ftype)
29709 
      else:
29710 
        iprot.skip(ftype)
29711 
      iprot.readFieldEnd()
29712 
    iprot.readStructEnd()
29713 
 
29714 
  def write(self, oprot):
29715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29717 
      return
29718 
    oprot.writeStructBegin('getRechargeDenominations_args')
29719 
    if self.operatorId is not None:
29720 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29721 
      oprot.writeI64(self.operatorId)
29722 
      oprot.writeFieldEnd()
6307 anupam.sin 29723 
    if self.circleCode is not None:
29724 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
29725 
      oprot.writeString(self.circleCode)
6289 anupam.sin 29726 
      oprot.writeFieldEnd()
29727 
    if self.denominationType is not None:
29728 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
29729 
      oprot.writeI32(self.denominationType)
29730 
      oprot.writeFieldEnd()
29731 
    oprot.writeFieldStop()
29732 
    oprot.writeStructEnd()
29733 
 
29734 
  def validate(self):
29735 
    return
29736 
 
29737 
 
29738 
  def __repr__(self):
29739 
    L = ['%s=%r' % (key, value)
29740 
      for key, value in self.__dict__.iteritems()]
29741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29742 
 
29743 
  def __eq__(self, other):
29744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29745 
 
29746 
  def __ne__(self, other):
29747 
    return not (self == other)
29748 
 
29749 
class getRechargeDenominations_result:
29750 
  """
29751 
  Attributes:
29752 
   - success
29753 
   - ex
29754 
  """
29755 
 
29756 
  thrift_spec = (
29757 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
29758 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29759 
  )
29760 
 
29761 
  def __init__(self, success=None, ex=None,):
29762 
    self.success = success
29763 
    self.ex = ex
29764 
 
29765 
  def read(self, iprot):
29766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29768 
      return
29769 
    iprot.readStructBegin()
29770 
    while True:
29771 
      (fname, ftype, fid) = iprot.readFieldBegin()
29772 
      if ftype == TType.STOP:
29773 
        break
29774 
      if fid == 0:
29775 
        if ftype == TType.LIST:
29776 
          self.success = []
29777 
          (_etype703, _size700) = iprot.readListBegin()
29778 
          for _i704 in xrange(_size700):
29779 
            _elem705 = RechargeDenomination()
29780 
            _elem705.read(iprot)
29781 
            self.success.append(_elem705)
29782 
          iprot.readListEnd()
29783 
        else:
29784 
          iprot.skip(ftype)
29785 
      elif fid == 1:
29786 
        if ftype == TType.STRUCT:
29787 
          self.ex = TransactionServiceException()
29788 
          self.ex.read(iprot)
29789 
        else:
29790 
          iprot.skip(ftype)
29791 
      else:
29792 
        iprot.skip(ftype)
29793 
      iprot.readFieldEnd()
29794 
    iprot.readStructEnd()
29795 
 
29796 
  def write(self, oprot):
29797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29799 
      return
29800 
    oprot.writeStructBegin('getRechargeDenominations_result')
29801 
    if self.success is not None:
29802 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29803 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29804 
      for iter706 in self.success:
29805 
        iter706.write(oprot)
29806 
      oprot.writeListEnd()
29807 
      oprot.writeFieldEnd()
29808 
    if self.ex is not None:
29809 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29810 
      self.ex.write(oprot)
29811 
      oprot.writeFieldEnd()
29812 
    oprot.writeFieldStop()
29813 
    oprot.writeStructEnd()
29814 
 
29815 
  def validate(self):
29816 
    return
29817 
 
29818 
 
29819 
  def __repr__(self):
29820 
    L = ['%s=%r' % (key, value)
29821 
      for key, value in self.__dict__.iteritems()]
29822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29823 
 
29824 
  def __eq__(self, other):
29825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29826 
 
29827 
  def __ne__(self, other):
29828 
    return not (self == other)
6371 rajveer 29829 
 
29830 
class updateAvailabilityStatus_args:
29831 
  """
29832 
  Attributes:
29833 
   - operatorId
29834 
   - circleId
29835 
   - isAvailable
29836 
  """
29837 
 
29838 
  thrift_spec = (
29839 
    None, # 0
29840 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29841 
    (2, TType.I64, 'circleId', None, None, ), # 2
29842 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
29843 
  )
29844 
 
29845 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
29846 
    self.operatorId = operatorId
29847 
    self.circleId = circleId
29848 
    self.isAvailable = isAvailable
29849 
 
29850 
  def read(self, iprot):
29851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29853 
      return
29854 
    iprot.readStructBegin()
29855 
    while True:
29856 
      (fname, ftype, fid) = iprot.readFieldBegin()
29857 
      if ftype == TType.STOP:
29858 
        break
29859 
      if fid == 1:
29860 
        if ftype == TType.I64:
29861 
          self.operatorId = iprot.readI64();
29862 
        else:
29863 
          iprot.skip(ftype)
29864 
      elif fid == 2:
29865 
        if ftype == TType.I64:
29866 
          self.circleId = iprot.readI64();
29867 
        else:
29868 
          iprot.skip(ftype)
29869 
      elif fid == 3:
29870 
        if ftype == TType.BOOL:
29871 
          self.isAvailable = iprot.readBool();
29872 
        else:
29873 
          iprot.skip(ftype)
29874 
      else:
29875 
        iprot.skip(ftype)
29876 
      iprot.readFieldEnd()
29877 
    iprot.readStructEnd()
29878 
 
29879 
  def write(self, oprot):
29880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29882 
      return
29883 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
29884 
    if self.operatorId is not None:
29885 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29886 
      oprot.writeI64(self.operatorId)
29887 
      oprot.writeFieldEnd()
29888 
    if self.circleId is not None:
29889 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
29890 
      oprot.writeI64(self.circleId)
29891 
      oprot.writeFieldEnd()
29892 
    if self.isAvailable is not None:
29893 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
29894 
      oprot.writeBool(self.isAvailable)
29895 
      oprot.writeFieldEnd()
29896 
    oprot.writeFieldStop()
29897 
    oprot.writeStructEnd()
29898 
 
29899 
  def validate(self):
29900 
    return
29901 
 
29902 
 
29903 
  def __repr__(self):
29904 
    L = ['%s=%r' % (key, value)
29905 
      for key, value in self.__dict__.iteritems()]
29906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29907 
 
29908 
  def __eq__(self, other):
29909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29910 
 
29911 
  def __ne__(self, other):
29912 
    return not (self == other)
29913 
 
29914 
class updateAvailabilityStatus_result:
29915 
 
29916 
  thrift_spec = (
29917 
  )
29918 
 
29919 
  def read(self, iprot):
29920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29922 
      return
29923 
    iprot.readStructBegin()
29924 
    while True:
29925 
      (fname, ftype, fid) = iprot.readFieldBegin()
29926 
      if ftype == TType.STOP:
29927 
        break
29928 
      else:
29929 
        iprot.skip(ftype)
29930 
      iprot.readFieldEnd()
29931 
    iprot.readStructEnd()
29932 
 
29933 
  def write(self, oprot):
29934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29936 
      return
29937 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
29938 
    oprot.writeFieldStop()
29939 
    oprot.writeStructEnd()
29940 
 
29941 
  def validate(self):
29942 
    return
29943 
 
29944 
 
29945 
  def __repr__(self):
29946 
    L = ['%s=%r' % (key, value)
29947 
      for key, value in self.__dict__.iteritems()]
29948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29949 
 
29950 
  def __eq__(self, other):
29951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29952 
 
29953 
  def __ne__(self, other):
29954 
    return not (self == other)
6389 rajveer 29955 
 
29956 
class getAvailableEmiSchemes_args:
29957 
 
29958 
  thrift_spec = (
29959 
  )
29960 
 
29961 
  def read(self, iprot):
29962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29964 
      return
29965 
    iprot.readStructBegin()
29966 
    while True:
29967 
      (fname, ftype, fid) = iprot.readFieldBegin()
29968 
      if ftype == TType.STOP:
29969 
        break
29970 
      else:
29971 
        iprot.skip(ftype)
29972 
      iprot.readFieldEnd()
29973 
    iprot.readStructEnd()
29974 
 
29975 
  def write(self, oprot):
29976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29978 
      return
29979 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
29980 
    oprot.writeFieldStop()
29981 
    oprot.writeStructEnd()
29982 
 
29983 
  def validate(self):
29984 
    return
29985 
 
29986 
 
29987 
  def __repr__(self):
29988 
    L = ['%s=%r' % (key, value)
29989 
      for key, value in self.__dict__.iteritems()]
29990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29991 
 
29992 
  def __eq__(self, other):
29993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29994 
 
29995 
  def __ne__(self, other):
29996 
    return not (self == other)
29997 
 
29998 
class getAvailableEmiSchemes_result:
29999 
  """
30000 
  Attributes:
30001 
   - success
30002 
  """
30003 
 
30004 
  thrift_spec = (
30005 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
30006 
  )
30007 
 
30008 
  def __init__(self, success=None,):
30009 
    self.success = success
30010 
 
30011 
  def read(self, iprot):
30012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30014 
      return
30015 
    iprot.readStructBegin()
30016 
    while True:
30017 
      (fname, ftype, fid) = iprot.readFieldBegin()
30018 
      if ftype == TType.STOP:
30019 
        break
30020 
      if fid == 0:
30021 
        if ftype == TType.LIST:
30022 
          self.success = []
30023 
          (_etype710, _size707) = iprot.readListBegin()
30024 
          for _i711 in xrange(_size707):
30025 
            _elem712 = EmiScheme()
30026 
            _elem712.read(iprot)
30027 
            self.success.append(_elem712)
30028 
          iprot.readListEnd()
30029 
        else:
30030 
          iprot.skip(ftype)
30031 
      else:
30032 
        iprot.skip(ftype)
30033 
      iprot.readFieldEnd()
30034 
    iprot.readStructEnd()
30035 
 
30036 
  def write(self, oprot):
30037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30039 
      return
30040 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
30041 
    if self.success is not None:
30042 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30043 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30044 
      for iter713 in self.success:
30045 
        iter713.write(oprot)
30046 
      oprot.writeListEnd()
30047 
      oprot.writeFieldEnd()
30048 
    oprot.writeFieldStop()
30049 
    oprot.writeStructEnd()
30050 
 
30051 
  def validate(self):
30052 
    return
30053 
 
30054 
 
30055 
  def __repr__(self):
30056 
    L = ['%s=%r' % (key, value)
30057 
      for key, value in self.__dict__.iteritems()]
30058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30059 
 
30060 
  def __eq__(self, other):
30061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30062 
 
30063 
  def __ne__(self, other):
30064 
    return not (self == other)
30065 
 
30066 
class getMiscCharges_args:
30067 
  """
30068 
  Attributes:
30069 
   - transactionId
30070 
  """
30071 
 
30072 
  thrift_spec = (
30073 
    None, # 0
30074 
    (1, TType.I64, 'transactionId', None, None, ), # 1
30075 
  )
30076 
 
30077 
  def __init__(self, transactionId=None,):
30078 
    self.transactionId = transactionId
30079 
 
30080 
  def read(self, iprot):
30081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30083 
      return
30084 
    iprot.readStructBegin()
30085 
    while True:
30086 
      (fname, ftype, fid) = iprot.readFieldBegin()
30087 
      if ftype == TType.STOP:
30088 
        break
30089 
      if fid == 1:
30090 
        if ftype == TType.I64:
30091 
          self.transactionId = iprot.readI64();
30092 
        else:
30093 
          iprot.skip(ftype)
30094 
      else:
30095 
        iprot.skip(ftype)
30096 
      iprot.readFieldEnd()
30097 
    iprot.readStructEnd()
30098 
 
30099 
  def write(self, oprot):
30100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30102 
      return
30103 
    oprot.writeStructBegin('getMiscCharges_args')
30104 
    if self.transactionId is not None:
30105 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
30106 
      oprot.writeI64(self.transactionId)
30107 
      oprot.writeFieldEnd()
30108 
    oprot.writeFieldStop()
30109 
    oprot.writeStructEnd()
30110 
 
30111 
  def validate(self):
30112 
    return
30113 
 
30114 
 
30115 
  def __repr__(self):
30116 
    L = ['%s=%r' % (key, value)
30117 
      for key, value in self.__dict__.iteritems()]
30118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30119 
 
30120 
  def __eq__(self, other):
30121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30122 
 
30123 
  def __ne__(self, other):
30124 
    return not (self == other)
30125 
 
30126 
class getMiscCharges_result:
30127 
  """
30128 
  Attributes:
30129 
   - success
30130 
  """
30131 
 
30132 
  thrift_spec = (
6412 rajveer 30133 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 30134 
  )
30135 
 
30136 
  def __init__(self, success=None,):
30137 
    self.success = success
30138 
 
30139 
  def read(self, iprot):
30140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30142 
      return
30143 
    iprot.readStructBegin()
30144 
    while True:
30145 
      (fname, ftype, fid) = iprot.readFieldBegin()
30146 
      if ftype == TType.STOP:
30147 
        break
30148 
      if fid == 0:
30149 
        if ftype == TType.MAP:
30150 
          self.success = {}
30151 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
30152 
          for _i718 in xrange(_size714):
30153 
            _key719 = iprot.readI64();
6412 rajveer 30154 
            _val720 = iprot.readDouble();
6389 rajveer 30155 
            self.success[_key719] = _val720
30156 
          iprot.readMapEnd()
30157 
        else:
30158 
          iprot.skip(ftype)
30159 
      else:
30160 
        iprot.skip(ftype)
30161 
      iprot.readFieldEnd()
30162 
    iprot.readStructEnd()
30163 
 
30164 
  def write(self, oprot):
30165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30167 
      return
30168 
    oprot.writeStructBegin('getMiscCharges_result')
30169 
    if self.success is not None:
30170 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 30171 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 30172 
      for kiter721,viter722 in self.success.items():
30173 
        oprot.writeI64(kiter721)
6412 rajveer 30174 
        oprot.writeDouble(viter722)
6389 rajveer 30175 
      oprot.writeMapEnd()
30176 
      oprot.writeFieldEnd()
30177 
    oprot.writeFieldStop()
30178 
    oprot.writeStructEnd()
30179 
 
30180 
  def validate(self):
30181 
    return
30182 
 
30183 
 
30184 
  def __repr__(self):
30185 
    L = ['%s=%r' % (key, value)
30186 
      for key, value in self.__dict__.iteritems()]
30187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30188 
 
30189 
  def __eq__(self, other):
30190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30191 
 
30192 
  def __ne__(self, other):
30193 
    return not (self == other)
6507 anupam.sin 30194 
 
30195 
class refundRechargeOrder_args:
30196 
  """
30197 
  Attributes:
30198 
   - rechargeOrderId
30199 
  """
30200 
 
30201 
  thrift_spec = (
30202 
    None, # 0
30203 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
30204 
  )
30205 
 
30206 
  def __init__(self, rechargeOrderId=None,):
30207 
    self.rechargeOrderId = rechargeOrderId
30208 
 
30209 
  def read(self, iprot):
30210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30212 
      return
30213 
    iprot.readStructBegin()
30214 
    while True:
30215 
      (fname, ftype, fid) = iprot.readFieldBegin()
30216 
      if ftype == TType.STOP:
30217 
        break
30218 
      if fid == 1:
30219 
        if ftype == TType.I64:
30220 
          self.rechargeOrderId = iprot.readI64();
30221 
        else:
30222 
          iprot.skip(ftype)
30223 
      else:
30224 
        iprot.skip(ftype)
30225 
      iprot.readFieldEnd()
30226 
    iprot.readStructEnd()
30227 
 
30228 
  def write(self, oprot):
30229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30231 
      return
30232 
    oprot.writeStructBegin('refundRechargeOrder_args')
30233 
    if self.rechargeOrderId is not None:
30234 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
30235 
      oprot.writeI64(self.rechargeOrderId)
30236 
      oprot.writeFieldEnd()
30237 
    oprot.writeFieldStop()
30238 
    oprot.writeStructEnd()
30239 
 
30240 
  def validate(self):
30241 
    return
30242 
 
30243 
 
30244 
  def __repr__(self):
30245 
    L = ['%s=%r' % (key, value)
30246 
      for key, value in self.__dict__.iteritems()]
30247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30248 
 
30249 
  def __eq__(self, other):
30250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30251 
 
30252 
  def __ne__(self, other):
30253 
    return not (self == other)
30254 
 
30255 
class refundRechargeOrder_result:
30256 
  """
30257 
  Attributes:
30258 
   - success
30259 
   - ex
30260 
  """
30261 
 
30262 
  thrift_spec = (
30263 
    (0, TType.BOOL, 'success', None, None, ), # 0
30264 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
30265 
  )
30266 
 
30267 
  def __init__(self, success=None, ex=None,):
30268 
    self.success = success
30269 
    self.ex = ex
30270 
 
30271 
  def read(self, iprot):
30272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30274 
      return
30275 
    iprot.readStructBegin()
30276 
    while True:
30277 
      (fname, ftype, fid) = iprot.readFieldBegin()
30278 
      if ftype == TType.STOP:
30279 
        break
30280 
      if fid == 0:
30281 
        if ftype == TType.BOOL:
30282 
          self.success = iprot.readBool();
30283 
        else:
30284 
          iprot.skip(ftype)
30285 
      elif fid == 1:
30286 
        if ftype == TType.STRUCT:
30287 
          self.ex = TransactionServiceException()
30288 
          self.ex.read(iprot)
30289 
        else:
30290 
          iprot.skip(ftype)
30291 
      else:
30292 
        iprot.skip(ftype)
30293 
      iprot.readFieldEnd()
30294 
    iprot.readStructEnd()
30295 
 
30296 
  def write(self, oprot):
30297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30299 
      return
30300 
    oprot.writeStructBegin('refundRechargeOrder_result')
30301 
    if self.success is not None:
30302 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30303 
      oprot.writeBool(self.success)
30304 
      oprot.writeFieldEnd()
30305 
    if self.ex is not None:
30306 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
30307 
      self.ex.write(oprot)
30308 
      oprot.writeFieldEnd()
30309 
    oprot.writeFieldStop()
30310 
    oprot.writeStructEnd()
30311 
 
30312 
  def validate(self):
30313 
    return
30314 
 
30315 
 
30316 
  def __repr__(self):
30317 
    L = ['%s=%r' % (key, value)
30318 
      for key, value in self.__dict__.iteritems()]
30319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30320 
 
30321 
  def __eq__(self, other):
30322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30323 
 
30324 
  def __ne__(self, other):
30325 
    return not (self == other)
6821 amar.kumar 30326 
 
30327 
class getPhysicalOrders_args:
30328 
  """
30329 
  Attributes:
30330 
   - fromDate
30331 
   - toDate
30332 
  """
30333 
 
30334 
  thrift_spec = (
30335 
    None, # 0
30336 
    (1, TType.I64, 'fromDate', None, None, ), # 1
30337 
    (2, TType.I64, 'toDate', None, None, ), # 2
30338 
  )
30339 
 
30340 
  def __init__(self, fromDate=None, toDate=None,):
30341 
    self.fromDate = fromDate
30342 
    self.toDate = toDate
30343 
 
30344 
  def read(self, iprot):
30345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30347 
      return
30348 
    iprot.readStructBegin()
30349 
    while True:
30350 
      (fname, ftype, fid) = iprot.readFieldBegin()
30351 
      if ftype == TType.STOP:
30352 
        break
30353 
      if fid == 1:
30354 
        if ftype == TType.I64:
30355 
          self.fromDate = iprot.readI64();
30356 
        else:
30357 
          iprot.skip(ftype)
30358 
      elif fid == 2:
30359 
        if ftype == TType.I64:
30360 
          self.toDate = iprot.readI64();
30361 
        else:
30362 
          iprot.skip(ftype)
30363 
      else:
30364 
        iprot.skip(ftype)
30365 
      iprot.readFieldEnd()
30366 
    iprot.readStructEnd()
30367 
 
30368 
  def write(self, oprot):
30369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30371 
      return
30372 
    oprot.writeStructBegin('getPhysicalOrders_args')
30373 
    if self.fromDate is not None:
30374 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
30375 
      oprot.writeI64(self.fromDate)
30376 
      oprot.writeFieldEnd()
30377 
    if self.toDate is not None:
30378 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
30379 
      oprot.writeI64(self.toDate)
30380 
      oprot.writeFieldEnd()
30381 
    oprot.writeFieldStop()
30382 
    oprot.writeStructEnd()
30383 
 
30384 
  def validate(self):
30385 
    return
30386 
 
30387 
 
30388 
  def __repr__(self):
30389 
    L = ['%s=%r' % (key, value)
30390 
      for key, value in self.__dict__.iteritems()]
30391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30392 
 
30393 
  def __eq__(self, other):
30394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30395 
 
30396 
  def __ne__(self, other):
30397 
    return not (self == other)
30398 
 
30399 
class getPhysicalOrders_result:
30400 
  """
30401 
  Attributes:
30402 
   - success
30403 
  """
30404 
 
30405 
  thrift_spec = (
30406 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
30407 
  )
30408 
 
30409 
  def __init__(self, success=None,):
30410 
    self.success = success
30411 
 
30412 
  def read(self, iprot):
30413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30415 
      return
30416 
    iprot.readStructBegin()
30417 
    while True:
30418 
      (fname, ftype, fid) = iprot.readFieldBegin()
30419 
      if ftype == TType.STOP:
30420 
        break
30421 
      if fid == 0:
30422 
        if ftype == TType.LIST:
30423 
          self.success = []
30424 
          (_etype726, _size723) = iprot.readListBegin()
30425 
          for _i727 in xrange(_size723):
30426 
            _elem728 = Order()
30427 
            _elem728.read(iprot)
30428 
            self.success.append(_elem728)
30429 
          iprot.readListEnd()
30430 
        else:
30431 
          iprot.skip(ftype)
30432 
      else:
30433 
        iprot.skip(ftype)
30434 
      iprot.readFieldEnd()
30435 
    iprot.readStructEnd()
30436 
 
30437 
  def write(self, oprot):
30438 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30439 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30440 
      return
30441 
    oprot.writeStructBegin('getPhysicalOrders_result')
30442 
    if self.success is not None:
30443 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30444 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30445 
      for iter729 in self.success:
30446 
        iter729.write(oprot)
30447 
      oprot.writeListEnd()
30448 
      oprot.writeFieldEnd()
30449 
    oprot.writeFieldStop()
30450 
    oprot.writeStructEnd()
30451 
 
30452 
  def validate(self):
30453 
    return
30454 
 
30455 
 
30456 
  def __repr__(self):
30457 
    L = ['%s=%r' % (key, value)
30458 
      for key, value in self.__dict__.iteritems()]
30459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30460 
 
30461 
  def __eq__(self, other):
30462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30463 
 
30464 
  def __ne__(self, other):
30465 
    return not (self == other)
6906 rajveer 30466 
 
30467 
class getDocument_args:
30468 
  """
30469 
  Attributes:
30470 
   - docType
30471 
   - docSource
30472 
  """
30473 
 
30474 
  thrift_spec = (
30475 
    None, # 0
30476 
    (1, TType.I64, 'docType', None, None, ), # 1
30477 
    (2, TType.I64, 'docSource', None, None, ), # 2
30478 
  )
30479 
 
30480 
  def __init__(self, docType=None, docSource=None,):
30481 
    self.docType = docType
30482 
    self.docSource = docSource
30483 
 
30484 
  def read(self, iprot):
30485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30487 
      return
30488 
    iprot.readStructBegin()
30489 
    while True:
30490 
      (fname, ftype, fid) = iprot.readFieldBegin()
30491 
      if ftype == TType.STOP:
30492 
        break
30493 
      if fid == 1:
30494 
        if ftype == TType.I64:
30495 
          self.docType = iprot.readI64();
30496 
        else:
30497 
          iprot.skip(ftype)
30498 
      elif fid == 2:
30499 
        if ftype == TType.I64:
30500 
          self.docSource = iprot.readI64();
30501 
        else:
30502 
          iprot.skip(ftype)
30503 
      else:
30504 
        iprot.skip(ftype)
30505 
      iprot.readFieldEnd()
30506 
    iprot.readStructEnd()
30507 
 
30508 
  def write(self, oprot):
30509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30511 
      return
30512 
    oprot.writeStructBegin('getDocument_args')
30513 
    if self.docType is not None:
30514 
      oprot.writeFieldBegin('docType', TType.I64, 1)
30515 
      oprot.writeI64(self.docType)
30516 
      oprot.writeFieldEnd()
30517 
    if self.docSource is not None:
30518 
      oprot.writeFieldBegin('docSource', TType.I64, 2)
30519 
      oprot.writeI64(self.docSource)
30520 
      oprot.writeFieldEnd()
30521 
    oprot.writeFieldStop()
30522 
    oprot.writeStructEnd()
30523 
 
30524 
  def validate(self):
30525 
    return
30526 
 
30527 
 
30528 
  def __repr__(self):
30529 
    L = ['%s=%r' % (key, value)
30530 
      for key, value in self.__dict__.iteritems()]
30531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30532 
 
30533 
  def __eq__(self, other):
30534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30535 
 
30536 
  def __ne__(self, other):
30537 
    return not (self == other)
30538 
 
30539 
class getDocument_result:
30540 
  """
30541 
  Attributes:
30542 
   - success
30543 
  """
30544 
 
30545 
  thrift_spec = (
30546 
    (0, TType.STRING, 'success', None, None, ), # 0
30547 
  )
30548 
 
30549 
  def __init__(self, success=None,):
30550 
    self.success = success
30551 
 
30552 
  def read(self, iprot):
30553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30555 
      return
30556 
    iprot.readStructBegin()
30557 
    while True:
30558 
      (fname, ftype, fid) = iprot.readFieldBegin()
30559 
      if ftype == TType.STOP:
30560 
        break
30561 
      if fid == 0:
30562 
        if ftype == TType.STRING:
30563 
          self.success = iprot.readString();
30564 
        else:
30565 
          iprot.skip(ftype)
30566 
      else:
30567 
        iprot.skip(ftype)
30568 
      iprot.readFieldEnd()
30569 
    iprot.readStructEnd()
30570 
 
30571 
  def write(self, oprot):
30572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30574 
      return
30575 
    oprot.writeStructBegin('getDocument_result')
30576 
    if self.success is not None:
30577 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30578 
      oprot.writeString(self.success)
30579 
      oprot.writeFieldEnd()
30580 
    oprot.writeFieldStop()
30581 
    oprot.writeStructEnd()
30582 
 
30583 
  def validate(self):
30584 
    return
30585 
 
30586 
 
30587 
  def __repr__(self):
30588 
    L = ['%s=%r' % (key, value)
30589 
      for key, value in self.__dict__.iteritems()]
30590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30591 
 
30592 
  def __eq__(self, other):
30593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30594 
 
30595 
  def __ne__(self, other):
30596 
    return not (self == other)
6985 anupam.sin 30597 
 
30598 
class changeShippingAddress_args:
30599 
  """
30600 
  Attributes:
30601 
   - orderId
30602 
   - line1
30603 
   - line2
30604 
   - city
30605 
   - state
30606 
   - pin
30607 
  """
30608 
 
30609 
  thrift_spec = (
30610 
    None, # 0
30611 
    (1, TType.I64, 'orderId', None, None, ), # 1
30612 
    (2, TType.STRING, 'line1', None, None, ), # 2
30613 
    (3, TType.STRING, 'line2', None, None, ), # 3
30614 
    (4, TType.STRING, 'city', None, None, ), # 4
30615 
    (5, TType.STRING, 'state', None, None, ), # 5
30616 
    (6, TType.STRING, 'pin', None, None, ), # 6
30617 
  )
30618 
 
30619 
  def __init__(self, orderId=None, line1=None, line2=None, city=None, state=None, pin=None,):
30620 
    self.orderId = orderId
30621 
    self.line1 = line1
30622 
    self.line2 = line2
30623 
    self.city = city
30624 
    self.state = state
30625 
    self.pin = pin
30626 
 
30627 
  def read(self, iprot):
30628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30630 
      return
30631 
    iprot.readStructBegin()
30632 
    while True:
30633 
      (fname, ftype, fid) = iprot.readFieldBegin()
30634 
      if ftype == TType.STOP:
30635 
        break
30636 
      if fid == 1:
30637 
        if ftype == TType.I64:
30638 
          self.orderId = iprot.readI64();
30639 
        else:
30640 
          iprot.skip(ftype)
30641 
      elif fid == 2:
30642 
        if ftype == TType.STRING:
30643 
          self.line1 = iprot.readString();
30644 
        else:
30645 
          iprot.skip(ftype)
30646 
      elif fid == 3:
30647 
        if ftype == TType.STRING:
30648 
          self.line2 = iprot.readString();
30649 
        else:
30650 
          iprot.skip(ftype)
30651 
      elif fid == 4:
30652 
        if ftype == TType.STRING:
30653 
          self.city = iprot.readString();
30654 
        else:
30655 
          iprot.skip(ftype)
30656 
      elif fid == 5:
30657 
        if ftype == TType.STRING:
30658 
          self.state = iprot.readString();
30659 
        else:
30660 
          iprot.skip(ftype)
30661 
      elif fid == 6:
30662 
        if ftype == TType.STRING:
30663 
          self.pin = iprot.readString();
30664 
        else:
30665 
          iprot.skip(ftype)
30666 
      else:
30667 
        iprot.skip(ftype)
30668 
      iprot.readFieldEnd()
30669 
    iprot.readStructEnd()
30670 
 
30671 
  def write(self, oprot):
30672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30674 
      return
30675 
    oprot.writeStructBegin('changeShippingAddress_args')
30676 
    if self.orderId is not None:
30677 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30678 
      oprot.writeI64(self.orderId)
30679 
      oprot.writeFieldEnd()
30680 
    if self.line1 is not None:
30681 
      oprot.writeFieldBegin('line1', TType.STRING, 2)
30682 
      oprot.writeString(self.line1)
30683 
      oprot.writeFieldEnd()
30684 
    if self.line2 is not None:
30685 
      oprot.writeFieldBegin('line2', TType.STRING, 3)
30686 
      oprot.writeString(self.line2)
30687 
      oprot.writeFieldEnd()
30688 
    if self.city is not None:
30689 
      oprot.writeFieldBegin('city', TType.STRING, 4)
30690 
      oprot.writeString(self.city)
30691 
      oprot.writeFieldEnd()
30692 
    if self.state is not None:
30693 
      oprot.writeFieldBegin('state', TType.STRING, 5)
30694 
      oprot.writeString(self.state)
30695 
      oprot.writeFieldEnd()
30696 
    if self.pin is not None:
30697 
      oprot.writeFieldBegin('pin', TType.STRING, 6)
30698 
      oprot.writeString(self.pin)
30699 
      oprot.writeFieldEnd()
30700 
    oprot.writeFieldStop()
30701 
    oprot.writeStructEnd()
30702 
 
30703 
  def validate(self):
30704 
    return
30705 
 
30706 
 
30707 
  def __repr__(self):
30708 
    L = ['%s=%r' % (key, value)
30709 
      for key, value in self.__dict__.iteritems()]
30710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30711 
 
30712 
  def __eq__(self, other):
30713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30714 
 
30715 
  def __ne__(self, other):
30716 
    return not (self == other)
30717 
 
30718 
class changeShippingAddress_result:
30719 
  """
30720 
  Attributes:
30721 
   - success
30722 
  """
30723 
 
30724 
  thrift_spec = (
30725 
    (0, TType.BOOL, 'success', None, None, ), # 0
30726 
  )
30727 
 
30728 
  def __init__(self, success=None,):
30729 
    self.success = success
30730 
 
30731 
  def read(self, iprot):
30732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30734 
      return
30735 
    iprot.readStructBegin()
30736 
    while True:
30737 
      (fname, ftype, fid) = iprot.readFieldBegin()
30738 
      if ftype == TType.STOP:
30739 
        break
30740 
      if fid == 0:
30741 
        if ftype == TType.BOOL:
30742 
          self.success = iprot.readBool();
30743 
        else:
30744 
          iprot.skip(ftype)
30745 
      else:
30746 
        iprot.skip(ftype)
30747 
      iprot.readFieldEnd()
30748 
    iprot.readStructEnd()
30749 
 
30750 
  def write(self, oprot):
30751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30753 
      return
30754 
    oprot.writeStructBegin('changeShippingAddress_result')
30755 
    if self.success is not None:
30756 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30757 
      oprot.writeBool(self.success)
30758 
      oprot.writeFieldEnd()
30759 
    oprot.writeFieldStop()
30760 
    oprot.writeStructEnd()
30761 
 
30762 
  def validate(self):
30763 
    return
30764 
 
30765 
 
30766 
  def __repr__(self):
30767 
    L = ['%s=%r' % (key, value)
30768 
      for key, value in self.__dict__.iteritems()]
30769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30770 
 
30771 
  def __eq__(self, other):
30772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30773 
 
30774 
  def __ne__(self, other):
30775 
    return not (self == other)
6988 rajveer 30776 
 
30777 
class retrieveInvoice_args:
30778 
  """
30779 
  Attributes:
30780 
   - orderId
7075 rajveer 30781 
   - userId
6988 rajveer 30782 
  """
30783 
 
30784 
  thrift_spec = (
30785 
    None, # 0
30786 
    (1, TType.I64, 'orderId', None, None, ), # 1
7075 rajveer 30787 
    (2, TType.I64, 'userId', None, None, ), # 2
6988 rajveer 30788 
  )
30789 
 
7075 rajveer 30790 
  def __init__(self, orderId=None, userId=None,):
6988 rajveer 30791 
    self.orderId = orderId
7075 rajveer 30792 
    self.userId = userId
6988 rajveer 30793 
 
30794 
  def read(self, iprot):
30795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30797 
      return
30798 
    iprot.readStructBegin()
30799 
    while True:
30800 
      (fname, ftype, fid) = iprot.readFieldBegin()
30801 
      if ftype == TType.STOP:
30802 
        break
30803 
      if fid == 1:
30804 
        if ftype == TType.I64:
30805 
          self.orderId = iprot.readI64();
30806 
        else:
30807 
          iprot.skip(ftype)
7075 rajveer 30808 
      elif fid == 2:
30809 
        if ftype == TType.I64:
30810 
          self.userId = iprot.readI64();
30811 
        else:
30812 
          iprot.skip(ftype)
6988 rajveer 30813 
      else:
30814 
        iprot.skip(ftype)
30815 
      iprot.readFieldEnd()
30816 
    iprot.readStructEnd()
30817 
 
30818 
  def write(self, oprot):
30819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30821 
      return
30822 
    oprot.writeStructBegin('retrieveInvoice_args')
30823 
    if self.orderId is not None:
30824 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30825 
      oprot.writeI64(self.orderId)
30826 
      oprot.writeFieldEnd()
7075 rajveer 30827 
    if self.userId is not None:
30828 
      oprot.writeFieldBegin('userId', TType.I64, 2)
30829 
      oprot.writeI64(self.userId)
30830 
      oprot.writeFieldEnd()
6988 rajveer 30831 
    oprot.writeFieldStop()
30832 
    oprot.writeStructEnd()
30833 
 
30834 
  def validate(self):
30835 
    return
30836 
 
30837 
 
30838 
  def __repr__(self):
30839 
    L = ['%s=%r' % (key, value)
30840 
      for key, value in self.__dict__.iteritems()]
30841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30842 
 
30843 
  def __eq__(self, other):
30844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30845 
 
30846 
  def __ne__(self, other):
30847 
    return not (self == other)
30848 
 
30849 
class retrieveInvoice_result:
30850 
  """
30851 
  Attributes:
30852 
   - success
30853 
  """
30854 
 
30855 
  thrift_spec = (
30856 
    (0, TType.STRING, 'success', None, None, ), # 0
30857 
  )
30858 
 
30859 
  def __init__(self, success=None,):
30860 
    self.success = success
30861 
 
30862 
  def read(self, iprot):
30863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30865 
      return
30866 
    iprot.readStructBegin()
30867 
    while True:
30868 
      (fname, ftype, fid) = iprot.readFieldBegin()
30869 
      if ftype == TType.STOP:
30870 
        break
30871 
      if fid == 0:
30872 
        if ftype == TType.STRING:
30873 
          self.success = iprot.readString();
30874 
        else:
30875 
          iprot.skip(ftype)
30876 
      else:
30877 
        iprot.skip(ftype)
30878 
      iprot.readFieldEnd()
30879 
    iprot.readStructEnd()
30880 
 
30881 
  def write(self, oprot):
30882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30884 
      return
30885 
    oprot.writeStructBegin('retrieveInvoice_result')
30886 
    if self.success is not None:
30887 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30888 
      oprot.writeString(self.success)
30889 
      oprot.writeFieldEnd()
30890 
    oprot.writeFieldStop()
30891 
    oprot.writeStructEnd()
30892 
 
30893 
  def validate(self):
30894 
    return
30895 
 
30896 
 
30897 
  def __repr__(self):
30898 
    L = ['%s=%r' % (key, value)
30899 
      for key, value in self.__dict__.iteritems()]
30900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30901 
 
30902 
  def __eq__(self, other):
30903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30904 
 
30905 
  def __ne__(self, other):
30906 
    return not (self == other)
7026 rajveer 30907 
 
30908 
class receiveUpdatesForRedExpress_args:
30909 
  """
30910 
  Attributes:
30911 
   - awbNumber
30912 
  """
30913 
 
30914 
  thrift_spec = (
30915 
    None, # 0
30916 
    (1, TType.STRING, 'awbNumber', None, None, ), # 1
30917 
  )
30918 
 
30919 
  def __init__(self, awbNumber=None,):
30920 
    self.awbNumber = awbNumber
30921 
 
30922 
  def read(self, iprot):
30923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30925 
      return
30926 
    iprot.readStructBegin()
30927 
    while True:
30928 
      (fname, ftype, fid) = iprot.readFieldBegin()
30929 
      if ftype == TType.STOP:
30930 
        break
30931 
      if fid == 1:
30932 
        if ftype == TType.STRING:
30933 
          self.awbNumber = iprot.readString();
30934 
        else:
30935 
          iprot.skip(ftype)
30936 
      else:
30937 
        iprot.skip(ftype)
30938 
      iprot.readFieldEnd()
30939 
    iprot.readStructEnd()
30940 
 
30941 
  def write(self, oprot):
30942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30944 
      return
30945 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_args')
30946 
    if self.awbNumber is not None:
30947 
      oprot.writeFieldBegin('awbNumber', TType.STRING, 1)
30948 
      oprot.writeString(self.awbNumber)
30949 
      oprot.writeFieldEnd()
30950 
    oprot.writeFieldStop()
30951 
    oprot.writeStructEnd()
30952 
 
30953 
  def validate(self):
30954 
    return
30955 
 
30956 
 
30957 
  def __repr__(self):
30958 
    L = ['%s=%r' % (key, value)
30959 
      for key, value in self.__dict__.iteritems()]
30960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30961 
 
30962 
  def __eq__(self, other):
30963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30964 
 
30965 
  def __ne__(self, other):
30966 
    return not (self == other)
30967 
 
30968 
class receiveUpdatesForRedExpress_result:
30969 
  """
30970 
  Attributes:
30971 
   - success
30972 
  """
30973 
 
30974 
  thrift_spec = (
30975 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
30976 
  )
30977 
 
30978 
  def __init__(self, success=None,):
30979 
    self.success = success
30980 
 
30981 
  def read(self, iprot):
30982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30984 
      return
30985 
    iprot.readStructBegin()
30986 
    while True:
30987 
      (fname, ftype, fid) = iprot.readFieldBegin()
30988 
      if ftype == TType.STOP:
30989 
        break
30990 
      if fid == 0:
30991 
        if ftype == TType.LIST:
30992 
          self.success = []
30993 
          (_etype733, _size730) = iprot.readListBegin()
30994 
          for _i734 in xrange(_size730):
30995 
            _elem735 = iprot.readString();
30996 
            self.success.append(_elem735)
30997 
          iprot.readListEnd()
30998 
        else:
30999 
          iprot.skip(ftype)
31000 
      else:
31001 
        iprot.skip(ftype)
31002 
      iprot.readFieldEnd()
31003 
    iprot.readStructEnd()
31004 
 
31005 
  def write(self, oprot):
31006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31008 
      return
31009 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_result')
31010 
    if self.success is not None:
31011 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31012 
      oprot.writeListBegin(TType.STRING, len(self.success))
31013 
      for iter736 in self.success:
31014 
        oprot.writeString(iter736)
31015 
      oprot.writeListEnd()
31016 
      oprot.writeFieldEnd()
31017 
    oprot.writeFieldStop()
31018 
    oprot.writeStructEnd()
31019 
 
31020 
  def validate(self):
31021 
    return
31022 
 
31023 
 
31024 
  def __repr__(self):
31025 
    L = ['%s=%r' % (key, value)
31026 
      for key, value in self.__dict__.iteritems()]
31027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31028 
 
31029 
  def __eq__(self, other):
31030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31031 
 
31032 
  def __ne__(self, other):
31033 
    return not (self == other)
7073 anupam.sin 31034 
 
31035 
class createRechargeTransaction_args:
31036 
  """
31037 
  Attributes:
31038 
   - thriftRechargeTransaction
31039 
  """
31040 
 
31041 
  thrift_spec = (
31042 
    None, # 0
31043 
    (1, TType.STRUCT, 'thriftRechargeTransaction', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 1
31044 
  )
31045 
 
31046 
  def __init__(self, thriftRechargeTransaction=None,):
31047 
    self.thriftRechargeTransaction = thriftRechargeTransaction
31048 
 
31049 
  def read(self, iprot):
31050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31052 
      return
31053 
    iprot.readStructBegin()
31054 
    while True:
31055 
      (fname, ftype, fid) = iprot.readFieldBegin()
31056 
      if ftype == TType.STOP:
31057 
        break
31058 
      if fid == 1:
31059 
        if ftype == TType.STRUCT:
31060 
          self.thriftRechargeTransaction = RechargeTransaction()
31061 
          self.thriftRechargeTransaction.read(iprot)
31062 
        else:
31063 
          iprot.skip(ftype)
31064 
      else:
31065 
        iprot.skip(ftype)
31066 
      iprot.readFieldEnd()
31067 
    iprot.readStructEnd()
31068 
 
31069 
  def write(self, oprot):
31070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31072 
      return
31073 
    oprot.writeStructBegin('createRechargeTransaction_args')
31074 
    if self.thriftRechargeTransaction is not None:
31075 
      oprot.writeFieldBegin('thriftRechargeTransaction', TType.STRUCT, 1)
31076 
      self.thriftRechargeTransaction.write(oprot)
31077 
      oprot.writeFieldEnd()
31078 
    oprot.writeFieldStop()
31079 
    oprot.writeStructEnd()
31080 
 
31081 
  def validate(self):
31082 
    return
31083 
 
31084 
 
31085 
  def __repr__(self):
31086 
    L = ['%s=%r' % (key, value)
31087 
      for key, value in self.__dict__.iteritems()]
31088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31089 
 
31090 
  def __eq__(self, other):
31091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31092 
 
31093 
  def __ne__(self, other):
31094 
    return not (self == other)
31095 
 
31096 
class createRechargeTransaction_result:
31097 
  """
31098 
  Attributes:
31099 
   - success
31100 
  """
31101 
 
31102 
  thrift_spec = (
31103 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
31104 
  )
31105 
 
31106 
  def __init__(self, success=None,):
31107 
    self.success = success
31108 
 
31109 
  def read(self, iprot):
31110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31112 
      return
31113 
    iprot.readStructBegin()
31114 
    while True:
31115 
      (fname, ftype, fid) = iprot.readFieldBegin()
31116 
      if ftype == TType.STOP:
31117 
        break
31118 
      if fid == 0:
31119 
        if ftype == TType.STRUCT:
31120 
          self.success = RechargeTransaction()
31121 
          self.success.read(iprot)
31122 
        else:
31123 
          iprot.skip(ftype)
31124 
      else:
31125 
        iprot.skip(ftype)
31126 
      iprot.readFieldEnd()
31127 
    iprot.readStructEnd()
31128 
 
31129 
  def write(self, oprot):
31130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31132 
      return
31133 
    oprot.writeStructBegin('createRechargeTransaction_result')
31134 
    if self.success is not None:
31135 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31136 
      self.success.write(oprot)
31137 
      oprot.writeFieldEnd()
31138 
    oprot.writeFieldStop()
31139 
    oprot.writeStructEnd()
31140 
 
31141 
  def validate(self):
31142 
    return
31143 
 
31144 
 
31145 
  def __repr__(self):
31146 
    L = ['%s=%r' % (key, value)
31147 
      for key, value in self.__dict__.iteritems()]
31148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31149 
 
31150 
  def __eq__(self, other):
31151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31152 
 
31153 
  def __ne__(self, other):
31154 
    return not (self == other)
7080 anupam.sin 31155 
 
7085 rajveer 31156 
class getRechargeTransactions_args:
31157 
  """
31158 
  Attributes:
31159 
   - storeId
31160 
  """
31161 
 
31162 
  thrift_spec = (
31163 
    None, # 0
31164 
    (1, TType.I64, 'storeId', None, None, ), # 1
31165 
  )
31166 
 
31167 
  def __init__(self, storeId=None,):
31168 
    self.storeId = storeId
31169 
 
31170 
  def read(self, iprot):
31171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31173 
      return
31174 
    iprot.readStructBegin()
31175 
    while True:
31176 
      (fname, ftype, fid) = iprot.readFieldBegin()
31177 
      if ftype == TType.STOP:
31178 
        break
31179 
      if fid == 1:
31180 
        if ftype == TType.I64:
31181 
          self.storeId = iprot.readI64();
31182 
        else:
31183 
          iprot.skip(ftype)
31184 
      else:
31185 
        iprot.skip(ftype)
31186 
      iprot.readFieldEnd()
31187 
    iprot.readStructEnd()
31188 
 
31189 
  def write(self, oprot):
31190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31192 
      return
31193 
    oprot.writeStructBegin('getRechargeTransactions_args')
31194 
    if self.storeId is not None:
31195 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
31196 
      oprot.writeI64(self.storeId)
31197 
      oprot.writeFieldEnd()
31198 
    oprot.writeFieldStop()
31199 
    oprot.writeStructEnd()
31200 
 
31201 
  def validate(self):
31202 
    return
31203 
 
31204 
 
31205 
  def __repr__(self):
31206 
    L = ['%s=%r' % (key, value)
31207 
      for key, value in self.__dict__.iteritems()]
31208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31209 
 
31210 
  def __eq__(self, other):
31211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31212 
 
31213 
  def __ne__(self, other):
31214 
    return not (self == other)
31215 
 
31216 
class getRechargeTransactions_result:
31217 
  """
31218 
  Attributes:
31219 
   - success
31220 
  """
31221 
 
31222 
  thrift_spec = (
31223 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
31224 
  )
31225 
 
31226 
  def __init__(self, success=None,):
31227 
    self.success = success
31228 
 
31229 
  def read(self, iprot):
31230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31232 
      return
31233 
    iprot.readStructBegin()
31234 
    while True:
31235 
      (fname, ftype, fid) = iprot.readFieldBegin()
31236 
      if ftype == TType.STOP:
31237 
        break
31238 
      if fid == 0:
31239 
        if ftype == TType.LIST:
31240 
          self.success = []
31241 
          (_etype740, _size737) = iprot.readListBegin()
31242 
          for _i741 in xrange(_size737):
31243 
            _elem742 = RechargeTransaction()
31244 
            _elem742.read(iprot)
31245 
            self.success.append(_elem742)
31246 
          iprot.readListEnd()
31247 
        else:
31248 
          iprot.skip(ftype)
31249 
      else:
31250 
        iprot.skip(ftype)
31251 
      iprot.readFieldEnd()
31252 
    iprot.readStructEnd()
31253 
 
31254 
  def write(self, oprot):
31255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31257 
      return
31258 
    oprot.writeStructBegin('getRechargeTransactions_result')
31259 
    if self.success is not None:
31260 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31261 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
31262 
      for iter743 in self.success:
31263 
        iter743.write(oprot)
31264 
      oprot.writeListEnd()
31265 
      oprot.writeFieldEnd()
31266 
    oprot.writeFieldStop()
31267 
    oprot.writeStructEnd()
31268 
 
31269 
  def validate(self):
31270 
    return
31271 
 
31272 
 
31273 
  def __repr__(self):
31274 
    L = ['%s=%r' % (key, value)
31275 
      for key, value in self.__dict__.iteritems()]
31276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31277 
 
31278 
  def __eq__(self, other):
31279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31280 
 
31281 
  def __ne__(self, other):
31282 
    return not (self == other)
31283 
 
7151 amit.gupta 31284 
class getRechargeTrans_args:
31285 
  """
31286 
  Attributes:
31287 
   - storeId
31288 
   - startDate
31289 
   - endDate
31290 
   - status
31291 
  """
31292 
 
31293 
  thrift_spec = (
31294 
    None, # 0
31295 
    (1, TType.I64, 'storeId', None, None, ), # 1
31296 
    (2, TType.I64, 'startDate', None, None, ), # 2
31297 
    (3, TType.I64, 'endDate', None, None, ), # 3
31298 
    (4, TType.I32, 'status', None, None, ), # 4
31299 
  )
31300 
 
31301 
  def __init__(self, storeId=None, startDate=None, endDate=None, status=None,):
31302 
    self.storeId = storeId
31303 
    self.startDate = startDate
31304 
    self.endDate = endDate
31305 
    self.status = status
31306 
 
31307 
  def read(self, iprot):
31308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31310 
      return
31311 
    iprot.readStructBegin()
31312 
    while True:
31313 
      (fname, ftype, fid) = iprot.readFieldBegin()
31314 
      if ftype == TType.STOP:
31315 
        break
31316 
      if fid == 1:
31317 
        if ftype == TType.I64:
31318 
          self.storeId = iprot.readI64();
31319 
        else:
31320 
          iprot.skip(ftype)
31321 
      elif fid == 2:
31322 
        if ftype == TType.I64:
31323 
          self.startDate = iprot.readI64();
31324 
        else:
31325 
          iprot.skip(ftype)
31326 
      elif fid == 3:
31327 
        if ftype == TType.I64:
31328 
          self.endDate = iprot.readI64();
31329 
        else:
31330 
          iprot.skip(ftype)
31331 
      elif fid == 4:
31332 
        if ftype == TType.I32:
31333 
          self.status = iprot.readI32();
31334 
        else:
31335 
          iprot.skip(ftype)
31336 
      else:
31337 
        iprot.skip(ftype)
31338 
      iprot.readFieldEnd()
31339 
    iprot.readStructEnd()
31340 
 
31341 
  def write(self, oprot):
31342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31344 
      return
31345 
    oprot.writeStructBegin('getRechargeTrans_args')
31346 
    if self.storeId is not None:
31347 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
31348 
      oprot.writeI64(self.storeId)
31349 
      oprot.writeFieldEnd()
31350 
    if self.startDate is not None:
31351 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
31352 
      oprot.writeI64(self.startDate)
31353 
      oprot.writeFieldEnd()
31354 
    if self.endDate is not None:
31355 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
31356 
      oprot.writeI64(self.endDate)
31357 
      oprot.writeFieldEnd()
31358 
    if self.status is not None:
31359 
      oprot.writeFieldBegin('status', TType.I32, 4)
31360 
      oprot.writeI32(self.status)
31361 
      oprot.writeFieldEnd()
31362 
    oprot.writeFieldStop()
31363 
    oprot.writeStructEnd()
31364 
 
31365 
  def validate(self):
31366 
    return
31367 
 
31368 
 
31369 
  def __repr__(self):
31370 
    L = ['%s=%r' % (key, value)
31371 
      for key, value in self.__dict__.iteritems()]
31372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31373 
 
31374 
  def __eq__(self, other):
31375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31376 
 
31377 
  def __ne__(self, other):
31378 
    return not (self == other)
31379 
 
31380 
class getRechargeTrans_result:
31381 
  """
31382 
  Attributes:
31383 
   - success
31384 
  """
31385 
 
31386 
  thrift_spec = (
31387 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
31388 
  )
31389 
 
31390 
  def __init__(self, success=None,):
31391 
    self.success = success
31392 
 
31393 
  def read(self, iprot):
31394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31396 
      return
31397 
    iprot.readStructBegin()
31398 
    while True:
31399 
      (fname, ftype, fid) = iprot.readFieldBegin()
31400 
      if ftype == TType.STOP:
31401 
        break
31402 
      if fid == 0:
31403 
        if ftype == TType.LIST:
31404 
          self.success = []
31405 
          (_etype747, _size744) = iprot.readListBegin()
31406 
          for _i748 in xrange(_size744):
31407 
            _elem749 = RechargeTransaction()
31408 
            _elem749.read(iprot)
31409 
            self.success.append(_elem749)
31410 
          iprot.readListEnd()
31411 
        else:
31412 
          iprot.skip(ftype)
31413 
      else:
31414 
        iprot.skip(ftype)
31415 
      iprot.readFieldEnd()
31416 
    iprot.readStructEnd()
31417 
 
31418 
  def write(self, oprot):
31419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31421 
      return
31422 
    oprot.writeStructBegin('getRechargeTrans_result')
31423 
    if self.success is not None:
31424 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31425 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
31426 
      for iter750 in self.success:
31427 
        iter750.write(oprot)
31428 
      oprot.writeListEnd()
31429 
      oprot.writeFieldEnd()
31430 
    oprot.writeFieldStop()
31431 
    oprot.writeStructEnd()
31432 
 
31433 
  def validate(self):
31434 
    return
31435 
 
31436 
 
31437 
  def __repr__(self):
31438 
    L = ['%s=%r' % (key, value)
31439 
      for key, value in self.__dict__.iteritems()]
31440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31441 
 
31442 
  def __eq__(self, other):
31443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31444 
 
31445 
  def __ne__(self, other):
31446 
    return not (self == other)
31447 
 
7080 anupam.sin 31448 
class getRechargeTransaction_args:
31449 
  """
31450 
  Attributes:
31451 
   - rechargeId
31452 
  """
31453 
 
31454 
  thrift_spec = (
31455 
    None, # 0
31456 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
31457 
  )
31458 
 
31459 
  def __init__(self, rechargeId=None,):
31460 
    self.rechargeId = rechargeId
31461 
 
31462 
  def read(self, iprot):
31463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31465 
      return
31466 
    iprot.readStructBegin()
31467 
    while True:
31468 
      (fname, ftype, fid) = iprot.readFieldBegin()
31469 
      if ftype == TType.STOP:
31470 
        break
31471 
      if fid == 1:
31472 
        if ftype == TType.I64:
31473 
          self.rechargeId = iprot.readI64();
31474 
        else:
31475 
          iprot.skip(ftype)
31476 
      else:
31477 
        iprot.skip(ftype)
31478 
      iprot.readFieldEnd()
31479 
    iprot.readStructEnd()
31480 
 
31481 
  def write(self, oprot):
31482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31484 
      return
31485 
    oprot.writeStructBegin('getRechargeTransaction_args')
31486 
    if self.rechargeId is not None:
31487 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
31488 
      oprot.writeI64(self.rechargeId)
31489 
      oprot.writeFieldEnd()
31490 
    oprot.writeFieldStop()
31491 
    oprot.writeStructEnd()
31492 
 
31493 
  def validate(self):
31494 
    return
31495 
 
31496 
 
31497 
  def __repr__(self):
31498 
    L = ['%s=%r' % (key, value)
31499 
      for key, value in self.__dict__.iteritems()]
31500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31501 
 
31502 
  def __eq__(self, other):
31503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31504 
 
31505 
  def __ne__(self, other):
31506 
    return not (self == other)
31507 
 
31508 
class getRechargeTransaction_result:
31509 
  """
31510 
  Attributes:
31511 
   - success
31512 
  """
31513 
 
31514 
  thrift_spec = (
31515 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
31516 
  )
31517 
 
31518 
  def __init__(self, success=None,):
31519 
    self.success = success
31520 
 
31521 
  def read(self, iprot):
31522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31524 
      return
31525 
    iprot.readStructBegin()
31526 
    while True:
31527 
      (fname, ftype, fid) = iprot.readFieldBegin()
31528 
      if ftype == TType.STOP:
31529 
        break
31530 
      if fid == 0:
31531 
        if ftype == TType.STRUCT:
31532 
          self.success = RechargeTransaction()
31533 
          self.success.read(iprot)
31534 
        else:
31535 
          iprot.skip(ftype)
31536 
      else:
31537 
        iprot.skip(ftype)
31538 
      iprot.readFieldEnd()
31539 
    iprot.readStructEnd()
31540 
 
31541 
  def write(self, oprot):
31542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31544 
      return
31545 
    oprot.writeStructBegin('getRechargeTransaction_result')
31546 
    if self.success is not None:
31547 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31548 
      self.success.write(oprot)
31549 
      oprot.writeFieldEnd()
31550 
    oprot.writeFieldStop()
31551 
    oprot.writeStructEnd()
31552 
 
31553 
  def validate(self):
31554 
    return
31555 
 
31556 
 
31557 
  def __repr__(self):
31558 
    L = ['%s=%r' % (key, value)
31559 
      for key, value in self.__dict__.iteritems()]
31560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31561 
 
31562 
  def __eq__(self, other):
31563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31564 
 
31565 
  def __ne__(self, other):
31566 
    return not (self == other)
31567 
 
31568 
class getFRCs_args:
31569 
  """
31570 
  Attributes:
31571 
   - circleId
31572 
   - operatorId
31573 
  """
31574 
 
31575 
  thrift_spec = (
31576 
    None, # 0
31577 
    (1, TType.I64, 'circleId', None, None, ), # 1
31578 
    (2, TType.I64, 'operatorId', None, None, ), # 2
31579 
  )
31580 
 
31581 
  def __init__(self, circleId=None, operatorId=None,):
31582 
    self.circleId = circleId
31583 
    self.operatorId = operatorId
31584 
 
31585 
  def read(self, iprot):
31586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31588 
      return
31589 
    iprot.readStructBegin()
31590 
    while True:
31591 
      (fname, ftype, fid) = iprot.readFieldBegin()
31592 
      if ftype == TType.STOP:
31593 
        break
31594 
      if fid == 1:
31595 
        if ftype == TType.I64:
31596 
          self.circleId = iprot.readI64();
31597 
        else:
31598 
          iprot.skip(ftype)
31599 
      elif fid == 2:
31600 
        if ftype == TType.I64:
31601 
          self.operatorId = iprot.readI64();
31602 
        else:
31603 
          iprot.skip(ftype)
31604 
      else:
31605 
        iprot.skip(ftype)
31606 
      iprot.readFieldEnd()
31607 
    iprot.readStructEnd()
31608 
 
31609 
  def write(self, oprot):
31610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31612 
      return
31613 
    oprot.writeStructBegin('getFRCs_args')
31614 
    if self.circleId is not None:
31615 
      oprot.writeFieldBegin('circleId', TType.I64, 1)
31616 
      oprot.writeI64(self.circleId)
31617 
      oprot.writeFieldEnd()
31618 
    if self.operatorId is not None:
31619 
      oprot.writeFieldBegin('operatorId', TType.I64, 2)
31620 
      oprot.writeI64(self.operatorId)
31621 
      oprot.writeFieldEnd()
31622 
    oprot.writeFieldStop()
31623 
    oprot.writeStructEnd()
31624 
 
31625 
  def validate(self):
31626 
    return
31627 
 
31628 
 
31629 
  def __repr__(self):
31630 
    L = ['%s=%r' % (key, value)
31631 
      for key, value in self.__dict__.iteritems()]
31632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31633 
 
31634 
  def __eq__(self, other):
31635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31636 
 
31637 
  def __ne__(self, other):
31638 
    return not (self == other)
31639 
 
31640 
class getFRCs_result:
31641 
  """
31642 
  Attributes:
31643 
   - success
31644 
  """
31645 
 
31646 
  thrift_spec = (
31647 
    (0, TType.LIST, 'success', (TType.STRUCT,(FRC, FRC.thrift_spec)), None, ), # 0
31648 
  )
31649 
 
31650 
  def __init__(self, success=None,):
31651 
    self.success = success
31652 
 
31653 
  def read(self, iprot):
31654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31656 
      return
31657 
    iprot.readStructBegin()
31658 
    while True:
31659 
      (fname, ftype, fid) = iprot.readFieldBegin()
31660 
      if ftype == TType.STOP:
31661 
        break
31662 
      if fid == 0:
31663 
        if ftype == TType.LIST:
31664 
          self.success = []
7151 amit.gupta 31665 
          (_etype754, _size751) = iprot.readListBegin()
31666 
          for _i755 in xrange(_size751):
31667 
            _elem756 = FRC()
31668 
            _elem756.read(iprot)
31669 
            self.success.append(_elem756)
7080 anupam.sin 31670 
          iprot.readListEnd()
31671 
        else:
31672 
          iprot.skip(ftype)
31673 
      else:
31674 
        iprot.skip(ftype)
31675 
      iprot.readFieldEnd()
31676 
    iprot.readStructEnd()
31677 
 
31678 
  def write(self, oprot):
31679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31681 
      return
31682 
    oprot.writeStructBegin('getFRCs_result')
31683 
    if self.success is not None:
31684 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31685 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7151 amit.gupta 31686 
      for iter757 in self.success:
31687 
        iter757.write(oprot)
7080 anupam.sin 31688 
      oprot.writeListEnd()
31689 
      oprot.writeFieldEnd()
31690 
    oprot.writeFieldStop()
31691 
    oprot.writeStructEnd()
31692 
 
31693 
  def validate(self):
31694 
    return
31695 
 
31696 
 
31697 
  def __repr__(self):
31698 
    L = ['%s=%r' % (key, value)
31699 
      for key, value in self.__dict__.iteritems()]
31700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31701 
 
31702 
  def __eq__(self, other):
31703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31704 
 
31705 
  def __ne__(self, other):
31706 
    return not (self == other)
7096 anupam.sin 31707 
 
31708 
class getHotspotStore_args:
31709 
  """
31710 
  Attributes:
31711 
   - id
31712 
   - hotspotid
31713 
  """
31714 
 
31715 
  thrift_spec = (
31716 
    None, # 0
31717 
    (1, TType.I64, 'id', None, None, ), # 1
31718 
    (2, TType.STRING, 'hotspotid', None, None, ), # 2
31719 
  )
31720 
 
31721 
  def __init__(self, id=None, hotspotid=None,):
31722 
    self.id = id
31723 
    self.hotspotid = hotspotid
31724 
 
31725 
  def read(self, iprot):
31726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31728 
      return
31729 
    iprot.readStructBegin()
31730 
    while True:
31731 
      (fname, ftype, fid) = iprot.readFieldBegin()
31732 
      if ftype == TType.STOP:
31733 
        break
31734 
      if fid == 1:
31735 
        if ftype == TType.I64:
31736 
          self.id = iprot.readI64();
31737 
        else:
31738 
          iprot.skip(ftype)
31739 
      elif fid == 2:
31740 
        if ftype == TType.STRING:
31741 
          self.hotspotid = iprot.readString();
31742 
        else:
31743 
          iprot.skip(ftype)
31744 
      else:
31745 
        iprot.skip(ftype)
31746 
      iprot.readFieldEnd()
31747 
    iprot.readStructEnd()
31748 
 
31749 
  def write(self, oprot):
31750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31752 
      return
31753 
    oprot.writeStructBegin('getHotspotStore_args')
31754 
    if self.id is not None:
31755 
      oprot.writeFieldBegin('id', TType.I64, 1)
31756 
      oprot.writeI64(self.id)
31757 
      oprot.writeFieldEnd()
31758 
    if self.hotspotid is not None:
31759 
      oprot.writeFieldBegin('hotspotid', TType.STRING, 2)
31760 
      oprot.writeString(self.hotspotid)
31761 
      oprot.writeFieldEnd()
31762 
    oprot.writeFieldStop()
31763 
    oprot.writeStructEnd()
31764 
 
31765 
  def validate(self):
31766 
    return
31767 
 
31768 
 
31769 
  def __repr__(self):
31770 
    L = ['%s=%r' % (key, value)
31771 
      for key, value in self.__dict__.iteritems()]
31772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31773 
 
31774 
  def __eq__(self, other):
31775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31776 
 
31777 
  def __ne__(self, other):
31778 
    return not (self == other)
31779 
 
31780 
class getHotspotStore_result:
31781 
  """
31782 
  Attributes:
31783 
   - success
31784 
  """
31785 
 
31786 
  thrift_spec = (
31787 
    (0, TType.STRUCT, 'success', (HotspotStore, HotspotStore.thrift_spec), None, ), # 0
31788 
  )
31789 
 
31790 
  def __init__(self, success=None,):
31791 
    self.success = success
31792 
 
31793 
  def read(self, iprot):
31794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31796 
      return
31797 
    iprot.readStructBegin()
31798 
    while True:
31799 
      (fname, ftype, fid) = iprot.readFieldBegin()
31800 
      if ftype == TType.STOP:
31801 
        break
31802 
      if fid == 0:
31803 
        if ftype == TType.STRUCT:
31804 
          self.success = HotspotStore()
31805 
          self.success.read(iprot)
31806 
        else:
31807 
          iprot.skip(ftype)
31808 
      else:
31809 
        iprot.skip(ftype)
31810 
      iprot.readFieldEnd()
31811 
    iprot.readStructEnd()
31812 
 
31813 
  def write(self, oprot):
31814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31816 
      return
31817 
    oprot.writeStructBegin('getHotspotStore_result')
31818 
    if self.success is not None:
31819 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31820 
      self.success.write(oprot)
31821 
      oprot.writeFieldEnd()
31822 
    oprot.writeFieldStop()
31823 
    oprot.writeStructEnd()
31824 
 
31825 
  def validate(self):
31826 
    return
31827 
 
31828 
 
31829 
  def __repr__(self):
31830 
    L = ['%s=%r' % (key, value)
31831 
      for key, value in self.__dict__.iteritems()]
31832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31833 
 
31834 
  def __eq__(self, other):
31835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31836 
 
31837 
  def __ne__(self, other):
31838 
    return not (self == other)
31839 
 
31840 
class getTelecomCircle_args:
31841 
  """
31842 
  Attributes:
31843 
   - id
31844 
   - code
31845 
  """
31846 
 
31847 
  thrift_spec = (
31848 
    None, # 0
31849 
    (1, TType.I64, 'id', None, None, ), # 1
31850 
    (2, TType.STRING, 'code', None, None, ), # 2
31851 
  )
31852 
 
31853 
  def __init__(self, id=None, code=None,):
31854 
    self.id = id
31855 
    self.code = code
31856 
 
31857 
  def read(self, iprot):
31858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31860 
      return
31861 
    iprot.readStructBegin()
31862 
    while True:
31863 
      (fname, ftype, fid) = iprot.readFieldBegin()
31864 
      if ftype == TType.STOP:
31865 
        break
31866 
      if fid == 1:
31867 
        if ftype == TType.I64:
31868 
          self.id = iprot.readI64();
31869 
        else:
31870 
          iprot.skip(ftype)
31871 
      elif fid == 2:
31872 
        if ftype == TType.STRING:
31873 
          self.code = iprot.readString();
31874 
        else:
31875 
          iprot.skip(ftype)
31876 
      else:
31877 
        iprot.skip(ftype)
31878 
      iprot.readFieldEnd()
31879 
    iprot.readStructEnd()
31880 
 
31881 
  def write(self, oprot):
31882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31884 
      return
31885 
    oprot.writeStructBegin('getTelecomCircle_args')
31886 
    if self.id is not None:
31887 
      oprot.writeFieldBegin('id', TType.I64, 1)
31888 
      oprot.writeI64(self.id)
31889 
      oprot.writeFieldEnd()
31890 
    if self.code is not None:
31891 
      oprot.writeFieldBegin('code', TType.STRING, 2)
31892 
      oprot.writeString(self.code)
31893 
      oprot.writeFieldEnd()
31894 
    oprot.writeFieldStop()
31895 
    oprot.writeStructEnd()
31896 
 
31897 
  def validate(self):
31898 
    return
31899 
 
31900 
 
31901 
  def __repr__(self):
31902 
    L = ['%s=%r' % (key, value)
31903 
      for key, value in self.__dict__.iteritems()]
31904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31905 
 
31906 
  def __eq__(self, other):
31907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31908 
 
31909 
  def __ne__(self, other):
31910 
    return not (self == other)
31911 
 
31912 
class getTelecomCircle_result:
31913 
  """
31914 
  Attributes:
31915 
   - success
31916 
  """
31917 
 
31918 
  thrift_spec = (
31919 
    (0, TType.STRUCT, 'success', (TelecomCircle, TelecomCircle.thrift_spec), None, ), # 0
31920 
  )
31921 
 
31922 
  def __init__(self, success=None,):
31923 
    self.success = success
31924 
 
31925 
  def read(self, iprot):
31926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31928 
      return
31929 
    iprot.readStructBegin()
31930 
    while True:
31931 
      (fname, ftype, fid) = iprot.readFieldBegin()
31932 
      if ftype == TType.STOP:
31933 
        break
31934 
      if fid == 0:
31935 
        if ftype == TType.STRUCT:
31936 
          self.success = TelecomCircle()
31937 
          self.success.read(iprot)
31938 
        else:
31939 
          iprot.skip(ftype)
31940 
      else:
31941 
        iprot.skip(ftype)
31942 
      iprot.readFieldEnd()
31943 
    iprot.readStructEnd()
31944 
 
31945 
  def write(self, oprot):
31946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31948 
      return
31949 
    oprot.writeStructBegin('getTelecomCircle_result')
31950 
    if self.success is not None:
31951 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31952 
      self.success.write(oprot)
31953 
      oprot.writeFieldEnd()
31954 
    oprot.writeFieldStop()
31955 
    oprot.writeStructEnd()
31956 
 
31957 
  def validate(self):
31958 
    return
31959 
 
31960 
 
31961 
  def __repr__(self):
31962 
    L = ['%s=%r' % (key, value)
31963 
      for key, value in self.__dict__.iteritems()]
31964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31965 
 
31966 
  def __eq__(self, other):
31967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31968 
 
31969 
  def __ne__(self, other):
31970 
    return not (self == other)
7109 anupam.sin 31971 
 
31972 
class retrieveHotspotRechargeInvoice_args:
31973 
  """
31974 
  Attributes:
31975 
   - rechargeId
31976 
  """
31977 
 
31978 
  thrift_spec = (
31979 
    None, # 0
31980 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
31981 
  )
31982 
 
31983 
  def __init__(self, rechargeId=None,):
31984 
    self.rechargeId = rechargeId
31985 
 
31986 
  def read(self, iprot):
31987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31989 
      return
31990 
    iprot.readStructBegin()
31991 
    while True:
31992 
      (fname, ftype, fid) = iprot.readFieldBegin()
31993 
      if ftype == TType.STOP:
31994 
        break
31995 
      if fid == 1:
31996 
        if ftype == TType.I64:
31997 
          self.rechargeId = iprot.readI64();
31998 
        else:
31999 
          iprot.skip(ftype)
32000 
      else:
32001 
        iprot.skip(ftype)
32002 
      iprot.readFieldEnd()
32003 
    iprot.readStructEnd()
32004 
 
32005 
  def write(self, oprot):
32006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32008 
      return
32009 
    oprot.writeStructBegin('retrieveHotspotRechargeInvoice_args')
32010 
    if self.rechargeId is not None:
32011 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
32012 
      oprot.writeI64(self.rechargeId)
32013 
      oprot.writeFieldEnd()
32014 
    oprot.writeFieldStop()
32015 
    oprot.writeStructEnd()
32016 
 
32017 
  def validate(self):
32018 
    return
32019 
 
32020 
 
32021 
  def __repr__(self):
32022 
    L = ['%s=%r' % (key, value)
32023 
      for key, value in self.__dict__.iteritems()]
32024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32025 
 
32026 
  def __eq__(self, other):
32027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32028 
 
32029 
  def __ne__(self, other):
32030 
    return not (self == other)
32031 
 
32032 
class retrieveHotspotRechargeInvoice_result:
32033 
  """
32034 
  Attributes:
32035 
   - success
32036 
  """
32037 
 
32038 
  thrift_spec = (
32039 
    (0, TType.STRING, 'success', None, None, ), # 0
32040 
  )
32041 
 
32042 
  def __init__(self, success=None,):
32043 
    self.success = success
32044 
 
32045 
  def read(self, iprot):
32046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32048 
      return
32049 
    iprot.readStructBegin()
32050 
    while True:
32051 
      (fname, ftype, fid) = iprot.readFieldBegin()
32052 
      if ftype == TType.STOP:
32053 
        break
32054 
      if fid == 0:
32055 
        if ftype == TType.STRING:
32056 
          self.success = iprot.readString();
32057 
        else:
32058 
          iprot.skip(ftype)
32059 
      else:
32060 
        iprot.skip(ftype)
32061 
      iprot.readFieldEnd()
32062 
    iprot.readStructEnd()
32063 
 
32064 
  def write(self, oprot):
32065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32067 
      return
32068 
    oprot.writeStructBegin('retrieveHotspotRechargeInvoice_result')
32069 
    if self.success is not None:
32070 
      oprot.writeFieldBegin('success', TType.STRING, 0)
32071 
      oprot.writeString(self.success)
32072 
      oprot.writeFieldEnd()
32073 
    oprot.writeFieldStop()
32074 
    oprot.writeStructEnd()
32075 
 
32076 
  def validate(self):
32077 
    return
32078 
 
32079 
 
32080 
  def __repr__(self):
32081 
    L = ['%s=%r' % (key, value)
32082 
      for key, value in self.__dict__.iteritems()]
32083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32084 
 
32085 
  def __eq__(self, other):
32086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32087 
 
32088 
  def __ne__(self, other):
32089 
    return not (self == other)
7169 anupam.sin 32090 
 
7190 amar.kumar 32091 
class splitFreebieOrder_args:
32092 
  """
32093 
  Attributes:
32094 
   - orderId
32095 
   - splitReason
32096 
   - shippingDate
32097 
  """
32098 
 
32099 
  thrift_spec = (
32100 
    None, # 0
32101 
    (1, TType.I64, 'orderId', None, None, ), # 1
32102 
    (2, TType.STRING, 'splitReason', None, None, ), # 2
32103 
    (3, TType.I64, 'shippingDate', None, None, ), # 3
32104 
  )
32105 
 
32106 
  def __init__(self, orderId=None, splitReason=None, shippingDate=None,):
32107 
    self.orderId = orderId
32108 
    self.splitReason = splitReason
32109 
    self.shippingDate = shippingDate
32110 
 
32111 
  def read(self, iprot):
32112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32114 
      return
32115 
    iprot.readStructBegin()
32116 
    while True:
32117 
      (fname, ftype, fid) = iprot.readFieldBegin()
32118 
      if ftype == TType.STOP:
32119 
        break
32120 
      if fid == 1:
32121 
        if ftype == TType.I64:
32122 
          self.orderId = iprot.readI64();
32123 
        else:
32124 
          iprot.skip(ftype)
32125 
      elif fid == 2:
32126 
        if ftype == TType.STRING:
32127 
          self.splitReason = iprot.readString();
32128 
        else:
32129 
          iprot.skip(ftype)
32130 
      elif fid == 3:
32131 
        if ftype == TType.I64:
32132 
          self.shippingDate = iprot.readI64();
32133 
        else:
32134 
          iprot.skip(ftype)
32135 
      else:
32136 
        iprot.skip(ftype)
32137 
      iprot.readFieldEnd()
32138 
    iprot.readStructEnd()
32139 
 
32140 
  def write(self, oprot):
32141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32143 
      return
32144 
    oprot.writeStructBegin('splitFreebieOrder_args')
32145 
    if self.orderId is not None:
32146 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
32147 
      oprot.writeI64(self.orderId)
32148 
      oprot.writeFieldEnd()
32149 
    if self.splitReason is not None:
32150 
      oprot.writeFieldBegin('splitReason', TType.STRING, 2)
32151 
      oprot.writeString(self.splitReason)
32152 
      oprot.writeFieldEnd()
32153 
    if self.shippingDate is not None:
32154 
      oprot.writeFieldBegin('shippingDate', TType.I64, 3)
32155 
      oprot.writeI64(self.shippingDate)
32156 
      oprot.writeFieldEnd()
32157 
    oprot.writeFieldStop()
32158 
    oprot.writeStructEnd()
32159 
 
32160 
  def validate(self):
32161 
    return
32162 
 
32163 
 
32164 
  def __repr__(self):
32165 
    L = ['%s=%r' % (key, value)
32166 
      for key, value in self.__dict__.iteritems()]
32167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32168 
 
32169 
  def __eq__(self, other):
32170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32171 
 
32172 
  def __ne__(self, other):
32173 
    return not (self == other)
32174 
 
32175 
class splitFreebieOrder_result:
32176 
  """
32177 
  Attributes:
32178 
   - success
32179 
  """
32180 
 
32181 
  thrift_spec = (
32182 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
32183 
  )
32184 
 
32185 
  def __init__(self, success=None,):
32186 
    self.success = success
32187 
 
32188 
  def read(self, iprot):
32189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32191 
      return
32192 
    iprot.readStructBegin()
32193 
    while True:
32194 
      (fname, ftype, fid) = iprot.readFieldBegin()
32195 
      if ftype == TType.STOP:
32196 
        break
32197 
      if fid == 0:
32198 
        if ftype == TType.STRUCT:
32199 
          self.success = Order()
32200 
          self.success.read(iprot)
32201 
        else:
32202 
          iprot.skip(ftype)
32203 
      else:
32204 
        iprot.skip(ftype)
32205 
      iprot.readFieldEnd()
32206 
    iprot.readStructEnd()
32207 
 
32208 
  def write(self, oprot):
32209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32211 
      return
32212 
    oprot.writeStructBegin('splitFreebieOrder_result')
32213 
    if self.success is not None:
32214 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
32215 
      self.success.write(oprot)
32216 
      oprot.writeFieldEnd()
32217 
    oprot.writeFieldStop()
32218 
    oprot.writeStructEnd()
32219 
 
32220 
  def validate(self):
32221 
    return
32222 
 
32223 
 
32224 
  def __repr__(self):
32225 
    L = ['%s=%r' % (key, value)
32226 
      for key, value in self.__dict__.iteritems()]
32227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32228 
 
32229 
  def __eq__(self, other):
32230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32231 
 
32232 
  def __ne__(self, other):
32233 
    return not (self == other)
32234 
 
7169 anupam.sin 32235 
class getRechargeTransactionsByNumber_args:
32236 
  """
32237 
  Attributes:
32238 
   - number
7172 anupam.sin 32239 
   - storeId
7169 anupam.sin 32240 
  """
32241 
 
32242 
  thrift_spec = (
32243 
    None, # 0
32244 
    (1, TType.STRING, 'number', None, None, ), # 1
7172 anupam.sin 32245 
    (2, TType.I64, 'storeId', None, None, ), # 2
7169 anupam.sin 32246 
  )
32247 
 
7172 anupam.sin 32248 
  def __init__(self, number=None, storeId=None,):
7169 anupam.sin 32249 
    self.number = number
7172 anupam.sin 32250 
    self.storeId = storeId
7169 anupam.sin 32251 
 
32252 
  def read(self, iprot):
32253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32255 
      return
32256 
    iprot.readStructBegin()
32257 
    while True:
32258 
      (fname, ftype, fid) = iprot.readFieldBegin()
32259 
      if ftype == TType.STOP:
32260 
        break
32261 
      if fid == 1:
32262 
        if ftype == TType.STRING:
32263 
          self.number = iprot.readString();
32264 
        else:
32265 
          iprot.skip(ftype)
7172 anupam.sin 32266 
      elif fid == 2:
32267 
        if ftype == TType.I64:
32268 
          self.storeId = iprot.readI64();
32269 
        else:
32270 
          iprot.skip(ftype)
7169 anupam.sin 32271 
      else:
32272 
        iprot.skip(ftype)
32273 
      iprot.readFieldEnd()
32274 
    iprot.readStructEnd()
32275 
 
32276 
  def write(self, oprot):
32277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32279 
      return
32280 
    oprot.writeStructBegin('getRechargeTransactionsByNumber_args')
32281 
    if self.number is not None:
32282 
      oprot.writeFieldBegin('number', TType.STRING, 1)
32283 
      oprot.writeString(self.number)
32284 
      oprot.writeFieldEnd()
7172 anupam.sin 32285 
    if self.storeId is not None:
32286 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
32287 
      oprot.writeI64(self.storeId)
32288 
      oprot.writeFieldEnd()
7169 anupam.sin 32289 
    oprot.writeFieldStop()
32290 
    oprot.writeStructEnd()
32291 
 
32292 
  def validate(self):
32293 
    return
32294 
 
32295 
 
32296 
  def __repr__(self):
32297 
    L = ['%s=%r' % (key, value)
32298 
      for key, value in self.__dict__.iteritems()]
32299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32300 
 
32301 
  def __eq__(self, other):
32302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32303 
 
32304 
  def __ne__(self, other):
32305 
    return not (self == other)
32306 
 
32307 
class getRechargeTransactionsByNumber_result:
32308 
  """
32309 
  Attributes:
32310 
   - success
32311 
  """
32312 
 
32313 
  thrift_spec = (
32314 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
32315 
  )
32316 
 
32317 
  def __init__(self, success=None,):
32318 
    self.success = success
32319 
 
32320 
  def read(self, iprot):
32321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32323 
      return
32324 
    iprot.readStructBegin()
32325 
    while True:
32326 
      (fname, ftype, fid) = iprot.readFieldBegin()
32327 
      if ftype == TType.STOP:
32328 
        break
32329 
      if fid == 0:
32330 
        if ftype == TType.LIST:
32331 
          self.success = []
32332 
          (_etype761, _size758) = iprot.readListBegin()
32333 
          for _i762 in xrange(_size758):
32334 
            _elem763 = RechargeTransaction()
32335 
            _elem763.read(iprot)
32336 
            self.success.append(_elem763)
32337 
          iprot.readListEnd()
32338 
        else:
32339 
          iprot.skip(ftype)
32340 
      else:
32341 
        iprot.skip(ftype)
32342 
      iprot.readFieldEnd()
32343 
    iprot.readStructEnd()
32344 
 
32345 
  def write(self, oprot):
32346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32348 
      return
32349 
    oprot.writeStructBegin('getRechargeTransactionsByNumber_result')
32350 
    if self.success is not None:
32351 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32352 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
32353 
      for iter764 in self.success:
32354 
        iter764.write(oprot)
32355 
      oprot.writeListEnd()
32356 
      oprot.writeFieldEnd()
32357 
    oprot.writeFieldStop()
32358 
    oprot.writeStructEnd()
32359 
 
32360 
  def validate(self):
32361 
    return
32362 
 
32363 
 
32364 
  def __repr__(self):
32365 
    L = ['%s=%r' % (key, value)
32366 
      for key, value in self.__dict__.iteritems()]
32367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32368 
 
32369 
  def __eq__(self, other):
32370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32371 
 
32372 
  def __ne__(self, other):
32373 
    return not (self == other)
32374 
 
32375 
class updateHotspotStorePassword_args:
32376 
  """
32377 
  Attributes:
32378 
   - storeId
32379 
   - password
32380 
  """
32381 
 
32382 
  thrift_spec = (
32383 
    None, # 0
32384 
    (1, TType.I64, 'storeId', None, None, ), # 1
32385 
    (2, TType.STRING, 'password', None, None, ), # 2
32386 
  )
32387 
 
32388 
  def __init__(self, storeId=None, password=None,):
32389 
    self.storeId = storeId
32390 
    self.password = password
32391 
 
32392 
  def read(self, iprot):
32393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32395 
      return
32396 
    iprot.readStructBegin()
32397 
    while True:
32398 
      (fname, ftype, fid) = iprot.readFieldBegin()
32399 
      if ftype == TType.STOP:
32400 
        break
32401 
      if fid == 1:
32402 
        if ftype == TType.I64:
32403 
          self.storeId = iprot.readI64();
32404 
        else:
32405 
          iprot.skip(ftype)
32406 
      elif fid == 2:
32407 
        if ftype == TType.STRING:
32408 
          self.password = iprot.readString();
32409 
        else:
32410 
          iprot.skip(ftype)
32411 
      else:
32412 
        iprot.skip(ftype)
32413 
      iprot.readFieldEnd()
32414 
    iprot.readStructEnd()
32415 
 
32416 
  def write(self, oprot):
32417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32419 
      return
32420 
    oprot.writeStructBegin('updateHotspotStorePassword_args')
32421 
    if self.storeId is not None:
32422 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
32423 
      oprot.writeI64(self.storeId)
32424 
      oprot.writeFieldEnd()
32425 
    if self.password is not None:
32426 
      oprot.writeFieldBegin('password', TType.STRING, 2)
32427 
      oprot.writeString(self.password)
32428 
      oprot.writeFieldEnd()
32429 
    oprot.writeFieldStop()
32430 
    oprot.writeStructEnd()
32431 
 
32432 
  def validate(self):
32433 
    return
32434 
 
32435 
 
32436 
  def __repr__(self):
32437 
    L = ['%s=%r' % (key, value)
32438 
      for key, value in self.__dict__.iteritems()]
32439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32440 
 
32441 
  def __eq__(self, other):
32442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32443 
 
32444 
  def __ne__(self, other):
32445 
    return not (self == other)
32446 
 
32447 
class updateHotspotStorePassword_result:
32448 
  """
32449 
  Attributes:
32450 
   - success
32451 
  """
32452 
 
32453 
  thrift_spec = (
32454 
    (0, TType.BOOL, 'success', None, None, ), # 0
32455 
  )
32456 
 
32457 
  def __init__(self, success=None,):
32458 
    self.success = success
32459 
 
32460 
  def read(self, iprot):
32461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32463 
      return
32464 
    iprot.readStructBegin()
32465 
    while True:
32466 
      (fname, ftype, fid) = iprot.readFieldBegin()
32467 
      if ftype == TType.STOP:
32468 
        break
32469 
      if fid == 0:
32470 
        if ftype == TType.BOOL:
32471 
          self.success = iprot.readBool();
32472 
        else:
32473 
          iprot.skip(ftype)
32474 
      else:
32475 
        iprot.skip(ftype)
32476 
      iprot.readFieldEnd()
32477 
    iprot.readStructEnd()
32478 
 
32479 
  def write(self, oprot):
32480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32482 
      return
32483 
    oprot.writeStructBegin('updateHotspotStorePassword_result')
32484 
    if self.success is not None:
32485 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
32486 
      oprot.writeBool(self.success)
32487 
      oprot.writeFieldEnd()
32488 
    oprot.writeFieldStop()
32489 
    oprot.writeStructEnd()
32490 
 
32491 
  def validate(self):
32492 
    return
32493 
 
32494 
 
32495 
  def __repr__(self):
32496 
    L = ['%s=%r' % (key, value)
32497 
      for key, value in self.__dict__.iteritems()]
32498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32499 
 
32500 
  def __eq__(self, other):
32501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32502 
 
32503 
  def __ne__(self, other):
32504 
    return not (self == other)