Subversion Repositories SmartDukaan

Rev

Rev 7190 | Rev 7267 | 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 
 
7263 anupam.sin 1578 
  def getSourceDetail(self, source):
1579 
    """
1580 
    Parameters:
1581 
     - source
1582 
    """
1583 
    pass
7169 anupam.sin 1584 
 
7263 anupam.sin 1585 
 
3376 rajveer 1586 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1587 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1588 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1589 
 
1590 
  def createTransaction(self, transaction):
1591 
    """
1592 
    Parameters:
1593 
     - transaction
1594 
    """
1595 
    self.send_createTransaction(transaction)
132 ashish 1596 
    return self.recv_createTransaction()
94 ashish 1597 
 
1598 
  def send_createTransaction(self, transaction):
1599 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1600 
    args = createTransaction_args()
1601 
    args.transaction = transaction
1602 
    args.write(self._oprot)
1603 
    self._oprot.writeMessageEnd()
1604 
    self._oprot.trans.flush()
1605 
 
1606 
  def recv_createTransaction(self, ):
1607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1608 
    if mtype == TMessageType.EXCEPTION:
1609 
      x = TApplicationException()
1610 
      x.read(self._iprot)
1611 
      self._iprot.readMessageEnd()
1612 
      raise x
1613 
    result = createTransaction_result()
1614 
    result.read(self._iprot)
1615 
    self._iprot.readMessageEnd()
3431 rajveer 1616 
    if result.success is not None:
132 ashish 1617 
      return result.success
3431 rajveer 1618 
    if result.ex is not None:
94 ashish 1619 
      raise result.ex
132 ashish 1620 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1621 
 
1622 
  def getTransaction(self, id):
1623 
    """
1624 
    Parameters:
1625 
     - id
1626 
    """
1627 
    self.send_getTransaction(id)
1628 
    return self.recv_getTransaction()
1629 
 
1630 
  def send_getTransaction(self, id):
1631 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1632 
    args = getTransaction_args()
1633 
    args.id = id
1634 
    args.write(self._oprot)
1635 
    self._oprot.writeMessageEnd()
1636 
    self._oprot.trans.flush()
1637 
 
1638 
  def recv_getTransaction(self, ):
1639 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1640 
    if mtype == TMessageType.EXCEPTION:
1641 
      x = TApplicationException()
1642 
      x.read(self._iprot)
1643 
      self._iprot.readMessageEnd()
1644 
      raise x
1645 
    result = getTransaction_result()
1646 
    result.read(self._iprot)
1647 
    self._iprot.readMessageEnd()
3431 rajveer 1648 
    if result.success is not None:
94 ashish 1649 
      return result.success
3431 rajveer 1650 
    if result.ex is not None:
94 ashish 1651 
      raise result.ex
1652 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1653 
 
1654 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1655 
    """
1656 
    Parameters:
1657 
     - customerId
1658 
     - from_date
1659 
     - to_date
1660 
     - status
1661 
    """
1662 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1663 
    return self.recv_getTransactionsForCustomer()
1664 
 
1665 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1666 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1667 
    args = getTransactionsForCustomer_args()
1668 
    args.customerId = customerId
1669 
    args.from_date = from_date
1670 
    args.to_date = to_date
1671 
    args.status = status
1672 
    args.write(self._oprot)
1673 
    self._oprot.writeMessageEnd()
1674 
    self._oprot.trans.flush()
1675 
 
1676 
  def recv_getTransactionsForCustomer(self, ):
1677 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1678 
    if mtype == TMessageType.EXCEPTION:
1679 
      x = TApplicationException()
1680 
      x.read(self._iprot)
1681 
      self._iprot.readMessageEnd()
1682 
      raise x
1683 
    result = getTransactionsForCustomer_result()
1684 
    result.read(self._iprot)
1685 
    self._iprot.readMessageEnd()
3431 rajveer 1686 
    if result.success is not None:
94 ashish 1687 
      return result.success
3431 rajveer 1688 
    if result.ex is not None:
94 ashish 1689 
      raise result.ex
1690 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1691 
 
132 ashish 1692 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1693 
    """
1694 
    Parameters:
1695 
     - shoppingCartId
1696 
    """
1697 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1698 
    return self.recv_getTransactionsForShoppingCartId()
1699 
 
1700 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1701 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1702 
    args = getTransactionsForShoppingCartId_args()
1703 
    args.shoppingCartId = shoppingCartId
1704 
    args.write(self._oprot)
1705 
    self._oprot.writeMessageEnd()
1706 
    self._oprot.trans.flush()
1707 
 
1708 
  def recv_getTransactionsForShoppingCartId(self, ):
1709 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1710 
    if mtype == TMessageType.EXCEPTION:
1711 
      x = TApplicationException()
1712 
      x.read(self._iprot)
1713 
      self._iprot.readMessageEnd()
1714 
      raise x
1715 
    result = getTransactionsForShoppingCartId_result()
1716 
    result.read(self._iprot)
1717 
    self._iprot.readMessageEnd()
3431 rajveer 1718 
    if result.success is not None:
132 ashish 1719 
      return result.success
3431 rajveer 1720 
    if result.ex is not None:
132 ashish 1721 
      raise result.ex
1722 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1723 
 
94 ashish 1724 
  def getTransactionStatus(self, transactionId):
1725 
    """
1726 
    Parameters:
1727 
     - transactionId
1728 
    """
1729 
    self.send_getTransactionStatus(transactionId)
1730 
    return self.recv_getTransactionStatus()
1731 
 
1732 
  def send_getTransactionStatus(self, transactionId):
1733 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1734 
    args = getTransactionStatus_args()
1735 
    args.transactionId = transactionId
1736 
    args.write(self._oprot)
1737 
    self._oprot.writeMessageEnd()
1738 
    self._oprot.trans.flush()
1739 
 
1740 
  def recv_getTransactionStatus(self, ):
1741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1742 
    if mtype == TMessageType.EXCEPTION:
1743 
      x = TApplicationException()
1744 
      x.read(self._iprot)
1745 
      self._iprot.readMessageEnd()
1746 
      raise x
1747 
    result = getTransactionStatus_result()
1748 
    result.read(self._iprot)
1749 
    self._iprot.readMessageEnd()
3431 rajveer 1750 
    if result.success is not None:
94 ashish 1751 
      return result.success
3431 rajveer 1752 
    if result.ex is not None:
94 ashish 1753 
      raise result.ex
1754 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1755 
 
5527 anupam.sin 1756 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1757 
    """
1758 
    Parameters:
1759 
     - transactionId
1760 
     - status
1761 
     - description
5527 anupam.sin 1762 
     - pickUp
1763 
     - orderType
94 ashish 1764 
    """
5527 anupam.sin 1765 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1766 
    return self.recv_changeTransactionStatus()
1767 
 
5527 anupam.sin 1768 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1769 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1770 
    args = changeTransactionStatus_args()
1771 
    args.transactionId = transactionId
1772 
    args.status = status
1773 
    args.description = description
5527 anupam.sin 1774 
    args.pickUp = pickUp
1775 
    args.orderType = orderType
94 ashish 1776 
    args.write(self._oprot)
1777 
    self._oprot.writeMessageEnd()
1778 
    self._oprot.trans.flush()
1779 
 
1780 
  def recv_changeTransactionStatus(self, ):
1781 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1782 
    if mtype == TMessageType.EXCEPTION:
1783 
      x = TApplicationException()
1784 
      x.read(self._iprot)
1785 
      self._iprot.readMessageEnd()
1786 
      raise x
1787 
    result = changeTransactionStatus_result()
1788 
    result.read(self._iprot)
1789 
    self._iprot.readMessageEnd()
3431 rajveer 1790 
    if result.success is not None:
94 ashish 1791 
      return result.success
3431 rajveer 1792 
    if result.ex is not None:
94 ashish 1793 
      raise result.ex
1794 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1795 
 
1398 varun.gupt 1796 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1797 
    """
1798 
    Parameters:
1799 
     - transactionId
1800 
    """
1398 varun.gupt 1801 
    self.send_enqueueTransactionInfoEmail(transactionId)
1802 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1803 
 
1398 varun.gupt 1804 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1805 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1806 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1807 
    args.transactionId = transactionId
1808 
    args.write(self._oprot)
1809 
    self._oprot.writeMessageEnd()
1810 
    self._oprot.trans.flush()
1811 
 
1398 varun.gupt 1812 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1813 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1814 
    if mtype == TMessageType.EXCEPTION:
1815 
      x = TApplicationException()
1816 
      x.read(self._iprot)
1817 
      self._iprot.readMessageEnd()
1818 
      raise x
1398 varun.gupt 1819 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1820 
    result.read(self._iprot)
1821 
    self._iprot.readMessageEnd()
3431 rajveer 1822 
    if result.success is not None:
1382 varun.gupt 1823 
      return result.success
3431 rajveer 1824 
    if result.ex is not None:
1382 varun.gupt 1825 
      raise result.ex
1398 varun.gupt 1826 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1827 
 
4801 anupam.sin 1828 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1829 
    """
1830 
    Parameters:
4801 anupam.sin 1831 
     - statuses
483 rajveer 1832 
     - from_date
1833 
     - to_date
1834 
     - warehouse_id
94 ashish 1835 
    """
4801 anupam.sin 1836 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1837 
    return self.recv_getAllOrders()
94 ashish 1838 
 
4801 anupam.sin 1839 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1840 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1841 
    args = getAllOrders_args()
4801 anupam.sin 1842 
    args.statuses = statuses
483 rajveer 1843 
    args.from_date = from_date
1844 
    args.to_date = to_date
1845 
    args.warehouse_id = warehouse_id
94 ashish 1846 
    args.write(self._oprot)
1847 
    self._oprot.writeMessageEnd()
1848 
    self._oprot.trans.flush()
1849 
 
483 rajveer 1850 
  def recv_getAllOrders(self, ):
94 ashish 1851 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1852 
    if mtype == TMessageType.EXCEPTION:
1853 
      x = TApplicationException()
1854 
      x.read(self._iprot)
1855 
      self._iprot.readMessageEnd()
1856 
      raise x
483 rajveer 1857 
    result = getAllOrders_result()
94 ashish 1858 
    result.read(self._iprot)
1859 
    self._iprot.readMessageEnd()
3431 rajveer 1860 
    if result.success is not None:
94 ashish 1861 
      return result.success
3431 rajveer 1862 
    if result.ex is not None:
94 ashish 1863 
      raise result.ex
483 rajveer 1864 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1865 
 
4133 chandransh 1866 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1867 
    """
1868 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1869 
    Pass the status as null and the limit as 0 to ignore them.
1870 
 
1871 
    Parameters:
1872 
     - statuses
1873 
     - offset
1874 
     - limit
1875 
     - warehouse_id
1876 
    """
1877 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1878 
    return self.recv_getOrdersInBatch()
1879 
 
1880 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1881 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1882 
    args = getOrdersInBatch_args()
1883 
    args.statuses = statuses
1884 
    args.offset = offset
1885 
    args.limit = limit
1886 
    args.warehouse_id = warehouse_id
1887 
    args.write(self._oprot)
1888 
    self._oprot.writeMessageEnd()
1889 
    self._oprot.trans.flush()
1890 
 
1891 
  def recv_getOrdersInBatch(self, ):
1892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1893 
    if mtype == TMessageType.EXCEPTION:
1894 
      x = TApplicationException()
1895 
      x.read(self._iprot)
1896 
      self._iprot.readMessageEnd()
1897 
      raise x
1898 
    result = getOrdersInBatch_result()
1899 
    result.read(self._iprot)
1900 
    self._iprot.readMessageEnd()
1901 
    if result.success is not None:
1902 
      return result.success
1903 
    if result.ex is not None:
1904 
      raise result.ex
1905 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1906 
 
1907 
  def getOrderCount(self, statuses, warehouseId):
1908 
    """
1909 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1910 
 
1911 
    Parameters:
1912 
     - statuses
1913 
     - warehouseId
1914 
    """
1915 
    self.send_getOrderCount(statuses, warehouseId)
1916 
    return self.recv_getOrderCount()
1917 
 
1918 
  def send_getOrderCount(self, statuses, warehouseId):
1919 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1920 
    args = getOrderCount_args()
1921 
    args.statuses = statuses
1922 
    args.warehouseId = warehouseId
1923 
    args.write(self._oprot)
1924 
    self._oprot.writeMessageEnd()
1925 
    self._oprot.trans.flush()
1926 
 
1927 
  def recv_getOrderCount(self, ):
1928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1929 
    if mtype == TMessageType.EXCEPTION:
1930 
      x = TApplicationException()
1931 
      x.read(self._iprot)
1932 
      self._iprot.readMessageEnd()
1933 
      raise x
1934 
    result = getOrderCount_result()
1935 
    result.read(self._iprot)
1936 
    self._iprot.readMessageEnd()
1937 
    if result.success is not None:
1938 
      return result.success
1939 
    if result.ex is not None:
1940 
      raise result.ex
1941 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1942 
 
999 varun.gupt 1943 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1944 
    """
1132 chandransh 1945 
    Returns orders within a range of their billing dates
3431 rajveer 1946 
 
999 varun.gupt 1947 
    Parameters:
1948 
     - status
1949 
     - start_billing_date
1950 
     - end_billing_date
1951 
     - warehouse_id
1952 
    """
1953 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1954 
    return self.recv_getOrdersByBillingDate()
1955 
 
1956 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1957 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1958 
    args = getOrdersByBillingDate_args()
1959 
    args.status = status
1960 
    args.start_billing_date = start_billing_date
1961 
    args.end_billing_date = end_billing_date
1962 
    args.warehouse_id = warehouse_id
1963 
    args.write(self._oprot)
1964 
    self._oprot.writeMessageEnd()
1965 
    self._oprot.trans.flush()
1966 
 
1967 
  def recv_getOrdersByBillingDate(self, ):
1968 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1969 
    if mtype == TMessageType.EXCEPTION:
1970 
      x = TApplicationException()
1971 
      x.read(self._iprot)
1972 
      self._iprot.readMessageEnd()
1973 
      raise x
1974 
    result = getOrdersByBillingDate_result()
1975 
    result.read(self._iprot)
1976 
    self._iprot.readMessageEnd()
3431 rajveer 1977 
    if result.success is not None:
999 varun.gupt 1978 
      return result.success
3431 rajveer 1979 
    if result.ex is not None:
999 varun.gupt 1980 
      raise result.ex
1981 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1982 
 
3451 chandransh 1983 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1984 
    """
1985 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1986 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1987 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1988 
 
3427 chandransh 1989 
    Parameters:
1990 
     - fromShippingDate
1991 
     - toShippingDate
1992 
     - providerId
1993 
     - warehouseId
3451 chandransh 1994 
     - cod
3427 chandransh 1995 
    """
3451 chandransh 1996 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1997 
    return self.recv_getOrdersByShippingDate()
1998 
 
3451 chandransh 1999 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 2000 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
2001 
    args = getOrdersByShippingDate_args()
2002 
    args.fromShippingDate = fromShippingDate
2003 
    args.toShippingDate = toShippingDate
2004 
    args.providerId = providerId
2005 
    args.warehouseId = warehouseId
3451 chandransh 2006 
    args.cod = cod
3427 chandransh 2007 
    args.write(self._oprot)
2008 
    self._oprot.writeMessageEnd()
2009 
    self._oprot.trans.flush()
2010 
 
2011 
  def recv_getOrdersByShippingDate(self, ):
2012 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2013 
    if mtype == TMessageType.EXCEPTION:
2014 
      x = TApplicationException()
2015 
      x.read(self._iprot)
2016 
      self._iprot.readMessageEnd()
2017 
      raise x
2018 
    result = getOrdersByShippingDate_result()
2019 
    result.read(self._iprot)
2020 
    self._iprot.readMessageEnd()
3431 rajveer 2021 
    if result.success is not None:
3427 chandransh 2022 
      return result.success
3431 rajveer 2023 
    if result.ex is not None:
3427 chandransh 2024 
      raise result.ex
2025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
2026 
 
1382 varun.gupt 2027 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
2028 
    """
2029 
    Returns order ids for orders which can be returned
3431 rajveer 2030 
 
1382 varun.gupt 2031 
    Parameters:
2032 
     - customer_id
2033 
     - limit
2034 
    """
2035 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
2036 
    return self.recv_getReturnableOrdersForCustomer()
2037 
 
2038 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
2039 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
2040 
    args = getReturnableOrdersForCustomer_args()
2041 
    args.customer_id = customer_id
2042 
    args.limit = limit
2043 
    args.write(self._oprot)
2044 
    self._oprot.writeMessageEnd()
2045 
    self._oprot.trans.flush()
2046 
 
2047 
  def recv_getReturnableOrdersForCustomer(self, ):
2048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2049 
    if mtype == TMessageType.EXCEPTION:
2050 
      x = TApplicationException()
2051 
      x.read(self._iprot)
2052 
      self._iprot.readMessageEnd()
2053 
      raise x
2054 
    result = getReturnableOrdersForCustomer_result()
2055 
    result.read(self._iprot)
2056 
    self._iprot.readMessageEnd()
3431 rajveer 2057 
    if result.success is not None:
1382 varun.gupt 2058 
      return result.success
3431 rajveer 2059 
    if result.ex is not None:
1382 varun.gupt 2060 
      raise result.ex
2061 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
2062 
 
2063 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
2064 
    """
2065 
    Returns order ids for orders which can be cancelled
3431 rajveer 2066 
 
1382 varun.gupt 2067 
    Parameters:
2068 
     - customer_id
2069 
     - limit
2070 
    """
2071 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
2072 
    return self.recv_getCancellableOrdersForCustomer()
2073 
 
2074 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
2075 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
2076 
    args = getCancellableOrdersForCustomer_args()
2077 
    args.customer_id = customer_id
2078 
    args.limit = limit
2079 
    args.write(self._oprot)
2080 
    self._oprot.writeMessageEnd()
2081 
    self._oprot.trans.flush()
2082 
 
2083 
  def recv_getCancellableOrdersForCustomer(self, ):
2084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2085 
    if mtype == TMessageType.EXCEPTION:
2086 
      x = TApplicationException()
2087 
      x.read(self._iprot)
2088 
      self._iprot.readMessageEnd()
2089 
      raise x
2090 
    result = getCancellableOrdersForCustomer_result()
2091 
    result.read(self._iprot)
2092 
    self._iprot.readMessageEnd()
3431 rajveer 2093 
    if result.success is not None:
1382 varun.gupt 2094 
      return result.success
3431 rajveer 2095 
    if result.ex is not None:
1382 varun.gupt 2096 
      raise result.ex
2097 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
2098 
 
483 rajveer 2099 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 2100 
    """
2101 
    Parameters:
483 rajveer 2102 
     - orderId
2103 
     - status
2104 
     - description
94 ashish 2105 
    """
483 rajveer 2106 
    self.send_changeOrderStatus(orderId, status, description)
2107 
    return self.recv_changeOrderStatus()
94 ashish 2108 
 
483 rajveer 2109 
  def send_changeOrderStatus(self, orderId, status, description):
2110 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
2111 
    args = changeOrderStatus_args()
2112 
    args.orderId = orderId
2113 
    args.status = status
2114 
    args.description = description
94 ashish 2115 
    args.write(self._oprot)
2116 
    self._oprot.writeMessageEnd()
2117 
    self._oprot.trans.flush()
2118 
 
483 rajveer 2119 
  def recv_changeOrderStatus(self, ):
94 ashish 2120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2121 
    if mtype == TMessageType.EXCEPTION:
2122 
      x = TApplicationException()
2123 
      x.read(self._iprot)
2124 
      self._iprot.readMessageEnd()
2125 
      raise x
483 rajveer 2126 
    result = changeOrderStatus_result()
94 ashish 2127 
    result.read(self._iprot)
2128 
    self._iprot.readMessageEnd()
3431 rajveer 2129 
    if result.success is not None:
94 ashish 2130 
      return result.success
3431 rajveer 2131 
    if result.ex is not None:
94 ashish 2132 
      raise result.ex
483 rajveer 2133 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 2134 
 
1528 ankur.sing 2135 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 2136 
    """
1528 ankur.sing 2137 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
2138 
    only user who owns the transaction can view its order details.
3431 rajveer 2139 
 
94 ashish 2140 
    Parameters:
2141 
     - transactionId
1528 ankur.sing 2142 
     - customerId
94 ashish 2143 
    """
1528 ankur.sing 2144 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2145 
    return self.recv_getOrdersForTransaction()
94 ashish 2146 
 
1528 ankur.sing 2147 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2148 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2149 
    args = getOrdersForTransaction_args()
94 ashish 2150 
    args.transactionId = transactionId
1528 ankur.sing 2151 
    args.customerId = customerId
94 ashish 2152 
    args.write(self._oprot)
2153 
    self._oprot.writeMessageEnd()
2154 
    self._oprot.trans.flush()
2155 
 
483 rajveer 2156 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2157 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2158 
    if mtype == TMessageType.EXCEPTION:
2159 
      x = TApplicationException()
2160 
      x.read(self._iprot)
2161 
      self._iprot.readMessageEnd()
2162 
      raise x
483 rajveer 2163 
    result = getOrdersForTransaction_result()
94 ashish 2164 
    result.read(self._iprot)
2165 
    self._iprot.readMessageEnd()
3431 rajveer 2166 
    if result.success is not None:
94 ashish 2167 
      return result.success
3431 rajveer 2168 
    if result.ex is not None:
94 ashish 2169 
      raise result.ex
483 rajveer 2170 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2171 
 
3014 chandransh 2172 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2173 
    """
3014 chandransh 2174 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2175 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2176 
 
94 ashish 2177 
    Parameters:
483 rajveer 2178 
     - customerId
2179 
     - from_date
2180 
     - to_date
3014 chandransh 2181 
     - statuses
94 ashish 2182 
    """
3014 chandransh 2183 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2184 
    return self.recv_getOrdersForCustomer()
94 ashish 2185 
 
3014 chandransh 2186 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2187 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2188 
    args = getOrdersForCustomer_args()
2189 
    args.customerId = customerId
2190 
    args.from_date = from_date
2191 
    args.to_date = to_date
3014 chandransh 2192 
    args.statuses = statuses
94 ashish 2193 
    args.write(self._oprot)
2194 
    self._oprot.writeMessageEnd()
2195 
    self._oprot.trans.flush()
2196 
 
483 rajveer 2197 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2198 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2199 
    if mtype == TMessageType.EXCEPTION:
2200 
      x = TApplicationException()
2201 
      x.read(self._iprot)
2202 
      self._iprot.readMessageEnd()
2203 
      raise x
483 rajveer 2204 
    result = getOrdersForCustomer_result()
94 ashish 2205 
    result.read(self._iprot)
2206 
    self._iprot.readMessageEnd()
3431 rajveer 2207 
    if result.success is not None:
94 ashish 2208 
      return result.success
3431 rajveer 2209 
    if result.ex is not None:
94 ashish 2210 
      raise result.ex
483 rajveer 2211 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2212 
 
483 rajveer 2213 
  def createOrder(self, order):
94 ashish 2214 
    """
2215 
    Parameters:
483 rajveer 2216 
     - order
94 ashish 2217 
    """
483 rajveer 2218 
    self.send_createOrder(order)
2219 
    return self.recv_createOrder()
94 ashish 2220 
 
483 rajveer 2221 
  def send_createOrder(self, order):
2222 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2223 
    args = createOrder_args()
2224 
    args.order = order
94 ashish 2225 
    args.write(self._oprot)
2226 
    self._oprot.writeMessageEnd()
2227 
    self._oprot.trans.flush()
2228 
 
483 rajveer 2229 
  def recv_createOrder(self, ):
94 ashish 2230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2231 
    if mtype == TMessageType.EXCEPTION:
2232 
      x = TApplicationException()
2233 
      x.read(self._iprot)
2234 
      self._iprot.readMessageEnd()
2235 
      raise x
483 rajveer 2236 
    result = createOrder_result()
94 ashish 2237 
    result.read(self._iprot)
2238 
    self._iprot.readMessageEnd()
3431 rajveer 2239 
    if result.success is not None:
94 ashish 2240 
      return result.success
3431 rajveer 2241 
    if result.ex is not None:
94 ashish 2242 
      raise result.ex
483 rajveer 2243 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2244 
 
483 rajveer 2245 
  def getOrder(self, id):
94 ashish 2246 
    """
2247 
    Parameters:
483 rajveer 2248 
     - id
94 ashish 2249 
    """
483 rajveer 2250 
    self.send_getOrder(id)
2251 
    return self.recv_getOrder()
94 ashish 2252 
 
483 rajveer 2253 
  def send_getOrder(self, id):
2254 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2255 
    args = getOrder_args()
2256 
    args.id = id
94 ashish 2257 
    args.write(self._oprot)
2258 
    self._oprot.writeMessageEnd()
2259 
    self._oprot.trans.flush()
2260 
 
483 rajveer 2261 
  def recv_getOrder(self, ):
94 ashish 2262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2263 
    if mtype == TMessageType.EXCEPTION:
2264 
      x = TApplicationException()
2265 
      x.read(self._iprot)
2266 
      self._iprot.readMessageEnd()
2267 
      raise x
483 rajveer 2268 
    result = getOrder_result()
94 ashish 2269 
    result.read(self._iprot)
2270 
    self._iprot.readMessageEnd()
3431 rajveer 2271 
    if result.success is not None:
94 ashish 2272 
      return result.success
3431 rajveer 2273 
    if result.ex is not None:
94 ashish 2274 
      raise result.ex
483 rajveer 2275 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2276 
 
483 rajveer 2277 
  def getLineItemsForOrder(self, orderId):
94 ashish 2278 
    """
2279 
    Parameters:
483 rajveer 2280 
     - orderId
94 ashish 2281 
    """
483 rajveer 2282 
    self.send_getLineItemsForOrder(orderId)
2283 
    return self.recv_getLineItemsForOrder()
94 ashish 2284 
 
483 rajveer 2285 
  def send_getLineItemsForOrder(self, orderId):
2286 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2287 
    args = getLineItemsForOrder_args()
2288 
    args.orderId = orderId
94 ashish 2289 
    args.write(self._oprot)
2290 
    self._oprot.writeMessageEnd()
2291 
    self._oprot.trans.flush()
2292 
 
483 rajveer 2293 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2294 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2295 
    if mtype == TMessageType.EXCEPTION:
2296 
      x = TApplicationException()
2297 
      x.read(self._iprot)
2298 
      self._iprot.readMessageEnd()
2299 
      raise x
483 rajveer 2300 
    result = getLineItemsForOrder_result()
94 ashish 2301 
    result.read(self._iprot)
2302 
    self._iprot.readMessageEnd()
3431 rajveer 2303 
    if result.success is not None:
94 ashish 2304 
      return result.success
3431 rajveer 2305 
    if result.ex is not None:
94 ashish 2306 
      raise result.ex
483 rajveer 2307 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2308 
 
4999 phani.kuma 2309 
  def getOrderList(self, order_ids):
2310 
    """
2311 
    Parameters:
2312 
     - order_ids
2313 
    """
2314 
    self.send_getOrderList(order_ids)
2315 
    return self.recv_getOrderList()
2316 
 
2317 
  def send_getOrderList(self, order_ids):
2318 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2319 
    args = getOrderList_args()
2320 
    args.order_ids = order_ids
2321 
    args.write(self._oprot)
2322 
    self._oprot.writeMessageEnd()
2323 
    self._oprot.trans.flush()
2324 
 
2325 
  def recv_getOrderList(self, ):
2326 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2327 
    if mtype == TMessageType.EXCEPTION:
2328 
      x = TApplicationException()
2329 
      x.read(self._iprot)
2330 
      self._iprot.readMessageEnd()
2331 
      raise x
2332 
    result = getOrderList_result()
2333 
    result.read(self._iprot)
2334 
    self._iprot.readMessageEnd()
2335 
    if result.success is not None:
2336 
      return result.success
2337 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2338 
 
5386 phani.kuma 2339 
  def getOrderListForVendor(self, order_ids, vendorId):
2340 
    """
2341 
    Parameters:
2342 
     - order_ids
2343 
     - vendorId
2344 
    """
2345 
    self.send_getOrderListForVendor(order_ids, vendorId)
2346 
    return self.recv_getOrderListForVendor()
2347 
 
2348 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2349 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2350 
    args = getOrderListForVendor_args()
2351 
    args.order_ids = order_ids
2352 
    args.vendorId = vendorId
2353 
    args.write(self._oprot)
2354 
    self._oprot.writeMessageEnd()
2355 
    self._oprot.trans.flush()
2356 
 
2357 
  def recv_getOrderListForVendor(self, ):
2358 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2359 
    if mtype == TMessageType.EXCEPTION:
2360 
      x = TApplicationException()
2361 
      x.read(self._iprot)
2362 
      self._iprot.readMessageEnd()
2363 
      raise x
2364 
    result = getOrderListForVendor_result()
2365 
    result.read(self._iprot)
2366 
    self._iprot.readMessageEnd()
2367 
    if result.success is not None:
2368 
      return result.success
2369 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2370 
 
1528 ankur.sing 2371 
  def getOrderForCustomer(self, orderId, customerId):
2372 
    """
2373 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2374 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2375 
 
1528 ankur.sing 2376 
    Parameters:
2377 
     - orderId
2378 
     - customerId
2379 
    """
2380 
    self.send_getOrderForCustomer(orderId, customerId)
2381 
    return self.recv_getOrderForCustomer()
2382 
 
2383 
  def send_getOrderForCustomer(self, orderId, customerId):
2384 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2385 
    args = getOrderForCustomer_args()
2386 
    args.orderId = orderId
2387 
    args.customerId = customerId
2388 
    args.write(self._oprot)
2389 
    self._oprot.writeMessageEnd()
2390 
    self._oprot.trans.flush()
2391 
 
2392 
  def recv_getOrderForCustomer(self, ):
2393 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2394 
    if mtype == TMessageType.EXCEPTION:
2395 
      x = TApplicationException()
2396 
      x.read(self._iprot)
2397 
      self._iprot.readMessageEnd()
2398 
      raise x
2399 
    result = getOrderForCustomer_result()
2400 
    result.read(self._iprot)
2401 
    self._iprot.readMessageEnd()
3431 rajveer 2402 
    if result.success is not None:
1528 ankur.sing 2403 
      return result.success
3431 rajveer 2404 
    if result.ex is not None:
1528 ankur.sing 2405 
      raise result.ex
2406 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2407 
 
4444 rajveer 2408 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2409 
    """
2410 
    Parameters:
4394 rajveer 2411 
     - type
4444 rajveer 2412 
     - warehouseId
4394 rajveer 2413 
     - status
2414 
     - timestamp
3064 chandransh 2415 
    """
4444 rajveer 2416 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2417 
    return self.recv_getAlerts()
2418 
 
4444 rajveer 2419 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2420 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2421 
    args = getAlerts_args()
4394 rajveer 2422 
    args.type = type
4444 rajveer 2423 
    args.warehouseId = warehouseId
4394 rajveer 2424 
    args.status = status
2425 
    args.timestamp = timestamp
3064 chandransh 2426 
    args.write(self._oprot)
2427 
    self._oprot.writeMessageEnd()
2428 
    self._oprot.trans.flush()
2429 
 
2430 
  def recv_getAlerts(self, ):
2431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2432 
    if mtype == TMessageType.EXCEPTION:
2433 
      x = TApplicationException()
2434 
      x.read(self._iprot)
2435 
      self._iprot.readMessageEnd()
2436 
      raise x
2437 
    result = getAlerts_result()
2438 
    result.read(self._iprot)
2439 
    self._iprot.readMessageEnd()
3431 rajveer 2440 
    if result.success is not None:
3064 chandransh 2441 
      return result.success
2442 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2443 
 
4444 rajveer 2444 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2445 
    """
2446 
    Parameters:
2447 
     - type
4444 rajveer 2448 
     - warehouseId
4394 rajveer 2449 
     - description
3064 chandransh 2450 
    """
4444 rajveer 2451 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2452 
    self.recv_addAlert()
3064 chandransh 2453 
 
4444 rajveer 2454 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2455 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2456 
    args = addAlert_args()
3064 chandransh 2457 
    args.type = type
4444 rajveer 2458 
    args.warehouseId = warehouseId
4394 rajveer 2459 
    args.description = description
3064 chandransh 2460 
    args.write(self._oprot)
2461 
    self._oprot.writeMessageEnd()
2462 
    self._oprot.trans.flush()
2463 
 
4394 rajveer 2464 
  def recv_addAlert(self, ):
3064 chandransh 2465 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2466 
    if mtype == TMessageType.EXCEPTION:
2467 
      x = TApplicationException()
2468 
      x.read(self._iprot)
2469 
      self._iprot.readMessageEnd()
2470 
      raise x
4394 rajveer 2471 
    result = addAlert_result()
3064 chandransh 2472 
    result.read(self._iprot)
2473 
    self._iprot.readMessageEnd()
2474 
    return
2475 
 
4444 rajveer 2476 
  def markAlertsAsSeen(self, warehouseId):
2477 
    """
2478 
    Parameters:
2479 
     - warehouseId
2480 
    """
2481 
    self.send_markAlertsAsSeen(warehouseId)
2482 
    self.recv_markAlertsAsSeen()
2483 
 
2484 
  def send_markAlertsAsSeen(self, warehouseId):
2485 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2486 
    args = markAlertsAsSeen_args()
2487 
    args.warehouseId = warehouseId
2488 
    args.write(self._oprot)
2489 
    self._oprot.writeMessageEnd()
2490 
    self._oprot.trans.flush()
2491 
 
2492 
  def recv_markAlertsAsSeen(self, ):
2493 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2494 
    if mtype == TMessageType.EXCEPTION:
2495 
      x = TApplicationException()
2496 
      x.read(self._iprot)
2497 
      self._iprot.readMessageEnd()
2498 
      raise x
2499 
    result = markAlertsAsSeen_result()
2500 
    result.read(self._iprot)
2501 
    self._iprot.readMessageEnd()
2502 
    return
2503 
 
3064 chandransh 2504 
  def getValidOrderCount(self, ):
2505 
    """
2506 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2507 
    """
2508 
    self.send_getValidOrderCount()
2509 
    return self.recv_getValidOrderCount()
2510 
 
2511 
  def send_getValidOrderCount(self, ):
2512 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2513 
    args = getValidOrderCount_args()
2514 
    args.write(self._oprot)
2515 
    self._oprot.writeMessageEnd()
2516 
    self._oprot.trans.flush()
2517 
 
2518 
  def recv_getValidOrderCount(self, ):
2519 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2520 
    if mtype == TMessageType.EXCEPTION:
2521 
      x = TApplicationException()
2522 
      x.read(self._iprot)
2523 
      self._iprot.readMessageEnd()
2524 
      raise x
2525 
    result = getValidOrderCount_result()
2526 
    result.read(self._iprot)
2527 
    self._iprot.readMessageEnd()
3431 rajveer 2528 
    if result.success is not None:
3064 chandransh 2529 
      return result.success
2530 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2531 
 
2532 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2533 
    """
2534 
    Returns the number of distinct customers who have done successful transactions
2535 
    """
2536 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2537 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2538 
 
2539 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2540 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2541 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2542 
    args.write(self._oprot)
2543 
    self._oprot.writeMessageEnd()
2544 
    self._oprot.trans.flush()
2545 
 
2546 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2547 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2548 
    if mtype == TMessageType.EXCEPTION:
2549 
      x = TApplicationException()
2550 
      x.read(self._iprot)
2551 
      self._iprot.readMessageEnd()
2552 
      raise x
2553 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2554 
    result.read(self._iprot)
2555 
    self._iprot.readMessageEnd()
3431 rajveer 2556 
    if result.success is not None:
3064 chandransh 2557 
      return result.success
2558 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2559 
 
2560 
  def getValidOrdersAmountRange(self, ):
2561 
    """
2562 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2563 
    List contains two values, first minimum amount and second maximum amount.
2564 
    """
2565 
    self.send_getValidOrdersAmountRange()
2566 
    return self.recv_getValidOrdersAmountRange()
2567 
 
2568 
  def send_getValidOrdersAmountRange(self, ):
2569 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2570 
    args = getValidOrdersAmountRange_args()
2571 
    args.write(self._oprot)
2572 
    self._oprot.writeMessageEnd()
2573 
    self._oprot.trans.flush()
2574 
 
2575 
  def recv_getValidOrdersAmountRange(self, ):
2576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2577 
    if mtype == TMessageType.EXCEPTION:
2578 
      x = TApplicationException()
2579 
      x.read(self._iprot)
2580 
      self._iprot.readMessageEnd()
2581 
      raise x
2582 
    result = getValidOrdersAmountRange_result()
2583 
    result.read(self._iprot)
2584 
    self._iprot.readMessageEnd()
3431 rajveer 2585 
    if result.success is not None:
3064 chandransh 2586 
      return result.success
2587 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2588 
 
5874 rajveer 2589 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2590 
    """
2591 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2592 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2593 
 
3064 chandransh 2594 
    Parameters:
2595 
     - limit
5874 rajveer 2596 
     - onlyStore
3064 chandransh 2597 
    """
5874 rajveer 2598 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2599 
    return self.recv_getValidOrders()
2600 
 
5874 rajveer 2601 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2602 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2603 
    args = getValidOrders_args()
2604 
    args.limit = limit
5874 rajveer 2605 
    args.onlyStore = onlyStore
3064 chandransh 2606 
    args.write(self._oprot)
2607 
    self._oprot.writeMessageEnd()
2608 
    self._oprot.trans.flush()
2609 
 
2610 
  def recv_getValidOrders(self, ):
2611 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2612 
    if mtype == TMessageType.EXCEPTION:
2613 
      x = TApplicationException()
2614 
      x.read(self._iprot)
2615 
      self._iprot.readMessageEnd()
2616 
      raise x
2617 
    result = getValidOrders_result()
2618 
    result.read(self._iprot)
2619 
    self._iprot.readMessageEnd()
3431 rajveer 2620 
    if result.success is not None:
3064 chandransh 2621 
      return result.success
2622 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2623 
 
1220 chandransh 2624 
  def batchOrders(self, warehouseId):
2625 
    """
2626 
    Create a batch of all the pending orders for the given warehouse.
2627 
    The returned list is orderd by created_timestamp.
2628 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2629 
 
1220 chandransh 2630 
    Parameters:
2631 
     - warehouseId
2632 
    """
2633 
    self.send_batchOrders(warehouseId)
2634 
    return self.recv_batchOrders()
2635 
 
2636 
  def send_batchOrders(self, warehouseId):
2637 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2638 
    args = batchOrders_args()
2639 
    args.warehouseId = warehouseId
2640 
    args.write(self._oprot)
2641 
    self._oprot.writeMessageEnd()
2642 
    self._oprot.trans.flush()
2643 
 
2644 
  def recv_batchOrders(self, ):
2645 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2646 
    if mtype == TMessageType.EXCEPTION:
2647 
      x = TApplicationException()
2648 
      x.read(self._iprot)
2649 
      self._iprot.readMessageEnd()
2650 
      raise x
2651 
    result = batchOrders_result()
2652 
    result.read(self._iprot)
2653 
    self._iprot.readMessageEnd()
3431 rajveer 2654 
    if result.success is not None:
1220 chandransh 2655 
      return result.success
3431 rajveer 2656 
    if result.ex is not None:
1220 chandransh 2657 
      raise result.ex
2658 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2659 
 
1208 chandransh 2660 
  def markOrderAsOutOfStock(self, orderId):
2661 
    """
2662 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2663 
 
1208 chandransh 2664 
    Parameters:
2665 
     - orderId
2666 
    """
2667 
    self.send_markOrderAsOutOfStock(orderId)
2668 
    return self.recv_markOrderAsOutOfStock()
2669 
 
2670 
  def send_markOrderAsOutOfStock(self, orderId):
2671 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2672 
    args = markOrderAsOutOfStock_args()
2673 
    args.orderId = orderId
2674 
    args.write(self._oprot)
2675 
    self._oprot.writeMessageEnd()
2676 
    self._oprot.trans.flush()
2677 
 
2678 
  def recv_markOrderAsOutOfStock(self, ):
2679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2680 
    if mtype == TMessageType.EXCEPTION:
2681 
      x = TApplicationException()
2682 
      x.read(self._iprot)
2683 
      self._iprot.readMessageEnd()
2684 
      raise x
2685 
    result = markOrderAsOutOfStock_result()
2686 
    result.read(self._iprot)
2687 
    self._iprot.readMessageEnd()
3431 rajveer 2688 
    if result.success is not None:
1208 chandransh 2689 
      return result.success
3431 rajveer 2690 
    if result.ex is not None:
1208 chandransh 2691 
      raise result.ex
2692 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2693 
 
3064 chandransh 2694 
  def verifyOrder(self, orderId):
759 chandransh 2695 
    """
3064 chandransh 2696 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2697 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2698 
    used for all other orders as well.
2699 
    Throws an exception if no such order exists.
3431 rajveer 2700 
 
759 chandransh 2701 
    Parameters:
3064 chandransh 2702 
     - orderId
759 chandransh 2703 
    """
3064 chandransh 2704 
    self.send_verifyOrder(orderId)
2705 
    return self.recv_verifyOrder()
759 chandransh 2706 
 
3064 chandransh 2707 
  def send_verifyOrder(self, orderId):
2708 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2709 
    args = verifyOrder_args()
2710 
    args.orderId = orderId
759 chandransh 2711 
    args.write(self._oprot)
2712 
    self._oprot.writeMessageEnd()
2713 
    self._oprot.trans.flush()
2714 
 
3064 chandransh 2715 
  def recv_verifyOrder(self, ):
759 chandransh 2716 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2717 
    if mtype == TMessageType.EXCEPTION:
2718 
      x = TApplicationException()
2719 
      x.read(self._iprot)
2720 
      self._iprot.readMessageEnd()
2721 
      raise x
3064 chandransh 2722 
    result = verifyOrder_result()
759 chandransh 2723 
    result.read(self._iprot)
2724 
    self._iprot.readMessageEnd()
3431 rajveer 2725 
    if result.success is not None:
759 chandransh 2726 
      return result.success
3431 rajveer 2727 
    if result.ex is not None:
759 chandransh 2728 
      raise result.ex
3064 chandransh 2729 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2730 
 
3064 chandransh 2731 
  def acceptOrder(self, orderId):
1113 chandransh 2732 
    """
3064 chandransh 2733 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2734 
    given order is not a COD order, it also captures the payment if the same has
2735 
    not been captured.
2736 
    Throws an exception if no such order exists.
3431 rajveer 2737 
 
1113 chandransh 2738 
    Parameters:
3064 chandransh 2739 
     - orderId
1113 chandransh 2740 
    """
3064 chandransh 2741 
    self.send_acceptOrder(orderId)
2742 
    return self.recv_acceptOrder()
1113 chandransh 2743 
 
3064 chandransh 2744 
  def send_acceptOrder(self, orderId):
2745 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2746 
    args = acceptOrder_args()
2747 
    args.orderId = orderId
1113 chandransh 2748 
    args.write(self._oprot)
2749 
    self._oprot.writeMessageEnd()
2750 
    self._oprot.trans.flush()
2751 
 
3064 chandransh 2752 
  def recv_acceptOrder(self, ):
1113 chandransh 2753 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2754 
    if mtype == TMessageType.EXCEPTION:
2755 
      x = TApplicationException()
2756 
      x.read(self._iprot)
2757 
      self._iprot.readMessageEnd()
2758 
      raise x
3064 chandransh 2759 
    result = acceptOrder_result()
1113 chandransh 2760 
    result.read(self._iprot)
2761 
    self._iprot.readMessageEnd()
3431 rajveer 2762 
    if result.success is not None:
1113 chandransh 2763 
      return result.success
3431 rajveer 2764 
    if result.ex is not None:
1113 chandransh 2765 
      raise result.ex
3064 chandransh 2766 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2767 
 
7190 amar.kumar 2768 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2769 
    """
3064 chandransh 2770 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2771 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2772 
    the IMEI no. if a -1 is supplied.
2773 
    Also, it generates an invoice number for the order, marks the order as
2774 
    BILLED and sets the billing timestamp.
2775 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2776 
 
1135 chandransh 2777 
    Parameters:
3064 chandransh 2778 
     - orderId
2779 
     - invoice_number
4658 mandeep.dh 2780 
     - serialNumber
4283 anupam.sin 2781 
     - itemNumber
7190 amar.kumar 2782 
     - freebieWarehouseId
3064 chandransh 2783 
     - billed_by
4264 rajveer 2784 
     - jacketNumber
4283 anupam.sin 2785 
     - billingType
5110 mandeep.dh 2786 
     - fulfilmentWarehouseId
4763 rajveer 2787 
     - authorize
1135 chandransh 2788 
    """
7190 amar.kumar 2789 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2790 
    return self.recv_addBillingDetails()
1135 chandransh 2791 
 
7190 amar.kumar 2792 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, freebieWarehouseId, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2793 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2794 
    args = addBillingDetails_args()
2795 
    args.orderId = orderId
2796 
    args.invoice_number = invoice_number
4658 mandeep.dh 2797 
    args.serialNumber = serialNumber
4283 anupam.sin 2798 
    args.itemNumber = itemNumber
7190 amar.kumar 2799 
    args.freebieWarehouseId = freebieWarehouseId
3064 chandransh 2800 
    args.billed_by = billed_by
4264 rajveer 2801 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2802 
    args.billingType = billingType
5110 mandeep.dh 2803 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2804 
    args.authorize = authorize
1135 chandransh 2805 
    args.write(self._oprot)
2806 
    self._oprot.writeMessageEnd()
2807 
    self._oprot.trans.flush()
2808 
 
3064 chandransh 2809 
  def recv_addBillingDetails(self, ):
1135 chandransh 2810 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2811 
    if mtype == TMessageType.EXCEPTION:
2812 
      x = TApplicationException()
2813 
      x.read(self._iprot)
2814 
      self._iprot.readMessageEnd()
2815 
      raise x
3064 chandransh 2816 
    result = addBillingDetails_result()
1135 chandransh 2817 
    result.read(self._iprot)
2818 
    self._iprot.readMessageEnd()
3431 rajveer 2819 
    if result.success is not None:
3064 chandransh 2820 
      return result.success
3431 rajveer 2821 
    if result.ex is not None:
1135 chandransh 2822 
      raise result.ex
3064 chandransh 2823 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2824 
 
6756 amar.kumar 2825 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2826 
    """
2827 
    Add the invoice number to the order.
2828 
 
2829 
    Parameters:
2830 
     - orderId
2831 
     - invoiceNumber
4763 rajveer 2832 
     - color
6756 amar.kumar 2833 
     - serialNumber
2834 
     - itemNumber
4579 rajveer 2835 
    """
6756 amar.kumar 2836 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color, serialNumber, itemNumber)
4579 rajveer 2837 
    self.recv_addInvoiceNumber()
2838 
 
6756 amar.kumar 2839 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2840 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2841 
    args = addInvoiceNumber_args()
2842 
    args.orderId = orderId
2843 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2844 
    args.color = color
6756 amar.kumar 2845 
    args.serialNumber = serialNumber
2846 
    args.itemNumber = itemNumber
4579 rajveer 2847 
    args.write(self._oprot)
2848 
    self._oprot.writeMessageEnd()
2849 
    self._oprot.trans.flush()
2850 
 
2851 
  def recv_addInvoiceNumber(self, ):
2852 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2853 
    if mtype == TMessageType.EXCEPTION:
2854 
      x = TApplicationException()
2855 
      x.read(self._iprot)
2856 
      self._iprot.readMessageEnd()
2857 
      raise x
2858 
    result = addInvoiceNumber_result()
2859 
    result.read(self._iprot)
2860 
    self._iprot.readMessageEnd()
2861 
    if result.ex is not None:
2862 
      raise result.ex
2863 
    return
2864 
 
4910 phani.kuma 2865 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2866 
    """
3064 chandransh 2867 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2868 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2869 
 
1408 ankur.sing 2870 
    Parameters:
3064 chandransh 2871 
     - warehouseId
1408 ankur.sing 2872 
     - providerId
3064 chandransh 2873 
     - cod
4910 phani.kuma 2874 
     - orderIds
1408 ankur.sing 2875 
    """
4910 phani.kuma 2876 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2877 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2878 
 
4910 phani.kuma 2879 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2880 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2881 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2882 
    args.warehouseId = warehouseId
1408 ankur.sing 2883 
    args.providerId = providerId
3064 chandransh 2884 
    args.cod = cod
4910 phani.kuma 2885 
    args.orderIds = orderIds
1408 ankur.sing 2886 
    args.write(self._oprot)
2887 
    self._oprot.writeMessageEnd()
2888 
    self._oprot.trans.flush()
2889 
 
4910 phani.kuma 2890 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2891 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2892 
    if mtype == TMessageType.EXCEPTION:
2893 
      x = TApplicationException()
2894 
      x.read(self._iprot)
2895 
      self._iprot.readMessageEnd()
2896 
      raise x
4910 phani.kuma 2897 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2898 
    result.read(self._iprot)
2899 
    self._iprot.readMessageEnd()
3431 rajveer 2900 
    if result.success is not None:
1408 ankur.sing 2901 
      return result.success
3431 rajveer 2902 
    if result.ex is not None:
3064 chandransh 2903 
      raise result.ex
4910 phani.kuma 2904 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2905 
 
5713 rajveer 2906 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2907 
    """
2908 
    Parameters:
2909 
     - providerId
2910 
     - orderIds
5713 rajveer 2911 
     - awbs
5676 rajveer 2912 
    """
5713 rajveer 2913 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2914 
    return self.recv_markOrdersAsReturnedFromStore()
2915 
 
5713 rajveer 2916 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2917 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2918 
    args = markOrdersAsReturnedFromStore_args()
2919 
    args.providerId = providerId
2920 
    args.orderIds = orderIds
5713 rajveer 2921 
    args.awbs = awbs
5676 rajveer 2922 
    args.write(self._oprot)
2923 
    self._oprot.writeMessageEnd()
2924 
    self._oprot.trans.flush()
2925 
 
2926 
  def recv_markOrdersAsReturnedFromStore(self, ):
2927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2928 
    if mtype == TMessageType.EXCEPTION:
2929 
      x = TApplicationException()
2930 
      x.read(self._iprot)
2931 
      self._iprot.readMessageEnd()
2932 
      raise x
2933 
    result = markOrdersAsReturnedFromStore_result()
2934 
    result.read(self._iprot)
2935 
    self._iprot.readMessageEnd()
2936 
    if result.success is not None:
2937 
      return result.success
2938 
    if result.ex is not None:
2939 
      raise result.ex
2940 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2941 
 
4910 phani.kuma 2942 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2943 
    """
4910 phani.kuma 2944 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2945 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2946 
 
2947 
    Parameters:
2948 
     - providerId
4910 phani.kuma 2949 
     - pickupDetails
4410 rajveer 2950 
    """
4910 phani.kuma 2951 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2952 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2953 
 
4910 phani.kuma 2954 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2955 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2956 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2957 
    args.providerId = providerId
4910 phani.kuma 2958 
    args.pickupDetails = pickupDetails
4410 rajveer 2959 
    args.write(self._oprot)
2960 
    self._oprot.writeMessageEnd()
2961 
    self._oprot.trans.flush()
2962 
 
4910 phani.kuma 2963 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2964 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2965 
    if mtype == TMessageType.EXCEPTION:
2966 
      x = TApplicationException()
2967 
      x.read(self._iprot)
2968 
      self._iprot.readMessageEnd()
2969 
      raise x
4910 phani.kuma 2970 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2971 
    result.read(self._iprot)
2972 
    self._iprot.readMessageEnd()
2973 
    if result.ex is not None:
2974 
      raise result.ex
4910 phani.kuma 2975 
    return
4410 rajveer 2976 
 
4910 phani.kuma 2977 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2978 
    """
3064 chandransh 2979 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2980 
 
94 ashish 2981 
    Parameters:
3064 chandransh 2982 
     - providerId
304 ashish 2983 
    """
4910 phani.kuma 2984 
    self.send_getOrdersNotPickedUp(providerId)
2985 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2986 
 
4910 phani.kuma 2987 
  def send_getOrdersNotPickedUp(self, providerId):
2988 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2989 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2990 
    args.providerId = providerId
304 ashish 2991 
    args.write(self._oprot)
2992 
    self._oprot.writeMessageEnd()
2993 
    self._oprot.trans.flush()
2994 
 
4910 phani.kuma 2995 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2996 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2997 
    if mtype == TMessageType.EXCEPTION:
2998 
      x = TApplicationException()
2999 
      x.read(self._iprot)
3000 
      self._iprot.readMessageEnd()
3001 
      raise x
4910 phani.kuma 3002 
    result = getOrdersNotPickedUp_result()
304 ashish 3003 
    result.read(self._iprot)
3004 
    self._iprot.readMessageEnd()
3431 rajveer 3005 
    if result.success is not None:
304 ashish 3006 
      return result.success
4910 phani.kuma 3007 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 3008 
 
3064 chandransh 3009 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 3010 
    """
3064 chandransh 3011 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
3012 
    the name of the receiver.
3013 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 3014 
 
304 ashish 3015 
    Parameters:
3064 chandransh 3016 
     - providerId
3017 
     - deliveredOrders
304 ashish 3018 
    """
3064 chandransh 3019 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
3020 
    self.recv_markOrdersAsDelivered()
304 ashish 3021 
 
3064 chandransh 3022 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
3023 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
3024 
    args = markOrdersAsDelivered_args()
3025 
    args.providerId = providerId
3026 
    args.deliveredOrders = deliveredOrders
304 ashish 3027 
    args.write(self._oprot)
3028 
    self._oprot.writeMessageEnd()
3029 
    self._oprot.trans.flush()
3030 
 
3064 chandransh 3031 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 3032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3033 
    if mtype == TMessageType.EXCEPTION:
3034 
      x = TApplicationException()
3035 
      x.read(self._iprot)
3036 
      self._iprot.readMessageEnd()
3037 
      raise x
3064 chandransh 3038 
    result = markOrdersAsDelivered_result()
304 ashish 3039 
    result.read(self._iprot)
3040 
    self._iprot.readMessageEnd()
3431 rajveer 3041 
    if result.ex is not None:
3064 chandransh 3042 
      raise result.ex
304 ashish 3043 
    return
3044 
 
4910 phani.kuma 3045 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 3046 
    """
4910 phani.kuma 3047 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 3048 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 3049 
 
3064 chandransh 3050 
    Parameters:
3051 
     - providerId
3052 
     - returnedOrders
1596 ankur.sing 3053 
    """
4910 phani.kuma 3054 
    self.send_markAsRTOrders(providerId, returnedOrders)
3055 
    self.recv_markAsRTOrders()
304 ashish 3056 
 
4910 phani.kuma 3057 
  def send_markAsRTOrders(self, providerId, returnedOrders):
3058 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
3059 
    args = markAsRTOrders_args()
3064 chandransh 3060 
    args.providerId = providerId
3061 
    args.returnedOrders = returnedOrders
1596 ankur.sing 3062 
    args.write(self._oprot)
3063 
    self._oprot.writeMessageEnd()
3064 
    self._oprot.trans.flush()
3065 
 
4910 phani.kuma 3066 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 3067 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3068 
    if mtype == TMessageType.EXCEPTION:
3069 
      x = TApplicationException()
3070 
      x.read(self._iprot)
3071 
      self._iprot.readMessageEnd()
3072 
      raise x
4910 phani.kuma 3073 
    result = markAsRTOrders_result()
1596 ankur.sing 3074 
    result.read(self._iprot)
3075 
    self._iprot.readMessageEnd()
3431 rajveer 3076 
    if result.ex is not None:
3064 chandransh 3077 
      raise result.ex
3078 
    return
1596 ankur.sing 3079 
 
4910 phani.kuma 3080 
  def getRTOrders(self, providerId):
3081 
    """
3082 
    Returns a list of orders that were returned by courier.
3083 
 
3084 
    Parameters:
3085 
     - providerId
3086 
    """
3087 
    self.send_getRTOrders(providerId)
3088 
    return self.recv_getRTOrders()
3089 
 
3090 
  def send_getRTOrders(self, providerId):
3091 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
3092 
    args = getRTOrders_args()
3093 
    args.providerId = providerId
3094 
    args.write(self._oprot)
3095 
    self._oprot.writeMessageEnd()
3096 
    self._oprot.trans.flush()
3097 
 
3098 
  def recv_getRTOrders(self, ):
3099 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3100 
    if mtype == TMessageType.EXCEPTION:
3101 
      x = TApplicationException()
3102 
      x.read(self._iprot)
3103 
      self._iprot.readMessageEnd()
3104 
      raise x
3105 
    result = getRTOrders_result()
3106 
    result.read(self._iprot)
3107 
    self._iprot.readMessageEnd()
3108 
    if result.success is not None:
3109 
      return result.success
3110 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
3111 
 
3064 chandransh 3112 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 3113 
    """
3064 chandransh 3114 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 3115 
 
3064 chandransh 3116 
    Parameters:
3117 
     - providerId
3118 
     - undeliveredOrders
1627 ankur.sing 3119 
    """
3064 chandransh 3120 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 3121 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 3122 
 
3064 chandransh 3123 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
3124 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
3125 
    args = updateNonDeliveryReason_args()
3126 
    args.providerId = providerId
3127 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 3128 
    args.write(self._oprot)
3129 
    self._oprot.writeMessageEnd()
3130 
    self._oprot.trans.flush()
3131 
 
3064 chandransh 3132 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 3133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3134 
    if mtype == TMessageType.EXCEPTION:
3135 
      x = TApplicationException()
3136 
      x.read(self._iprot)
3137 
      self._iprot.readMessageEnd()
3138 
      raise x
3064 chandransh 3139 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 3140 
    result.read(self._iprot)
3141 
    self._iprot.readMessageEnd()
4910 phani.kuma 3142 
    if result.ex is not None:
3143 
      raise result.ex
3144 
    return
3145 
 
3146 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3147 
    """
3148 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3149 
 
3150 
    Parameters:
3151 
     - providerId
3152 
    """
3153 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3154 
    return self.recv_getNonDeliveredOrdersbyCourier()
3155 
 
3156 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3157 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3158 
    args = getNonDeliveredOrdersbyCourier_args()
3159 
    args.providerId = providerId
3160 
    args.write(self._oprot)
3161 
    self._oprot.writeMessageEnd()
3162 
    self._oprot.trans.flush()
3163 
 
3164 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3165 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3166 
    if mtype == TMessageType.EXCEPTION:
3167 
      x = TApplicationException()
3168 
      x.read(self._iprot)
3169 
      self._iprot.readMessageEnd()
3170 
      raise x
3171 
    result = getNonDeliveredOrdersbyCourier_result()
3172 
    result.read(self._iprot)
3173 
    self._iprot.readMessageEnd()
4581 phani.kuma 3174 
    if result.success is not None:
3175 
      return result.success
4910 phani.kuma 3176 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3177 
 
3178 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3179 
    """
3180 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3181 
 
3182 
    Parameters:
3183 
     - providerId
3184 
     - local_connected_orders
3185 
    """
3186 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3187 
    self.recv_markOrdersAsLocalConnected()
3188 
 
3189 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3190 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3191 
    args = markOrdersAsLocalConnected_args()
3192 
    args.providerId = providerId
3193 
    args.local_connected_orders = local_connected_orders
3194 
    args.write(self._oprot)
3195 
    self._oprot.writeMessageEnd()
3196 
    self._oprot.trans.flush()
3197 
 
3198 
  def recv_markOrdersAsLocalConnected(self, ):
3199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3200 
    if mtype == TMessageType.EXCEPTION:
3201 
      x = TApplicationException()
3202 
      x.read(self._iprot)
3203 
      self._iprot.readMessageEnd()
3204 
      raise x
3205 
    result = markOrdersAsLocalConnected_result()
3206 
    result.read(self._iprot)
3207 
    self._iprot.readMessageEnd()
3431 rajveer 3208 
    if result.ex is not None:
3064 chandransh 3209 
      raise result.ex
4910 phani.kuma 3210 
    return
1627 ankur.sing 3211 
 
4910 phani.kuma 3212 
  def getOrdersNotLocalConnected(self, providerId):
3213 
    """
3214 
    Returns a list of orders that were picked up or shipped but pending local connection.
3215 
 
3216 
    Parameters:
3217 
     - providerId
3218 
    """
3219 
    self.send_getOrdersNotLocalConnected(providerId)
3220 
    return self.recv_getOrdersNotLocalConnected()
3221 
 
3222 
  def send_getOrdersNotLocalConnected(self, providerId):
3223 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3224 
    args = getOrdersNotLocalConnected_args()
3225 
    args.providerId = providerId
3226 
    args.write(self._oprot)
3227 
    self._oprot.writeMessageEnd()
3228 
    self._oprot.trans.flush()
3229 
 
3230 
  def recv_getOrdersNotLocalConnected(self, ):
3231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3232 
    if mtype == TMessageType.EXCEPTION:
3233 
      x = TApplicationException()
3234 
      x.read(self._iprot)
3235 
      self._iprot.readMessageEnd()
3236 
      raise x
3237 
    result = getOrdersNotLocalConnected_result()
3238 
    result.read(self._iprot)
3239 
    self._iprot.readMessageEnd()
3240 
    if result.success is not None:
3241 
      return result.success
3242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3243 
 
3244 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3245 
    """
3246 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3247 
 
3248 
    Parameters:
3249 
     - providerId
3250 
     - destination_city_reached_orders
3251 
    """
3252 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3253 
    self.recv_markOrdersAsDestinationCityReached()
3254 
 
3255 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3256 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3257 
    args = markOrdersAsDestinationCityReached_args()
3258 
    args.providerId = providerId
3259 
    args.destination_city_reached_orders = destination_city_reached_orders
3260 
    args.write(self._oprot)
3261 
    self._oprot.writeMessageEnd()
3262 
    self._oprot.trans.flush()
3263 
 
3264 
  def recv_markOrdersAsDestinationCityReached(self, ):
3265 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3266 
    if mtype == TMessageType.EXCEPTION:
3267 
      x = TApplicationException()
3268 
      x.read(self._iprot)
3269 
      self._iprot.readMessageEnd()
3270 
      raise x
3271 
    result = markOrdersAsDestinationCityReached_result()
3272 
    result.read(self._iprot)
3273 
    self._iprot.readMessageEnd()
3274 
    if result.ex is not None:
3275 
      raise result.ex
3276 
    return
3277 
 
3278 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3279 
    """
3280 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3281 
 
3282 
    Parameters:
3283 
     - providerId
3284 
     - first_atdl_orders
3285 
    """
3286 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3287 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3288 
 
3289 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3290 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3291 
    args = markOrdersAsFirstDeliveryAttempted_args()
3292 
    args.providerId = providerId
3293 
    args.first_atdl_orders = first_atdl_orders
3294 
    args.write(self._oprot)
3295 
    self._oprot.writeMessageEnd()
3296 
    self._oprot.trans.flush()
3297 
 
3298 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3299 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3300 
    if mtype == TMessageType.EXCEPTION:
3301 
      x = TApplicationException()
3302 
      x.read(self._iprot)
3303 
      self._iprot.readMessageEnd()
3304 
      raise x
3305 
    result = markOrdersAsFirstDeliveryAttempted_result()
3306 
    result.read(self._iprot)
3307 
    self._iprot.readMessageEnd()
3308 
    if result.ex is not None:
3309 
      raise result.ex
3310 
    return
3311 
 
3064 chandransh 3312 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3313 
    """
3064 chandransh 3314 
    Returns the list of orders whose delivery time has passed but have not been
3315 
    delivered yet for the given provider and warehouse. To get a complete list of
3316 
    undelivered orders, pass them as -1.
3317 
    Returns an empty list if no such orders exist.
3431 rajveer 3318 
 
1886 ankur.sing 3319 
    Parameters:
3064 chandransh 3320 
     - providerId
3321 
     - warehouseId
1886 ankur.sing 3322 
    """
3064 chandransh 3323 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3324 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3325 
 
3064 chandransh 3326 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3327 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3328 
    args = getUndeliveredOrders_args()
3329 
    args.providerId = providerId
3330 
    args.warehouseId = warehouseId
1886 ankur.sing 3331 
    args.write(self._oprot)
3332 
    self._oprot.writeMessageEnd()
3333 
    self._oprot.trans.flush()
3334 
 
3064 chandransh 3335 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3336 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3337 
    if mtype == TMessageType.EXCEPTION:
3338 
      x = TApplicationException()
3339 
      x.read(self._iprot)
3340 
      self._iprot.readMessageEnd()
3341 
      raise x
3064 chandransh 3342 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3343 
    result.read(self._iprot)
3344 
    self._iprot.readMessageEnd()
3431 rajveer 3345 
    if result.success is not None:
1886 ankur.sing 3346 
      return result.success
3064 chandransh 3347 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3348 
 
4783 phani.kuma 3349 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3350 
    """
3351 
    Returns the list of orders whose expected delivery date has passed but have not been
3352 
    delivered yet.
3353 
    Returns an empty list if no such orders exist.
3354 
    """
3355 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3356 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3357 
 
3358 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3359 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3360 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3361 
    args.write(self._oprot)
3362 
    self._oprot.writeMessageEnd()
3363 
    self._oprot.trans.flush()
3364 
 
3365 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3366 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3367 
    if mtype == TMessageType.EXCEPTION:
3368 
      x = TApplicationException()
3369 
      x.read(self._iprot)
3370 
      self._iprot.readMessageEnd()
3371 
      raise x
3372 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3373 
    result.read(self._iprot)
3374 
    self._iprot.readMessageEnd()
3375 
    if result.success is not None:
3376 
      return result.success
3377 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3378 
 
2536 chandransh 3379 
  def toggleDOAFlag(self, orderId):
3380 
    """
3381 
    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.
3382 
    Returns the final flag status.
3383 
    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 3384 
 
2536 chandransh 3385 
    Parameters:
3386 
     - orderId
3387 
    """
3388 
    self.send_toggleDOAFlag(orderId)
3389 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3390 
 
2536 chandransh 3391 
  def send_toggleDOAFlag(self, orderId):
3392 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3393 
    args = toggleDOAFlag_args()
3394 
    args.orderId = orderId
3395 
    args.write(self._oprot)
3396 
    self._oprot.writeMessageEnd()
3397 
    self._oprot.trans.flush()
3398 
 
3399 
  def recv_toggleDOAFlag(self, ):
3400 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3401 
    if mtype == TMessageType.EXCEPTION:
3402 
      x = TApplicationException()
3403 
      x.read(self._iprot)
3404 
      self._iprot.readMessageEnd()
3405 
      raise x
3406 
    result = toggleDOAFlag_result()
3407 
    result.read(self._iprot)
3408 
    self._iprot.readMessageEnd()
3431 rajveer 3409 
    if result.success is not None:
2536 chandransh 3410 
      return result.success
3431 rajveer 3411 
    if result.ex is not None:
2536 chandransh 3412 
      raise result.ex
3413 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3414 
 
4712 rajveer 3415 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3416 
    """
3417 
    Parameters:
3418 
     - orderId
3419 
     - deliveryTimestamp
3420 
     - receiver
3421 
    """
3422 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3423 
    self.recv_markOrderAsDelivered()
3424 
 
3425 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3426 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3427 
    args = markOrderAsDelivered_args()
3428 
    args.orderId = orderId
3429 
    args.deliveryTimestamp = deliveryTimestamp
3430 
    args.receiver = receiver
3431 
    args.write(self._oprot)
3432 
    self._oprot.writeMessageEnd()
3433 
    self._oprot.trans.flush()
3434 
 
3435 
  def recv_markOrderAsDelivered(self, ):
3436 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3437 
    if mtype == TMessageType.EXCEPTION:
3438 
      x = TApplicationException()
3439 
      x.read(self._iprot)
3440 
      self._iprot.readMessageEnd()
3441 
      raise x
3442 
    result = markOrderAsDelivered_result()
3443 
    result.read(self._iprot)
3444 
    self._iprot.readMessageEnd()
3445 
    if result.ex is not None:
3446 
      raise result.ex
3447 
    return
3448 
 
5553 rajveer 3449 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3450 
    """
3451 
    Parameters:
3452 
     - orderId
3453 
     - deliveryTimestamp
3454 
    """
3455 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3456 
    self.recv_markOrderAsReceivedAtStore()
3457 
 
3458 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3459 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3460 
    args = markOrderAsReceivedAtStore_args()
3461 
    args.orderId = orderId
3462 
    args.deliveryTimestamp = deliveryTimestamp
3463 
    args.write(self._oprot)
3464 
    self._oprot.writeMessageEnd()
3465 
    self._oprot.trans.flush()
3466 
 
3467 
  def recv_markOrderAsReceivedAtStore(self, ):
3468 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3469 
    if mtype == TMessageType.EXCEPTION:
3470 
      x = TApplicationException()
3471 
      x.read(self._iprot)
3472 
      self._iprot.readMessageEnd()
3473 
      raise x
3474 
    result = markOrderAsReceivedAtStore_result()
3475 
    result.read(self._iprot)
3476 
    self._iprot.readMessageEnd()
3477 
    if result.ex is not None:
3478 
      raise result.ex
3479 
    return
3480 
 
4454 rajveer 3481 
  def markOrderDoaRequestReceived(self, orderId):
3482 
    """
3483 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3484 
 
3485 
    Parameters:
3486 
     - orderId
3487 
    """
3488 
    self.send_markOrderDoaRequestReceived(orderId)
3489 
    return self.recv_markOrderDoaRequestReceived()
3490 
 
3491 
  def send_markOrderDoaRequestReceived(self, orderId):
3492 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3493 
    args = markOrderDoaRequestReceived_args()
3494 
    args.orderId = orderId
3495 
    args.write(self._oprot)
3496 
    self._oprot.writeMessageEnd()
3497 
    self._oprot.trans.flush()
3498 
 
3499 
  def recv_markOrderDoaRequestReceived(self, ):
3500 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3501 
    if mtype == TMessageType.EXCEPTION:
3502 
      x = TApplicationException()
3503 
      x.read(self._iprot)
3504 
      self._iprot.readMessageEnd()
3505 
      raise x
3506 
    result = markOrderDoaRequestReceived_result()
3507 
    result.read(self._iprot)
3508 
    self._iprot.readMessageEnd()
3509 
    if result.success is not None:
3510 
      return result.success
3511 
    if result.ex is not None:
3512 
      raise result.ex
3513 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3514 
 
3515 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3516 
    """
3517 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3518 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3519 
 
3520 
    Parameters:
3521 
     - orderId
3522 
     - isAuthorized
3523 
    """
3524 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3525 
    return self.recv_markOrderDoaRequestAuthorized()
3526 
 
3527 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3528 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3529 
    args = markOrderDoaRequestAuthorized_args()
3530 
    args.orderId = orderId
3531 
    args.isAuthorized = isAuthorized
3532 
    args.write(self._oprot)
3533 
    self._oprot.writeMessageEnd()
3534 
    self._oprot.trans.flush()
3535 
 
3536 
  def recv_markOrderDoaRequestAuthorized(self, ):
3537 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3538 
    if mtype == TMessageType.EXCEPTION:
3539 
      x = TApplicationException()
3540 
      x.read(self._iprot)
3541 
      self._iprot.readMessageEnd()
3542 
      raise x
3543 
    result = markOrderDoaRequestAuthorized_result()
3544 
    result.read(self._iprot)
3545 
    self._iprot.readMessageEnd()
3546 
    if result.success is not None:
3547 
      return result.success
3548 
    if result.ex is not None:
3549 
      raise result.ex
3550 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3551 
 
4488 rajveer 3552 
  def markOrderReturnRequestReceived(self, orderId):
3553 
    """
3554 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3555 
 
3556 
    Parameters:
3557 
     - orderId
3558 
    """
3559 
    self.send_markOrderReturnRequestReceived(orderId)
3560 
    return self.recv_markOrderReturnRequestReceived()
3561 
 
3562 
  def send_markOrderReturnRequestReceived(self, orderId):
3563 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3564 
    args = markOrderReturnRequestReceived_args()
3565 
    args.orderId = orderId
3566 
    args.write(self._oprot)
3567 
    self._oprot.writeMessageEnd()
3568 
    self._oprot.trans.flush()
3569 
 
3570 
  def recv_markOrderReturnRequestReceived(self, ):
3571 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3572 
    if mtype == TMessageType.EXCEPTION:
3573 
      x = TApplicationException()
3574 
      x.read(self._iprot)
3575 
      self._iprot.readMessageEnd()
3576 
      raise x
3577 
    result = markOrderReturnRequestReceived_result()
3578 
    result.read(self._iprot)
3579 
    self._iprot.readMessageEnd()
3580 
    if result.success is not None:
3581 
      return result.success
3582 
    if result.ex is not None:
3583 
      raise result.ex
3584 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3585 
 
3586 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3587 
    """
3588 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3589 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3590 
 
3591 
    Parameters:
3592 
     - orderId
3593 
     - isAuthorized
3594 
    """
3595 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3596 
    return self.recv_markOrderReturnRequestAuthorized()
3597 
 
3598 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3599 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3600 
    args = markOrderReturnRequestAuthorized_args()
3601 
    args.orderId = orderId
3602 
    args.isAuthorized = isAuthorized
3603 
    args.write(self._oprot)
3604 
    self._oprot.writeMessageEnd()
3605 
    self._oprot.trans.flush()
3606 
 
3607 
  def recv_markOrderReturnRequestAuthorized(self, ):
3608 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3609 
    if mtype == TMessageType.EXCEPTION:
3610 
      x = TApplicationException()
3611 
      x.read(self._iprot)
3612 
      self._iprot.readMessageEnd()
3613 
      raise x
3614 
    result = markOrderReturnRequestAuthorized_result()
3615 
    result.read(self._iprot)
3616 
    self._iprot.readMessageEnd()
3617 
    if result.success is not None:
3618 
      return result.success
3619 
    if result.ex is not None:
3620 
      raise result.ex
3621 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3622 
 
4579 rajveer 3623 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3624 
    """
3625 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3626 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3627 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3628 
    For any other status, it returns false.
3629 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3630 
 
2536 chandransh 3631 
    Parameters:
3632 
     - orderId
4579 rajveer 3633 
     - providerId
2536 chandransh 3634 
    """
4579 rajveer 3635 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3636 
    return self.recv_requestPickupNumber()
3637 
 
4579 rajveer 3638 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3639 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3640 
    args = requestPickupNumber_args()
3641 
    args.orderId = orderId
4579 rajveer 3642 
    args.providerId = providerId
2536 chandransh 3643 
    args.write(self._oprot)
3644 
    self._oprot.writeMessageEnd()
3645 
    self._oprot.trans.flush()
3646 
 
3647 
  def recv_requestPickupNumber(self, ):
3648 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3649 
    if mtype == TMessageType.EXCEPTION:
3650 
      x = TApplicationException()
3651 
      x.read(self._iprot)
3652 
      self._iprot.readMessageEnd()
3653 
      raise x
3654 
    result = requestPickupNumber_result()
3655 
    result.read(self._iprot)
3656 
    self._iprot.readMessageEnd()
3431 rajveer 3657 
    if result.success is not None:
2536 chandransh 3658 
      return result.success
3431 rajveer 3659 
    if result.ex is not None:
2536 chandransh 3660 
      raise result.ex
3661 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3662 
 
4602 rajveer 3663 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3664 
    """
4452 rajveer 3665 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3666 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3667 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3668 
    	3. Returns true
2591 chandransh 3669 
    If the order is in any other status, it returns false.
2536 chandransh 3670 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3671 
 
2536 chandransh 3672 
    Parameters:
3673 
     - orderId
3674 
     - pickupNumber
4602 rajveer 3675 
     - providerId
2536 chandransh 3676 
    """
4602 rajveer 3677 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3678 
    return self.recv_authorizePickup()
3679 
 
4602 rajveer 3680 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3681 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3682 
    args = authorizePickup_args()
3683 
    args.orderId = orderId
3684 
    args.pickupNumber = pickupNumber
4602 rajveer 3685 
    args.providerId = providerId
2536 chandransh 3686 
    args.write(self._oprot)
3687 
    self._oprot.writeMessageEnd()
3688 
    self._oprot.trans.flush()
3689 
 
3690 
  def recv_authorizePickup(self, ):
3691 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3692 
    if mtype == TMessageType.EXCEPTION:
3693 
      x = TApplicationException()
3694 
      x.read(self._iprot)
3695 
      self._iprot.readMessageEnd()
3696 
      raise x
3697 
    result = authorizePickup_result()
3698 
    result.read(self._iprot)
3699 
    self._iprot.readMessageEnd()
3431 rajveer 3700 
    if result.success is not None:
2536 chandransh 3701 
      return result.success
3431 rajveer 3702 
    if result.ex is not None:
2536 chandransh 3703 
      raise result.ex
3704 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3705 
 
2764 chandransh 3706 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3707 
    """
3708 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3709 
 
2764 chandransh 3710 
    Parameters:
3711 
     - providerId
3712 
     - pickupDetails
3713 
    """
3714 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3715 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3716 
 
3717 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3718 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3719 
    args = markDoasAsPickedUp_args()
3720 
    args.providerId = providerId
3721 
    args.pickupDetails = pickupDetails
3722 
    args.write(self._oprot)
3723 
    self._oprot.writeMessageEnd()
3724 
    self._oprot.trans.flush()
3725 
 
3726 
  def recv_markDoasAsPickedUp(self, ):
3727 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3728 
    if mtype == TMessageType.EXCEPTION:
3729 
      x = TApplicationException()
3730 
      x.read(self._iprot)
3731 
      self._iprot.readMessageEnd()
3732 
      raise x
3733 
    result = markDoasAsPickedUp_result()
3734 
    result.read(self._iprot)
3735 
    self._iprot.readMessageEnd()
4910 phani.kuma 3736 
    return
3737 
 
3738 
  def getDoasNotPickedUp(self, providerId):
3739 
    """
3740 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3741 
 
3742 
    Parameters:
3743 
     - providerId
3744 
    """
3745 
    self.send_getDoasNotPickedUp(providerId)
3746 
    return self.recv_getDoasNotPickedUp()
3747 
 
3748 
  def send_getDoasNotPickedUp(self, providerId):
3749 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3750 
    args = getDoasNotPickedUp_args()
3751 
    args.providerId = providerId
3752 
    args.write(self._oprot)
3753 
    self._oprot.writeMessageEnd()
3754 
    self._oprot.trans.flush()
3755 
 
3756 
  def recv_getDoasNotPickedUp(self, ):
3757 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3758 
    if mtype == TMessageType.EXCEPTION:
3759 
      x = TApplicationException()
3760 
      x.read(self._iprot)
3761 
      self._iprot.readMessageEnd()
3762 
      raise x
3763 
    result = getDoasNotPickedUp_result()
3764 
    result.read(self._iprot)
3765 
    self._iprot.readMessageEnd()
3431 rajveer 3766 
    if result.success is not None:
2764 chandransh 3767 
      return result.success
4910 phani.kuma 3768 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3769 
 
4741 phani.kuma 3770 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3771 
    """
3772 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3773 
 
3774 
    Parameters:
3775 
     - providerId
3776 
     - pickupDetails
3777 
    """
3778 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3779 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3780 
 
3781 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3782 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3783 
    args = markReturnOrdersAsPickedUp_args()
3784 
    args.providerId = providerId
3785 
    args.pickupDetails = pickupDetails
3786 
    args.write(self._oprot)
3787 
    self._oprot.writeMessageEnd()
3788 
    self._oprot.trans.flush()
3789 
 
3790 
  def recv_markReturnOrdersAsPickedUp(self, ):
3791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3792 
    if mtype == TMessageType.EXCEPTION:
3793 
      x = TApplicationException()
3794 
      x.read(self._iprot)
3795 
      self._iprot.readMessageEnd()
3796 
      raise x
3797 
    result = markReturnOrdersAsPickedUp_result()
3798 
    result.read(self._iprot)
3799 
    self._iprot.readMessageEnd()
4910 phani.kuma 3800 
    return
3801 
 
3802 
  def getReturnOrdersNotPickedUp(self, providerId):
3803 
    """
3804 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3805 
 
3806 
    Parameters:
3807 
     - providerId
3808 
    """
3809 
    self.send_getReturnOrdersNotPickedUp(providerId)
3810 
    return self.recv_getReturnOrdersNotPickedUp()
3811 
 
3812 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3813 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3814 
    args = getReturnOrdersNotPickedUp_args()
3815 
    args.providerId = providerId
3816 
    args.write(self._oprot)
3817 
    self._oprot.writeMessageEnd()
3818 
    self._oprot.trans.flush()
3819 
 
3820 
  def recv_getReturnOrdersNotPickedUp(self, ):
3821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3822 
    if mtype == TMessageType.EXCEPTION:
3823 
      x = TApplicationException()
3824 
      x.read(self._iprot)
3825 
      self._iprot.readMessageEnd()
3826 
      raise x
3827 
    result = getReturnOrdersNotPickedUp_result()
3828 
    result.read(self._iprot)
3829 
    self._iprot.readMessageEnd()
4741 phani.kuma 3830 
    if result.success is not None:
3831 
      return result.success
4910 phani.kuma 3832 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3833 
 
4479 rajveer 3834 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3835 
    """
4452 rajveer 3836 
    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 3837 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3838 
    If the order is in any other state, it returns false.
3839 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3840 
 
2591 chandransh 3841 
    Parameters:
3842 
     - orderId
4479 rajveer 3843 
     - receiveCondition
2591 chandransh 3844 
    """
4479 rajveer 3845 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3846 
    return self.recv_receiveReturn()
2536 chandransh 3847 
 
4479 rajveer 3848 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3849 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3850 
    args = receiveReturn_args()
2591 chandransh 3851 
    args.orderId = orderId
4479 rajveer 3852 
    args.receiveCondition = receiveCondition
2591 chandransh 3853 
    args.write(self._oprot)
3854 
    self._oprot.writeMessageEnd()
3855 
    self._oprot.trans.flush()
3856 
 
2616 chandransh 3857 
  def recv_receiveReturn(self, ):
2591 chandransh 3858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3859 
    if mtype == TMessageType.EXCEPTION:
3860 
      x = TApplicationException()
3861 
      x.read(self._iprot)
3862 
      self._iprot.readMessageEnd()
3863 
      raise x
2616 chandransh 3864 
    result = receiveReturn_result()
2591 chandransh 3865 
    result.read(self._iprot)
3866 
    self._iprot.readMessageEnd()
3431 rajveer 3867 
    if result.success is not None:
2591 chandransh 3868 
      return result.success
3431 rajveer 3869 
    if result.ex is not None:
2591 chandransh 3870 
      raise result.ex
2616 chandransh 3871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3872 
 
3873 
  def validateDoa(self, orderId, isValid):
3874 
    """
4452 rajveer 3875 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3876 
    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 3877 
    If the order is in any other state, it returns false.
3878 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3879 
 
2591 chandransh 3880 
    Parameters:
3881 
     - orderId
3882 
     - isValid
3883 
    """
3884 
    self.send_validateDoa(orderId, isValid)
3885 
    return self.recv_validateDoa()
3886 
 
3887 
  def send_validateDoa(self, orderId, isValid):
3888 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3889 
    args = validateDoa_args()
3890 
    args.orderId = orderId
3891 
    args.isValid = isValid
3892 
    args.write(self._oprot)
3893 
    self._oprot.writeMessageEnd()
3894 
    self._oprot.trans.flush()
3895 
 
3896 
  def recv_validateDoa(self, ):
3897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3898 
    if mtype == TMessageType.EXCEPTION:
3899 
      x = TApplicationException()
3900 
      x.read(self._iprot)
3901 
      self._iprot.readMessageEnd()
3902 
      raise x
3903 
    result = validateDoa_result()
3904 
    result.read(self._iprot)
3905 
    self._iprot.readMessageEnd()
3431 rajveer 3906 
    if result.success is not None:
2591 chandransh 3907 
      return result.success
3431 rajveer 3908 
    if result.ex is not None:
2591 chandransh 3909 
      raise result.ex
3910 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3911 
 
4495 rajveer 3912 
  def validateReturnProduct(self, orderId, isUsable):
3913 
    """
3914 
    Parameters:
3915 
     - orderId
3916 
     - isUsable
3917 
    """
3918 
    self.send_validateReturnProduct(orderId, isUsable)
3919 
    return self.recv_validateReturnProduct()
3920 
 
3921 
  def send_validateReturnProduct(self, orderId, isUsable):
3922 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3923 
    args = validateReturnProduct_args()
3924 
    args.orderId = orderId
3925 
    args.isUsable = isUsable
3926 
    args.write(self._oprot)
3927 
    self._oprot.writeMessageEnd()
3928 
    self._oprot.trans.flush()
3929 
 
3930 
  def recv_validateReturnProduct(self, ):
3931 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3932 
    if mtype == TMessageType.EXCEPTION:
3933 
      x = TApplicationException()
3934 
      x.read(self._iprot)
3935 
      self._iprot.readMessageEnd()
3936 
      raise x
3937 
    result = validateReturnProduct_result()
3938 
    result.read(self._iprot)
3939 
    self._iprot.readMessageEnd()
3940 
    if result.success is not None:
3941 
      return result.success
3942 
    if result.ex is not None:
3943 
      raise result.ex
3944 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3945 
 
2616 chandransh 3946 
  def reshipOrder(self, orderId):
3947 
    """
4484 rajveer 3948 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3949 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3950 
    	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 3951 
 
3952 
    If the order is in DOA_CERT_VALID state, it does the following:
3953 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3954 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3955 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3956 
 
2616 chandransh 3957 
    Returns the id of the newly created order.
3431 rajveer 3958 
 
2616 chandransh 3959 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3960 
 
2616 chandransh 3961 
    Parameters:
3962 
     - orderId
3963 
    """
3964 
    self.send_reshipOrder(orderId)
3965 
    return self.recv_reshipOrder()
2591 chandransh 3966 
 
2616 chandransh 3967 
  def send_reshipOrder(self, orderId):
3968 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3969 
    args = reshipOrder_args()
3970 
    args.orderId = orderId
3971 
    args.write(self._oprot)
3972 
    self._oprot.writeMessageEnd()
3973 
    self._oprot.trans.flush()
3974 
 
3975 
  def recv_reshipOrder(self, ):
3976 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3977 
    if mtype == TMessageType.EXCEPTION:
3978 
      x = TApplicationException()
3979 
      x.read(self._iprot)
3980 
      self._iprot.readMessageEnd()
3981 
      raise x
3982 
    result = reshipOrder_result()
3983 
    result.read(self._iprot)
3984 
    self._iprot.readMessageEnd()
3431 rajveer 3985 
    if result.success is not None:
2616 chandransh 3986 
      return result.success
3431 rajveer 3987 
    if result.ex is not None:
2616 chandransh 3988 
      raise result.ex
3989 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3990 
 
3226 chandransh 3991 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3992 
    """
4484 rajveer 3993 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3994 
    	1. Creates a refund request for batch processing.
3995 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3996 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3997 
 
2616 chandransh 3998 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3999 
    	1. Creates a refund request for batch processing.
3226 chandransh 4000 
    	2. Cancels the reservation of the item in the warehouse.
4001 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 4002 
 
3226 chandransh 4003 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
4004 
    	1. Cancels the reservation of the item in the warehouse.
4005 
    	2. Marks the current order as CANCELED.
4006 
 
4007 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
4008 
 
2616 chandransh 4009 
    Returns True if it is successful, False otherwise.
3431 rajveer 4010 
 
2616 chandransh 4011 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 4012 
 
2616 chandransh 4013 
    Parameters:
4014 
     - orderId
3226 chandransh 4015 
     - refundedBy
4016 
     - reason
2616 chandransh 4017 
    """
3226 chandransh 4018 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 4019 
    return self.recv_refundOrder()
4020 
 
3226 chandransh 4021 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 4022 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
4023 
    args = refundOrder_args()
4024 
    args.orderId = orderId
3226 chandransh 4025 
    args.refundedBy = refundedBy
4026 
    args.reason = reason
2616 chandransh 4027 
    args.write(self._oprot)
4028 
    self._oprot.writeMessageEnd()
4029 
    self._oprot.trans.flush()
4030 
 
4031 
  def recv_refundOrder(self, ):
4032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4033 
    if mtype == TMessageType.EXCEPTION:
4034 
      x = TApplicationException()
4035 
      x.read(self._iprot)
4036 
      self._iprot.readMessageEnd()
4037 
      raise x
4038 
    result = refundOrder_result()
4039 
    result.read(self._iprot)
4040 
    self._iprot.readMessageEnd()
3431 rajveer 4041 
    if result.success is not None:
2616 chandransh 4042 
      return result.success
3431 rajveer 4043 
    if result.ex is not None:
2616 chandransh 4044 
      raise result.ex
4045 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
4046 
 
2690 chandransh 4047 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
4048 
    """
4049 
    Get all return orders created between the from and to dates for the given warehouse.
4050 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 4051 
 
2690 chandransh 4052 
    Parameters:
4053 
     - warehouseId
4054 
     - fromDate
4055 
     - toDate
4056 
    """
4057 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
4058 
    return self.recv_getReturnOrders()
2616 chandransh 4059 
 
2690 chandransh 4060 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
4061 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
4062 
    args = getReturnOrders_args()
4063 
    args.warehouseId = warehouseId
4064 
    args.fromDate = fromDate
4065 
    args.toDate = toDate
4066 
    args.write(self._oprot)
4067 
    self._oprot.writeMessageEnd()
4068 
    self._oprot.trans.flush()
4069 
 
4070 
  def recv_getReturnOrders(self, ):
4071 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4072 
    if mtype == TMessageType.EXCEPTION:
4073 
      x = TApplicationException()
4074 
      x.read(self._iprot)
4075 
      self._iprot.readMessageEnd()
4076 
      raise x
4077 
    result = getReturnOrders_result()
4078 
    result.read(self._iprot)
4079 
    self._iprot.readMessageEnd()
3431 rajveer 4080 
    if result.success is not None:
2690 chandransh 4081 
      return result.success
4082 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
4083 
 
5481 phani.kuma 4084 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4085 
    """
4086 
    Get all return orders created between the from and to dates.
4087 
 
4088 
    Parameters:
4089 
     - onlyNotProcessed
4090 
     - fromDate
4091 
     - toDate
4092 
    """
4093 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
4094 
    return self.recv_getAllReturnOrders()
4095 
 
4096 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
4097 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
4098 
    args = getAllReturnOrders_args()
4099 
    args.onlyNotProcessed = onlyNotProcessed
4100 
    args.fromDate = fromDate
4101 
    args.toDate = toDate
4102 
    args.write(self._oprot)
4103 
    self._oprot.writeMessageEnd()
4104 
    self._oprot.trans.flush()
4105 
 
4106 
  def recv_getAllReturnOrders(self, ):
4107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4108 
    if mtype == TMessageType.EXCEPTION:
4109 
      x = TApplicationException()
4110 
      x.read(self._iprot)
4111 
      self._iprot.readMessageEnd()
4112 
      raise x
4113 
    result = getAllReturnOrders_result()
4114 
    result.read(self._iprot)
4115 
    self._iprot.readMessageEnd()
4116 
    if result.success is not None:
4117 
      return result.success
4118 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
4119 
 
2700 chandransh 4120 
  def getReturnOrder(self, id):
4121 
    """
4122 
    Returns the ReturnOrder corresponding to the given id.
4123 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 4124 
 
2700 chandransh 4125 
    Parameters:
4126 
     - id
4127 
    """
4128 
    self.send_getReturnOrder(id)
4129 
    return self.recv_getReturnOrder()
4130 
 
4131 
  def send_getReturnOrder(self, id):
4132 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
4133 
    args = getReturnOrder_args()
4134 
    args.id = id
4135 
    args.write(self._oprot)
4136 
    self._oprot.writeMessageEnd()
4137 
    self._oprot.trans.flush()
4138 
 
4139 
  def recv_getReturnOrder(self, ):
4140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4141 
    if mtype == TMessageType.EXCEPTION:
4142 
      x = TApplicationException()
4143 
      x.read(self._iprot)
4144 
      self._iprot.readMessageEnd()
4145 
      raise x
4146 
    result = getReturnOrder_result()
4147 
    result.read(self._iprot)
4148 
    self._iprot.readMessageEnd()
3431 rajveer 4149 
    if result.success is not None:
2700 chandransh 4150 
      return result.success
3431 rajveer 4151 
    if result.ex is not None:
2700 chandransh 4152 
      raise result.ex
4153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4154 
 
2690 chandransh 4155 
  def processReturn(self, returnOrderId):
4156 
    """
4157 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4158 
 
2690 chandransh 4159 
    Parameters:
4160 
     - returnOrderId
4161 
    """
4162 
    self.send_processReturn(returnOrderId)
4163 
    self.recv_processReturn()
4164 
 
4165 
  def send_processReturn(self, returnOrderId):
4166 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4167 
    args = processReturn_args()
4168 
    args.returnOrderId = returnOrderId
4169 
    args.write(self._oprot)
4170 
    self._oprot.writeMessageEnd()
4171 
    self._oprot.trans.flush()
4172 
 
4173 
  def recv_processReturn(self, ):
4174 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4175 
    if mtype == TMessageType.EXCEPTION:
4176 
      x = TApplicationException()
4177 
      x.read(self._iprot)
4178 
      self._iprot.readMessageEnd()
4179 
      raise x
4180 
    result = processReturn_result()
4181 
    result.read(self._iprot)
4182 
    self._iprot.readMessageEnd()
3431 rajveer 4183 
    if result.ex is not None:
2690 chandransh 4184 
      raise result.ex
4185 
    return
4186 
 
3451 chandransh 4187 
  def updateWeight(self, orderId, weight):
4188 
    """
4189 
    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 4190 
 
3451 chandransh 4191 
    Parameters:
4192 
     - orderId
4193 
     - weight
4194 
    """
4195 
    self.send_updateWeight(orderId, weight)
4196 
    return self.recv_updateWeight()
4197 
 
4198 
  def send_updateWeight(self, orderId, weight):
4199 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4200 
    args = updateWeight_args()
4201 
    args.orderId = orderId
4202 
    args.weight = weight
4203 
    args.write(self._oprot)
4204 
    self._oprot.writeMessageEnd()
4205 
    self._oprot.trans.flush()
4206 
 
4207 
  def recv_updateWeight(self, ):
4208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4209 
    if mtype == TMessageType.EXCEPTION:
4210 
      x = TApplicationException()
4211 
      x.read(self._iprot)
4212 
      self._iprot.readMessageEnd()
4213 
      raise x
4214 
    result = updateWeight_result()
4215 
    result.read(self._iprot)
4216 
    self._iprot.readMessageEnd()
4217 
    if result.success is not None:
4218 
      return result.success
4219 
    if result.ex is not None:
4220 
      raise result.ex
4221 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4222 
 
3469 chandransh 4223 
  def changeItem(self, orderId, itemId):
4224 
    """
4225 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4226 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4227 
 
3469 chandransh 4228 
    Parameters:
4229 
     - orderId
4230 
     - itemId
4231 
    """
4232 
    self.send_changeItem(orderId, itemId)
4233 
    return self.recv_changeItem()
4234 
 
4235 
  def send_changeItem(self, orderId, itemId):
4236 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4237 
    args = changeItem_args()
4238 
    args.orderId = orderId
4239 
    args.itemId = itemId
4240 
    args.write(self._oprot)
4241 
    self._oprot.writeMessageEnd()
4242 
    self._oprot.trans.flush()
4243 
 
4244 
  def recv_changeItem(self, ):
4245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4246 
    if mtype == TMessageType.EXCEPTION:
4247 
      x = TApplicationException()
4248 
      x.read(self._iprot)
4249 
      self._iprot.readMessageEnd()
4250 
      raise x
4251 
    result = changeItem_result()
4252 
    result.read(self._iprot)
4253 
    self._iprot.readMessageEnd()
4254 
    if result.success is not None:
4255 
      return result.success
4256 
    if result.ex is not None:
4257 
      raise result.ex
4258 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4259 
 
4260 
  def shiftToWarehouse(self, orderId, warehouseId):
4261 
    """
4262 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4263 
 
4264 
    Parameters:
4265 
     - orderId
4266 
     - warehouseId
4267 
    """
4268 
    self.send_shiftToWarehouse(orderId, warehouseId)
4269 
    return self.recv_shiftToWarehouse()
4270 
 
4271 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4272 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4273 
    args = shiftToWarehouse_args()
4274 
    args.orderId = orderId
4275 
    args.warehouseId = warehouseId
4276 
    args.write(self._oprot)
4277 
    self._oprot.writeMessageEnd()
4278 
    self._oprot.trans.flush()
4279 
 
4280 
  def recv_shiftToWarehouse(self, ):
4281 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4282 
    if mtype == TMessageType.EXCEPTION:
4283 
      x = TApplicationException()
4284 
      x.read(self._iprot)
4285 
      self._iprot.readMessageEnd()
4286 
      raise x
4287 
    result = shiftToWarehouse_result()
4288 
    result.read(self._iprot)
4289 
    self._iprot.readMessageEnd()
4290 
    if result.success is not None:
4291 
      return result.success
4292 
    if result.ex is not None:
4293 
      raise result.ex
4294 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4295 
 
4647 rajveer 4296 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4297 
    """
4298 
    Adds the given delay reason to the given order.
3986 chandransh 4299 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4300 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4301 
 
3553 chandransh 4302 
    Parameters:
4303 
     - orderId
4304 
     - delayReason
3986 chandransh 4305 
     - furtherDelay
4647 rajveer 4306 
     - delayReasonText
3553 chandransh 4307 
    """
4647 rajveer 4308 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4309 
    return self.recv_addDelayReason()
4310 
 
4647 rajveer 4311 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4312 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4313 
    args = addDelayReason_args()
4314 
    args.orderId = orderId
4315 
    args.delayReason = delayReason
3986 chandransh 4316 
    args.furtherDelay = furtherDelay
4647 rajveer 4317 
    args.delayReasonText = delayReasonText
3553 chandransh 4318 
    args.write(self._oprot)
4319 
    self._oprot.writeMessageEnd()
4320 
    self._oprot.trans.flush()
4321 
 
4322 
  def recv_addDelayReason(self, ):
4323 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4324 
    if mtype == TMessageType.EXCEPTION:
4325 
      x = TApplicationException()
4326 
      x.read(self._iprot)
4327 
      self._iprot.readMessageEnd()
4328 
      raise x
4329 
    result = addDelayReason_result()
4330 
    result.read(self._iprot)
4331 
    self._iprot.readMessageEnd()
4332 
    if result.success is not None:
4333 
      return result.success
4334 
    if result.ex is not None:
4335 
      raise result.ex
4336 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4337 
 
3956 chandransh 4338 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4339 
    """
4340 
    Marks the COD orders with given AWB nos. as having been processed.
4341 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4342 
 
3956 chandransh 4343 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4344 
    1. There is no order corresponding to an AWB number.
4345 
    2. The captured amount for a payment exceeds the total payment.
4346 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4347 
 
4348 
    Parameters:
4349 
     - collectedAmountMap
4350 
     - xferBy
4351 
     - xferTxnId
4352 
     - xferDate
4353 
    """
4354 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4355 
    return self.recv_reconcileCodCollection()
4356 
 
4357 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4358 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4359 
    args = reconcileCodCollection_args()
4360 
    args.collectedAmountMap = collectedAmountMap
4361 
    args.xferBy = xferBy
4362 
    args.xferTxnId = xferTxnId
4363 
    args.xferDate = xferDate
4364 
    args.write(self._oprot)
4365 
    self._oprot.writeMessageEnd()
4366 
    self._oprot.trans.flush()
4367 
 
4368 
  def recv_reconcileCodCollection(self, ):
4369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4370 
    if mtype == TMessageType.EXCEPTION:
4371 
      x = TApplicationException()
4372 
      x.read(self._iprot)
4373 
      self._iprot.readMessageEnd()
4374 
      raise x
4375 
    result = reconcileCodCollection_result()
4376 
    result.read(self._iprot)
4377 
    self._iprot.readMessageEnd()
4378 
    if result.success is not None:
4379 
      return result.success
4380 
    if result.ex is not None:
4381 
      raise result.ex
4382 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4383 
 
4008 mandeep.dh 4384 
  def getTransactionsRequiringExtraProcessing(self, category):
4385 
    """
4065 mandeep.dh 4386 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4387 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4388 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4389 
 
4008 mandeep.dh 4390 
    Parameters:
4391 
     - category
4392 
    """
4393 
    self.send_getTransactionsRequiringExtraProcessing(category)
4394 
    return self.recv_getTransactionsRequiringExtraProcessing()
4395 
 
4396 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4397 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4398 
    args = getTransactionsRequiringExtraProcessing_args()
4399 
    args.category = category
4400 
    args.write(self._oprot)
4401 
    self._oprot.writeMessageEnd()
4402 
    self._oprot.trans.flush()
4403 
 
4404 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4405 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4406 
    if mtype == TMessageType.EXCEPTION:
4407 
      x = TApplicationException()
4408 
      x.read(self._iprot)
4409 
      self._iprot.readMessageEnd()
4410 
      raise x
4411 
    result = getTransactionsRequiringExtraProcessing_result()
4412 
    result.read(self._iprot)
4413 
    self._iprot.readMessageEnd()
4414 
    if result.success is not None:
4415 
      return result.success
4416 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4417 
 
4418 
  def markTransactionAsProcessed(self, transactionId, category):
4419 
    """
4420 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4421 
    It essentially deletes the transaction id record for a particular
4422 
    processing type category (if present) from DB.
4423 
    This is currently used by CRM application.
4008 mandeep.dh 4424 
 
4425 
    Parameters:
4426 
     - transactionId
4427 
     - category
4428 
    """
4429 
    self.send_markTransactionAsProcessed(transactionId, category)
4430 
    self.recv_markTransactionAsProcessed()
4431 
 
4432 
  def send_markTransactionAsProcessed(self, transactionId, category):
4433 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4434 
    args = markTransactionAsProcessed_args()
4435 
    args.transactionId = transactionId
4436 
    args.category = category
4437 
    args.write(self._oprot)
4438 
    self._oprot.writeMessageEnd()
4439 
    self._oprot.trans.flush()
4440 
 
4441 
  def recv_markTransactionAsProcessed(self, ):
4442 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4443 
    if mtype == TMessageType.EXCEPTION:
4444 
      x = TApplicationException()
4445 
      x.read(self._iprot)
4446 
      self._iprot.readMessageEnd()
4447 
      raise x
4448 
    result = markTransactionAsProcessed_result()
4449 
    result.read(self._iprot)
4450 
    self._iprot.readMessageEnd()
4451 
    return
4452 
 
4018 chandransh 4453 
  def getItemWiseRiskyOrdersCount(self, ):
4454 
    """
4455 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4456 
    is defined as one whose shipping date is about to expire.
4457 
    """
4458 
    self.send_getItemWiseRiskyOrdersCount()
4459 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4460 
 
4018 chandransh 4461 
  def send_getItemWiseRiskyOrdersCount(self, ):
4462 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4463 
    args = getItemWiseRiskyOrdersCount_args()
4464 
    args.write(self._oprot)
4465 
    self._oprot.writeMessageEnd()
4466 
    self._oprot.trans.flush()
4467 
 
4468 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4470 
    if mtype == TMessageType.EXCEPTION:
4471 
      x = TApplicationException()
4472 
      x.read(self._iprot)
4473 
      self._iprot.readMessageEnd()
4474 
      raise x
4475 
    result = getItemWiseRiskyOrdersCount_result()
4476 
    result.read(self._iprot)
4477 
    self._iprot.readMessageEnd()
4478 
    if result.success is not None:
4479 
      return result.success
4480 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4481 
 
4295 varun.gupt 4482 
  def getOrdersForItemIds(self, itemIds):
4483 
    """
4484 
    Returns a list of all orders which have items with given id
4485 
 
4486 
    Parameters:
4487 
     - itemIds
4488 
    """
4489 
    self.send_getOrdersForItemIds(itemIds)
4490 
    return self.recv_getOrdersForItemIds()
4491 
 
4492 
  def send_getOrdersForItemIds(self, itemIds):
4493 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4494 
    args = getOrdersForItemIds_args()
4495 
    args.itemIds = itemIds
4496 
    args.write(self._oprot)
4497 
    self._oprot.writeMessageEnd()
4498 
    self._oprot.trans.flush()
4499 
 
4500 
  def recv_getOrdersForItemIds(self, ):
4501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4502 
    if mtype == TMessageType.EXCEPTION:
4503 
      x = TApplicationException()
4504 
      x.read(self._iprot)
4505 
      self._iprot.readMessageEnd()
4506 
      raise x
4507 
    result = getOrdersForItemIds_result()
4508 
    result.read(self._iprot)
4509 
    self._iprot.readMessageEnd()
4510 
    if result.success is not None:
4511 
      return result.success
4512 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4513 
 
4247 rajveer 4514 
  def markOrderCancellationRequestReceived(self, orderId):
4515 
    """
4516 
    Mark order as cancellation request received. If customer sends request of cancellation of
4517 
    a particular order, this method will be called. It will just change status of the order
4518 
    depending on its current status. It also records the previous status, so that we can move
4519 
    back to that status if cancellation request is denied.
4018 chandransh 4520 
 
4247 rajveer 4521 
    Parameters:
4522 
     - orderId
4523 
    """
4524 
    self.send_markOrderCancellationRequestReceived(orderId)
4525 
    self.recv_markOrderCancellationRequestReceived()
4526 
 
4527 
  def send_markOrderCancellationRequestReceived(self, orderId):
4528 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4529 
    args = markOrderCancellationRequestReceived_args()
4530 
    args.orderId = orderId
4531 
    args.write(self._oprot)
4532 
    self._oprot.writeMessageEnd()
4533 
    self._oprot.trans.flush()
4534 
 
4535 
  def recv_markOrderCancellationRequestReceived(self, ):
4536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4537 
    if mtype == TMessageType.EXCEPTION:
4538 
      x = TApplicationException()
4539 
      x.read(self._iprot)
4540 
      self._iprot.readMessageEnd()
4541 
      raise x
4542 
    result = markOrderCancellationRequestReceived_result()
4543 
    result.read(self._iprot)
4544 
    self._iprot.readMessageEnd()
4545 
    if result.ex is not None:
4546 
      raise result.ex
4547 
    return
4548 
 
4549 
  def markOrderCancellationRequestConfirmed(self, orderId):
4550 
    """
4551 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4552 
    cancellation request confirmed. After this OM will be able to cancel the order.
4553 
 
4554 
    Parameters:
4555 
     - orderId
4556 
    """
4557 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4558 
    self.recv_markOrderCancellationRequestConfirmed()
4559 
 
4560 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4561 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4562 
    args = markOrderCancellationRequestConfirmed_args()
4563 
    args.orderId = orderId
4564 
    args.write(self._oprot)
4565 
    self._oprot.writeMessageEnd()
4566 
    self._oprot.trans.flush()
4567 
 
4568 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4569 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4570 
    if mtype == TMessageType.EXCEPTION:
4571 
      x = TApplicationException()
4572 
      x.read(self._iprot)
4573 
      self._iprot.readMessageEnd()
4574 
      raise x
4575 
    result = markOrderCancellationRequestConfirmed_result()
4576 
    result.read(self._iprot)
4577 
    self._iprot.readMessageEnd()
4578 
    if result.ex is not None:
4579 
      raise result.ex
4580 
    return
4581 
 
4582 
  def markOrderCancellationRequestDenied(self, orderId):
4583 
    """
4584 
    If we decide to not to cancel order, we will move the order ro previous status.
4585 
 
4586 
    Parameters:
4587 
     - orderId
4588 
    """
4589 
    self.send_markOrderCancellationRequestDenied(orderId)
4590 
    self.recv_markOrderCancellationRequestDenied()
4591 
 
4592 
  def send_markOrderCancellationRequestDenied(self, orderId):
4593 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4594 
    args = markOrderCancellationRequestDenied_args()
4595 
    args.orderId = orderId
4596 
    args.write(self._oprot)
4597 
    self._oprot.writeMessageEnd()
4598 
    self._oprot.trans.flush()
4599 
 
4600 
  def recv_markOrderCancellationRequestDenied(self, ):
4601 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4602 
    if mtype == TMessageType.EXCEPTION:
4603 
      x = TApplicationException()
4604 
      x.read(self._iprot)
4605 
      self._iprot.readMessageEnd()
4606 
      raise x
4607 
    result = markOrderCancellationRequestDenied_result()
4608 
    result.read(self._iprot)
4609 
    self._iprot.readMessageEnd()
4610 
    if result.ex is not None:
4611 
      raise result.ex
4612 
    return
4613 
 
4258 rajveer 4614 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4615 
    """
4258 rajveer 4616 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4617 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4618 
 
4619 
    Parameters:
4258 rajveer 4620 
     - transactionId
4247 rajveer 4621 
    """
4258 rajveer 4622 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4623 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4624 
 
4258 rajveer 4625 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4626 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4627 
    args = markTransactionAsPaymentFlagRemoved_args()
4628 
    args.transactionId = transactionId
4247 rajveer 4629 
    args.write(self._oprot)
4630 
    self._oprot.writeMessageEnd()
4631 
    self._oprot.trans.flush()
4632 
 
4258 rajveer 4633 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4635 
    if mtype == TMessageType.EXCEPTION:
4636 
      x = TApplicationException()
4637 
      x.read(self._iprot)
4638 
      self._iprot.readMessageEnd()
4639 
      raise x
4258 rajveer 4640 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4641 
    result.read(self._iprot)
4642 
    self._iprot.readMessageEnd()
4643 
    if result.ex is not None:
4644 
      raise result.ex
4645 
    return
4646 
 
4259 anupam.sin 4647 
  def refundTransaction(self, transactionId, refundedBy, reason):
4648 
    """
4649 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4650 
    need to be cancelled
4247 rajveer 4651 
 
4259 anupam.sin 4652 
    Parameters:
4653 
     - transactionId
4654 
     - refundedBy
4655 
     - reason
4656 
    """
4657 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4658 
    self.recv_refundTransaction()
4659 
 
4660 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4661 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4662 
    args = refundTransaction_args()
4663 
    args.transactionId = transactionId
4664 
    args.refundedBy = refundedBy
4665 
    args.reason = reason
4666 
    args.write(self._oprot)
4667 
    self._oprot.writeMessageEnd()
4668 
    self._oprot.trans.flush()
4669 
 
4670 
  def recv_refundTransaction(self, ):
4671 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4672 
    if mtype == TMessageType.EXCEPTION:
4673 
      x = TApplicationException()
4674 
      x.read(self._iprot)
4675 
      self._iprot.readMessageEnd()
4676 
      raise x
4677 
    result = refundTransaction_result()
4678 
    result.read(self._iprot)
4679 
    self._iprot.readMessageEnd()
4680 
    if result.ex is not None:
4681 
      raise result.ex
4682 
    return
4683 
 
4324 mandeep.dh 4684 
  def updateShipmentAddress(self, orderId, addressId):
4685 
    """
4686 
    Updates shipment address of an order. Delivery and shipping date estimates
4687 
    etc. are also updated here.
4688 
 
4689 
    Throws TransactionServiceException in case address change is not
4690 
    possible due to certain reasons such as new pincode in address is
4691 
    not serviceable etc.
4692 
 
4693 
    Parameters:
4694 
     - orderId
4695 
     - addressId
4696 
    """
4697 
    self.send_updateShipmentAddress(orderId, addressId)
4698 
    self.recv_updateShipmentAddress()
4699 
 
4700 
  def send_updateShipmentAddress(self, orderId, addressId):
4701 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4702 
    args = updateShipmentAddress_args()
4703 
    args.orderId = orderId
4704 
    args.addressId = addressId
4705 
    args.write(self._oprot)
4706 
    self._oprot.writeMessageEnd()
4707 
    self._oprot.trans.flush()
4708 
 
4709 
  def recv_updateShipmentAddress(self, ):
4710 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4711 
    if mtype == TMessageType.EXCEPTION:
4712 
      x = TApplicationException()
4713 
      x.read(self._iprot)
4714 
      self._iprot.readMessageEnd()
4715 
      raise x
4716 
    result = updateShipmentAddress_result()
4717 
    result.read(self._iprot)
4718 
    self._iprot.readMessageEnd()
4719 
    if result.ex is not None:
4720 
      raise result.ex
4721 
    return
4722 
 
4285 rajveer 4723 
  def acceptOrdersForItemId(self, itemId, inventory):
4724 
    """
4725 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4726 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4727 
 
4285 rajveer 4728 
    Parameters:
4729 
     - itemId
4730 
     - inventory
4731 
    """
4732 
    self.send_acceptOrdersForItemId(itemId, inventory)
4733 
    return self.recv_acceptOrdersForItemId()
4734 
 
4735 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4736 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4737 
    args = acceptOrdersForItemId_args()
4738 
    args.itemId = itemId
4739 
    args.inventory = inventory
4740 
    args.write(self._oprot)
4741 
    self._oprot.writeMessageEnd()
4742 
    self._oprot.trans.flush()
4743 
 
4744 
  def recv_acceptOrdersForItemId(self, ):
4745 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4746 
    if mtype == TMessageType.EXCEPTION:
4747 
      x = TApplicationException()
4748 
      x.read(self._iprot)
4749 
      self._iprot.readMessageEnd()
4750 
      raise x
4751 
    result = acceptOrdersForItemId_result()
4752 
    result.read(self._iprot)
4753 
    self._iprot.readMessageEnd()
4754 
    if result.success is not None:
4755 
      return result.success
4756 
    if result.ex is not None:
4757 
      raise result.ex
4758 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4759 
 
4369 rajveer 4760 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4761 
    """
4762 
    Parameters:
4763 
     - vendorId
4764 
     - itemId
4765 
     - quantity
4766 
     - estimate
4369 rajveer 4767 
     - isReminder
4303 rajveer 4768 
    """
4369 rajveer 4769 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4770 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4771 
 
4369 rajveer 4772 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4773 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4774 
    args = markOrdersAsPORaised_args()
4775 
    args.vendorId = vendorId
4776 
    args.itemId = itemId
4777 
    args.quantity = quantity
4778 
    args.estimate = estimate
4369 rajveer 4779 
    args.isReminder = isReminder
4303 rajveer 4780 
    args.write(self._oprot)
4781 
    self._oprot.writeMessageEnd()
4782 
    self._oprot.trans.flush()
4783 
 
4784 
  def recv_markOrdersAsPORaised(self, ):
4785 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4786 
    if mtype == TMessageType.EXCEPTION:
4787 
      x = TApplicationException()
4788 
      x.read(self._iprot)
4789 
      self._iprot.readMessageEnd()
4790 
      raise x
4791 
    result = markOrdersAsPORaised_result()
4792 
    result.read(self._iprot)
4793 
    self._iprot.readMessageEnd()
4794 
    if result.ex is not None:
4795 
      raise result.ex
4796 
    return
4797 
 
4369 rajveer 4798 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4799 
    """
4800 
    Parameters:
4801 
     - vendorId
4802 
     - itemId
4803 
     - quantity
4804 
     - estimate
4369 rajveer 4805 
     - isReminder
4303 rajveer 4806 
    """
4369 rajveer 4807 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4808 
    self.recv_markOrdersAsReversalInitiated()
4809 
 
4369 rajveer 4810 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4811 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4812 
    args = markOrdersAsReversalInitiated_args()
4813 
    args.vendorId = vendorId
4814 
    args.itemId = itemId
4815 
    args.quantity = quantity
4816 
    args.estimate = estimate
4369 rajveer 4817 
    args.isReminder = isReminder
4303 rajveer 4818 
    args.write(self._oprot)
4819 
    self._oprot.writeMessageEnd()
4820 
    self._oprot.trans.flush()
4821 
 
4822 
  def recv_markOrdersAsReversalInitiated(self, ):
4823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4824 
    if mtype == TMessageType.EXCEPTION:
4825 
      x = TApplicationException()
4826 
      x.read(self._iprot)
4827 
      self._iprot.readMessageEnd()
4828 
      raise x
4829 
    result = markOrdersAsReversalInitiated_result()
4830 
    result.read(self._iprot)
4831 
    self._iprot.readMessageEnd()
4832 
    if result.ex is not None:
4833 
      raise result.ex
4834 
    return
4835 
 
4369 rajveer 4836 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4837 
    """
4838 
    Parameters:
4839 
     - vendorId
4840 
     - itemId
4841 
     - quantity
4842 
     - estimate
4369 rajveer 4843 
     - isReminder
4303 rajveer 4844 
    """
4369 rajveer 4845 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4846 
    self.recv_markOrdersAsNotAvailabke()
4847 
 
4369 rajveer 4848 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4849 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4850 
    args = markOrdersAsNotAvailabke_args()
4851 
    args.vendorId = vendorId
4852 
    args.itemId = itemId
4853 
    args.quantity = quantity
4854 
    args.estimate = estimate
4369 rajveer 4855 
    args.isReminder = isReminder
4303 rajveer 4856 
    args.write(self._oprot)
4857 
    self._oprot.writeMessageEnd()
4858 
    self._oprot.trans.flush()
4859 
 
4860 
  def recv_markOrdersAsNotAvailabke(self, ):
4861 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4862 
    if mtype == TMessageType.EXCEPTION:
4863 
      x = TApplicationException()
4864 
      x.read(self._iprot)
4865 
      self._iprot.readMessageEnd()
4866 
      raise x
4867 
    result = markOrdersAsNotAvailabke_result()
4868 
    result.read(self._iprot)
4869 
    self._iprot.readMessageEnd()
4870 
    if result.ex is not None:
4871 
      raise result.ex
4872 
    return
4873 
 
4369 rajveer 4874 
  def markOrdersAsTimeout(self, vendorId):
4875 
    """
4876 
    Parameters:
4877 
     - vendorId
4878 
    """
4879 
    self.send_markOrdersAsTimeout(vendorId)
4880 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4881 
 
4369 rajveer 4882 
  def send_markOrdersAsTimeout(self, vendorId):
4883 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4884 
    args = markOrdersAsTimeout_args()
4885 
    args.vendorId = vendorId
4886 
    args.write(self._oprot)
4887 
    self._oprot.writeMessageEnd()
4888 
    self._oprot.trans.flush()
4889 
 
4890 
  def recv_markOrdersAsTimeout(self, ):
4891 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4892 
    if mtype == TMessageType.EXCEPTION:
4893 
      x = TApplicationException()
4894 
      x.read(self._iprot)
4895 
      self._iprot.readMessageEnd()
4896 
      raise x
4897 
    result = markOrdersAsTimeout_result()
4898 
    result.read(self._iprot)
4899 
    self._iprot.readMessageEnd()
4900 
    if result.success is not None:
4901 
      return result.success
4902 
    if result.ex is not None:
4903 
      raise result.ex
4904 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4905 
 
4662 rajveer 4906 
  def markOrderAsLostInTransit(self, orderId):
4907 
    """
4908 
    Mark order as LOST_IN_TRANSIT
4909 
 
4910 
    Parameters:
4911 
     - orderId
4912 
    """
4913 
    self.send_markOrderAsLostInTransit(orderId)
4914 
    return self.recv_markOrderAsLostInTransit()
4915 
 
4916 
  def send_markOrderAsLostInTransit(self, orderId):
4917 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4918 
    args = markOrderAsLostInTransit_args()
4919 
    args.orderId = orderId
4920 
    args.write(self._oprot)
4921 
    self._oprot.writeMessageEnd()
4922 
    self._oprot.trans.flush()
4923 
 
4924 
  def recv_markOrderAsLostInTransit(self, ):
4925 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4926 
    if mtype == TMessageType.EXCEPTION:
4927 
      x = TApplicationException()
4928 
      x.read(self._iprot)
4929 
      self._iprot.readMessageEnd()
4930 
      raise x
4931 
    result = markOrderAsLostInTransit_result()
4932 
    result.read(self._iprot)
4933 
    self._iprot.readMessageEnd()
4934 
    if result.success is not None:
4935 
      return result.success
4936 
    if result.ex is not None:
4937 
      raise result.ex
4938 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4939 
 
4386 anupam.sin 4940 
  def getOrderForAwb(self, awb):
4941 
    """
4942 
    Returns the order corresponding to an AWB number
4369 rajveer 4943 
 
4386 anupam.sin 4944 
    Parameters:
4945 
     - awb
4946 
    """
4947 
    self.send_getOrderForAwb(awb)
4948 
    return self.recv_getOrderForAwb()
4949 
 
4950 
  def send_getOrderForAwb(self, awb):
4951 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4952 
    args = getOrderForAwb_args()
4953 
    args.awb = awb
4954 
    args.write(self._oprot)
4955 
    self._oprot.writeMessageEnd()
4956 
    self._oprot.trans.flush()
4957 
 
4958 
  def recv_getOrderForAwb(self, ):
4959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4960 
    if mtype == TMessageType.EXCEPTION:
4961 
      x = TApplicationException()
4962 
      x.read(self._iprot)
4963 
      self._iprot.readMessageEnd()
4964 
      raise x
4965 
    result = getOrderForAwb_result()
4966 
    result.read(self._iprot)
4967 
    self._iprot.readMessageEnd()
4968 
    if result.success is not None:
4969 
      return result.success
4970 
    if result.ex is not None:
4971 
      raise result.ex
4972 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4973 
 
4910 phani.kuma 4974 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4975 
    """
4910 phani.kuma 4976 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4977 
 
4506 phani.kuma 4978 
    Parameters:
4979 
     - logistics_provider_id
4910 phani.kuma 4980 
     - order_status_list
4506 phani.kuma 4981 
    """
4910 phani.kuma 4982 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4983 
    return self.recv_getOrdersForProviderForStatus()
4984 
 
4910 phani.kuma 4985 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4986 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4987 
    args = getOrdersForProviderForStatus_args()
4988 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4989 
    args.order_status_list = order_status_list
4506 phani.kuma 4990 
    args.write(self._oprot)
4991 
    self._oprot.writeMessageEnd()
4992 
    self._oprot.trans.flush()
4993 
 
4994 
  def recv_getOrdersForProviderForStatus(self, ):
4995 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4996 
    if mtype == TMessageType.EXCEPTION:
4997 
      x = TApplicationException()
4998 
      x.read(self._iprot)
4999 
      self._iprot.readMessageEnd()
5000 
      raise x
5001 
    result = getOrdersForProviderForStatus_result()
5002 
    result.read(self._iprot)
5003 
    self._iprot.readMessageEnd()
5004 
    if result.success is not None:
5005 
      return result.success
5006 
    if result.ex is not None:
5007 
      raise result.ex
5008 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
5009 
 
4600 varun.gupt 5010 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
5011 
    """
5012 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 5013 
 
4600 varun.gupt 5014 
    Parameters:
5015 
     - vendorId
5016 
     - billingDateFrom
5017 
     - billingDateTo
5018 
    """
5019 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
5020 
    return self.recv_getBilledOrdersForVendor()
5021 
 
5022 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
5023 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
5024 
    args = getBilledOrdersForVendor_args()
5025 
    args.vendorId = vendorId
5026 
    args.billingDateFrom = billingDateFrom
5027 
    args.billingDateTo = billingDateTo
5028 
    args.write(self._oprot)
5029 
    self._oprot.writeMessageEnd()
5030 
    self._oprot.trans.flush()
5031 
 
5032 
  def recv_getBilledOrdersForVendor(self, ):
5033 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5034 
    if mtype == TMessageType.EXCEPTION:
5035 
      x = TApplicationException()
5036 
      x.read(self._iprot)
5037 
      self._iprot.readMessageEnd()
5038 
      raise x
5039 
    result = getBilledOrdersForVendor_result()
5040 
    result.read(self._iprot)
5041 
    self._iprot.readMessageEnd()
5042 
    if result.success is not None:
5043 
      return result.success
5044 
    if result.ex is not None:
5045 
      raise result.ex
5046 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
5047 
 
4607 rajveer 5048 
  def getSlippedSippingDateOrders(self, ):
5049 
    self.send_getSlippedSippingDateOrders()
5050 
    return self.recv_getSlippedSippingDateOrders()
5051 
 
5052 
  def send_getSlippedSippingDateOrders(self, ):
5053 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
5054 
    args = getSlippedSippingDateOrders_args()
5055 
    args.write(self._oprot)
5056 
    self._oprot.writeMessageEnd()
5057 
    self._oprot.trans.flush()
5058 
 
5059 
  def recv_getSlippedSippingDateOrders(self, ):
5060 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5061 
    if mtype == TMessageType.EXCEPTION:
5062 
      x = TApplicationException()
5063 
      x.read(self._iprot)
5064 
      self._iprot.readMessageEnd()
5065 
      raise x
5066 
    result = getSlippedSippingDateOrders_result()
5067 
    result.read(self._iprot)
5068 
    self._iprot.readMessageEnd()
5069 
    if result.success is not None:
5070 
      return result.success
5071 
    if result.ex is not None:
5072 
      raise result.ex
5073 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
5074 
 
4709 rajveer 5075 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5076 
    """
5077 
    Parameters:
5078 
     - cancelDateFrom
5079 
     - cancelDateTo
5080 
    """
5081 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
5082 
    return self.recv_getCancelledOrders()
5083 
 
5084 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
5085 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
5086 
    args = getCancelledOrders_args()
5087 
    args.cancelDateFrom = cancelDateFrom
5088 
    args.cancelDateTo = cancelDateTo
5089 
    args.write(self._oprot)
5090 
    self._oprot.writeMessageEnd()
5091 
    self._oprot.trans.flush()
5092 
 
5093 
  def recv_getCancelledOrders(self, ):
5094 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5095 
    if mtype == TMessageType.EXCEPTION:
5096 
      x = TApplicationException()
5097 
      x.read(self._iprot)
5098 
      self._iprot.readMessageEnd()
5099 
      raise x
5100 
    result = getCancelledOrders_result()
5101 
    result.read(self._iprot)
5102 
    self._iprot.readMessageEnd()
5103 
    if result.success is not None:
5104 
      return result.success
5105 
    if result.ex is not None:
5106 
      raise result.ex
5107 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
5108 
 
4600 varun.gupt 5109 
  def saveBluedartSettlements(self, mapAWBAndAmount):
5110 
    """
5111 
    Parameters:
5112 
     - mapAWBAndAmount
5113 
    """
5114 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
5115 
    self.recv_saveBluedartSettlements()
5116 
 
5117 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
5118 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
5119 
    args = saveBluedartSettlements_args()
5120 
    args.mapAWBAndAmount = mapAWBAndAmount
5121 
    args.write(self._oprot)
5122 
    self._oprot.writeMessageEnd()
5123 
    self._oprot.trans.flush()
5124 
 
5125 
  def recv_saveBluedartSettlements(self, ):
5126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5127 
    if mtype == TMessageType.EXCEPTION:
5128 
      x = TApplicationException()
5129 
      x.read(self._iprot)
5130 
      self._iprot.readMessageEnd()
5131 
      raise x
5132 
    result = saveBluedartSettlements_result()
5133 
    result.read(self._iprot)
5134 
    self._iprot.readMessageEnd()
5135 
    if result.ex is not None:
5136 
      raise result.ex
5137 
    return
5138 
 
4905 varun.gupt 5139 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5140 
    """
5141 
    Parameters:
5142 
     - settlementDate
5143 
     - paymentGatewayId
4905 varun.gupt 5144 
     - referenceId
4600 varun.gupt 5145 
     - serviceTax
5146 
     - otherCharges
5147 
     - netCollection
5148 
    """
4905 varun.gupt 5149 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5150 
    self.recv_savePaymentSettlements()
5151 
 
4905 varun.gupt 5152 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5153 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5154 
    args = savePaymentSettlements_args()
5155 
    args.settlementDate = settlementDate
5156 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5157 
    args.referenceId = referenceId
4600 varun.gupt 5158 
    args.serviceTax = serviceTax
5159 
    args.otherCharges = otherCharges
5160 
    args.netCollection = netCollection
5161 
    args.write(self._oprot)
5162 
    self._oprot.writeMessageEnd()
5163 
    self._oprot.trans.flush()
5164 
 
5165 
  def recv_savePaymentSettlements(self, ):
5166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5167 
    if mtype == TMessageType.EXCEPTION:
5168 
      x = TApplicationException()
5169 
      x.read(self._iprot)
5170 
      self._iprot.readMessageEnd()
5171 
      raise x
5172 
    result = savePaymentSettlements_result()
5173 
    result.read(self._iprot)
5174 
    self._iprot.readMessageEnd()
5175 
    if result.ex is not None:
5176 
      raise result.ex
5177 
    return
5178 
 
5179 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5180 
    """
5181 
    Parameters:
5182 
     - settlementId
5183 
     - settlementDate
5184 
     - transactionDateFrom
5185 
     - transactionDateTo
5186 
     - amount
5187 
    """
5188 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5189 
    self.recv_saveEBSSettlementSummary()
5190 
 
5191 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5192 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5193 
    args = saveEBSSettlementSummary_args()
5194 
    args.settlementId = settlementId
5195 
    args.settlementDate = settlementDate
5196 
    args.transactionDateFrom = transactionDateFrom
5197 
    args.transactionDateTo = transactionDateTo
5198 
    args.amount = amount
5199 
    args.write(self._oprot)
5200 
    self._oprot.writeMessageEnd()
5201 
    self._oprot.trans.flush()
5202 
 
5203 
  def recv_saveEBSSettlementSummary(self, ):
5204 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5205 
    if mtype == TMessageType.EXCEPTION:
5206 
      x = TApplicationException()
5207 
      x.read(self._iprot)
5208 
      self._iprot.readMessageEnd()
5209 
      raise x
5210 
    result = saveEBSSettlementSummary_result()
5211 
    result.read(self._iprot)
5212 
    self._iprot.readMessageEnd()
5213 
    if result.ex is not None:
5214 
      raise result.ex
5215 
    return
5216 
 
5386 phani.kuma 5217 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5218 
    """
5219 
    Parameters:
5189 varun.gupt 5220 
     - referenceId
5221 
     - isRefund
4600 varun.gupt 5222 
    """
5386 phani.kuma 5223 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5224 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5225 
 
5386 phani.kuma 5226 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5227 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5228 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5229 
    args.referenceId = referenceId
5230 
    args.isRefund = isRefund
4600 varun.gupt 5231 
    args.write(self._oprot)
5232 
    self._oprot.writeMessageEnd()
5233 
    self._oprot.trans.flush()
5234 
 
5386 phani.kuma 5235 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5237 
    if mtype == TMessageType.EXCEPTION:
5238 
      x = TApplicationException()
5239 
      x.read(self._iprot)
5240 
      self._iprot.readMessageEnd()
5241 
      raise x
5386 phani.kuma 5242 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5243 
    result.read(self._iprot)
5244 
    self._iprot.readMessageEnd()
5245 
    if result.success is not None:
5246 
      return result.success
5247 
    if result.ex is not None:
5248 
      raise result.ex
5386 phani.kuma 5249 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5250 
 
5386 phani.kuma 5251 
  def getSettlementForCod(self, orderId, isRefund):
5252 
    """
5253 
    Parameters:
5254 
     - orderId
5255 
     - isRefund
5256 
    """
5257 
    self.send_getSettlementForCod(orderId, isRefund)
5258 
    return self.recv_getSettlementForCod()
5259 
 
5260 
  def send_getSettlementForCod(self, orderId, isRefund):
5261 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5262 
    args = getSettlementForCod_args()
5263 
    args.orderId = orderId
5264 
    args.isRefund = isRefund
5265 
    args.write(self._oprot)
5266 
    self._oprot.writeMessageEnd()
5267 
    self._oprot.trans.flush()
5268 
 
5269 
  def recv_getSettlementForCod(self, ):
5270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5271 
    if mtype == TMessageType.EXCEPTION:
5272 
      x = TApplicationException()
5273 
      x.read(self._iprot)
5274 
      self._iprot.readMessageEnd()
5275 
      raise x
5276 
    result = getSettlementForCod_result()
5277 
    result.read(self._iprot)
5278 
    self._iprot.readMessageEnd()
5279 
    if result.success is not None:
5280 
      return result.success
5281 
    if result.ex is not None:
5282 
      raise result.ex
5283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5284 
 
4600 varun.gupt 5285 
  def getEBSSettlementSummaries(self, ):
5286 
    self.send_getEBSSettlementSummaries()
5287 
    return self.recv_getEBSSettlementSummaries()
5288 
 
5289 
  def send_getEBSSettlementSummaries(self, ):
5290 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5291 
    args = getEBSSettlementSummaries_args()
5292 
    args.write(self._oprot)
5293 
    self._oprot.writeMessageEnd()
5294 
    self._oprot.trans.flush()
5295 
 
5296 
  def recv_getEBSSettlementSummaries(self, ):
5297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5298 
    if mtype == TMessageType.EXCEPTION:
5299 
      x = TApplicationException()
5300 
      x.read(self._iprot)
5301 
      self._iprot.readMessageEnd()
5302 
      raise x
5303 
    result = getEBSSettlementSummaries_result()
5304 
    result.read(self._iprot)
5305 
    self._iprot.readMessageEnd()
5306 
    if result.success is not None:
5307 
      return result.success
5308 
    if result.ex is not None:
5309 
      raise result.ex
5310 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5311 
 
5312 
  def markEBSSettlementUploaded(self, settlementId):
5313 
    """
5314 
    Parameters:
5315 
     - settlementId
5316 
    """
5317 
    self.send_markEBSSettlementUploaded(settlementId)
5318 
    self.recv_markEBSSettlementUploaded()
5319 
 
5320 
  def send_markEBSSettlementUploaded(self, settlementId):
5321 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5322 
    args = markEBSSettlementUploaded_args()
5323 
    args.settlementId = settlementId
5324 
    args.write(self._oprot)
5325 
    self._oprot.writeMessageEnd()
5326 
    self._oprot.trans.flush()
5327 
 
5328 
  def recv_markEBSSettlementUploaded(self, ):
5329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5330 
    if mtype == TMessageType.EXCEPTION:
5331 
      x = TApplicationException()
5332 
      x.read(self._iprot)
5333 
      self._iprot.readMessageEnd()
5334 
      raise x
5335 
    result = markEBSSettlementUploaded_result()
5336 
    result.read(self._iprot)
5337 
    self._iprot.readMessageEnd()
5338 
    if result.ex is not None:
5339 
      raise result.ex
5340 
    return
5341 
 
5342 
  def getEBSSettlementDate(self, settlementId):
5343 
    """
5344 
    Parameters:
5345 
     - settlementId
5346 
    """
5347 
    self.send_getEBSSettlementDate(settlementId)
5348 
    return self.recv_getEBSSettlementDate()
5349 
 
5350 
  def send_getEBSSettlementDate(self, settlementId):
5351 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5352 
    args = getEBSSettlementDate_args()
5353 
    args.settlementId = settlementId
5354 
    args.write(self._oprot)
5355 
    self._oprot.writeMessageEnd()
5356 
    self._oprot.trans.flush()
5357 
 
5358 
  def recv_getEBSSettlementDate(self, ):
5359 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5360 
    if mtype == TMessageType.EXCEPTION:
5361 
      x = TApplicationException()
5362 
      x.read(self._iprot)
5363 
      self._iprot.readMessageEnd()
5364 
      raise x
5365 
    result = getEBSSettlementDate_result()
5366 
    result.read(self._iprot)
5367 
    self._iprot.readMessageEnd()
5368 
    if result.success is not None:
5369 
      return result.success
5370 
    if result.ex is not None:
5371 
      raise result.ex
5372 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5373 
 
4715 varun.gupt 5374 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5375 
    """
5376 
    Parameters:
5377 
     - settlementDateFrom
5378 
     - settlementDateTo
5379 
     - isRefund
5380 
    """
5381 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5382 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5383 
 
4715 varun.gupt 5384 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5385 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5386 
    args = getSettlementsByDate_args()
5387 
    args.settlementDateFrom = settlementDateFrom
5388 
    args.settlementDateTo = settlementDateTo
5389 
    args.isRefund = isRefund
5390 
    args.write(self._oprot)
5391 
    self._oprot.writeMessageEnd()
5392 
    self._oprot.trans.flush()
5393 
 
5394 
  def recv_getSettlementsByDate(self, ):
5395 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5396 
    if mtype == TMessageType.EXCEPTION:
5397 
      x = TApplicationException()
5398 
      x.read(self._iprot)
5399 
      self._iprot.readMessageEnd()
5400 
      raise x
5401 
    result = getSettlementsByDate_result()
5402 
    result.read(self._iprot)
5403 
    self._iprot.readMessageEnd()
5404 
    if result.success is not None:
5405 
      return result.success
5406 
    if result.ex is not None:
5407 
      raise result.ex
5408 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5409 
 
5410 
  def getReshippedOrderIds(self, orderIds):
5411 
    """
5412 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5413 
 
5414 
    Parameters:
5415 
     - orderIds
5416 
    """
5417 
    self.send_getReshippedOrderIds(orderIds)
5418 
    return self.recv_getReshippedOrderIds()
5419 
 
5420 
  def send_getReshippedOrderIds(self, orderIds):
5421 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5422 
    args = getReshippedOrderIds_args()
5423 
    args.orderIds = orderIds
5424 
    args.write(self._oprot)
5425 
    self._oprot.writeMessageEnd()
5426 
    self._oprot.trans.flush()
5427 
 
5428 
  def recv_getReshippedOrderIds(self, ):
5429 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5430 
    if mtype == TMessageType.EXCEPTION:
5431 
      x = TApplicationException()
5432 
      x.read(self._iprot)
5433 
      self._iprot.readMessageEnd()
5434 
      raise x
5435 
    result = getReshippedOrderIds_result()
5436 
    result.read(self._iprot)
5437 
    self._iprot.readMessageEnd()
5438 
    if result.success is not None:
5439 
      return result.success
5440 
    if result.ex is not None:
5441 
      raise result.ex
5442 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5443 
 
5481 phani.kuma 5444 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5445 
    """
5446 
    Parameters:
5447 
     - vendorId
5481 phani.kuma 5448 
     - onlyVendorNotPaid
5449 
     - billingDateFrom
5450 
     - billingDateTo
4875 varun.gupt 5451 
    """
5481 phani.kuma 5452 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5453 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5454 
 
5481 phani.kuma 5455 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5456 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5457 
    args = getBilledOrders_args()
4875 varun.gupt 5458 
    args.vendorId = vendorId
5481 phani.kuma 5459 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5460 
    args.billingDateFrom = billingDateFrom
5461 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5462 
    args.write(self._oprot)
5463 
    self._oprot.writeMessageEnd()
5464 
    self._oprot.trans.flush()
5465 
 
5481 phani.kuma 5466 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5467 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5468 
    if mtype == TMessageType.EXCEPTION:
5469 
      x = TApplicationException()
5470 
      x.read(self._iprot)
5471 
      self._iprot.readMessageEnd()
5472 
      raise x
5481 phani.kuma 5473 
    result = getBilledOrders_result()
4875 varun.gupt 5474 
    result.read(self._iprot)
5475 
    self._iprot.readMessageEnd()
5476 
    if result.success is not None:
5477 
      return result.success
5478 
    if result.ex is not None:
5479 
      raise result.ex
5481 phani.kuma 5480 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5481 
 
5031 varun.gupt 5482 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5483 
    """
5484 
    Parameters:
5485 
     - startDate
5486 
     - endDate
5487 
    """
5488 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5489 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5490 
 
5031 varun.gupt 5491 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5492 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5493 
    args = getStatusDistributionOfOrders_args()
5494 
    args.startDate = startDate
5495 
    args.endDate = endDate
5496 
    args.write(self._oprot)
5497 
    self._oprot.writeMessageEnd()
5498 
    self._oprot.trans.flush()
5499 
 
5500 
  def recv_getStatusDistributionOfOrders(self, ):
5501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5502 
    if mtype == TMessageType.EXCEPTION:
5503 
      x = TApplicationException()
5504 
      x.read(self._iprot)
5505 
      self._iprot.readMessageEnd()
5506 
      raise x
5507 
    result = getStatusDistributionOfOrders_result()
5508 
    result.read(self._iprot)
5509 
    self._iprot.readMessageEnd()
5510 
    if result.success is not None:
5511 
      return result.success
5512 
    if result.ex is not None:
5513 
      raise result.ex
5514 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5515 
 
5067 varun.gupt 5516 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5517 
    """
5518 
    Parameters:
5519 
     - status
5520 
     - startDatetime
5521 
     - endDatetime
5522 
    """
5523 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5524 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5525 
 
5067 varun.gupt 5526 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5527 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5528 
    args = getOrderIdsForStatus_args()
5529 
    args.status = status
5530 
    args.startDatetime = startDatetime
5531 
    args.endDatetime = endDatetime
5532 
    args.write(self._oprot)
5533 
    self._oprot.writeMessageEnd()
5534 
    self._oprot.trans.flush()
5535 
 
5536 
  def recv_getOrderIdsForStatus(self, ):
5537 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5538 
    if mtype == TMessageType.EXCEPTION:
5539 
      x = TApplicationException()
5540 
      x.read(self._iprot)
5541 
      self._iprot.readMessageEnd()
5542 
      raise x
5543 
    result = getOrderIdsForStatus_result()
5544 
    result.read(self._iprot)
5545 
    self._iprot.readMessageEnd()
5546 
    if result.success is not None:
5547 
      return result.success
5548 
    if result.ex is not None:
5549 
      raise result.ex
5550 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5551 
 
5348 anupam.sin 5552 
  def updateCODAgent(self, agent, orderId):
5553 
    """
5554 
    Updates the agent who handled the COD verification call
5555 
 
5556 
    Parameters:
5557 
     - agent
5558 
     - orderId
5559 
    """
5560 
    self.send_updateCODAgent(agent, orderId)
5561 
    self.recv_updateCODAgent()
5562 
 
5563 
  def send_updateCODAgent(self, agent, orderId):
5564 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5565 
    args = updateCODAgent_args()
5566 
    args.agent = agent
5567 
    args.orderId = orderId
5568 
    args.write(self._oprot)
5569 
    self._oprot.writeMessageEnd()
5570 
    self._oprot.trans.flush()
5571 
 
5572 
  def recv_updateCODAgent(self, ):
5573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5574 
    if mtype == TMessageType.EXCEPTION:
5575 
      x = TApplicationException()
5576 
      x.read(self._iprot)
5577 
      self._iprot.readMessageEnd()
5578 
      raise x
5579 
    result = updateCODAgent_result()
5580 
    result.read(self._iprot)
5581 
    self._iprot.readMessageEnd()
5582 
    if result.ex is not None:
5583 
      raise result.ex
5584 
    return
5585 
 
5099 varun.gupt 5586 
  def updateOrderAsPaidToVendor(self, orderId):
5587 
    """
5588 
    Parameters:
5589 
     - orderId
5590 
    """
5591 
    self.send_updateOrderAsPaidToVendor(orderId)
5592 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5593 
 
5099 varun.gupt 5594 
  def send_updateOrderAsPaidToVendor(self, orderId):
5595 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5596 
    args = updateOrderAsPaidToVendor_args()
5597 
    args.orderId = orderId
5598 
    args.write(self._oprot)
5599 
    self._oprot.writeMessageEnd()
5600 
    self._oprot.trans.flush()
5601 
 
5602 
  def recv_updateOrderAsPaidToVendor(self, ):
5603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5604 
    if mtype == TMessageType.EXCEPTION:
5605 
      x = TApplicationException()
5606 
      x.read(self._iprot)
5607 
      self._iprot.readMessageEnd()
5608 
      raise x
5609 
    result = updateOrderAsPaidToVendor_result()
5610 
    result.read(self._iprot)
5611 
    self._iprot.readMessageEnd()
5612 
    if result.ex is not None:
5613 
      raise result.ex
5614 
    return
5615 
 
5386 phani.kuma 5616 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5617 
    """
5618 
    Parameters:
5619 
     - orderId
5620 
    """
5621 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5622 
    self.recv_updateOrderOnlyAsPaidToVendor()
5623 
 
5624 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5625 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5626 
    args = updateOrderOnlyAsPaidToVendor_args()
5627 
    args.orderId = orderId
5628 
    args.write(self._oprot)
5629 
    self._oprot.writeMessageEnd()
5630 
    self._oprot.trans.flush()
5631 
 
5632 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5633 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5634 
    if mtype == TMessageType.EXCEPTION:
5635 
      x = TApplicationException()
5636 
      x.read(self._iprot)
5637 
      self._iprot.readMessageEnd()
5638 
      raise x
5639 
    result = updateOrderOnlyAsPaidToVendor_result()
5640 
    result.read(self._iprot)
5641 
    self._iprot.readMessageEnd()
5642 
    if result.ex is not None:
5643 
      raise result.ex
5644 
    return
5645 
 
5208 varun.gupt 5646 
  def getRefundedOrdersMarkedPaid(self, ):
5647 
    self.send_getRefundedOrdersMarkedPaid()
5648 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5649 
 
5208 varun.gupt 5650 
  def send_getRefundedOrdersMarkedPaid(self, ):
5651 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5652 
    args = getRefundedOrdersMarkedPaid_args()
5653 
    args.write(self._oprot)
5654 
    self._oprot.writeMessageEnd()
5655 
    self._oprot.trans.flush()
5656 
 
5657 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5658 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5659 
    if mtype == TMessageType.EXCEPTION:
5660 
      x = TApplicationException()
5661 
      x.read(self._iprot)
5662 
      self._iprot.readMessageEnd()
5663 
      raise x
5664 
    result = getRefundedOrdersMarkedPaid_result()
5665 
    result.read(self._iprot)
5666 
    self._iprot.readMessageEnd()
5667 
    if result.success is not None:
5668 
      return result.success
5669 
    if result.ex is not None:
5670 
      raise result.ex
5671 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5672 
 
5447 anupam.sin 5673 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5674 
    """
5675 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5676 
 
5447 anupam.sin 5677 
 
5678 
    Parameters:
5679 
     - minOrderId
5680 
     - maxOrderId
5681 
    """
5682 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5683 
    return self.recv_getAllVerificationAgents()
5684 
 
5685 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5686 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5687 
    args = getAllVerificationAgents_args()
5688 
    args.minOrderId = minOrderId
5689 
    args.maxOrderId = maxOrderId
5690 
    args.write(self._oprot)
5691 
    self._oprot.writeMessageEnd()
5692 
    self._oprot.trans.flush()
5693 
 
5694 
  def recv_getAllVerificationAgents(self, ):
5695 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5696 
    if mtype == TMessageType.EXCEPTION:
5697 
      x = TApplicationException()
5698 
      x.read(self._iprot)
5699 
      self._iprot.readMessageEnd()
5700 
      raise x
5701 
    result = getAllVerificationAgents_result()
5702 
    result.read(self._iprot)
5703 
    self._iprot.readMessageEnd()
5704 
    if result.success is not None:
5705 
      return result.success
5706 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5707 
 
5527 anupam.sin 5708 
  def getAllAttributesForOrderId(self, orderId):
5709 
    """
5710 
    gets all attributes for a given orderId
5447 anupam.sin 5711 
 
5527 anupam.sin 5712 
    Parameters:
5713 
     - orderId
5714 
    """
5715 
    self.send_getAllAttributesForOrderId(orderId)
5716 
    return self.recv_getAllAttributesForOrderId()
5717 
 
5718 
  def send_getAllAttributesForOrderId(self, orderId):
5719 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5720 
    args = getAllAttributesForOrderId_args()
5721 
    args.orderId = orderId
5722 
    args.write(self._oprot)
5723 
    self._oprot.writeMessageEnd()
5724 
    self._oprot.trans.flush()
5725 
 
5726 
  def recv_getAllAttributesForOrderId(self, ):
5727 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5728 
    if mtype == TMessageType.EXCEPTION:
5729 
      x = TApplicationException()
5730 
      x.read(self._iprot)
5731 
      self._iprot.readMessageEnd()
5732 
      raise x
5733 
    result = getAllAttributesForOrderId_result()
5734 
    result.read(self._iprot)
5735 
    self._iprot.readMessageEnd()
5736 
    if result.success is not None:
5737 
      return result.success
5738 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5739 
 
5676 rajveer 5740 
  def setOrderAttributes(self, orderId, attributes):
5741 
    """
5742 
    sets attributes for an order
5743 
 
5744 
    Parameters:
5745 
     - orderId
5746 
     - attributes
5747 
    """
5748 
    self.send_setOrderAttributes(orderId, attributes)
5749 
    self.recv_setOrderAttributes()
5750 
 
5751 
  def send_setOrderAttributes(self, orderId, attributes):
5752 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5753 
    args = setOrderAttributes_args()
5754 
    args.orderId = orderId
5755 
    args.attributes = attributes
5756 
    args.write(self._oprot)
5757 
    self._oprot.writeMessageEnd()
5758 
    self._oprot.trans.flush()
5759 
 
5760 
  def recv_setOrderAttributes(self, ):
5761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5762 
    if mtype == TMessageType.EXCEPTION:
5763 
      x = TApplicationException()
5764 
      x.read(self._iprot)
5765 
      self._iprot.readMessageEnd()
5766 
      raise x
5767 
    result = setOrderAttributes_result()
5768 
    result.read(self._iprot)
5769 
    self._iprot.readMessageEnd()
5770 
    return
5771 
 
5527 anupam.sin 5772 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5773 
    """
5774 
    sets attributes for all orders in a transaction
5775 
 
5776 
    Parameters:
5777 
     - transactionId
5778 
     - attribute
5779 
    """
5780 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5781 
    self.recv_setOrderAttributeForTransaction()
5782 
 
5783 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5784 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5785 
    args = setOrderAttributeForTransaction_args()
5786 
    args.transactionId = transactionId
5787 
    args.attribute = attribute
5788 
    args.write(self._oprot)
5789 
    self._oprot.writeMessageEnd()
5790 
    self._oprot.trans.flush()
5791 
 
5792 
  def recv_setOrderAttributeForTransaction(self, ):
5793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5794 
    if mtype == TMessageType.EXCEPTION:
5795 
      x = TApplicationException()
5796 
      x.read(self._iprot)
5797 
      self._iprot.readMessageEnd()
5798 
      raise x
5799 
    result = setOrderAttributeForTransaction_result()
5800 
    result.read(self._iprot)
5801 
    self._iprot.readMessageEnd()
5802 
    return
5803 
 
5553 rajveer 5804 
  def getReceivePendingOrders(self, storeId):
5805 
    """
5806 
    Parameters:
5807 
     - storeId
5808 
    """
5809 
    self.send_getReceivePendingOrders(storeId)
5810 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5811 
 
5553 rajveer 5812 
  def send_getReceivePendingOrders(self, storeId):
5813 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5814 
    args = getReceivePendingOrders_args()
5815 
    args.storeId = storeId
5816 
    args.write(self._oprot)
5817 
    self._oprot.writeMessageEnd()
5818 
    self._oprot.trans.flush()
5819 
 
5820 
  def recv_getReceivePendingOrders(self, ):
5821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5822 
    if mtype == TMessageType.EXCEPTION:
5823 
      x = TApplicationException()
5824 
      x.read(self._iprot)
5825 
      self._iprot.readMessageEnd()
5826 
      raise x
5827 
    result = getReceivePendingOrders_result()
5828 
    result.read(self._iprot)
5829 
    self._iprot.readMessageEnd()
5830 
    if result.success is not None:
5831 
      return result.success
5832 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5833 
 
5834 
  def getReceivedAtStoreOrders(self, storeId):
5835 
    """
5836 
    Parameters:
5837 
     - storeId
5838 
    """
5839 
    self.send_getReceivedAtStoreOrders(storeId)
5840 
    return self.recv_getReceivedAtStoreOrders()
5841 
 
5842 
  def send_getReceivedAtStoreOrders(self, storeId):
5843 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5844 
    args = getReceivedAtStoreOrders_args()
5845 
    args.storeId = storeId
5846 
    args.write(self._oprot)
5847 
    self._oprot.writeMessageEnd()
5848 
    self._oprot.trans.flush()
5849 
 
5850 
  def recv_getReceivedAtStoreOrders(self, ):
5851 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5852 
    if mtype == TMessageType.EXCEPTION:
5853 
      x = TApplicationException()
5854 
      x.read(self._iprot)
5855 
      self._iprot.readMessageEnd()
5856 
      raise x
5857 
    result = getReceivedAtStoreOrders_result()
5858 
    result.read(self._iprot)
5859 
    self._iprot.readMessageEnd()
5860 
    if result.success is not None:
5861 
      return result.success
5862 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5863 
 
5713 rajveer 5864 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5865 
    """
5866 
    Parameters:
5867 
     - storeId
5868 
     - fromDate
5869 
     - toDate
5870 
     - onlyCod
5871 
    """
5872 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5873 
    return self.recv_getOrdersCollectionAtStore()
5874 
 
5875 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5876 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5877 
    args = getOrdersCollectionAtStore_args()
5878 
    args.storeId = storeId
5879 
    args.fromDate = fromDate
5880 
    args.toDate = toDate
5881 
    args.onlyCod = onlyCod
5882 
    args.write(self._oprot)
5883 
    self._oprot.writeMessageEnd()
5884 
    self._oprot.trans.flush()
5885 
 
5886 
  def recv_getOrdersCollectionAtStore(self, ):
5887 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5888 
    if mtype == TMessageType.EXCEPTION:
5889 
      x = TApplicationException()
5890 
      x.read(self._iprot)
5891 
      self._iprot.readMessageEnd()
5892 
      raise x
5893 
    result = getOrdersCollectionAtStore_result()
5894 
    result.read(self._iprot)
5895 
    self._iprot.readMessageEnd()
5896 
    if result.success is not None:
5897 
      return result.success
5898 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5899 
 
5833 rajveer 5900 
  def getOrderAttributeValue(self, orderId, attributeName):
5901 
    """
5902 
    Parameters:
5903 
     - orderId
5904 
     - attributeName
5905 
    """
5906 
    self.send_getOrderAttributeValue(orderId, attributeName)
5907 
    return self.recv_getOrderAttributeValue()
5908 
 
5909 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5910 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5911 
    args = getOrderAttributeValue_args()
5912 
    args.orderId = orderId
5913 
    args.attributeName = attributeName
5914 
    args.write(self._oprot)
5915 
    self._oprot.writeMessageEnd()
5916 
    self._oprot.trans.flush()
5917 
 
5918 
  def recv_getOrderAttributeValue(self, ):
5919 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5920 
    if mtype == TMessageType.EXCEPTION:
5921 
      x = TApplicationException()
5922 
      x.read(self._iprot)
5923 
      self._iprot.readMessageEnd()
5924 
      raise x
5925 
    result = getOrderAttributeValue_result()
5926 
    result.read(self._iprot)
5927 
    self._iprot.readMessageEnd()
5928 
    if result.success is not None:
5929 
      return result.success
5930 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5931 
 
6019 rajveer 5932 
  def changeJacketNumber(self, orderId, jacketNumber):
5933 
    """
5934 
    Parameters:
5935 
     - orderId
5936 
     - jacketNumber
5937 
    """
5938 
    self.send_changeJacketNumber(orderId, jacketNumber)
5939 
    return self.recv_changeJacketNumber()
5940 
 
5941 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5942 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5943 
    args = changeJacketNumber_args()
5944 
    args.orderId = orderId
5945 
    args.jacketNumber = jacketNumber
5946 
    args.write(self._oprot)
5947 
    self._oprot.writeMessageEnd()
5948 
    self._oprot.trans.flush()
5949 
 
5950 
  def recv_changeJacketNumber(self, ):
5951 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5952 
    if mtype == TMessageType.EXCEPTION:
5953 
      x = TApplicationException()
5954 
      x.read(self._iprot)
5955 
      self._iprot.readMessageEnd()
5956 
      raise x
5957 
    result = changeJacketNumber_result()
5958 
    result.read(self._iprot)
5959 
    self._iprot.readMessageEnd()
5960 
    if result.success is not None:
5961 
      return result.success
5962 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5963 
 
5964 
  def markOrderAsRtoInTransit(self, orderId):
5965 
    """
5966 
    Parameters:
5967 
     - orderId
5968 
    """
5969 
    self.send_markOrderAsRtoInTransit(orderId)
5970 
    return self.recv_markOrderAsRtoInTransit()
5971 
 
5972 
  def send_markOrderAsRtoInTransit(self, orderId):
5973 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5974 
    args = markOrderAsRtoInTransit_args()
5975 
    args.orderId = orderId
5976 
    args.write(self._oprot)
5977 
    self._oprot.writeMessageEnd()
5978 
    self._oprot.trans.flush()
5979 
 
5980 
  def recv_markOrderAsRtoInTransit(self, ):
5981 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5982 
    if mtype == TMessageType.EXCEPTION:
5983 
      x = TApplicationException()
5984 
      x.read(self._iprot)
5985 
      self._iprot.readMessageEnd()
5986 
      raise x
5987 
    result = markOrderAsRtoInTransit_result()
5988 
    result.read(self._iprot)
5989 
    self._iprot.readMessageEnd()
5990 
    if result.success is not None:
5991 
      return result.success
5992 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5993 
 
5593 mandeep.dh 5994 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5995 
    """
5996 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5997 
    invoked while scanning IN of items.
5553 rajveer 5998 
 
5593 mandeep.dh 5999 
    Parameters:
6000 
     - itemId
6001 
     - quantity
6002 
     - fulfilmentWarehouseId
6003 
     - billingWarehouseId
6004 
    """
6005 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
6006 
    self.recv_acceptOrderForItem()
6007 
 
6008 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
6009 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
6010 
    args = acceptOrderForItem_args()
6011 
    args.itemId = itemId
6012 
    args.quantity = quantity
6013 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
6014 
    args.billingWarehouseId = billingWarehouseId
6015 
    args.write(self._oprot)
6016 
    self._oprot.writeMessageEnd()
6017 
    self._oprot.trans.flush()
6018 
 
6019 
  def recv_acceptOrderForItem(self, ):
6020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6021 
    if mtype == TMessageType.EXCEPTION:
6022 
      x = TApplicationException()
6023 
      x.read(self._iprot)
6024 
      self._iprot.readMessageEnd()
6025 
      raise x
6026 
    result = acceptOrderForItem_result()
6027 
    result.read(self._iprot)
6028 
    self._iprot.readMessageEnd()
6029 
    return
6030 
 
6000 mandeep.dh 6031 
  def createRechargeOrder(self, rechargeOrder):
6032 
    """
6033 
    Parameters:
6034 
     - rechargeOrder
6035 
    """
6036 
    self.send_createRechargeOrder(rechargeOrder)
6037 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 6038 
 
6000 mandeep.dh 6039 
  def send_createRechargeOrder(self, rechargeOrder):
6040 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
6041 
    args = createRechargeOrder_args()
6042 
    args.rechargeOrder = rechargeOrder
6043 
    args.write(self._oprot)
6044 
    self._oprot.writeMessageEnd()
6045 
    self._oprot.trans.flush()
6046 
 
6047 
  def recv_createRechargeOrder(self, ):
6048 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6049 
    if mtype == TMessageType.EXCEPTION:
6050 
      x = TApplicationException()
6051 
      x.read(self._iprot)
6052 
      self._iprot.readMessageEnd()
6053 
      raise x
6054 
    result = createRechargeOrder_result()
6055 
    result.read(self._iprot)
6056 
    self._iprot.readMessageEnd()
6057 
    if result.success is not None:
6058 
      return result.success
6059 
    if result.ex is not None:
6060 
      raise result.ex
6061 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
6062 
 
6031 rajveer 6063 
  def getRechargeOrder(self, rechargeRrderId):
6064 
    """
6065 
    Parameters:
6066 
     - rechargeRrderId
6067 
    """
6068 
    self.send_getRechargeOrder(rechargeRrderId)
6069 
    return self.recv_getRechargeOrder()
6070 
 
6071 
  def send_getRechargeOrder(self, rechargeRrderId):
6072 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
6073 
    args = getRechargeOrder_args()
6074 
    args.rechargeRrderId = rechargeRrderId
6075 
    args.write(self._oprot)
6076 
    self._oprot.writeMessageEnd()
6077 
    self._oprot.trans.flush()
6078 
 
6079 
  def recv_getRechargeOrder(self, ):
6080 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6081 
    if mtype == TMessageType.EXCEPTION:
6082 
      x = TApplicationException()
6083 
      x.read(self._iprot)
6084 
      self._iprot.readMessageEnd()
6085 
      raise x
6086 
    result = getRechargeOrder_result()
6087 
    result.read(self._iprot)
6088 
    self._iprot.readMessageEnd()
6089 
    if result.success is not None:
6090 
      return result.success
6091 
    if result.ex is not None:
6092 
      raise result.ex
6093 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
6094 
 
6095 
  def getRechargeOrders(self, userId):
6096 
    """
6097 
    Parameters:
6098 
     - userId
6099 
    """
6100 
    self.send_getRechargeOrders(userId)
6101 
    return self.recv_getRechargeOrders()
6102 
 
6103 
  def send_getRechargeOrders(self, userId):
6104 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
6105 
    args = getRechargeOrders_args()
6106 
    args.userId = userId
6107 
    args.write(self._oprot)
6108 
    self._oprot.writeMessageEnd()
6109 
    self._oprot.trans.flush()
6110 
 
6111 
  def recv_getRechargeOrders(self, ):
6112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6113 
    if mtype == TMessageType.EXCEPTION:
6114 
      x = TApplicationException()
6115 
      x.read(self._iprot)
6116 
      self._iprot.readMessageEnd()
6117 
      raise x
6118 
    result = getRechargeOrders_result()
6119 
    result.read(self._iprot)
6120 
    self._iprot.readMessageEnd()
6121 
    if result.success is not None:
6122 
      return result.success
6123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
6124 
 
6000 mandeep.dh 6125 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6126 
    """
6127 
    Parameters:
6128 
     - rechargeOrderId
6129 
     - rechargeOrderStatus
6130 
    """
6131 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 6132 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 6133 
 
6134 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6135 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
6136 
    args = updateRechargeOrderStatus_args()
6137 
    args.rechargeOrderId = rechargeOrderId
6138 
    args.rechargeOrderStatus = rechargeOrderStatus
6139 
    args.write(self._oprot)
6140 
    self._oprot.writeMessageEnd()
6141 
    self._oprot.trans.flush()
6142 
 
6143 
  def recv_updateRechargeOrderStatus(self, ):
6144 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6145 
    if mtype == TMessageType.EXCEPTION:
6146 
      x = TApplicationException()
6147 
      x.read(self._iprot)
6148 
      self._iprot.readMessageEnd()
6149 
      raise x
6150 
    result = updateRechargeOrderStatus_result()
6151 
    result.read(self._iprot)
6152 
    self._iprot.readMessageEnd()
6031 rajveer 6153 
    if result.success is not None:
6154 
      return result.success
6000 mandeep.dh 6155 
    if result.ex is not None:
6156 
      raise result.ex
6031 rajveer 6157 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6158 
 
6031 rajveer 6159 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6160 
    """
6161 
    Parameters:
6031 rajveer 6162 
     - rechargeOrderId
6000 mandeep.dh 6163 
    """
6031 rajveer 6164 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6165 
    return self.recv_activateRechargeTxn()
6166 
 
6031 rajveer 6167 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6168 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6169 
    args = activateRechargeTxn_args()
6031 rajveer 6170 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6171 
    args.write(self._oprot)
6172 
    self._oprot.writeMessageEnd()
6173 
    self._oprot.trans.flush()
6174 
 
6175 
  def recv_activateRechargeTxn(self, ):
6176 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6177 
    if mtype == TMessageType.EXCEPTION:
6178 
      x = TApplicationException()
6179 
      x.read(self._iprot)
6180 
      self._iprot.readMessageEnd()
6181 
      raise x
6182 
    result = activateRechargeTxn_result()
6183 
    result.read(self._iprot)
6184 
    self._iprot.readMessageEnd()
6185 
    if result.success is not None:
6186 
      return result.success
6187 
    if result.ex is not None:
6188 
      raise result.ex
6189 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6190 
 
6031 rajveer 6191 
  def getUserWallet(self, userId):
6000 mandeep.dh 6192 
    """
6193 
    Parameters:
6031 rajveer 6194 
     - userId
6000 mandeep.dh 6195 
    """
6031 rajveer 6196 
    self.send_getUserWallet(userId)
6197 
    return self.recv_getUserWallet()
6000 mandeep.dh 6198 
 
6031 rajveer 6199 
  def send_getUserWallet(self, userId):
6200 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6201 
    args = getUserWallet_args()
6202 
    args.userId = userId
6000 mandeep.dh 6203 
    args.write(self._oprot)
6204 
    self._oprot.writeMessageEnd()
6205 
    self._oprot.trans.flush()
6206 
 
6031 rajveer 6207 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6208 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6209 
    if mtype == TMessageType.EXCEPTION:
6210 
      x = TApplicationException()
6211 
      x.read(self._iprot)
6212 
      self._iprot.readMessageEnd()
6213 
      raise x
6031 rajveer 6214 
    result = getUserWallet_result()
6000 mandeep.dh 6215 
    result.read(self._iprot)
6216 
    self._iprot.readMessageEnd()
6217 
    if result.success is not None:
6218 
      return result.success
6031 rajveer 6219 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6220 
 
6031 rajveer 6221 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6222 
    """
6223 
    Parameters:
6031 rajveer 6224 
     - userId
6000 mandeep.dh 6225 
    """
6031 rajveer 6226 
    self.send_getUserWalletHistory(userId)
6227 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6228 
 
6031 rajveer 6229 
  def send_getUserWalletHistory(self, userId):
6230 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6231 
    args = getUserWalletHistory_args()
6232 
    args.userId = userId
6000 mandeep.dh 6233 
    args.write(self._oprot)
6234 
    self._oprot.writeMessageEnd()
6235 
    self._oprot.trans.flush()
6236 
 
6031 rajveer 6237 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6238 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6239 
    if mtype == TMessageType.EXCEPTION:
6240 
      x = TApplicationException()
6241 
      x.read(self._iprot)
6242 
      self._iprot.readMessageEnd()
6243 
      raise x
6031 rajveer 6244 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6245 
    result.read(self._iprot)
6246 
    self._iprot.readMessageEnd()
6247 
    if result.success is not None:
6248 
      return result.success
6031 rajveer 6249 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6250 
 
6050 anupam.sin 6251 
  def getRechargeOrdersForTransaction(self, txnId):
6252 
    """
6253 
    Returns a recharge order for a given transactionId
6254 
 
6255 
    Parameters:
6256 
     - txnId
6257 
    """
6258 
    self.send_getRechargeOrdersForTransaction(txnId)
6259 
    return self.recv_getRechargeOrdersForTransaction()
6260 
 
6261 
  def send_getRechargeOrdersForTransaction(self, txnId):
6262 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6263 
    args = getRechargeOrdersForTransaction_args()
6264 
    args.txnId = txnId
6265 
    args.write(self._oprot)
6266 
    self._oprot.writeMessageEnd()
6267 
    self._oprot.trans.flush()
6268 
 
6269 
  def recv_getRechargeOrdersForTransaction(self, ):
6270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6271 
    if mtype == TMessageType.EXCEPTION:
6272 
      x = TApplicationException()
6273 
      x.read(self._iprot)
6274 
      self._iprot.readMessageEnd()
6275 
      raise x
6276 
    result = getRechargeOrdersForTransaction_result()
6277 
    result.read(self._iprot)
6278 
    self._iprot.readMessageEnd()
6279 
    if result.success is not None:
6280 
      return result.success
6281 
    if result.ex is not None:
6282 
      raise result.ex
6283 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6284 
 
6206 rajveer 6285 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6286 
    """
6287 
    Parameters:
6288 
     - rechargeType
6206 rajveer 6289 
     - onlyActive
6048 rajveer 6290 
    """
6206 rajveer 6291 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6292 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6293 
 
6206 rajveer 6294 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6295 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6296 
    args = getServiceProviders_args()
6297 
    args.rechargeType = rechargeType
6206 rajveer 6298 
    args.onlyActive = onlyActive
6048 rajveer 6299 
    args.write(self._oprot)
6300 
    self._oprot.writeMessageEnd()
6301 
    self._oprot.trans.flush()
6302 
 
6303 
  def recv_getServiceProviders(self, ):
6304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6305 
    if mtype == TMessageType.EXCEPTION:
6306 
      x = TApplicationException()
6307 
      x.read(self._iprot)
6308 
      self._iprot.readMessageEnd()
6309 
      raise x
6310 
    result = getServiceProviders_result()
6311 
    result.read(self._iprot)
6312 
    self._iprot.readMessageEnd()
6313 
    if result.success is not None:
6314 
      return result.success
6315 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6316 
 
6049 rajveer 6317 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6318 
    """
6319 
    Parameters:
6049 rajveer 6320 
     - rechargeType
6048 rajveer 6321 
     - deviceNumber
6322 
    """
6049 rajveer 6323 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6324 
    return self.recv_getServiceProviderForDevice()
6325 
 
6049 rajveer 6326 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6327 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6328 
    args = getServiceProviderForDevice_args()
6049 rajveer 6329 
    args.rechargeType = rechargeType
6048 rajveer 6330 
    args.deviceNumber = deviceNumber
6331 
    args.write(self._oprot)
6332 
    self._oprot.writeMessageEnd()
6333 
    self._oprot.trans.flush()
6334 
 
6335 
  def recv_getServiceProviderForDevice(self, ):
6336 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6337 
    if mtype == TMessageType.EXCEPTION:
6338 
      x = TApplicationException()
6339 
      x.read(self._iprot)
6340 
      self._iprot.readMessageEnd()
6341 
      raise x
6342 
    result = getServiceProviderForDevice_result()
6343 
    result.read(self._iprot)
6344 
    self._iprot.readMessageEnd()
6345 
    if result.success is not None:
6346 
      return result.success
6347 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6348 
 
6591 anupam.sin 6349 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6350 
    """
6351 
    Parameters:
6352 
     - rechargeType
6353 
     - deviceNumber
6307 anupam.sin 6354 
     - userSelectedProviderId
6591 anupam.sin 6355 
     - clientAddress
6269 rajveer 6356 
    """
6591 anupam.sin 6357 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId, clientAddress)
6269 rajveer 6358 
    return self.recv_validateRecharge()
6359 
 
6591 anupam.sin 6360 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6361 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6362 
    args = validateRecharge_args()
6363 
    args.rechargeType = rechargeType
6364 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6365 
    args.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 6366 
    args.clientAddress = clientAddress
6269 rajveer 6367 
    args.write(self._oprot)
6368 
    self._oprot.writeMessageEnd()
6369 
    self._oprot.trans.flush()
6370 
 
6371 
  def recv_validateRecharge(self, ):
6372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6373 
    if mtype == TMessageType.EXCEPTION:
6374 
      x = TApplicationException()
6375 
      x.read(self._iprot)
6376 
      self._iprot.readMessageEnd()
6377 
      raise x
6378 
    result = validateRecharge_result()
6379 
    result.read(self._iprot)
6380 
    self._iprot.readMessageEnd()
6381 
    if result.success is not None:
6382 
      return result.success
6383 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6384 
 
6094 rajveer 6385 
  def getRechargeOrdersForDevice(self, deviceNumber):
6386 
    """
6387 
    Parameters:
6388 
     - deviceNumber
6389 
    """
6390 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6391 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6392 
 
6094 rajveer 6393 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6394 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6395 
    args = getRechargeOrdersForDevice_args()
6396 
    args.deviceNumber = deviceNumber
6397 
    args.write(self._oprot)
6398 
    self._oprot.writeMessageEnd()
6399 
    self._oprot.trans.flush()
6400 
 
6401 
  def recv_getRechargeOrdersForDevice(self, ):
6402 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6403 
    if mtype == TMessageType.EXCEPTION:
6404 
      x = TApplicationException()
6405 
      x.read(self._iprot)
6406 
      self._iprot.readMessageEnd()
6407 
      raise x
6408 
    result = getRechargeOrdersForDevice_result()
6409 
    result.read(self._iprot)
6410 
    self._iprot.readMessageEnd()
6411 
    if result.success is not None:
6412 
      return result.success
6413 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6414 
 
6415 
  def addAmountToWallet(self, userId, orderId, amount):
6416 
    """
6417 
    Parameters:
6418 
     - userId
6419 
     - orderId
6420 
     - amount
6421 
    """
6422 
    self.send_addAmountToWallet(userId, orderId, amount)
6423 
    self.recv_addAmountToWallet()
6424 
 
6425 
  def send_addAmountToWallet(self, userId, orderId, amount):
6426 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6427 
    args = addAmountToWallet_args()
6428 
    args.userId = userId
6429 
    args.orderId = orderId
6430 
    args.amount = amount
6431 
    args.write(self._oprot)
6432 
    self._oprot.writeMessageEnd()
6433 
    self._oprot.trans.flush()
6434 
 
6435 
  def recv_addAmountToWallet(self, ):
6436 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6437 
    if mtype == TMessageType.EXCEPTION:
6438 
      x = TApplicationException()
6439 
      x.read(self._iprot)
6440 
      self._iprot.readMessageEnd()
6441 
      raise x
6442 
    result = addAmountToWallet_result()
6443 
    result.read(self._iprot)
6444 
    self._iprot.readMessageEnd()
6445 
    return
6446 
 
6188 rajveer 6447 
  def getRechargeStatistics(self, ):
6448 
    self.send_getRechargeStatistics()
6449 
    return self.recv_getRechargeStatistics()
6450 
 
6451 
  def send_getRechargeStatistics(self, ):
6452 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6453 
    args = getRechargeStatistics_args()
6454 
    args.write(self._oprot)
6455 
    self._oprot.writeMessageEnd()
6456 
    self._oprot.trans.flush()
6457 
 
6458 
  def recv_getRechargeStatistics(self, ):
6459 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6460 
    if mtype == TMessageType.EXCEPTION:
6461 
      x = TApplicationException()
6462 
      x.read(self._iprot)
6463 
      self._iprot.readMessageEnd()
6464 
      raise x
6465 
    result = getRechargeStatistics_result()
6466 
    result.read(self._iprot)
6467 
    self._iprot.readMessageEnd()
6468 
    if result.success is not None:
6469 
      return result.success
6470 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6471 
 
6154 rajveer 6472 
  def getRechargeOrdersForStatus(self, status):
6473 
    """
6474 
    Parameters:
6475 
     - status
6476 
    """
6477 
    self.send_getRechargeOrdersForStatus(status)
6478 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6479 
 
6154 rajveer 6480 
  def send_getRechargeOrdersForStatus(self, status):
6481 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6482 
    args = getRechargeOrdersForStatus_args()
6483 
    args.status = status
6484 
    args.write(self._oprot)
6485 
    self._oprot.writeMessageEnd()
6486 
    self._oprot.trans.flush()
6487 
 
6488 
  def recv_getRechargeOrdersForStatus(self, ):
6489 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6490 
    if mtype == TMessageType.EXCEPTION:
6491 
      x = TApplicationException()
6492 
      x.read(self._iprot)
6493 
      self._iprot.readMessageEnd()
6494 
      raise x
6495 
    result = getRechargeOrdersForStatus_result()
6496 
    result.read(self._iprot)
6497 
    self._iprot.readMessageEnd()
6498 
    if result.success is not None:
6499 
      return result.success
6500 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6501 
 
6159 rajveer 6502 
  def getPlansForOperator(self, operatorId):
6503 
    """
6504 
    Parameters:
6505 
     - operatorId
6506 
    """
6507 
    self.send_getPlansForOperator(operatorId)
6508 
    return self.recv_getPlansForOperator()
6154 rajveer 6509 
 
6159 rajveer 6510 
  def send_getPlansForOperator(self, operatorId):
6511 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6512 
    args = getPlansForOperator_args()
6513 
    args.operatorId = operatorId
6514 
    args.write(self._oprot)
6515 
    self._oprot.writeMessageEnd()
6516 
    self._oprot.trans.flush()
6517 
 
6518 
  def recv_getPlansForOperator(self, ):
6519 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6520 
    if mtype == TMessageType.EXCEPTION:
6521 
      x = TApplicationException()
6522 
      x.read(self._iprot)
6523 
      self._iprot.readMessageEnd()
6524 
      raise x
6525 
    result = getPlansForOperator_result()
6526 
    result.read(self._iprot)
6527 
    self._iprot.readMessageEnd()
6528 
    if result.success is not None:
6529 
      return result.success
6530 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6531 
 
6307 anupam.sin 6532 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6533 
    """
6534 
    Returns denominations for a given operator and circle
6159 rajveer 6535 
 
6289 anupam.sin 6536 
    Parameters:
6537 
     - operatorId
6307 anupam.sin 6538 
     - circleCode
6289 anupam.sin 6539 
     - denominationType
6540 
    """
6307 anupam.sin 6541 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6542 
    return self.recv_getRechargeDenominations()
6543 
 
6307 anupam.sin 6544 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6545 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6546 
    args = getRechargeDenominations_args()
6547 
    args.operatorId = operatorId
6307 anupam.sin 6548 
    args.circleCode = circleCode
6289 anupam.sin 6549 
    args.denominationType = denominationType
6550 
    args.write(self._oprot)
6551 
    self._oprot.writeMessageEnd()
6552 
    self._oprot.trans.flush()
6553 
 
6554 
  def recv_getRechargeDenominations(self, ):
6555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6556 
    if mtype == TMessageType.EXCEPTION:
6557 
      x = TApplicationException()
6558 
      x.read(self._iprot)
6559 
      self._iprot.readMessageEnd()
6560 
      raise x
6561 
    result = getRechargeDenominations_result()
6562 
    result.read(self._iprot)
6563 
    self._iprot.readMessageEnd()
6564 
    if result.success is not None:
6565 
      return result.success
6566 
    if result.ex is not None:
6567 
      raise result.ex
6568 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6569 
 
6371 rajveer 6570 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6571 
    """
6572 
    Parameters:
6573 
     - operatorId
6574 
     - circleId
6575 
     - isAvailable
6576 
    """
6577 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6578 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6579 
 
6371 rajveer 6580 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6581 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6582 
    args = updateAvailabilityStatus_args()
6583 
    args.operatorId = operatorId
6584 
    args.circleId = circleId
6585 
    args.isAvailable = isAvailable
6586 
    args.write(self._oprot)
6587 
    self._oprot.writeMessageEnd()
6588 
    self._oprot.trans.flush()
6589 
 
6590 
  def recv_updateAvailabilityStatus(self, ):
6591 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6592 
    if mtype == TMessageType.EXCEPTION:
6593 
      x = TApplicationException()
6594 
      x.read(self._iprot)
6595 
      self._iprot.readMessageEnd()
6596 
      raise x
6597 
    result = updateAvailabilityStatus_result()
6598 
    result.read(self._iprot)
6599 
    self._iprot.readMessageEnd()
6600 
    return
6601 
 
6389 rajveer 6602 
  def getAvailableEmiSchemes(self, ):
6603 
    self.send_getAvailableEmiSchemes()
6604 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6605 
 
6389 rajveer 6606 
  def send_getAvailableEmiSchemes(self, ):
6607 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6608 
    args = getAvailableEmiSchemes_args()
6609 
    args.write(self._oprot)
6610 
    self._oprot.writeMessageEnd()
6611 
    self._oprot.trans.flush()
6612 
 
6613 
  def recv_getAvailableEmiSchemes(self, ):
6614 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6615 
    if mtype == TMessageType.EXCEPTION:
6616 
      x = TApplicationException()
6617 
      x.read(self._iprot)
6618 
      self._iprot.readMessageEnd()
6619 
      raise x
6620 
    result = getAvailableEmiSchemes_result()
6621 
    result.read(self._iprot)
6622 
    self._iprot.readMessageEnd()
6623 
    if result.success is not None:
6624 
      return result.success
6625 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6626 
 
6627 
  def getMiscCharges(self, transactionId):
6628 
    """
6629 
    Parameters:
6630 
     - transactionId
6631 
    """
6632 
    self.send_getMiscCharges(transactionId)
6633 
    return self.recv_getMiscCharges()
6634 
 
6635 
  def send_getMiscCharges(self, transactionId):
6636 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6637 
    args = getMiscCharges_args()
6638 
    args.transactionId = transactionId
6639 
    args.write(self._oprot)
6640 
    self._oprot.writeMessageEnd()
6641 
    self._oprot.trans.flush()
6642 
 
6643 
  def recv_getMiscCharges(self, ):
6644 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6645 
    if mtype == TMessageType.EXCEPTION:
6646 
      x = TApplicationException()
6647 
      x.read(self._iprot)
6648 
      self._iprot.readMessageEnd()
6649 
      raise x
6650 
    result = getMiscCharges_result()
6651 
    result.read(self._iprot)
6652 
    self._iprot.readMessageEnd()
6653 
    if result.success is not None:
6654 
      return result.success
6655 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6656 
 
6507 anupam.sin 6657 
  def refundRechargeOrder(self, rechargeOrderId):
6658 
    """
6659 
    Parameters:
6660 
     - rechargeOrderId
6661 
    """
6662 
    self.send_refundRechargeOrder(rechargeOrderId)
6663 
    return self.recv_refundRechargeOrder()
6389 rajveer 6664 
 
6507 anupam.sin 6665 
  def send_refundRechargeOrder(self, rechargeOrderId):
6666 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6667 
    args = refundRechargeOrder_args()
6668 
    args.rechargeOrderId = rechargeOrderId
6669 
    args.write(self._oprot)
6670 
    self._oprot.writeMessageEnd()
6671 
    self._oprot.trans.flush()
6672 
 
6673 
  def recv_refundRechargeOrder(self, ):
6674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6675 
    if mtype == TMessageType.EXCEPTION:
6676 
      x = TApplicationException()
6677 
      x.read(self._iprot)
6678 
      self._iprot.readMessageEnd()
6679 
      raise x
6680 
    result = refundRechargeOrder_result()
6681 
    result.read(self._iprot)
6682 
    self._iprot.readMessageEnd()
6683 
    if result.success is not None:
6684 
      return result.success
6685 
    if result.ex is not None:
6686 
      raise result.ex
6687 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6688 
 
6821 amar.kumar 6689 
  def getPhysicalOrders(self, fromDate, toDate):
6690 
    """
6691 
    Parameters:
6692 
     - fromDate
6693 
     - toDate
6694 
    """
6695 
    self.send_getPhysicalOrders(fromDate, toDate)
6696 
    return self.recv_getPhysicalOrders()
6507 anupam.sin 6697 
 
6821 amar.kumar 6698 
  def send_getPhysicalOrders(self, fromDate, toDate):
6699 
    self._oprot.writeMessageBegin('getPhysicalOrders', TMessageType.CALL, self._seqid)
6700 
    args = getPhysicalOrders_args()
6701 
    args.fromDate = fromDate
6702 
    args.toDate = toDate
6703 
    args.write(self._oprot)
6704 
    self._oprot.writeMessageEnd()
6705 
    self._oprot.trans.flush()
6706 
 
6707 
  def recv_getPhysicalOrders(self, ):
6708 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6709 
    if mtype == TMessageType.EXCEPTION:
6710 
      x = TApplicationException()
6711 
      x.read(self._iprot)
6712 
      self._iprot.readMessageEnd()
6713 
      raise x
6714 
    result = getPhysicalOrders_result()
6715 
    result.read(self._iprot)
6716 
    self._iprot.readMessageEnd()
6717 
    if result.success is not None:
6718 
      return result.success
6719 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPhysicalOrders failed: unknown result");
6720 
 
6906 rajveer 6721 
  def getDocument(self, docType, docSource):
6722 
    """
6723 
    Parameters:
6724 
     - docType
6725 
     - docSource
6726 
    """
6727 
    self.send_getDocument(docType, docSource)
6728 
    return self.recv_getDocument()
6821 amar.kumar 6729 
 
6906 rajveer 6730 
  def send_getDocument(self, docType, docSource):
6731 
    self._oprot.writeMessageBegin('getDocument', TMessageType.CALL, self._seqid)
6732 
    args = getDocument_args()
6733 
    args.docType = docType
6734 
    args.docSource = docSource
6735 
    args.write(self._oprot)
6736 
    self._oprot.writeMessageEnd()
6737 
    self._oprot.trans.flush()
6738 
 
6739 
  def recv_getDocument(self, ):
6740 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6741 
    if mtype == TMessageType.EXCEPTION:
6742 
      x = TApplicationException()
6743 
      x.read(self._iprot)
6744 
      self._iprot.readMessageEnd()
6745 
      raise x
6746 
    result = getDocument_result()
6747 
    result.read(self._iprot)
6748 
    self._iprot.readMessageEnd()
6749 
    if result.success is not None:
6750 
      return result.success
6751 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDocument failed: unknown result");
6752 
 
6985 anupam.sin 6753 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6754 
    """
6755 
    Parameters:
6756 
     - orderId
6757 
     - line1
6758 
     - line2
6759 
     - city
6760 
     - state
6761 
     - pin
6762 
    """
6763 
    self.send_changeShippingAddress(orderId, line1, line2, city, state, pin)
6764 
    return self.recv_changeShippingAddress()
6906 rajveer 6765 
 
6985 anupam.sin 6766 
  def send_changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6767 
    self._oprot.writeMessageBegin('changeShippingAddress', TMessageType.CALL, self._seqid)
6768 
    args = changeShippingAddress_args()
6769 
    args.orderId = orderId
6770 
    args.line1 = line1
6771 
    args.line2 = line2
6772 
    args.city = city
6773 
    args.state = state
6774 
    args.pin = pin
6775 
    args.write(self._oprot)
6776 
    self._oprot.writeMessageEnd()
6777 
    self._oprot.trans.flush()
6778 
 
6779 
  def recv_changeShippingAddress(self, ):
6780 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6781 
    if mtype == TMessageType.EXCEPTION:
6782 
      x = TApplicationException()
6783 
      x.read(self._iprot)
6784 
      self._iprot.readMessageEnd()
6785 
      raise x
6786 
    result = changeShippingAddress_result()
6787 
    result.read(self._iprot)
6788 
    self._iprot.readMessageEnd()
6789 
    if result.success is not None:
6790 
      return result.success
6791 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeShippingAddress failed: unknown result");
6792 
 
7075 rajveer 6793 
  def retrieveInvoice(self, orderId, userId):
6988 rajveer 6794 
    """
6795 
    Parameters:
6796 
     - orderId
7075 rajveer 6797 
     - userId
6988 rajveer 6798 
    """
7075 rajveer 6799 
    self.send_retrieveInvoice(orderId, userId)
6988 rajveer 6800 
    return self.recv_retrieveInvoice()
6985 anupam.sin 6801 
 
7075 rajveer 6802 
  def send_retrieveInvoice(self, orderId, userId):
6988 rajveer 6803 
    self._oprot.writeMessageBegin('retrieveInvoice', TMessageType.CALL, self._seqid)
6804 
    args = retrieveInvoice_args()
6805 
    args.orderId = orderId
7075 rajveer 6806 
    args.userId = userId
6988 rajveer 6807 
    args.write(self._oprot)
6808 
    self._oprot.writeMessageEnd()
6809 
    self._oprot.trans.flush()
6810 
 
6811 
  def recv_retrieveInvoice(self, ):
6812 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6813 
    if mtype == TMessageType.EXCEPTION:
6814 
      x = TApplicationException()
6815 
      x.read(self._iprot)
6816 
      self._iprot.readMessageEnd()
6817 
      raise x
6818 
    result = retrieveInvoice_result()
6819 
    result.read(self._iprot)
6820 
    self._iprot.readMessageEnd()
6821 
    if result.success is not None:
6822 
      return result.success
6823 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveInvoice failed: unknown result");
6824 
 
7026 rajveer 6825 
  def receiveUpdatesForRedExpress(self, awbNumber):
6826 
    """
6827 
    Parameters:
6828 
     - awbNumber
6829 
    """
6830 
    self.send_receiveUpdatesForRedExpress(awbNumber)
6831 
    return self.recv_receiveUpdatesForRedExpress()
6988 rajveer 6832 
 
7026 rajveer 6833 
  def send_receiveUpdatesForRedExpress(self, awbNumber):
6834 
    self._oprot.writeMessageBegin('receiveUpdatesForRedExpress', TMessageType.CALL, self._seqid)
6835 
    args = receiveUpdatesForRedExpress_args()
6836 
    args.awbNumber = awbNumber
6837 
    args.write(self._oprot)
6838 
    self._oprot.writeMessageEnd()
6839 
    self._oprot.trans.flush()
6840 
 
6841 
  def recv_receiveUpdatesForRedExpress(self, ):
6842 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6843 
    if mtype == TMessageType.EXCEPTION:
6844 
      x = TApplicationException()
6845 
      x.read(self._iprot)
6846 
      self._iprot.readMessageEnd()
6847 
      raise x
6848 
    result = receiveUpdatesForRedExpress_result()
6849 
    result.read(self._iprot)
6850 
    self._iprot.readMessageEnd()
6851 
    if result.success is not None:
6852 
      return result.success
6853 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveUpdatesForRedExpress failed: unknown result");
6854 
 
7073 anupam.sin 6855 
  def createRechargeTransaction(self, thriftRechargeTransaction):
6856 
    """
6857 
    Parameters:
6858 
     - thriftRechargeTransaction
6859 
    """
6860 
    self.send_createRechargeTransaction(thriftRechargeTransaction)
6861 
    return self.recv_createRechargeTransaction()
7026 rajveer 6862 
 
7073 anupam.sin 6863 
  def send_createRechargeTransaction(self, thriftRechargeTransaction):
6864 
    self._oprot.writeMessageBegin('createRechargeTransaction', TMessageType.CALL, self._seqid)
6865 
    args = createRechargeTransaction_args()
6866 
    args.thriftRechargeTransaction = thriftRechargeTransaction
6867 
    args.write(self._oprot)
6868 
    self._oprot.writeMessageEnd()
6869 
    self._oprot.trans.flush()
6870 
 
6871 
  def recv_createRechargeTransaction(self, ):
6872 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6873 
    if mtype == TMessageType.EXCEPTION:
6874 
      x = TApplicationException()
6875 
      x.read(self._iprot)
6876 
      self._iprot.readMessageEnd()
6877 
      raise x
6878 
    result = createRechargeTransaction_result()
6879 
    result.read(self._iprot)
6880 
    self._iprot.readMessageEnd()
6881 
    if result.success is not None:
6882 
      return result.success
6883 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeTransaction failed: unknown result");
6884 
 
7085 rajveer 6885 
  def getRechargeTransactions(self, storeId):
6886 
    """
6887 
    Parameters:
6888 
     - storeId
6889 
    """
6890 
    self.send_getRechargeTransactions(storeId)
6891 
    return self.recv_getRechargeTransactions()
6892 
 
6893 
  def send_getRechargeTransactions(self, storeId):
6894 
    self._oprot.writeMessageBegin('getRechargeTransactions', TMessageType.CALL, self._seqid)
6895 
    args = getRechargeTransactions_args()
6896 
    args.storeId = storeId
6897 
    args.write(self._oprot)
6898 
    self._oprot.writeMessageEnd()
6899 
    self._oprot.trans.flush()
6900 
 
6901 
  def recv_getRechargeTransactions(self, ):
6902 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6903 
    if mtype == TMessageType.EXCEPTION:
6904 
      x = TApplicationException()
6905 
      x.read(self._iprot)
6906 
      self._iprot.readMessageEnd()
6907 
      raise x
6908 
    result = getRechargeTransactions_result()
6909 
    result.read(self._iprot)
6910 
    self._iprot.readMessageEnd()
6911 
    if result.success is not None:
6912 
      return result.success
6913 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransactions failed: unknown result");
6914 
 
7151 amit.gupta 6915 
  def getRechargeTrans(self, storeId, startDate, endDate, status):
6916 
    """
6917 
    Parameters:
6918 
     - storeId
6919 
     - startDate
6920 
     - endDate
6921 
     - status
6922 
    """
6923 
    self.send_getRechargeTrans(storeId, startDate, endDate, status)
6924 
    return self.recv_getRechargeTrans()
6925 
 
6926 
  def send_getRechargeTrans(self, storeId, startDate, endDate, status):
6927 
    self._oprot.writeMessageBegin('getRechargeTrans', TMessageType.CALL, self._seqid)
6928 
    args = getRechargeTrans_args()
6929 
    args.storeId = storeId
6930 
    args.startDate = startDate
6931 
    args.endDate = endDate
6932 
    args.status = status
6933 
    args.write(self._oprot)
6934 
    self._oprot.writeMessageEnd()
6935 
    self._oprot.trans.flush()
6936 
 
6937 
  def recv_getRechargeTrans(self, ):
6938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6939 
    if mtype == TMessageType.EXCEPTION:
6940 
      x = TApplicationException()
6941 
      x.read(self._iprot)
6942 
      self._iprot.readMessageEnd()
6943 
      raise x
6944 
    result = getRechargeTrans_result()
6945 
    result.read(self._iprot)
6946 
    self._iprot.readMessageEnd()
6947 
    if result.success is not None:
6948 
      return result.success
6949 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTrans failed: unknown result");
6950 
 
7080 anupam.sin 6951 
  def getRechargeTransaction(self, rechargeId):
6952 
    """
6953 
    Parameters:
6954 
     - rechargeId
6955 
    """
6956 
    self.send_getRechargeTransaction(rechargeId)
6957 
    return self.recv_getRechargeTransaction()
7073 anupam.sin 6958 
 
7080 anupam.sin 6959 
  def send_getRechargeTransaction(self, rechargeId):
6960 
    self._oprot.writeMessageBegin('getRechargeTransaction', TMessageType.CALL, self._seqid)
6961 
    args = getRechargeTransaction_args()
6962 
    args.rechargeId = rechargeId
6963 
    args.write(self._oprot)
6964 
    self._oprot.writeMessageEnd()
6965 
    self._oprot.trans.flush()
6966 
 
6967 
  def recv_getRechargeTransaction(self, ):
6968 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6969 
    if mtype == TMessageType.EXCEPTION:
6970 
      x = TApplicationException()
6971 
      x.read(self._iprot)
6972 
      self._iprot.readMessageEnd()
6973 
      raise x
6974 
    result = getRechargeTransaction_result()
6975 
    result.read(self._iprot)
6976 
    self._iprot.readMessageEnd()
6977 
    if result.success is not None:
6978 
      return result.success
6979 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransaction failed: unknown result");
6980 
 
6981 
  def getFRCs(self, circleId, operatorId):
6982 
    """
6983 
    Parameters:
6984 
     - circleId
6985 
     - operatorId
6986 
    """
6987 
    self.send_getFRCs(circleId, operatorId)
6988 
    return self.recv_getFRCs()
6989 
 
6990 
  def send_getFRCs(self, circleId, operatorId):
6991 
    self._oprot.writeMessageBegin('getFRCs', TMessageType.CALL, self._seqid)
6992 
    args = getFRCs_args()
6993 
    args.circleId = circleId
6994 
    args.operatorId = operatorId
6995 
    args.write(self._oprot)
6996 
    self._oprot.writeMessageEnd()
6997 
    self._oprot.trans.flush()
6998 
 
6999 
  def recv_getFRCs(self, ):
7000 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7001 
    if mtype == TMessageType.EXCEPTION:
7002 
      x = TApplicationException()
7003 
      x.read(self._iprot)
7004 
      self._iprot.readMessageEnd()
7005 
      raise x
7006 
    result = getFRCs_result()
7007 
    result.read(self._iprot)
7008 
    self._iprot.readMessageEnd()
7009 
    if result.success is not None:
7010 
      return result.success
7011 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getFRCs failed: unknown result");
7012 
 
7096 anupam.sin 7013 
  def getHotspotStore(self, id, hotspotid):
7014 
    """
7015 
    Parameters:
7016 
     - id
7017 
     - hotspotid
7018 
    """
7019 
    self.send_getHotspotStore(id, hotspotid)
7020 
    return self.recv_getHotspotStore()
7080 anupam.sin 7021 
 
7096 anupam.sin 7022 
  def send_getHotspotStore(self, id, hotspotid):
7023 
    self._oprot.writeMessageBegin('getHotspotStore', TMessageType.CALL, self._seqid)
7024 
    args = getHotspotStore_args()
7025 
    args.id = id
7026 
    args.hotspotid = hotspotid
7027 
    args.write(self._oprot)
7028 
    self._oprot.writeMessageEnd()
7029 
    self._oprot.trans.flush()
7030 
 
7031 
  def recv_getHotspotStore(self, ):
7032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7033 
    if mtype == TMessageType.EXCEPTION:
7034 
      x = TApplicationException()
7035 
      x.read(self._iprot)
7036 
      self._iprot.readMessageEnd()
7037 
      raise x
7038 
    result = getHotspotStore_result()
7039 
    result.read(self._iprot)
7040 
    self._iprot.readMessageEnd()
7041 
    if result.success is not None:
7042 
      return result.success
7043 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getHotspotStore failed: unknown result");
7044 
 
7045 
  def getTelecomCircle(self, id, code):
7046 
    """
7047 
    Parameters:
7048 
     - id
7049 
     - code
7050 
    """
7051 
    self.send_getTelecomCircle(id, code)
7052 
    return self.recv_getTelecomCircle()
7053 
 
7054 
  def send_getTelecomCircle(self, id, code):
7055 
    self._oprot.writeMessageBegin('getTelecomCircle', TMessageType.CALL, self._seqid)
7056 
    args = getTelecomCircle_args()
7057 
    args.id = id
7058 
    args.code = code
7059 
    args.write(self._oprot)
7060 
    self._oprot.writeMessageEnd()
7061 
    self._oprot.trans.flush()
7062 
 
7063 
  def recv_getTelecomCircle(self, ):
7064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7065 
    if mtype == TMessageType.EXCEPTION:
7066 
      x = TApplicationException()
7067 
      x.read(self._iprot)
7068 
      self._iprot.readMessageEnd()
7069 
      raise x
7070 
    result = getTelecomCircle_result()
7071 
    result.read(self._iprot)
7072 
    self._iprot.readMessageEnd()
7073 
    if result.success is not None:
7074 
      return result.success
7075 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTelecomCircle failed: unknown result");
7076 
 
7109 anupam.sin 7077 
  def retrieveHotspotRechargeInvoice(self, rechargeId):
7078 
    """
7079 
    Parameters:
7080 
     - rechargeId
7081 
    """
7082 
    self.send_retrieveHotspotRechargeInvoice(rechargeId)
7083 
    return self.recv_retrieveHotspotRechargeInvoice()
7096 anupam.sin 7084 
 
7109 anupam.sin 7085 
  def send_retrieveHotspotRechargeInvoice(self, rechargeId):
7086 
    self._oprot.writeMessageBegin('retrieveHotspotRechargeInvoice', TMessageType.CALL, self._seqid)
7087 
    args = retrieveHotspotRechargeInvoice_args()
7088 
    args.rechargeId = rechargeId
7089 
    args.write(self._oprot)
7090 
    self._oprot.writeMessageEnd()
7091 
    self._oprot.trans.flush()
7092 
 
7093 
  def recv_retrieveHotspotRechargeInvoice(self, ):
7094 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7095 
    if mtype == TMessageType.EXCEPTION:
7096 
      x = TApplicationException()
7097 
      x.read(self._iprot)
7098 
      self._iprot.readMessageEnd()
7099 
      raise x
7100 
    result = retrieveHotspotRechargeInvoice_result()
7101 
    result.read(self._iprot)
7102 
    self._iprot.readMessageEnd()
7103 
    if result.success is not None:
7104 
      return result.success
7105 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveHotspotRechargeInvoice failed: unknown result");
7106 
 
7190 amar.kumar 7107 
  def splitFreebieOrder(self, orderId, splitReason, shippingDate):
7108 
    """
7109 
    Parameters:
7110 
     - orderId
7111 
     - splitReason
7112 
     - shippingDate
7113 
    """
7114 
    self.send_splitFreebieOrder(orderId, splitReason, shippingDate)
7115 
    return self.recv_splitFreebieOrder()
7116 
 
7117 
  def send_splitFreebieOrder(self, orderId, splitReason, shippingDate):
7118 
    self._oprot.writeMessageBegin('splitFreebieOrder', TMessageType.CALL, self._seqid)
7119 
    args = splitFreebieOrder_args()
7120 
    args.orderId = orderId
7121 
    args.splitReason = splitReason
7122 
    args.shippingDate = shippingDate
7123 
    args.write(self._oprot)
7124 
    self._oprot.writeMessageEnd()
7125 
    self._oprot.trans.flush()
7126 
 
7127 
  def recv_splitFreebieOrder(self, ):
7128 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7129 
    if mtype == TMessageType.EXCEPTION:
7130 
      x = TApplicationException()
7131 
      x.read(self._iprot)
7132 
      self._iprot.readMessageEnd()
7133 
      raise x
7134 
    result = splitFreebieOrder_result()
7135 
    result.read(self._iprot)
7136 
    self._iprot.readMessageEnd()
7137 
    if result.success is not None:
7138 
      return result.success
7139 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "splitFreebieOrder failed: unknown result");
7140 
 
7172 anupam.sin 7141 
  def getRechargeTransactionsByNumber(self, number, storeId):
7169 anupam.sin 7142 
    """
7143 
    Parameters:
7144 
     - number
7172 anupam.sin 7145 
     - storeId
7169 anupam.sin 7146 
    """
7172 anupam.sin 7147 
    self.send_getRechargeTransactionsByNumber(number, storeId)
7169 anupam.sin 7148 
    return self.recv_getRechargeTransactionsByNumber()
7109 anupam.sin 7149 
 
7172 anupam.sin 7150 
  def send_getRechargeTransactionsByNumber(self, number, storeId):
7169 anupam.sin 7151 
    self._oprot.writeMessageBegin('getRechargeTransactionsByNumber', TMessageType.CALL, self._seqid)
7152 
    args = getRechargeTransactionsByNumber_args()
7153 
    args.number = number
7172 anupam.sin 7154 
    args.storeId = storeId
7169 anupam.sin 7155 
    args.write(self._oprot)
7156 
    self._oprot.writeMessageEnd()
7157 
    self._oprot.trans.flush()
7158 
 
7159 
  def recv_getRechargeTransactionsByNumber(self, ):
7160 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7161 
    if mtype == TMessageType.EXCEPTION:
7162 
      x = TApplicationException()
7163 
      x.read(self._iprot)
7164 
      self._iprot.readMessageEnd()
7165 
      raise x
7166 
    result = getRechargeTransactionsByNumber_result()
7167 
    result.read(self._iprot)
7168 
    self._iprot.readMessageEnd()
7169 
    if result.success is not None:
7170 
      return result.success
7171 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeTransactionsByNumber failed: unknown result");
7172 
 
7173 
  def updateHotspotStorePassword(self, storeId, password):
7174 
    """
7175 
    Parameters:
7176 
     - storeId
7177 
     - password
7178 
    """
7179 
    self.send_updateHotspotStorePassword(storeId, password)
7180 
    return self.recv_updateHotspotStorePassword()
7181 
 
7182 
  def send_updateHotspotStorePassword(self, storeId, password):
7183 
    self._oprot.writeMessageBegin('updateHotspotStorePassword', TMessageType.CALL, self._seqid)
7184 
    args = updateHotspotStorePassword_args()
7185 
    args.storeId = storeId
7186 
    args.password = password
7187 
    args.write(self._oprot)
7188 
    self._oprot.writeMessageEnd()
7189 
    self._oprot.trans.flush()
7190 
 
7191 
  def recv_updateHotspotStorePassword(self, ):
7192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7193 
    if mtype == TMessageType.EXCEPTION:
7194 
      x = TApplicationException()
7195 
      x.read(self._iprot)
7196 
      self._iprot.readMessageEnd()
7197 
      raise x
7198 
    result = updateHotspotStorePassword_result()
7199 
    result.read(self._iprot)
7200 
    self._iprot.readMessageEnd()
7201 
    if result.success is not None:
7202 
      return result.success
7203 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateHotspotStorePassword failed: unknown result");
7204 
 
7263 anupam.sin 7205 
  def getSourceDetail(self, source):
7206 
    """
7207 
    Parameters:
7208 
     - source
7209 
    """
7210 
    self.send_getSourceDetail(source)
7211 
    return self.recv_getSourceDetail()
7169 anupam.sin 7212 
 
7263 anupam.sin 7213 
  def send_getSourceDetail(self, source):
7214 
    self._oprot.writeMessageBegin('getSourceDetail', TMessageType.CALL, self._seqid)
7215 
    args = getSourceDetail_args()
7216 
    args.source = source
7217 
    args.write(self._oprot)
7218 
    self._oprot.writeMessageEnd()
7219 
    self._oprot.trans.flush()
7220 
 
7221 
  def recv_getSourceDetail(self, ):
7222 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
7223 
    if mtype == TMessageType.EXCEPTION:
7224 
      x = TApplicationException()
7225 
      x.read(self._iprot)
7226 
      self._iprot.readMessageEnd()
7227 
      raise x
7228 
    result = getSourceDetail_result()
7229 
    result.read(self._iprot)
7230 
    self._iprot.readMessageEnd()
7231 
    if result.success is not None:
7232 
      return result.success
7233 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSourceDetail failed: unknown result");
7234 
 
7235 
 
3376 rajveer 7236 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 7237 
  def __init__(self, handler):
3376 rajveer 7238 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 7239 
    self._processMap["createTransaction"] = Processor.process_createTransaction
7240 
    self._processMap["getTransaction"] = Processor.process_getTransaction
7241 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 7242 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 7243 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
7244 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 7245 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 7246 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 7247 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
7248 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 7249 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 7250 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 7251 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
7252 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 7253 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
7254 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
7255 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
7256 
    self._processMap["createOrder"] = Processor.process_createOrder
7257 
    self._processMap["getOrder"] = Processor.process_getOrder
7258 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 7259 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 7260 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 7261 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 7262 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 7263 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 7264 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 7265 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
7266 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
7267 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
7268 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 7269 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 7270 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 7271 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
7272 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
7273 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 7274 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 7275 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 7276 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 7277 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 7278 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 7279 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 7280 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
7281 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 7282 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 7283 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
7284 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
7285 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
7286 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
7287 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 7288 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 7289 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 7290 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 7291 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 7292 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 7293 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
7294 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 7295 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
7296 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 7297 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
7298 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 7299 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 7300 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 7301 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 7302 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 7303 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 7304 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 7305 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 7306 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
7307 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 7308 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 7309 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 7310 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 7311 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 7312 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 7313 
    self._processMap["changeItem"] = Processor.process_changeItem
7314 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 7315 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 7316 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 7317 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
7318 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 7319 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 7320 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 7321 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
7322 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
7323 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 7324 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 7325 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 7326 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 7327 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 7328 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
7329 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
7330 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 7331 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 7332 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 7333 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 7334 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 7335 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 7336 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 7337 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 7338 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
7339 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
7340 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 7341 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
7342 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 7343 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
7344 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
7345 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 7346 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
7347 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 7348 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 7349 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 7350 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 7351 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 7352 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 7353 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 7354 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 7355 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 7356 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 7357 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 7358 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 7359 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
7360 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 7361 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 7362 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 7363 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
7364 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 7365 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 7366 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 7367 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
7368 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 7369 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
7370 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 7371 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
7372 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 7373 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 7374 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
7375 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 7376 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 7377 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
7378 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 7379 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 7380 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 7381 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 7382 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 7383 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 7384 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
7385 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 7386 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
6821 amar.kumar 7387 
    self._processMap["getPhysicalOrders"] = Processor.process_getPhysicalOrders
6906 rajveer 7388 
    self._processMap["getDocument"] = Processor.process_getDocument
6985 anupam.sin 7389 
    self._processMap["changeShippingAddress"] = Processor.process_changeShippingAddress
6988 rajveer 7390 
    self._processMap["retrieveInvoice"] = Processor.process_retrieveInvoice
7026 rajveer 7391 
    self._processMap["receiveUpdatesForRedExpress"] = Processor.process_receiveUpdatesForRedExpress
7073 anupam.sin 7392 
    self._processMap["createRechargeTransaction"] = Processor.process_createRechargeTransaction
7085 rajveer 7393 
    self._processMap["getRechargeTransactions"] = Processor.process_getRechargeTransactions
7151 amit.gupta 7394 
    self._processMap["getRechargeTrans"] = Processor.process_getRechargeTrans
7080 anupam.sin 7395 
    self._processMap["getRechargeTransaction"] = Processor.process_getRechargeTransaction
7396 
    self._processMap["getFRCs"] = Processor.process_getFRCs
7096 anupam.sin 7397 
    self._processMap["getHotspotStore"] = Processor.process_getHotspotStore
7398 
    self._processMap["getTelecomCircle"] = Processor.process_getTelecomCircle
7109 anupam.sin 7399 
    self._processMap["retrieveHotspotRechargeInvoice"] = Processor.process_retrieveHotspotRechargeInvoice
7190 amar.kumar 7400 
    self._processMap["splitFreebieOrder"] = Processor.process_splitFreebieOrder
7169 anupam.sin 7401 
    self._processMap["getRechargeTransactionsByNumber"] = Processor.process_getRechargeTransactionsByNumber
7402 
    self._processMap["updateHotspotStorePassword"] = Processor.process_updateHotspotStorePassword
7263 anupam.sin 7403 
    self._processMap["getSourceDetail"] = Processor.process_getSourceDetail
94 ashish 7404 
 
7405 
  def process(self, iprot, oprot):
7406 
    (name, type, seqid) = iprot.readMessageBegin()
7407 
    if name not in self._processMap:
7408 
      iprot.skip(TType.STRUCT)
7409 
      iprot.readMessageEnd()
7410 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
7411 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
7412 
      x.write(oprot)
7413 
      oprot.writeMessageEnd()
7414 
      oprot.trans.flush()
7415 
      return
7416 
    else:
7417 
      self._processMap[name](self, seqid, iprot, oprot)
7418 
    return True
7419 
 
7420 
  def process_createTransaction(self, seqid, iprot, oprot):
7421 
    args = createTransaction_args()
7422 
    args.read(iprot)
7423 
    iprot.readMessageEnd()
7424 
    result = createTransaction_result()
7425 
    try:
132 ashish 7426 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 7427 
    except TransactionServiceException, ex:
7428 
      result.ex = ex
7429 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
7430 
    result.write(oprot)
7431 
    oprot.writeMessageEnd()
7432 
    oprot.trans.flush()
7433 
 
7434 
  def process_getTransaction(self, seqid, iprot, oprot):
7435 
    args = getTransaction_args()
7436 
    args.read(iprot)
7437 
    iprot.readMessageEnd()
7438 
    result = getTransaction_result()
7439 
    try:
7440 
      result.success = self._handler.getTransaction(args.id)
7441 
    except TransactionServiceException, ex:
7442 
      result.ex = ex
7443 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
7444 
    result.write(oprot)
7445 
    oprot.writeMessageEnd()
7446 
    oprot.trans.flush()
7447 
 
7448 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
7449 
    args = getTransactionsForCustomer_args()
7450 
    args.read(iprot)
7451 
    iprot.readMessageEnd()
7452 
    result = getTransactionsForCustomer_result()
7453 
    try:
7454 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
7455 
    except TransactionServiceException, ex:
7456 
      result.ex = ex
7457 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
7458 
    result.write(oprot)
7459 
    oprot.writeMessageEnd()
7460 
    oprot.trans.flush()
7461 
 
132 ashish 7462 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
7463 
    args = getTransactionsForShoppingCartId_args()
7464 
    args.read(iprot)
7465 
    iprot.readMessageEnd()
7466 
    result = getTransactionsForShoppingCartId_result()
7467 
    try:
7468 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
7469 
    except TransactionServiceException, ex:
7470 
      result.ex = ex
7471 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
7472 
    result.write(oprot)
7473 
    oprot.writeMessageEnd()
7474 
    oprot.trans.flush()
7475 
 
94 ashish 7476 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
7477 
    args = getTransactionStatus_args()
7478 
    args.read(iprot)
7479 
    iprot.readMessageEnd()
7480 
    result = getTransactionStatus_result()
7481 
    try:
7482 
      result.success = self._handler.getTransactionStatus(args.transactionId)
7483 
    except TransactionServiceException, ex:
7484 
      result.ex = ex
7485 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
7486 
    result.write(oprot)
7487 
    oprot.writeMessageEnd()
7488 
    oprot.trans.flush()
7489 
 
7490 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
7491 
    args = changeTransactionStatus_args()
7492 
    args.read(iprot)
7493 
    iprot.readMessageEnd()
7494 
    result = changeTransactionStatus_result()
7495 
    try:
5527 anupam.sin 7496 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 7497 
    except TransactionServiceException, ex:
7498 
      result.ex = ex
7499 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
7500 
    result.write(oprot)
7501 
    oprot.writeMessageEnd()
7502 
    oprot.trans.flush()
7503 
 
1398 varun.gupt 7504 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
7505 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 7506 
    args.read(iprot)
7507 
    iprot.readMessageEnd()
1398 varun.gupt 7508 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 7509 
    try:
1398 varun.gupt 7510 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 7511 
    except TransactionServiceException, ex:
7512 
      result.ex = ex
1398 varun.gupt 7513 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 7514 
    result.write(oprot)
7515 
    oprot.writeMessageEnd()
7516 
    oprot.trans.flush()
7517 
 
483 rajveer 7518 
  def process_getAllOrders(self, seqid, iprot, oprot):
7519 
    args = getAllOrders_args()
94 ashish 7520 
    args.read(iprot)
7521 
    iprot.readMessageEnd()
483 rajveer 7522 
    result = getAllOrders_result()
94 ashish 7523 
    try:
4801 anupam.sin 7524 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 7525 
    except TransactionServiceException, ex:
7526 
      result.ex = ex
483 rajveer 7527 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 7528 
    result.write(oprot)
7529 
    oprot.writeMessageEnd()
7530 
    oprot.trans.flush()
7531 
 
4133 chandransh 7532 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
7533 
    args = getOrdersInBatch_args()
7534 
    args.read(iprot)
7535 
    iprot.readMessageEnd()
7536 
    result = getOrdersInBatch_result()
7537 
    try:
7538 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
7539 
    except TransactionServiceException, ex:
7540 
      result.ex = ex
7541 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
7542 
    result.write(oprot)
7543 
    oprot.writeMessageEnd()
7544 
    oprot.trans.flush()
7545 
 
7546 
  def process_getOrderCount(self, seqid, iprot, oprot):
7547 
    args = getOrderCount_args()
7548 
    args.read(iprot)
7549 
    iprot.readMessageEnd()
7550 
    result = getOrderCount_result()
7551 
    try:
7552 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
7553 
    except TransactionServiceException, ex:
7554 
      result.ex = ex
7555 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
7556 
    result.write(oprot)
7557 
    oprot.writeMessageEnd()
7558 
    oprot.trans.flush()
7559 
 
999 varun.gupt 7560 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
7561 
    args = getOrdersByBillingDate_args()
7562 
    args.read(iprot)
7563 
    iprot.readMessageEnd()
7564 
    result = getOrdersByBillingDate_result()
7565 
    try:
7566 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
7567 
    except TransactionServiceException, ex:
7568 
      result.ex = ex
7569 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
7570 
    result.write(oprot)
7571 
    oprot.writeMessageEnd()
7572 
    oprot.trans.flush()
7573 
 
3427 chandransh 7574 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
7575 
    args = getOrdersByShippingDate_args()
7576 
    args.read(iprot)
7577 
    iprot.readMessageEnd()
7578 
    result = getOrdersByShippingDate_result()
7579 
    try:
3451 chandransh 7580 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 7581 
    except TransactionServiceException, ex:
7582 
      result.ex = ex
7583 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
7584 
    result.write(oprot)
7585 
    oprot.writeMessageEnd()
7586 
    oprot.trans.flush()
7587 
 
1382 varun.gupt 7588 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
7589 
    args = getReturnableOrdersForCustomer_args()
7590 
    args.read(iprot)
7591 
    iprot.readMessageEnd()
7592 
    result = getReturnableOrdersForCustomer_result()
7593 
    try:
7594 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
7595 
    except TransactionServiceException, ex:
7596 
      result.ex = ex
7597 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
7598 
    result.write(oprot)
7599 
    oprot.writeMessageEnd()
7600 
    oprot.trans.flush()
7601 
 
7602 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
7603 
    args = getCancellableOrdersForCustomer_args()
7604 
    args.read(iprot)
7605 
    iprot.readMessageEnd()
7606 
    result = getCancellableOrdersForCustomer_result()
7607 
    try:
7608 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
7609 
    except TransactionServiceException, ex:
7610 
      result.ex = ex
7611 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
7612 
    result.write(oprot)
7613 
    oprot.writeMessageEnd()
7614 
    oprot.trans.flush()
7615 
 
483 rajveer 7616 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
7617 
    args = changeOrderStatus_args()
94 ashish 7618 
    args.read(iprot)
7619 
    iprot.readMessageEnd()
483 rajveer 7620 
    result = changeOrderStatus_result()
94 ashish 7621 
    try:
483 rajveer 7622 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 7623 
    except TransactionServiceException, ex:
7624 
      result.ex = ex
483 rajveer 7625 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 7626 
    result.write(oprot)
7627 
    oprot.writeMessageEnd()
7628 
    oprot.trans.flush()
7629 
 
483 rajveer 7630 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
7631 
    args = getOrdersForTransaction_args()
94 ashish 7632 
    args.read(iprot)
7633 
    iprot.readMessageEnd()
483 rajveer 7634 
    result = getOrdersForTransaction_result()
94 ashish 7635 
    try:
1528 ankur.sing 7636 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 7637 
    except TransactionServiceException, ex:
7638 
      result.ex = ex
483 rajveer 7639 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 7640 
    result.write(oprot)
7641 
    oprot.writeMessageEnd()
7642 
    oprot.trans.flush()
7643 
 
483 rajveer 7644 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
7645 
    args = getOrdersForCustomer_args()
94 ashish 7646 
    args.read(iprot)
7647 
    iprot.readMessageEnd()
483 rajveer 7648 
    result = getOrdersForCustomer_result()
94 ashish 7649 
    try:
3014 chandransh 7650 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 7651 
    except TransactionServiceException, ex:
7652 
      result.ex = ex
483 rajveer 7653 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 7654 
    result.write(oprot)
7655 
    oprot.writeMessageEnd()
7656 
    oprot.trans.flush()
7657 
 
483 rajveer 7658 
  def process_createOrder(self, seqid, iprot, oprot):
7659 
    args = createOrder_args()
94 ashish 7660 
    args.read(iprot)
7661 
    iprot.readMessageEnd()
483 rajveer 7662 
    result = createOrder_result()
94 ashish 7663 
    try:
483 rajveer 7664 
      result.success = self._handler.createOrder(args.order)
94 ashish 7665 
    except TransactionServiceException, ex:
7666 
      result.ex = ex
483 rajveer 7667 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 7668 
    result.write(oprot)
7669 
    oprot.writeMessageEnd()
7670 
    oprot.trans.flush()
7671 
 
483 rajveer 7672 
  def process_getOrder(self, seqid, iprot, oprot):
7673 
    args = getOrder_args()
94 ashish 7674 
    args.read(iprot)
7675 
    iprot.readMessageEnd()
483 rajveer 7676 
    result = getOrder_result()
94 ashish 7677 
    try:
483 rajveer 7678 
      result.success = self._handler.getOrder(args.id)
94 ashish 7679 
    except TransactionServiceException, ex:
7680 
      result.ex = ex
483 rajveer 7681 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 7682 
    result.write(oprot)
7683 
    oprot.writeMessageEnd()
7684 
    oprot.trans.flush()
7685 
 
483 rajveer 7686 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
7687 
    args = getLineItemsForOrder_args()
94 ashish 7688 
    args.read(iprot)
7689 
    iprot.readMessageEnd()
483 rajveer 7690 
    result = getLineItemsForOrder_result()
94 ashish 7691 
    try:
483 rajveer 7692 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 7693 
    except TransactionServiceException, ex:
7694 
      result.ex = ex
483 rajveer 7695 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 7696 
    result.write(oprot)
7697 
    oprot.writeMessageEnd()
7698 
    oprot.trans.flush()
7699 
 
4999 phani.kuma 7700 
  def process_getOrderList(self, seqid, iprot, oprot):
7701 
    args = getOrderList_args()
7702 
    args.read(iprot)
7703 
    iprot.readMessageEnd()
7704 
    result = getOrderList_result()
7705 
    result.success = self._handler.getOrderList(args.order_ids)
7706 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
7707 
    result.write(oprot)
7708 
    oprot.writeMessageEnd()
7709 
    oprot.trans.flush()
7710 
 
5386 phani.kuma 7711 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
7712 
    args = getOrderListForVendor_args()
7713 
    args.read(iprot)
7714 
    iprot.readMessageEnd()
7715 
    result = getOrderListForVendor_result()
7716 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
7717 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
7718 
    result.write(oprot)
7719 
    oprot.writeMessageEnd()
7720 
    oprot.trans.flush()
7721 
 
1528 ankur.sing 7722 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
7723 
    args = getOrderForCustomer_args()
7724 
    args.read(iprot)
7725 
    iprot.readMessageEnd()
7726 
    result = getOrderForCustomer_result()
7727 
    try:
7728 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
7729 
    except TransactionServiceException, ex:
7730 
      result.ex = ex
7731 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
7732 
    result.write(oprot)
7733 
    oprot.writeMessageEnd()
7734 
    oprot.trans.flush()
7735 
 
3064 chandransh 7736 
  def process_getAlerts(self, seqid, iprot, oprot):
7737 
    args = getAlerts_args()
7738 
    args.read(iprot)
7739 
    iprot.readMessageEnd()
7740 
    result = getAlerts_result()
4444 rajveer 7741 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 7742 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
7743 
    result.write(oprot)
7744 
    oprot.writeMessageEnd()
7745 
    oprot.trans.flush()
7746 
 
4394 rajveer 7747 
  def process_addAlert(self, seqid, iprot, oprot):
7748 
    args = addAlert_args()
3064 chandransh 7749 
    args.read(iprot)
7750 
    iprot.readMessageEnd()
4394 rajveer 7751 
    result = addAlert_result()
4444 rajveer 7752 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 7753 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 7754 
    result.write(oprot)
7755 
    oprot.writeMessageEnd()
7756 
    oprot.trans.flush()
7757 
 
4444 rajveer 7758 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
7759 
    args = markAlertsAsSeen_args()
7760 
    args.read(iprot)
7761 
    iprot.readMessageEnd()
7762 
    result = markAlertsAsSeen_result()
7763 
    self._handler.markAlertsAsSeen(args.warehouseId)
7764 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
7765 
    result.write(oprot)
7766 
    oprot.writeMessageEnd()
7767 
    oprot.trans.flush()
7768 
 
3064 chandransh 7769 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
7770 
    args = getValidOrderCount_args()
7771 
    args.read(iprot)
7772 
    iprot.readMessageEnd()
7773 
    result = getValidOrderCount_result()
7774 
    result.success = self._handler.getValidOrderCount()
7775 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
7776 
    result.write(oprot)
7777 
    oprot.writeMessageEnd()
7778 
    oprot.trans.flush()
7779 
 
7780 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
7781 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
7782 
    args.read(iprot)
7783 
    iprot.readMessageEnd()
7784 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
7785 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
7786 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
7787 
    result.write(oprot)
7788 
    oprot.writeMessageEnd()
7789 
    oprot.trans.flush()
7790 
 
7791 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
7792 
    args = getValidOrdersAmountRange_args()
7793 
    args.read(iprot)
7794 
    iprot.readMessageEnd()
7795 
    result = getValidOrdersAmountRange_result()
7796 
    result.success = self._handler.getValidOrdersAmountRange()
7797 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
7798 
    result.write(oprot)
7799 
    oprot.writeMessageEnd()
7800 
    oprot.trans.flush()
7801 
 
7802 
  def process_getValidOrders(self, seqid, iprot, oprot):
7803 
    args = getValidOrders_args()
7804 
    args.read(iprot)
7805 
    iprot.readMessageEnd()
7806 
    result = getValidOrders_result()
5874 rajveer 7807 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 7808 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
7809 
    result.write(oprot)
7810 
    oprot.writeMessageEnd()
7811 
    oprot.trans.flush()
7812 
 
1220 chandransh 7813 
  def process_batchOrders(self, seqid, iprot, oprot):
7814 
    args = batchOrders_args()
7815 
    args.read(iprot)
7816 
    iprot.readMessageEnd()
7817 
    result = batchOrders_result()
7818 
    try:
7819 
      result.success = self._handler.batchOrders(args.warehouseId)
7820 
    except TransactionServiceException, ex:
7821 
      result.ex = ex
7822 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
7823 
    result.write(oprot)
7824 
    oprot.writeMessageEnd()
7825 
    oprot.trans.flush()
7826 
 
1208 chandransh 7827 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
7828 
    args = markOrderAsOutOfStock_args()
7829 
    args.read(iprot)
7830 
    iprot.readMessageEnd()
7831 
    result = markOrderAsOutOfStock_result()
7832 
    try:
7833 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
7834 
    except TransactionServiceException, ex:
7835 
      result.ex = ex
7836 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
7837 
    result.write(oprot)
7838 
    oprot.writeMessageEnd()
7839 
    oprot.trans.flush()
7840 
 
3064 chandransh 7841 
  def process_verifyOrder(self, seqid, iprot, oprot):
7842 
    args = verifyOrder_args()
759 chandransh 7843 
    args.read(iprot)
7844 
    iprot.readMessageEnd()
3064 chandransh 7845 
    result = verifyOrder_result()
759 chandransh 7846 
    try:
3064 chandransh 7847 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 7848 
    except TransactionServiceException, ex:
7849 
      result.ex = ex
3064 chandransh 7850 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 7851 
    result.write(oprot)
7852 
    oprot.writeMessageEnd()
7853 
    oprot.trans.flush()
7854 
 
3064 chandransh 7855 
  def process_acceptOrder(self, seqid, iprot, oprot):
7856 
    args = acceptOrder_args()
1113 chandransh 7857 
    args.read(iprot)
7858 
    iprot.readMessageEnd()
3064 chandransh 7859 
    result = acceptOrder_result()
1113 chandransh 7860 
    try:
3064 chandransh 7861 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7862 
    except TransactionServiceException, ex:
7863 
      result.ex = ex
3064 chandransh 7864 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7865 
    result.write(oprot)
7866 
    oprot.writeMessageEnd()
7867 
    oprot.trans.flush()
7868 
 
3064 chandransh 7869 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7870 
    args = addBillingDetails_args()
1135 chandransh 7871 
    args.read(iprot)
7872 
    iprot.readMessageEnd()
3064 chandransh 7873 
    result = addBillingDetails_result()
1135 chandransh 7874 
    try:
7190 amar.kumar 7875 
      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 7876 
    except TransactionServiceException, ex:
7877 
      result.ex = ex
3064 chandransh 7878 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7879 
    result.write(oprot)
7880 
    oprot.writeMessageEnd()
7881 
    oprot.trans.flush()
7882 
 
4579 rajveer 7883 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7884 
    args = addInvoiceNumber_args()
7885 
    args.read(iprot)
7886 
    iprot.readMessageEnd()
7887 
    result = addInvoiceNumber_result()
7888 
    try:
6756 amar.kumar 7889 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color, args.serialNumber, args.itemNumber)
4579 rajveer 7890 
    except TransactionServiceException, ex:
7891 
      result.ex = ex
7892 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7893 
    result.write(oprot)
7894 
    oprot.writeMessageEnd()
7895 
    oprot.trans.flush()
7896 
 
4410 rajveer 7897 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7898 
    args = markOrdersAsShippedFromWarehouse_args()
7899 
    args.read(iprot)
7900 
    iprot.readMessageEnd()
7901 
    result = markOrdersAsShippedFromWarehouse_result()
7902 
    try:
4789 rajveer 7903 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7904 
    except TransactionServiceException, ex:
7905 
      result.ex = ex
7906 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7907 
    result.write(oprot)
7908 
    oprot.writeMessageEnd()
7909 
    oprot.trans.flush()
7910 
 
5676 rajveer 7911 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7912 
    args = markOrdersAsReturnedFromStore_args()
7913 
    args.read(iprot)
7914 
    iprot.readMessageEnd()
7915 
    result = markOrdersAsReturnedFromStore_result()
7916 
    try:
5713 rajveer 7917 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7918 
    except TransactionServiceException, ex:
7919 
      result.ex = ex
7920 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7921 
    result.write(oprot)
7922 
    oprot.writeMessageEnd()
7923 
    oprot.trans.flush()
7924 
 
3064 chandransh 7925 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7926 
    args = markOrdersAsPickedUp_args()
304 ashish 7927 
    args.read(iprot)
7928 
    iprot.readMessageEnd()
3064 chandransh 7929 
    result = markOrdersAsPickedUp_result()
7930 
    try:
4910 phani.kuma 7931 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7932 
    except TransactionServiceException, ex:
7933 
      result.ex = ex
7934 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7935 
    result.write(oprot)
7936 
    oprot.writeMessageEnd()
7937 
    oprot.trans.flush()
94 ashish 7938 
 
4910 phani.kuma 7939 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7940 
    args = getOrdersNotPickedUp_args()
7941 
    args.read(iprot)
7942 
    iprot.readMessageEnd()
7943 
    result = getOrdersNotPickedUp_result()
7944 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7945 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7946 
    result.write(oprot)
7947 
    oprot.writeMessageEnd()
7948 
    oprot.trans.flush()
7949 
 
3064 chandransh 7950 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7951 
    args = markOrdersAsDelivered_args()
304 ashish 7952 
    args.read(iprot)
7953 
    iprot.readMessageEnd()
3064 chandransh 7954 
    result = markOrdersAsDelivered_result()
7955 
    try:
7956 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7957 
    except TransactionServiceException, ex:
7958 
      result.ex = ex
7959 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7960 
    result.write(oprot)
7961 
    oprot.writeMessageEnd()
7962 
    oprot.trans.flush()
7963 
 
4910 phani.kuma 7964 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7965 
    args = markAsRTOrders_args()
1596 ankur.sing 7966 
    args.read(iprot)
7967 
    iprot.readMessageEnd()
4910 phani.kuma 7968 
    result = markAsRTOrders_result()
3064 chandransh 7969 
    try:
4910 phani.kuma 7970 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7971 
    except TransactionServiceException, ex:
7972 
      result.ex = ex
4910 phani.kuma 7973 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7974 
    result.write(oprot)
7975 
    oprot.writeMessageEnd()
7976 
    oprot.trans.flush()
304 ashish 7977 
 
4910 phani.kuma 7978 
  def process_getRTOrders(self, seqid, iprot, oprot):
7979 
    args = getRTOrders_args()
7980 
    args.read(iprot)
7981 
    iprot.readMessageEnd()
7982 
    result = getRTOrders_result()
7983 
    result.success = self._handler.getRTOrders(args.providerId)
7984 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7985 
    result.write(oprot)
7986 
    oprot.writeMessageEnd()
7987 
    oprot.trans.flush()
7988 
 
3064 chandransh 7989 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7990 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7991 
    args.read(iprot)
7992 
    iprot.readMessageEnd()
3064 chandransh 7993 
    result = updateNonDeliveryReason_result()
7994 
    try:
4910 phani.kuma 7995 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7996 
    except TransactionServiceException, ex:
7997 
      result.ex = ex
7998 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7999 
    result.write(oprot)
8000 
    oprot.writeMessageEnd()
8001 
    oprot.trans.flush()
1596 ankur.sing 8002 
 
4910 phani.kuma 8003 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
8004 
    args = getNonDeliveredOrdersbyCourier_args()
8005 
    args.read(iprot)
8006 
    iprot.readMessageEnd()
8007 
    result = getNonDeliveredOrdersbyCourier_result()
8008 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
8009 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
8010 
    result.write(oprot)
8011 
    oprot.writeMessageEnd()
8012 
    oprot.trans.flush()
8013 
 
8014 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
8015 
    args = markOrdersAsLocalConnected_args()
8016 
    args.read(iprot)
8017 
    iprot.readMessageEnd()
8018 
    result = markOrdersAsLocalConnected_result()
8019 
    try:
8020 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
8021 
    except TransactionServiceException, ex:
8022 
      result.ex = ex
8023 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
8024 
    result.write(oprot)
8025 
    oprot.writeMessageEnd()
8026 
    oprot.trans.flush()
8027 
 
8028 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
8029 
    args = getOrdersNotLocalConnected_args()
8030 
    args.read(iprot)
8031 
    iprot.readMessageEnd()
8032 
    result = getOrdersNotLocalConnected_result()
8033 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
8034 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
8035 
    result.write(oprot)
8036 
    oprot.writeMessageEnd()
8037 
    oprot.trans.flush()
8038 
 
8039 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
8040 
    args = markOrdersAsDestinationCityReached_args()
8041 
    args.read(iprot)
8042 
    iprot.readMessageEnd()
8043 
    result = markOrdersAsDestinationCityReached_result()
8044 
    try:
8045 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
8046 
    except TransactionServiceException, ex:
8047 
      result.ex = ex
8048 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
8049 
    result.write(oprot)
8050 
    oprot.writeMessageEnd()
8051 
    oprot.trans.flush()
8052 
 
8053 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
8054 
    args = markOrdersAsFirstDeliveryAttempted_args()
8055 
    args.read(iprot)
8056 
    iprot.readMessageEnd()
8057 
    result = markOrdersAsFirstDeliveryAttempted_result()
8058 
    try:
8059 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
8060 
    except TransactionServiceException, ex:
8061 
      result.ex = ex
8062 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
8063 
    result.write(oprot)
8064 
    oprot.writeMessageEnd()
8065 
    oprot.trans.flush()
8066 
 
3064 chandransh 8067 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
8068 
    args = getUndeliveredOrders_args()
1627 ankur.sing 8069 
    args.read(iprot)
8070 
    iprot.readMessageEnd()
3064 chandransh 8071 
    result = getUndeliveredOrders_result()
8072 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
8073 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 8074 
    result.write(oprot)
8075 
    oprot.writeMessageEnd()
8076 
    oprot.trans.flush()
8077 
 
4783 phani.kuma 8078 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
8079 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
8080 
    args.read(iprot)
8081 
    iprot.readMessageEnd()
8082 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
8083 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
8084 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
8085 
    result.write(oprot)
8086 
    oprot.writeMessageEnd()
8087 
    oprot.trans.flush()
8088 
 
2536 chandransh 8089 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
8090 
    args = toggleDOAFlag_args()
8091 
    args.read(iprot)
8092 
    iprot.readMessageEnd()
8093 
    result = toggleDOAFlag_result()
8094 
    try:
8095 
      result.success = self._handler.toggleDOAFlag(args.orderId)
8096 
    except TransactionServiceException, ex:
8097 
      result.ex = ex
8098 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
8099 
    result.write(oprot)
8100 
    oprot.writeMessageEnd()
8101 
    oprot.trans.flush()
1886 ankur.sing 8102 
 
4712 rajveer 8103 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
8104 
    args = markOrderAsDelivered_args()
8105 
    args.read(iprot)
8106 
    iprot.readMessageEnd()
8107 
    result = markOrderAsDelivered_result()
8108 
    try:
8109 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
8110 
    except TransactionServiceException, ex:
8111 
      result.ex = ex
8112 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
8113 
    result.write(oprot)
8114 
    oprot.writeMessageEnd()
8115 
    oprot.trans.flush()
8116 
 
5553 rajveer 8117 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
8118 
    args = markOrderAsReceivedAtStore_args()
8119 
    args.read(iprot)
8120 
    iprot.readMessageEnd()
8121 
    result = markOrderAsReceivedAtStore_result()
8122 
    try:
8123 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
8124 
    except TransactionServiceException, ex:
8125 
      result.ex = ex
8126 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
8127 
    result.write(oprot)
8128 
    oprot.writeMessageEnd()
8129 
    oprot.trans.flush()
8130 
 
4454 rajveer 8131 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
8132 
    args = markOrderDoaRequestReceived_args()
8133 
    args.read(iprot)
8134 
    iprot.readMessageEnd()
8135 
    result = markOrderDoaRequestReceived_result()
8136 
    try:
8137 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
8138 
    except TransactionServiceException, ex:
8139 
      result.ex = ex
8140 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
8141 
    result.write(oprot)
8142 
    oprot.writeMessageEnd()
8143 
    oprot.trans.flush()
8144 
 
8145 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
8146 
    args = markOrderDoaRequestAuthorized_args()
8147 
    args.read(iprot)
8148 
    iprot.readMessageEnd()
8149 
    result = markOrderDoaRequestAuthorized_result()
8150 
    try:
8151 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
8152 
    except TransactionServiceException, ex:
8153 
      result.ex = ex
8154 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
8155 
    result.write(oprot)
8156 
    oprot.writeMessageEnd()
8157 
    oprot.trans.flush()
8158 
 
4488 rajveer 8159 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
8160 
    args = markOrderReturnRequestReceived_args()
8161 
    args.read(iprot)
8162 
    iprot.readMessageEnd()
8163 
    result = markOrderReturnRequestReceived_result()
8164 
    try:
8165 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
8166 
    except TransactionServiceException, ex:
8167 
      result.ex = ex
8168 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
8169 
    result.write(oprot)
8170 
    oprot.writeMessageEnd()
8171 
    oprot.trans.flush()
8172 
 
8173 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
8174 
    args = markOrderReturnRequestAuthorized_args()
8175 
    args.read(iprot)
8176 
    iprot.readMessageEnd()
8177 
    result = markOrderReturnRequestAuthorized_result()
8178 
    try:
8179 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
8180 
    except TransactionServiceException, ex:
8181 
      result.ex = ex
8182 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
8183 
    result.write(oprot)
8184 
    oprot.writeMessageEnd()
8185 
    oprot.trans.flush()
8186 
 
2536 chandransh 8187 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
8188 
    args = requestPickupNumber_args()
8189 
    args.read(iprot)
8190 
    iprot.readMessageEnd()
8191 
    result = requestPickupNumber_result()
8192 
    try:
4579 rajveer 8193 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 8194 
    except TransactionServiceException, ex:
8195 
      result.ex = ex
8196 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
8197 
    result.write(oprot)
8198 
    oprot.writeMessageEnd()
8199 
    oprot.trans.flush()
8200 
 
8201 
  def process_authorizePickup(self, seqid, iprot, oprot):
8202 
    args = authorizePickup_args()
8203 
    args.read(iprot)
8204 
    iprot.readMessageEnd()
8205 
    result = authorizePickup_result()
8206 
    try:
4602 rajveer 8207 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 8208 
    except TransactionServiceException, ex:
8209 
      result.ex = ex
8210 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
8211 
    result.write(oprot)
8212 
    oprot.writeMessageEnd()
8213 
    oprot.trans.flush()
8214 
 
2764 chandransh 8215 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
8216 
    args = markDoasAsPickedUp_args()
8217 
    args.read(iprot)
8218 
    iprot.readMessageEnd()
8219 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 8220 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 8221 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
8222 
    result.write(oprot)
8223 
    oprot.writeMessageEnd()
8224 
    oprot.trans.flush()
8225 
 
4910 phani.kuma 8226 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
8227 
    args = getDoasNotPickedUp_args()
8228 
    args.read(iprot)
8229 
    iprot.readMessageEnd()
8230 
    result = getDoasNotPickedUp_result()
8231 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
8232 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
8233 
    result.write(oprot)
8234 
    oprot.writeMessageEnd()
8235 
    oprot.trans.flush()
8236 
 
4741 phani.kuma 8237 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
8238 
    args = markReturnOrdersAsPickedUp_args()
8239 
    args.read(iprot)
8240 
    iprot.readMessageEnd()
8241 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 8242 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 8243 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
8244 
    result.write(oprot)
8245 
    oprot.writeMessageEnd()
8246 
    oprot.trans.flush()
8247 
 
4910 phani.kuma 8248 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
8249 
    args = getReturnOrdersNotPickedUp_args()
8250 
    args.read(iprot)
8251 
    iprot.readMessageEnd()
8252 
    result = getReturnOrdersNotPickedUp_result()
8253 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
8254 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
8255 
    result.write(oprot)
8256 
    oprot.writeMessageEnd()
8257 
    oprot.trans.flush()
8258 
 
2616 chandransh 8259 
  def process_receiveReturn(self, seqid, iprot, oprot):
8260 
    args = receiveReturn_args()
2591 chandransh 8261 
    args.read(iprot)
8262 
    iprot.readMessageEnd()
2616 chandransh 8263 
    result = receiveReturn_result()
2591 chandransh 8264 
    try:
4479 rajveer 8265 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 8266 
    except TransactionServiceException, ex:
8267 
      result.ex = ex
2616 chandransh 8268 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 8269 
    result.write(oprot)
8270 
    oprot.writeMessageEnd()
8271 
    oprot.trans.flush()
2536 chandransh 8272 
 
2591 chandransh 8273 
  def process_validateDoa(self, seqid, iprot, oprot):
8274 
    args = validateDoa_args()
8275 
    args.read(iprot)
8276 
    iprot.readMessageEnd()
8277 
    result = validateDoa_result()
8278 
    try:
8279 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
8280 
    except TransactionServiceException, ex:
8281 
      result.ex = ex
8282 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
8283 
    result.write(oprot)
8284 
    oprot.writeMessageEnd()
8285 
    oprot.trans.flush()
8286 
 
4495 rajveer 8287 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
8288 
    args = validateReturnProduct_args()
8289 
    args.read(iprot)
8290 
    iprot.readMessageEnd()
8291 
    result = validateReturnProduct_result()
8292 
    try:
8293 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
8294 
    except TransactionServiceException, ex:
8295 
      result.ex = ex
8296 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
8297 
    result.write(oprot)
8298 
    oprot.writeMessageEnd()
8299 
    oprot.trans.flush()
8300 
 
2616 chandransh 8301 
  def process_reshipOrder(self, seqid, iprot, oprot):
8302 
    args = reshipOrder_args()
8303 
    args.read(iprot)
8304 
    iprot.readMessageEnd()
8305 
    result = reshipOrder_result()
8306 
    try:
8307 
      result.success = self._handler.reshipOrder(args.orderId)
8308 
    except TransactionServiceException, ex:
8309 
      result.ex = ex
8310 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
8311 
    result.write(oprot)
8312 
    oprot.writeMessageEnd()
8313 
    oprot.trans.flush()
2591 chandransh 8314 
 
2616 chandransh 8315 
  def process_refundOrder(self, seqid, iprot, oprot):
8316 
    args = refundOrder_args()
8317 
    args.read(iprot)
8318 
    iprot.readMessageEnd()
8319 
    result = refundOrder_result()
8320 
    try:
3226 chandransh 8321 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 8322 
    except TransactionServiceException, ex:
8323 
      result.ex = ex
8324 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
8325 
    result.write(oprot)
8326 
    oprot.writeMessageEnd()
8327 
    oprot.trans.flush()
8328 
 
2690 chandransh 8329 
  def process_getReturnOrders(self, seqid, iprot, oprot):
8330 
    args = getReturnOrders_args()
8331 
    args.read(iprot)
8332 
    iprot.readMessageEnd()
8333 
    result = getReturnOrders_result()
8334 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
8335 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
8336 
    result.write(oprot)
8337 
    oprot.writeMessageEnd()
8338 
    oprot.trans.flush()
2616 chandransh 8339 
 
5481 phani.kuma 8340 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
8341 
    args = getAllReturnOrders_args()
8342 
    args.read(iprot)
8343 
    iprot.readMessageEnd()
8344 
    result = getAllReturnOrders_result()
8345 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
8346 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
8347 
    result.write(oprot)
8348 
    oprot.writeMessageEnd()
8349 
    oprot.trans.flush()
8350 
 
2700 chandransh 8351 
  def process_getReturnOrder(self, seqid, iprot, oprot):
8352 
    args = getReturnOrder_args()
8353 
    args.read(iprot)
8354 
    iprot.readMessageEnd()
8355 
    result = getReturnOrder_result()
8356 
    try:
8357 
      result.success = self._handler.getReturnOrder(args.id)
8358 
    except TransactionServiceException, ex:
8359 
      result.ex = ex
8360 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
8361 
    result.write(oprot)
8362 
    oprot.writeMessageEnd()
8363 
    oprot.trans.flush()
8364 
 
2690 chandransh 8365 
  def process_processReturn(self, seqid, iprot, oprot):
8366 
    args = processReturn_args()
8367 
    args.read(iprot)
8368 
    iprot.readMessageEnd()
8369 
    result = processReturn_result()
8370 
    try:
8371 
      self._handler.processReturn(args.returnOrderId)
8372 
    except TransactionServiceException, ex:
8373 
      result.ex = ex
8374 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
8375 
    result.write(oprot)
8376 
    oprot.writeMessageEnd()
8377 
    oprot.trans.flush()
8378 
 
3451 chandransh 8379 
  def process_updateWeight(self, seqid, iprot, oprot):
8380 
    args = updateWeight_args()
8381 
    args.read(iprot)
8382 
    iprot.readMessageEnd()
8383 
    result = updateWeight_result()
8384 
    try:
8385 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
8386 
    except TransactionServiceException, ex:
8387 
      result.ex = ex
8388 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
8389 
    result.write(oprot)
8390 
    oprot.writeMessageEnd()
8391 
    oprot.trans.flush()
2819 chandransh 8392 
 
3469 chandransh 8393 
  def process_changeItem(self, seqid, iprot, oprot):
8394 
    args = changeItem_args()
8395 
    args.read(iprot)
8396 
    iprot.readMessageEnd()
8397 
    result = changeItem_result()
8398 
    try:
8399 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
8400 
    except TransactionServiceException, ex:
8401 
      result.ex = ex
8402 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
8403 
    result.write(oprot)
8404 
    oprot.writeMessageEnd()
8405 
    oprot.trans.flush()
3451 chandransh 8406 
 
3469 chandransh 8407 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
8408 
    args = shiftToWarehouse_args()
8409 
    args.read(iprot)
8410 
    iprot.readMessageEnd()
8411 
    result = shiftToWarehouse_result()
8412 
    try:
8413 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
8414 
    except TransactionServiceException, ex:
8415 
      result.ex = ex
8416 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
8417 
    result.write(oprot)
8418 
    oprot.writeMessageEnd()
8419 
    oprot.trans.flush()
8420 
 
3553 chandransh 8421 
  def process_addDelayReason(self, seqid, iprot, oprot):
8422 
    args = addDelayReason_args()
8423 
    args.read(iprot)
8424 
    iprot.readMessageEnd()
8425 
    result = addDelayReason_result()
8426 
    try:
4647 rajveer 8427 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 8428 
    except TransactionServiceException, ex:
8429 
      result.ex = ex
8430 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
8431 
    result.write(oprot)
8432 
    oprot.writeMessageEnd()
8433 
    oprot.trans.flush()
3469 chandransh 8434 
 
3956 chandransh 8435 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
8436 
    args = reconcileCodCollection_args()
8437 
    args.read(iprot)
8438 
    iprot.readMessageEnd()
8439 
    result = reconcileCodCollection_result()
8440 
    try:
8441 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
8442 
    except TransactionServiceException, ex:
8443 
      result.ex = ex
8444 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
8445 
    result.write(oprot)
8446 
    oprot.writeMessageEnd()
8447 
    oprot.trans.flush()
3553 chandransh 8448 
 
4008 mandeep.dh 8449 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
8450 
    args = getTransactionsRequiringExtraProcessing_args()
8451 
    args.read(iprot)
8452 
    iprot.readMessageEnd()
8453 
    result = getTransactionsRequiringExtraProcessing_result()
8454 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
8455 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
8456 
    result.write(oprot)
8457 
    oprot.writeMessageEnd()
8458 
    oprot.trans.flush()
3956 chandransh 8459 
 
4008 mandeep.dh 8460 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
8461 
    args = markTransactionAsProcessed_args()
8462 
    args.read(iprot)
8463 
    iprot.readMessageEnd()
8464 
    result = markTransactionAsProcessed_result()
8465 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
8466 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
8467 
    result.write(oprot)
8468 
    oprot.writeMessageEnd()
8469 
    oprot.trans.flush()
8470 
 
4018 chandransh 8471 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
8472 
    args = getItemWiseRiskyOrdersCount_args()
8473 
    args.read(iprot)
8474 
    iprot.readMessageEnd()
8475 
    result = getItemWiseRiskyOrdersCount_result()
8476 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
8477 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
8478 
    result.write(oprot)
8479 
    oprot.writeMessageEnd()
8480 
    oprot.trans.flush()
4008 mandeep.dh 8481 
 
4295 varun.gupt 8482 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
8483 
    args = getOrdersForItemIds_args()
8484 
    args.read(iprot)
8485 
    iprot.readMessageEnd()
8486 
    result = getOrdersForItemIds_result()
8487 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
8488 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
8489 
    result.write(oprot)
8490 
    oprot.writeMessageEnd()
8491 
    oprot.trans.flush()
8492 
 
4247 rajveer 8493 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
8494 
    args = markOrderCancellationRequestReceived_args()
8495 
    args.read(iprot)
8496 
    iprot.readMessageEnd()
8497 
    result = markOrderCancellationRequestReceived_result()
8498 
    try:
8499 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
8500 
    except TransactionServiceException, ex:
8501 
      result.ex = ex
8502 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
8503 
    result.write(oprot)
8504 
    oprot.writeMessageEnd()
8505 
    oprot.trans.flush()
4018 chandransh 8506 
 
4247 rajveer 8507 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
8508 
    args = markOrderCancellationRequestConfirmed_args()
8509 
    args.read(iprot)
8510 
    iprot.readMessageEnd()
8511 
    result = markOrderCancellationRequestConfirmed_result()
8512 
    try:
8513 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
8514 
    except TransactionServiceException, ex:
8515 
      result.ex = ex
8516 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
8517 
    result.write(oprot)
8518 
    oprot.writeMessageEnd()
8519 
    oprot.trans.flush()
8520 
 
8521 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
8522 
    args = markOrderCancellationRequestDenied_args()
8523 
    args.read(iprot)
8524 
    iprot.readMessageEnd()
8525 
    result = markOrderCancellationRequestDenied_result()
8526 
    try:
8527 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
8528 
    except TransactionServiceException, ex:
8529 
      result.ex = ex
8530 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
8531 
    result.write(oprot)
8532 
    oprot.writeMessageEnd()
8533 
    oprot.trans.flush()
8534 
 
4258 rajveer 8535 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
8536 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 8537 
    args.read(iprot)
8538 
    iprot.readMessageEnd()
4258 rajveer 8539 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 8540 
    try:
4258 rajveer 8541 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 8542 
    except TransactionServiceException, ex:
8543 
      result.ex = ex
4258 rajveer 8544 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 8545 
    result.write(oprot)
8546 
    oprot.writeMessageEnd()
8547 
    oprot.trans.flush()
8548 
 
4259 anupam.sin 8549 
  def process_refundTransaction(self, seqid, iprot, oprot):
8550 
    args = refundTransaction_args()
8551 
    args.read(iprot)
8552 
    iprot.readMessageEnd()
8553 
    result = refundTransaction_result()
8554 
    try:
8555 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
8556 
    except TransactionServiceException, ex:
8557 
      result.ex = ex
8558 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
8559 
    result.write(oprot)
8560 
    oprot.writeMessageEnd()
8561 
    oprot.trans.flush()
4247 rajveer 8562 
 
4324 mandeep.dh 8563 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
8564 
    args = updateShipmentAddress_args()
8565 
    args.read(iprot)
8566 
    iprot.readMessageEnd()
8567 
    result = updateShipmentAddress_result()
8568 
    try:
8569 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
8570 
    except TransactionServiceException, ex:
8571 
      result.ex = ex
8572 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
8573 
    result.write(oprot)
8574 
    oprot.writeMessageEnd()
8575 
    oprot.trans.flush()
8576 
 
4285 rajveer 8577 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
8578 
    args = acceptOrdersForItemId_args()
8579 
    args.read(iprot)
8580 
    iprot.readMessageEnd()
8581 
    result = acceptOrdersForItemId_result()
8582 
    try:
8583 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
8584 
    except TransactionServiceException, ex:
8585 
      result.ex = ex
8586 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
8587 
    result.write(oprot)
8588 
    oprot.writeMessageEnd()
8589 
    oprot.trans.flush()
4259 anupam.sin 8590 
 
4303 rajveer 8591 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
8592 
    args = markOrdersAsPORaised_args()
8593 
    args.read(iprot)
8594 
    iprot.readMessageEnd()
8595 
    result = markOrdersAsPORaised_result()
8596 
    try:
4369 rajveer 8597 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8598 
    except TransactionServiceException, ex:
8599 
      result.ex = ex
8600 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
8601 
    result.write(oprot)
8602 
    oprot.writeMessageEnd()
8603 
    oprot.trans.flush()
4285 rajveer 8604 
 
4303 rajveer 8605 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
8606 
    args = markOrdersAsReversalInitiated_args()
8607 
    args.read(iprot)
8608 
    iprot.readMessageEnd()
8609 
    result = markOrdersAsReversalInitiated_result()
8610 
    try:
4369 rajveer 8611 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8612 
    except TransactionServiceException, ex:
8613 
      result.ex = ex
8614 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
8615 
    result.write(oprot)
8616 
    oprot.writeMessageEnd()
8617 
    oprot.trans.flush()
8618 
 
8619 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
8620 
    args = markOrdersAsNotAvailabke_args()
8621 
    args.read(iprot)
8622 
    iprot.readMessageEnd()
8623 
    result = markOrdersAsNotAvailabke_result()
8624 
    try:
4369 rajveer 8625 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8626 
    except TransactionServiceException, ex:
8627 
      result.ex = ex
8628 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
8629 
    result.write(oprot)
8630 
    oprot.writeMessageEnd()
8631 
    oprot.trans.flush()
8632 
 
4369 rajveer 8633 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
8634 
    args = markOrdersAsTimeout_args()
8635 
    args.read(iprot)
8636 
    iprot.readMessageEnd()
8637 
    result = markOrdersAsTimeout_result()
8638 
    try:
8639 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
8640 
    except TransactionServiceException, ex:
8641 
      result.ex = ex
8642 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
8643 
    result.write(oprot)
8644 
    oprot.writeMessageEnd()
8645 
    oprot.trans.flush()
4303 rajveer 8646 
 
4662 rajveer 8647 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
8648 
    args = markOrderAsLostInTransit_args()
8649 
    args.read(iprot)
8650 
    iprot.readMessageEnd()
8651 
    result = markOrderAsLostInTransit_result()
8652 
    try:
8653 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
8654 
    except TransactionServiceException, ex:
8655 
      result.ex = ex
8656 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
8657 
    result.write(oprot)
8658 
    oprot.writeMessageEnd()
8659 
    oprot.trans.flush()
8660 
 
4386 anupam.sin 8661 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
8662 
    args = getOrderForAwb_args()
8663 
    args.read(iprot)
8664 
    iprot.readMessageEnd()
8665 
    result = getOrderForAwb_result()
8666 
    try:
8667 
      result.success = self._handler.getOrderForAwb(args.awb)
8668 
    except TransactionServiceException, ex:
8669 
      result.ex = ex
8670 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
8671 
    result.write(oprot)
8672 
    oprot.writeMessageEnd()
8673 
    oprot.trans.flush()
4369 rajveer 8674 
 
4506 phani.kuma 8675 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
8676 
    args = getOrdersForProviderForStatus_args()
8677 
    args.read(iprot)
8678 
    iprot.readMessageEnd()
8679 
    result = getOrdersForProviderForStatus_result()
8680 
    try:
4910 phani.kuma 8681 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 8682 
    except TransactionServiceException, ex:
8683 
      result.ex = ex
8684 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
8685 
    result.write(oprot)
8686 
    oprot.writeMessageEnd()
8687 
    oprot.trans.flush()
4386 anupam.sin 8688 
 
4600 varun.gupt 8689 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
8690 
    args = getBilledOrdersForVendor_args()
8691 
    args.read(iprot)
8692 
    iprot.readMessageEnd()
8693 
    result = getBilledOrdersForVendor_result()
8694 
    try:
8695 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
8696 
    except TransactionServiceException, ex:
8697 
      result.ex = ex
8698 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
8699 
    result.write(oprot)
8700 
    oprot.writeMessageEnd()
8701 
    oprot.trans.flush()
4506 phani.kuma 8702 
 
4607 rajveer 8703 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
8704 
    args = getSlippedSippingDateOrders_args()
8705 
    args.read(iprot)
8706 
    iprot.readMessageEnd()
8707 
    result = getSlippedSippingDateOrders_result()
8708 
    try:
8709 
      result.success = self._handler.getSlippedSippingDateOrders()
8710 
    except TransactionServiceException, ex:
8711 
      result.ex = ex
8712 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
8713 
    result.write(oprot)
8714 
    oprot.writeMessageEnd()
8715 
    oprot.trans.flush()
8716 
 
4709 rajveer 8717 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
8718 
    args = getCancelledOrders_args()
8719 
    args.read(iprot)
8720 
    iprot.readMessageEnd()
8721 
    result = getCancelledOrders_result()
8722 
    try:
8723 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
8724 
    except TransactionServiceException, ex:
8725 
      result.ex = ex
8726 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
8727 
    result.write(oprot)
8728 
    oprot.writeMessageEnd()
8729 
    oprot.trans.flush()
8730 
 
4600 varun.gupt 8731 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
8732 
    args = saveBluedartSettlements_args()
8733 
    args.read(iprot)
8734 
    iprot.readMessageEnd()
8735 
    result = saveBluedartSettlements_result()
8736 
    try:
8737 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
8738 
    except TransactionServiceException, ex:
8739 
      result.ex = ex
8740 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
8741 
    result.write(oprot)
8742 
    oprot.writeMessageEnd()
8743 
    oprot.trans.flush()
8744 
 
8745 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
8746 
    args = savePaymentSettlements_args()
8747 
    args.read(iprot)
8748 
    iprot.readMessageEnd()
8749 
    result = savePaymentSettlements_result()
8750 
    try:
4905 varun.gupt 8751 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 8752 
    except TransactionServiceException, ex:
8753 
      result.ex = ex
8754 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
8755 
    result.write(oprot)
8756 
    oprot.writeMessageEnd()
8757 
    oprot.trans.flush()
8758 
 
8759 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
8760 
    args = saveEBSSettlementSummary_args()
8761 
    args.read(iprot)
8762 
    iprot.readMessageEnd()
8763 
    result = saveEBSSettlementSummary_result()
8764 
    try:
8765 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
8766 
    except TransactionServiceException, ex:
8767 
      result.ex = ex
8768 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
8769 
    result.write(oprot)
8770 
    oprot.writeMessageEnd()
8771 
    oprot.trans.flush()
8772 
 
5386 phani.kuma 8773 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
8774 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 8775 
    args.read(iprot)
8776 
    iprot.readMessageEnd()
5386 phani.kuma 8777 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 8778 
    try:
5386 phani.kuma 8779 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 8780 
    except TransactionServiceException, ex:
8781 
      result.ex = ex
5386 phani.kuma 8782 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 8783 
    result.write(oprot)
8784 
    oprot.writeMessageEnd()
8785 
    oprot.trans.flush()
8786 
 
5386 phani.kuma 8787 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
8788 
    args = getSettlementForCod_args()
8789 
    args.read(iprot)
8790 
    iprot.readMessageEnd()
8791 
    result = getSettlementForCod_result()
8792 
    try:
8793 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
8794 
    except TransactionServiceException, ex:
8795 
      result.ex = ex
8796 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
8797 
    result.write(oprot)
8798 
    oprot.writeMessageEnd()
8799 
    oprot.trans.flush()
8800 
 
4600 varun.gupt 8801 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
8802 
    args = getEBSSettlementSummaries_args()
8803 
    args.read(iprot)
8804 
    iprot.readMessageEnd()
8805 
    result = getEBSSettlementSummaries_result()
8806 
    try:
8807 
      result.success = self._handler.getEBSSettlementSummaries()
8808 
    except TransactionServiceException, ex:
8809 
      result.ex = ex
8810 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
8811 
    result.write(oprot)
8812 
    oprot.writeMessageEnd()
8813 
    oprot.trans.flush()
8814 
 
8815 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
8816 
    args = markEBSSettlementUploaded_args()
8817 
    args.read(iprot)
8818 
    iprot.readMessageEnd()
8819 
    result = markEBSSettlementUploaded_result()
8820 
    try:
8821 
      self._handler.markEBSSettlementUploaded(args.settlementId)
8822 
    except TransactionServiceException, ex:
8823 
      result.ex = ex
8824 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
8825 
    result.write(oprot)
8826 
    oprot.writeMessageEnd()
8827 
    oprot.trans.flush()
8828 
 
8829 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
8830 
    args = getEBSSettlementDate_args()
8831 
    args.read(iprot)
8832 
    iprot.readMessageEnd()
8833 
    result = getEBSSettlementDate_result()
8834 
    try:
8835 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
8836 
    except TransactionServiceException, ex:
8837 
      result.ex = ex
8838 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
8839 
    result.write(oprot)
8840 
    oprot.writeMessageEnd()
8841 
    oprot.trans.flush()
8842 
 
4715 varun.gupt 8843 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
8844 
    args = getSettlementsByDate_args()
8845 
    args.read(iprot)
8846 
    iprot.readMessageEnd()
8847 
    result = getSettlementsByDate_result()
8848 
    try:
8849 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
8850 
    except TransactionServiceException, ex:
8851 
      result.ex = ex
8852 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
8853 
    result.write(oprot)
8854 
    oprot.writeMessageEnd()
8855 
    oprot.trans.flush()
4600 varun.gupt 8856 
 
4715 varun.gupt 8857 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
8858 
    args = getReshippedOrderIds_args()
8859 
    args.read(iprot)
8860 
    iprot.readMessageEnd()
8861 
    result = getReshippedOrderIds_result()
8862 
    try:
8863 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8864 
    except TransactionServiceException, ex:
8865 
      result.ex = ex
8866 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8867 
    result.write(oprot)
8868 
    oprot.writeMessageEnd()
8869 
    oprot.trans.flush()
8870 
 
5481 phani.kuma 8871 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8872 
    args = getBilledOrders_args()
4875 varun.gupt 8873 
    args.read(iprot)
8874 
    iprot.readMessageEnd()
5481 phani.kuma 8875 
    result = getBilledOrders_result()
4875 varun.gupt 8876 
    try:
5481 phani.kuma 8877 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8878 
    except TransactionServiceException, ex:
8879 
      result.ex = ex
5481 phani.kuma 8880 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8881 
    result.write(oprot)
8882 
    oprot.writeMessageEnd()
8883 
    oprot.trans.flush()
4757 mandeep.dh 8884 
 
5031 varun.gupt 8885 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8886 
    args = getStatusDistributionOfOrders_args()
8887 
    args.read(iprot)
8888 
    iprot.readMessageEnd()
8889 
    result = getStatusDistributionOfOrders_result()
8890 
    try:
8891 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8892 
    except TransactionServiceException, ex:
8893 
      result.ex = ex
8894 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8895 
    result.write(oprot)
8896 
    oprot.writeMessageEnd()
8897 
    oprot.trans.flush()
4875 varun.gupt 8898 
 
5067 varun.gupt 8899 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8900 
    args = getOrderIdsForStatus_args()
8901 
    args.read(iprot)
8902 
    iprot.readMessageEnd()
8903 
    result = getOrderIdsForStatus_result()
8904 
    try:
8905 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8906 
    except TransactionServiceException, ex:
8907 
      result.ex = ex
8908 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8909 
    result.write(oprot)
8910 
    oprot.writeMessageEnd()
8911 
    oprot.trans.flush()
5031 varun.gupt 8912 
 
5348 anupam.sin 8913 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8914 
    args = updateCODAgent_args()
8915 
    args.read(iprot)
8916 
    iprot.readMessageEnd()
8917 
    result = updateCODAgent_result()
8918 
    try:
8919 
      self._handler.updateCODAgent(args.agent, args.orderId)
8920 
    except TransactionServiceException, ex:
8921 
      result.ex = ex
8922 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8923 
    result.write(oprot)
8924 
    oprot.writeMessageEnd()
8925 
    oprot.trans.flush()
8926 
 
5099 varun.gupt 8927 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8928 
    args = updateOrderAsPaidToVendor_args()
8929 
    args.read(iprot)
8930 
    iprot.readMessageEnd()
8931 
    result = updateOrderAsPaidToVendor_result()
8932 
    try:
8933 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8934 
    except TransactionServiceException, ex:
8935 
      result.ex = ex
8936 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8937 
    result.write(oprot)
8938 
    oprot.writeMessageEnd()
8939 
    oprot.trans.flush()
5067 varun.gupt 8940 
 
5386 phani.kuma 8941 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8942 
    args = updateOrderOnlyAsPaidToVendor_args()
8943 
    args.read(iprot)
8944 
    iprot.readMessageEnd()
8945 
    result = updateOrderOnlyAsPaidToVendor_result()
8946 
    try:
8947 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8948 
    except TransactionServiceException, ex:
8949 
      result.ex = ex
8950 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8951 
    result.write(oprot)
8952 
    oprot.writeMessageEnd()
8953 
    oprot.trans.flush()
8954 
 
5208 varun.gupt 8955 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8956 
    args = getRefundedOrdersMarkedPaid_args()
8957 
    args.read(iprot)
8958 
    iprot.readMessageEnd()
8959 
    result = getRefundedOrdersMarkedPaid_result()
8960 
    try:
8961 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8962 
    except TransactionServiceException, ex:
8963 
      result.ex = ex
8964 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8965 
    result.write(oprot)
8966 
    oprot.writeMessageEnd()
8967 
    oprot.trans.flush()
5099 varun.gupt 8968 
 
5447 anupam.sin 8969 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8970 
    args = getAllVerificationAgents_args()
8971 
    args.read(iprot)
8972 
    iprot.readMessageEnd()
8973 
    result = getAllVerificationAgents_result()
8974 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8975 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8976 
    result.write(oprot)
8977 
    oprot.writeMessageEnd()
8978 
    oprot.trans.flush()
5208 varun.gupt 8979 
 
5527 anupam.sin 8980 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8981 
    args = getAllAttributesForOrderId_args()
8982 
    args.read(iprot)
8983 
    iprot.readMessageEnd()
8984 
    result = getAllAttributesForOrderId_result()
8985 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8986 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8987 
    result.write(oprot)
8988 
    oprot.writeMessageEnd()
8989 
    oprot.trans.flush()
5447 anupam.sin 8990 
 
5676 rajveer 8991 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8992 
    args = setOrderAttributes_args()
8993 
    args.read(iprot)
8994 
    iprot.readMessageEnd()
8995 
    result = setOrderAttributes_result()
8996 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8997 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8998 
    result.write(oprot)
8999 
    oprot.writeMessageEnd()
9000 
    oprot.trans.flush()
9001 
 
5527 anupam.sin 9002 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
9003 
    args = setOrderAttributeForTransaction_args()
9004 
    args.read(iprot)
9005 
    iprot.readMessageEnd()
9006 
    result = setOrderAttributeForTransaction_result()
9007 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
9008 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
9009 
    result.write(oprot)
9010 
    oprot.writeMessageEnd()
9011 
    oprot.trans.flush()
9012 
 
5553 rajveer 9013 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
9014 
    args = getReceivePendingOrders_args()
9015 
    args.read(iprot)
9016 
    iprot.readMessageEnd()
9017 
    result = getReceivePendingOrders_result()
9018 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
9019 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
9020 
    result.write(oprot)
9021 
    oprot.writeMessageEnd()
9022 
    oprot.trans.flush()
5527 anupam.sin 9023 
 
5553 rajveer 9024 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
9025 
    args = getReceivedAtStoreOrders_args()
9026 
    args.read(iprot)
9027 
    iprot.readMessageEnd()
9028 
    result = getReceivedAtStoreOrders_result()
9029 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
9030 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
9031 
    result.write(oprot)
9032 
    oprot.writeMessageEnd()
9033 
    oprot.trans.flush()
9034 
 
5713 rajveer 9035 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
9036 
    args = getOrdersCollectionAtStore_args()
9037 
    args.read(iprot)
9038 
    iprot.readMessageEnd()
9039 
    result = getOrdersCollectionAtStore_result()
9040 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
9041 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
9042 
    result.write(oprot)
9043 
    oprot.writeMessageEnd()
9044 
    oprot.trans.flush()
9045 
 
5833 rajveer 9046 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
9047 
    args = getOrderAttributeValue_args()
9048 
    args.read(iprot)
9049 
    iprot.readMessageEnd()
9050 
    result = getOrderAttributeValue_result()
9051 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
9052 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
9053 
    result.write(oprot)
9054 
    oprot.writeMessageEnd()
9055 
    oprot.trans.flush()
9056 
 
6019 rajveer 9057 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
9058 
    args = changeJacketNumber_args()
9059 
    args.read(iprot)
9060 
    iprot.readMessageEnd()
9061 
    result = changeJacketNumber_result()
9062 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
9063 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
9064 
    result.write(oprot)
9065 
    oprot.writeMessageEnd()
9066 
    oprot.trans.flush()
9067 
 
9068 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
9069 
    args = markOrderAsRtoInTransit_args()
9070 
    args.read(iprot)
9071 
    iprot.readMessageEnd()
9072 
    result = markOrderAsRtoInTransit_result()
9073 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
9074 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
9075 
    result.write(oprot)
9076 
    oprot.writeMessageEnd()
9077 
    oprot.trans.flush()
9078 
 
5593 mandeep.dh 9079 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
9080 
    args = acceptOrderForItem_args()
9081 
    args.read(iprot)
9082 
    iprot.readMessageEnd()
9083 
    result = acceptOrderForItem_result()
9084 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
9085 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
9086 
    result.write(oprot)
9087 
    oprot.writeMessageEnd()
9088 
    oprot.trans.flush()
5553 rajveer 9089 
 
6000 mandeep.dh 9090 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
9091 
    args = createRechargeOrder_args()
9092 
    args.read(iprot)
9093 
    iprot.readMessageEnd()
9094 
    result = createRechargeOrder_result()
9095 
    try:
9096 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
9097 
    except TransactionServiceException, ex:
9098 
      result.ex = ex
9099 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
9100 
    result.write(oprot)
9101 
    oprot.writeMessageEnd()
9102 
    oprot.trans.flush()
5593 mandeep.dh 9103 
 
6031 rajveer 9104 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
9105 
    args = getRechargeOrder_args()
9106 
    args.read(iprot)
9107 
    iprot.readMessageEnd()
9108 
    result = getRechargeOrder_result()
9109 
    try:
9110 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
9111 
    except TransactionServiceException, ex:
9112 
      result.ex = ex
9113 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
9114 
    result.write(oprot)
9115 
    oprot.writeMessageEnd()
9116 
    oprot.trans.flush()
9117 
 
9118 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
9119 
    args = getRechargeOrders_args()
9120 
    args.read(iprot)
9121 
    iprot.readMessageEnd()
9122 
    result = getRechargeOrders_result()
9123 
    result.success = self._handler.getRechargeOrders(args.userId)
9124 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
9125 
    result.write(oprot)
9126 
    oprot.writeMessageEnd()
9127 
    oprot.trans.flush()
9128 
 
6000 mandeep.dh 9129 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
9130 
    args = updateRechargeOrderStatus_args()
9131 
    args.read(iprot)
9132 
    iprot.readMessageEnd()
9133 
    result = updateRechargeOrderStatus_result()
9134 
    try:
6031 rajveer 9135 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 9136 
    except TransactionServiceException, ex:
9137 
      result.ex = ex
9138 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
9139 
    result.write(oprot)
9140 
    oprot.writeMessageEnd()
9141 
    oprot.trans.flush()
9142 
 
9143 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
9144 
    args = activateRechargeTxn_args()
9145 
    args.read(iprot)
9146 
    iprot.readMessageEnd()
9147 
    result = activateRechargeTxn_result()
9148 
    try:
6031 rajveer 9149 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 9150 
    except TransactionServiceException, ex:
9151 
      result.ex = ex
9152 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
9153 
    result.write(oprot)
9154 
    oprot.writeMessageEnd()
9155 
    oprot.trans.flush()
9156 
 
6031 rajveer 9157 
  def process_getUserWallet(self, seqid, iprot, oprot):
9158 
    args = getUserWallet_args()
6000 mandeep.dh 9159 
    args.read(iprot)
9160 
    iprot.readMessageEnd()
6031 rajveer 9161 
    result = getUserWallet_result()
9162 
    result.success = self._handler.getUserWallet(args.userId)
9163 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 9164 
    result.write(oprot)
9165 
    oprot.writeMessageEnd()
9166 
    oprot.trans.flush()
9167 
 
6031 rajveer 9168 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
9169 
    args = getUserWalletHistory_args()
6000 mandeep.dh 9170 
    args.read(iprot)
9171 
    iprot.readMessageEnd()
6031 rajveer 9172 
    result = getUserWalletHistory_result()
9173 
    result.success = self._handler.getUserWalletHistory(args.userId)
9174 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 9175 
    result.write(oprot)
9176 
    oprot.writeMessageEnd()
9177 
    oprot.trans.flush()
9178 
 
6050 anupam.sin 9179 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
9180 
    args = getRechargeOrdersForTransaction_args()
9181 
    args.read(iprot)
9182 
    iprot.readMessageEnd()
9183 
    result = getRechargeOrdersForTransaction_result()
9184 
    try:
9185 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
9186 
    except TransactionServiceException, ex:
9187 
      result.ex = ex
9188 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
9189 
    result.write(oprot)
9190 
    oprot.writeMessageEnd()
9191 
    oprot.trans.flush()
9192 
 
6048 rajveer 9193 
  def process_getServiceProviders(self, seqid, iprot, oprot):
9194 
    args = getServiceProviders_args()
9195 
    args.read(iprot)
9196 
    iprot.readMessageEnd()
9197 
    result = getServiceProviders_result()
6206 rajveer 9198 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 9199 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
9200 
    result.write(oprot)
9201 
    oprot.writeMessageEnd()
9202 
    oprot.trans.flush()
6000 mandeep.dh 9203 
 
6048 rajveer 9204 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
9205 
    args = getServiceProviderForDevice_args()
9206 
    args.read(iprot)
9207 
    iprot.readMessageEnd()
9208 
    result = getServiceProviderForDevice_result()
6049 rajveer 9209 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 9210 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
9211 
    result.write(oprot)
9212 
    oprot.writeMessageEnd()
9213 
    oprot.trans.flush()
9214 
 
6269 rajveer 9215 
  def process_validateRecharge(self, seqid, iprot, oprot):
9216 
    args = validateRecharge_args()
9217 
    args.read(iprot)
9218 
    iprot.readMessageEnd()
9219 
    result = validateRecharge_result()
6591 anupam.sin 9220 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId, args.clientAddress)
6269 rajveer 9221 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
9222 
    result.write(oprot)
9223 
    oprot.writeMessageEnd()
9224 
    oprot.trans.flush()
9225 
 
6094 rajveer 9226 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
9227 
    args = getRechargeOrdersForDevice_args()
9228 
    args.read(iprot)
9229 
    iprot.readMessageEnd()
9230 
    result = getRechargeOrdersForDevice_result()
9231 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
9232 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
9233 
    result.write(oprot)
9234 
    oprot.writeMessageEnd()
9235 
    oprot.trans.flush()
6048 rajveer 9236 
 
6094 rajveer 9237 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
9238 
    args = addAmountToWallet_args()
9239 
    args.read(iprot)
9240 
    iprot.readMessageEnd()
9241 
    result = addAmountToWallet_result()
9242 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
9243 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
9244 
    result.write(oprot)
9245 
    oprot.writeMessageEnd()
9246 
    oprot.trans.flush()
9247 
 
6188 rajveer 9248 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
9249 
    args = getRechargeStatistics_args()
9250 
    args.read(iprot)
9251 
    iprot.readMessageEnd()
9252 
    result = getRechargeStatistics_result()
9253 
    result.success = self._handler.getRechargeStatistics()
9254 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
9255 
    result.write(oprot)
9256 
    oprot.writeMessageEnd()
9257 
    oprot.trans.flush()
9258 
 
6154 rajveer 9259 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
9260 
    args = getRechargeOrdersForStatus_args()
9261 
    args.read(iprot)
9262 
    iprot.readMessageEnd()
9263 
    result = getRechargeOrdersForStatus_result()
9264 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
9265 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
9266 
    result.write(oprot)
9267 
    oprot.writeMessageEnd()
9268 
    oprot.trans.flush()
6094 rajveer 9269 
 
6159 rajveer 9270 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
9271 
    args = getPlansForOperator_args()
9272 
    args.read(iprot)
9273 
    iprot.readMessageEnd()
9274 
    result = getPlansForOperator_result()
9275 
    result.success = self._handler.getPlansForOperator(args.operatorId)
9276 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
9277 
    result.write(oprot)
9278 
    oprot.writeMessageEnd()
9279 
    oprot.trans.flush()
6154 rajveer 9280 
 
6289 anupam.sin 9281 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
9282 
    args = getRechargeDenominations_args()
9283 
    args.read(iprot)
9284 
    iprot.readMessageEnd()
9285 
    result = getRechargeDenominations_result()
9286 
    try:
6307 anupam.sin 9287 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 9288 
    except TransactionServiceException, ex:
9289 
      result.ex = ex
9290 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
9291 
    result.write(oprot)
9292 
    oprot.writeMessageEnd()
9293 
    oprot.trans.flush()
6159 rajveer 9294 
 
6371 rajveer 9295 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
9296 
    args = updateAvailabilityStatus_args()
9297 
    args.read(iprot)
9298 
    iprot.readMessageEnd()
9299 
    result = updateAvailabilityStatus_result()
9300 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
9301 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
9302 
    result.write(oprot)
9303 
    oprot.writeMessageEnd()
9304 
    oprot.trans.flush()
6289 anupam.sin 9305 
 
6389 rajveer 9306 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
9307 
    args = getAvailableEmiSchemes_args()
9308 
    args.read(iprot)
9309 
    iprot.readMessageEnd()
9310 
    result = getAvailableEmiSchemes_result()
9311 
    result.success = self._handler.getAvailableEmiSchemes()
9312 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
9313 
    result.write(oprot)
9314 
    oprot.writeMessageEnd()
9315 
    oprot.trans.flush()
6371 rajveer 9316 
 
6389 rajveer 9317 
  def process_getMiscCharges(self, seqid, iprot, oprot):
9318 
    args = getMiscCharges_args()
9319 
    args.read(iprot)
9320 
    iprot.readMessageEnd()
9321 
    result = getMiscCharges_result()
9322 
    result.success = self._handler.getMiscCharges(args.transactionId)
9323 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
9324 
    result.write(oprot)
9325 
    oprot.writeMessageEnd()
9326 
    oprot.trans.flush()
9327 
 
6507 anupam.sin 9328 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
9329 
    args = refundRechargeOrder_args()
9330 
    args.read(iprot)
9331 
    iprot.readMessageEnd()
9332 
    result = refundRechargeOrder_result()
9333 
    try:
9334 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
9335 
    except TransactionServiceException, ex:
9336 
      result.ex = ex
9337 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
9338 
    result.write(oprot)
9339 
    oprot.writeMessageEnd()
9340 
    oprot.trans.flush()
6389 rajveer 9341 
 
6821 amar.kumar 9342 
  def process_getPhysicalOrders(self, seqid, iprot, oprot):
9343 
    args = getPhysicalOrders_args()
9344 
    args.read(iprot)
9345 
    iprot.readMessageEnd()
9346 
    result = getPhysicalOrders_result()
9347 
    result.success = self._handler.getPhysicalOrders(args.fromDate, args.toDate)
9348 
    oprot.writeMessageBegin("getPhysicalOrders", TMessageType.REPLY, seqid)
9349 
    result.write(oprot)
9350 
    oprot.writeMessageEnd()
9351 
    oprot.trans.flush()
6507 anupam.sin 9352 
 
6906 rajveer 9353 
  def process_getDocument(self, seqid, iprot, oprot):
9354 
    args = getDocument_args()
9355 
    args.read(iprot)
9356 
    iprot.readMessageEnd()
9357 
    result = getDocument_result()
9358 
    result.success = self._handler.getDocument(args.docType, args.docSource)
9359 
    oprot.writeMessageBegin("getDocument", TMessageType.REPLY, seqid)
9360 
    result.write(oprot)
9361 
    oprot.writeMessageEnd()
9362 
    oprot.trans.flush()
6821 amar.kumar 9363 
 
6985 anupam.sin 9364 
  def process_changeShippingAddress(self, seqid, iprot, oprot):
9365 
    args = changeShippingAddress_args()
9366 
    args.read(iprot)
9367 
    iprot.readMessageEnd()
9368 
    result = changeShippingAddress_result()
9369 
    result.success = self._handler.changeShippingAddress(args.orderId, args.line1, args.line2, args.city, args.state, args.pin)
9370 
    oprot.writeMessageBegin("changeShippingAddress", TMessageType.REPLY, seqid)
9371 
    result.write(oprot)
9372 
    oprot.writeMessageEnd()
9373 
    oprot.trans.flush()
6906 rajveer 9374 
 
6988 rajveer 9375 
  def process_retrieveInvoice(self, seqid, iprot, oprot):
9376 
    args = retrieveInvoice_args()
9377 
    args.read(iprot)
9378 
    iprot.readMessageEnd()
9379 
    result = retrieveInvoice_result()
7075 rajveer 9380 
    result.success = self._handler.retrieveInvoice(args.orderId, args.userId)
6988 rajveer 9381 
    oprot.writeMessageBegin("retrieveInvoice", TMessageType.REPLY, seqid)
9382 
    result.write(oprot)
9383 
    oprot.writeMessageEnd()
9384 
    oprot.trans.flush()
6985 anupam.sin 9385 
 
7026 rajveer 9386 
  def process_receiveUpdatesForRedExpress(self, seqid, iprot, oprot):
9387 
    args = receiveUpdatesForRedExpress_args()
9388 
    args.read(iprot)
9389 
    iprot.readMessageEnd()
9390 
    result = receiveUpdatesForRedExpress_result()
9391 
    result.success = self._handler.receiveUpdatesForRedExpress(args.awbNumber)
9392 
    oprot.writeMessageBegin("receiveUpdatesForRedExpress", TMessageType.REPLY, seqid)
9393 
    result.write(oprot)
9394 
    oprot.writeMessageEnd()
9395 
    oprot.trans.flush()
6988 rajveer 9396 
 
7073 anupam.sin 9397 
  def process_createRechargeTransaction(self, seqid, iprot, oprot):
9398 
    args = createRechargeTransaction_args()
9399 
    args.read(iprot)
9400 
    iprot.readMessageEnd()
9401 
    result = createRechargeTransaction_result()
9402 
    result.success = self._handler.createRechargeTransaction(args.thriftRechargeTransaction)
9403 
    oprot.writeMessageBegin("createRechargeTransaction", TMessageType.REPLY, seqid)
9404 
    result.write(oprot)
9405 
    oprot.writeMessageEnd()
9406 
    oprot.trans.flush()
7026 rajveer 9407 
 
7085 rajveer 9408 
  def process_getRechargeTransactions(self, seqid, iprot, oprot):
9409 
    args = getRechargeTransactions_args()
9410 
    args.read(iprot)
9411 
    iprot.readMessageEnd()
9412 
    result = getRechargeTransactions_result()
9413 
    result.success = self._handler.getRechargeTransactions(args.storeId)
9414 
    oprot.writeMessageBegin("getRechargeTransactions", TMessageType.REPLY, seqid)
9415 
    result.write(oprot)
9416 
    oprot.writeMessageEnd()
9417 
    oprot.trans.flush()
9418 
 
7151 amit.gupta 9419 
  def process_getRechargeTrans(self, seqid, iprot, oprot):
9420 
    args = getRechargeTrans_args()
9421 
    args.read(iprot)
9422 
    iprot.readMessageEnd()
9423 
    result = getRechargeTrans_result()
9424 
    result.success = self._handler.getRechargeTrans(args.storeId, args.startDate, args.endDate, args.status)
9425 
    oprot.writeMessageBegin("getRechargeTrans", TMessageType.REPLY, seqid)
9426 
    result.write(oprot)
9427 
    oprot.writeMessageEnd()
9428 
    oprot.trans.flush()
9429 
 
7080 anupam.sin 9430 
  def process_getRechargeTransaction(self, seqid, iprot, oprot):
9431 
    args = getRechargeTransaction_args()
9432 
    args.read(iprot)
9433 
    iprot.readMessageEnd()
9434 
    result = getRechargeTransaction_result()
9435 
    result.success = self._handler.getRechargeTransaction(args.rechargeId)
9436 
    oprot.writeMessageBegin("getRechargeTransaction", TMessageType.REPLY, seqid)
9437 
    result.write(oprot)
9438 
    oprot.writeMessageEnd()
9439 
    oprot.trans.flush()
7073 anupam.sin 9440 
 
7080 anupam.sin 9441 
  def process_getFRCs(self, seqid, iprot, oprot):
9442 
    args = getFRCs_args()
9443 
    args.read(iprot)
9444 
    iprot.readMessageEnd()
9445 
    result = getFRCs_result()
9446 
    result.success = self._handler.getFRCs(args.circleId, args.operatorId)
9447 
    oprot.writeMessageBegin("getFRCs", TMessageType.REPLY, seqid)
9448 
    result.write(oprot)
9449 
    oprot.writeMessageEnd()
9450 
    oprot.trans.flush()
9451 
 
7096 anupam.sin 9452 
  def process_getHotspotStore(self, seqid, iprot, oprot):
9453 
    args = getHotspotStore_args()
9454 
    args.read(iprot)
9455 
    iprot.readMessageEnd()
9456 
    result = getHotspotStore_result()
9457 
    result.success = self._handler.getHotspotStore(args.id, args.hotspotid)
9458 
    oprot.writeMessageBegin("getHotspotStore", TMessageType.REPLY, seqid)
9459 
    result.write(oprot)
9460 
    oprot.writeMessageEnd()
9461 
    oprot.trans.flush()
7080 anupam.sin 9462 
 
7096 anupam.sin 9463 
  def process_getTelecomCircle(self, seqid, iprot, oprot):
9464 
    args = getTelecomCircle_args()
9465 
    args.read(iprot)
9466 
    iprot.readMessageEnd()
9467 
    result = getTelecomCircle_result()
9468 
    result.success = self._handler.getTelecomCircle(args.id, args.code)
9469 
    oprot.writeMessageBegin("getTelecomCircle", TMessageType.REPLY, seqid)
9470 
    result.write(oprot)
9471 
    oprot.writeMessageEnd()
9472 
    oprot.trans.flush()
9473 
 
7109 anupam.sin 9474 
  def process_retrieveHotspotRechargeInvoice(self, seqid, iprot, oprot):
9475 
    args = retrieveHotspotRechargeInvoice_args()
9476 
    args.read(iprot)
9477 
    iprot.readMessageEnd()
9478 
    result = retrieveHotspotRechargeInvoice_result()
9479 
    result.success = self._handler.retrieveHotspotRechargeInvoice(args.rechargeId)
9480 
    oprot.writeMessageBegin("retrieveHotspotRechargeInvoice", TMessageType.REPLY, seqid)
9481 
    result.write(oprot)
9482 
    oprot.writeMessageEnd()
9483 
    oprot.trans.flush()
7096 anupam.sin 9484 
 
7190 amar.kumar 9485 
  def process_splitFreebieOrder(self, seqid, iprot, oprot):
9486 
    args = splitFreebieOrder_args()
9487 
    args.read(iprot)
9488 
    iprot.readMessageEnd()
9489 
    result = splitFreebieOrder_result()
9490 
    result.success = self._handler.splitFreebieOrder(args.orderId, args.splitReason, args.shippingDate)
9491 
    oprot.writeMessageBegin("splitFreebieOrder", TMessageType.REPLY, seqid)
9492 
    result.write(oprot)
9493 
    oprot.writeMessageEnd()
9494 
    oprot.trans.flush()
9495 
 
7169 anupam.sin 9496 
  def process_getRechargeTransactionsByNumber(self, seqid, iprot, oprot):
9497 
    args = getRechargeTransactionsByNumber_args()
9498 
    args.read(iprot)
9499 
    iprot.readMessageEnd()
9500 
    result = getRechargeTransactionsByNumber_result()
7172 anupam.sin 9501 
    result.success = self._handler.getRechargeTransactionsByNumber(args.number, args.storeId)
7169 anupam.sin 9502 
    oprot.writeMessageBegin("getRechargeTransactionsByNumber", TMessageType.REPLY, seqid)
9503 
    result.write(oprot)
9504 
    oprot.writeMessageEnd()
9505 
    oprot.trans.flush()
7109 anupam.sin 9506 
 
7169 anupam.sin 9507 
  def process_updateHotspotStorePassword(self, seqid, iprot, oprot):
9508 
    args = updateHotspotStorePassword_args()
9509 
    args.read(iprot)
9510 
    iprot.readMessageEnd()
9511 
    result = updateHotspotStorePassword_result()
9512 
    result.success = self._handler.updateHotspotStorePassword(args.storeId, args.password)
9513 
    oprot.writeMessageBegin("updateHotspotStorePassword", TMessageType.REPLY, seqid)
9514 
    result.write(oprot)
9515 
    oprot.writeMessageEnd()
9516 
    oprot.trans.flush()
9517 
 
7263 anupam.sin 9518 
  def process_getSourceDetail(self, seqid, iprot, oprot):
9519 
    args = getSourceDetail_args()
9520 
    args.read(iprot)
9521 
    iprot.readMessageEnd()
9522 
    result = getSourceDetail_result()
9523 
    result.success = self._handler.getSourceDetail(args.source)
9524 
    oprot.writeMessageBegin("getSourceDetail", TMessageType.REPLY, seqid)
9525 
    result.write(oprot)
9526 
    oprot.writeMessageEnd()
9527 
    oprot.trans.flush()
7169 anupam.sin 9528 
 
7263 anupam.sin 9529 
 
94 ashish 9530 
# HELPER FUNCTIONS AND STRUCTURES
9531 
 
9532 
class createTransaction_args:
9533 
  """
9534 
  Attributes:
9535 
   - transaction
9536 
  """
9537 
 
9538 
  thrift_spec = (
9539 
    None, # 0
9540 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
9541 
  )
9542 
 
9543 
  def __init__(self, transaction=None,):
9544 
    self.transaction = transaction
9545 
 
9546 
  def read(self, iprot):
9547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9549 
      return
9550 
    iprot.readStructBegin()
9551 
    while True:
9552 
      (fname, ftype, fid) = iprot.readFieldBegin()
9553 
      if ftype == TType.STOP:
9554 
        break
9555 
      if fid == 1:
9556 
        if ftype == TType.STRUCT:
9557 
          self.transaction = Transaction()
9558 
          self.transaction.read(iprot)
9559 
        else:
9560 
          iprot.skip(ftype)
9561 
      else:
9562 
        iprot.skip(ftype)
9563 
      iprot.readFieldEnd()
9564 
    iprot.readStructEnd()
9565 
 
9566 
  def write(self, oprot):
9567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9569 
      return
9570 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 9571 
    if self.transaction is not None:
94 ashish 9572 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
9573 
      self.transaction.write(oprot)
9574 
      oprot.writeFieldEnd()
9575 
    oprot.writeFieldStop()
9576 
    oprot.writeStructEnd()
9577 
 
3431 rajveer 9578 
  def validate(self):
9579 
    return
9580 
 
9581 
 
94 ashish 9582 
  def __repr__(self):
9583 
    L = ['%s=%r' % (key, value)
9584 
      for key, value in self.__dict__.iteritems()]
9585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9586 
 
9587 
  def __eq__(self, other):
9588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9589 
 
9590 
  def __ne__(self, other):
9591 
    return not (self == other)
9592 
 
9593 
class createTransaction_result:
9594 
  """
9595 
  Attributes:
132 ashish 9596 
   - success
94 ashish 9597 
   - ex
9598 
  """
9599 
 
9600 
  thrift_spec = (
132 ashish 9601 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 9602 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9603 
  )
9604 
 
132 ashish 9605 
  def __init__(self, success=None, ex=None,):
9606 
    self.success = success
94 ashish 9607 
    self.ex = ex
9608 
 
9609 
  def read(self, iprot):
9610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9612 
      return
9613 
    iprot.readStructBegin()
9614 
    while True:
9615 
      (fname, ftype, fid) = iprot.readFieldBegin()
9616 
      if ftype == TType.STOP:
9617 
        break
132 ashish 9618 
      if fid == 0:
9619 
        if ftype == TType.I64:
9620 
          self.success = iprot.readI64();
9621 
        else:
9622 
          iprot.skip(ftype)
9623 
      elif fid == 1:
94 ashish 9624 
        if ftype == TType.STRUCT:
9625 
          self.ex = TransactionServiceException()
9626 
          self.ex.read(iprot)
9627 
        else:
9628 
          iprot.skip(ftype)
9629 
      else:
9630 
        iprot.skip(ftype)
9631 
      iprot.readFieldEnd()
9632 
    iprot.readStructEnd()
9633 
 
9634 
  def write(self, oprot):
9635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9637 
      return
9638 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 9639 
    if self.success is not None:
132 ashish 9640 
      oprot.writeFieldBegin('success', TType.I64, 0)
9641 
      oprot.writeI64(self.success)
9642 
      oprot.writeFieldEnd()
3431 rajveer 9643 
    if self.ex is not None:
94 ashish 9644 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9645 
      self.ex.write(oprot)
9646 
      oprot.writeFieldEnd()
9647 
    oprot.writeFieldStop()
9648 
    oprot.writeStructEnd()
9649 
 
3431 rajveer 9650 
  def validate(self):
9651 
    return
9652 
 
9653 
 
94 ashish 9654 
  def __repr__(self):
9655 
    L = ['%s=%r' % (key, value)
9656 
      for key, value in self.__dict__.iteritems()]
9657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9658 
 
9659 
  def __eq__(self, other):
9660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9661 
 
9662 
  def __ne__(self, other):
9663 
    return not (self == other)
9664 
 
9665 
class getTransaction_args:
9666 
  """
9667 
  Attributes:
9668 
   - id
9669 
  """
9670 
 
9671 
  thrift_spec = (
9672 
    None, # 0
9673 
    (1, TType.I64, 'id', None, None, ), # 1
9674 
  )
9675 
 
9676 
  def __init__(self, id=None,):
9677 
    self.id = id
9678 
 
9679 
  def read(self, iprot):
9680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9682 
      return
9683 
    iprot.readStructBegin()
9684 
    while True:
9685 
      (fname, ftype, fid) = iprot.readFieldBegin()
9686 
      if ftype == TType.STOP:
9687 
        break
9688 
      if fid == 1:
9689 
        if ftype == TType.I64:
9690 
          self.id = iprot.readI64();
9691 
        else:
9692 
          iprot.skip(ftype)
9693 
      else:
9694 
        iprot.skip(ftype)
9695 
      iprot.readFieldEnd()
9696 
    iprot.readStructEnd()
9697 
 
9698 
  def write(self, oprot):
9699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9701 
      return
9702 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 9703 
    if self.id is not None:
94 ashish 9704 
      oprot.writeFieldBegin('id', TType.I64, 1)
9705 
      oprot.writeI64(self.id)
9706 
      oprot.writeFieldEnd()
9707 
    oprot.writeFieldStop()
9708 
    oprot.writeStructEnd()
9709 
 
3431 rajveer 9710 
  def validate(self):
9711 
    return
9712 
 
9713 
 
94 ashish 9714 
  def __repr__(self):
9715 
    L = ['%s=%r' % (key, value)
9716 
      for key, value in self.__dict__.iteritems()]
9717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9718 
 
9719 
  def __eq__(self, other):
9720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9721 
 
9722 
  def __ne__(self, other):
9723 
    return not (self == other)
9724 
 
9725 
class getTransaction_result:
9726 
  """
9727 
  Attributes:
9728 
   - success
9729 
   - ex
9730 
  """
9731 
 
9732 
  thrift_spec = (
9733 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
9734 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9735 
  )
9736 
 
9737 
  def __init__(self, success=None, ex=None,):
9738 
    self.success = success
9739 
    self.ex = ex
9740 
 
9741 
  def read(self, iprot):
9742 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9743 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9744 
      return
9745 
    iprot.readStructBegin()
9746 
    while True:
9747 
      (fname, ftype, fid) = iprot.readFieldBegin()
9748 
      if ftype == TType.STOP:
9749 
        break
9750 
      if fid == 0:
9751 
        if ftype == TType.STRUCT:
9752 
          self.success = Transaction()
9753 
          self.success.read(iprot)
9754 
        else:
9755 
          iprot.skip(ftype)
9756 
      elif fid == 1:
9757 
        if ftype == TType.STRUCT:
9758 
          self.ex = TransactionServiceException()
9759 
          self.ex.read(iprot)
9760 
        else:
9761 
          iprot.skip(ftype)
9762 
      else:
9763 
        iprot.skip(ftype)
9764 
      iprot.readFieldEnd()
9765 
    iprot.readStructEnd()
9766 
 
9767 
  def write(self, oprot):
9768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9770 
      return
9771 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 9772 
    if self.success is not None:
94 ashish 9773 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9774 
      self.success.write(oprot)
9775 
      oprot.writeFieldEnd()
3431 rajveer 9776 
    if self.ex is not None:
94 ashish 9777 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9778 
      self.ex.write(oprot)
9779 
      oprot.writeFieldEnd()
9780 
    oprot.writeFieldStop()
9781 
    oprot.writeStructEnd()
9782 
 
3431 rajveer 9783 
  def validate(self):
9784 
    return
9785 
 
9786 
 
94 ashish 9787 
  def __repr__(self):
9788 
    L = ['%s=%r' % (key, value)
9789 
      for key, value in self.__dict__.iteritems()]
9790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9791 
 
9792 
  def __eq__(self, other):
9793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9794 
 
9795 
  def __ne__(self, other):
9796 
    return not (self == other)
9797 
 
9798 
class getTransactionsForCustomer_args:
9799 
  """
9800 
  Attributes:
9801 
   - customerId
9802 
   - from_date
9803 
   - to_date
9804 
   - status
9805 
  """
9806 
 
9807 
  thrift_spec = (
9808 
    None, # 0
9809 
    (1, TType.I64, 'customerId', None, None, ), # 1
9810 
    (2, TType.I64, 'from_date', None, None, ), # 2
9811 
    (3, TType.I64, 'to_date', None, None, ), # 3
9812 
    (4, TType.I32, 'status', None, None, ), # 4
9813 
  )
9814 
 
9815 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
9816 
    self.customerId = customerId
9817 
    self.from_date = from_date
9818 
    self.to_date = to_date
9819 
    self.status = status
9820 
 
9821 
  def read(self, iprot):
9822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9824 
      return
9825 
    iprot.readStructBegin()
9826 
    while True:
9827 
      (fname, ftype, fid) = iprot.readFieldBegin()
9828 
      if ftype == TType.STOP:
9829 
        break
9830 
      if fid == 1:
9831 
        if ftype == TType.I64:
9832 
          self.customerId = iprot.readI64();
9833 
        else:
9834 
          iprot.skip(ftype)
9835 
      elif fid == 2:
9836 
        if ftype == TType.I64:
9837 
          self.from_date = iprot.readI64();
9838 
        else:
9839 
          iprot.skip(ftype)
9840 
      elif fid == 3:
9841 
        if ftype == TType.I64:
9842 
          self.to_date = iprot.readI64();
9843 
        else:
9844 
          iprot.skip(ftype)
9845 
      elif fid == 4:
9846 
        if ftype == TType.I32:
9847 
          self.status = iprot.readI32();
9848 
        else:
9849 
          iprot.skip(ftype)
9850 
      else:
9851 
        iprot.skip(ftype)
9852 
      iprot.readFieldEnd()
9853 
    iprot.readStructEnd()
9854 
 
9855 
  def write(self, oprot):
9856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9858 
      return
9859 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 9860 
    if self.customerId is not None:
94 ashish 9861 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9862 
      oprot.writeI64(self.customerId)
9863 
      oprot.writeFieldEnd()
3431 rajveer 9864 
    if self.from_date is not None:
94 ashish 9865 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9866 
      oprot.writeI64(self.from_date)
9867 
      oprot.writeFieldEnd()
3431 rajveer 9868 
    if self.to_date is not None:
94 ashish 9869 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9870 
      oprot.writeI64(self.to_date)
9871 
      oprot.writeFieldEnd()
3431 rajveer 9872 
    if self.status is not None:
94 ashish 9873 
      oprot.writeFieldBegin('status', TType.I32, 4)
9874 
      oprot.writeI32(self.status)
9875 
      oprot.writeFieldEnd()
9876 
    oprot.writeFieldStop()
9877 
    oprot.writeStructEnd()
9878 
 
3431 rajveer 9879 
  def validate(self):
9880 
    return
9881 
 
9882 
 
94 ashish 9883 
  def __repr__(self):
9884 
    L = ['%s=%r' % (key, value)
9885 
      for key, value in self.__dict__.iteritems()]
9886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9887 
 
9888 
  def __eq__(self, other):
9889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9890 
 
9891 
  def __ne__(self, other):
9892 
    return not (self == other)
9893 
 
9894 
class getTransactionsForCustomer_result:
9895 
  """
9896 
  Attributes:
9897 
   - success
9898 
   - ex
9899 
  """
9900 
 
9901 
  thrift_spec = (
9902 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9903 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9904 
  )
9905 
 
9906 
  def __init__(self, success=None, ex=None,):
9907 
    self.success = success
9908 
    self.ex = ex
9909 
 
9910 
  def read(self, iprot):
9911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9913 
      return
9914 
    iprot.readStructBegin()
9915 
    while True:
9916 
      (fname, ftype, fid) = iprot.readFieldBegin()
9917 
      if ftype == TType.STOP:
9918 
        break
9919 
      if fid == 0:
9920 
        if ftype == TType.LIST:
9921 
          self.success = []
6188 rajveer 9922 
          (_etype109, _size106) = iprot.readListBegin()
9923 
          for _i110 in xrange(_size106):
9924 
            _elem111 = Transaction()
9925 
            _elem111.read(iprot)
9926 
            self.success.append(_elem111)
94 ashish 9927 
          iprot.readListEnd()
9928 
        else:
9929 
          iprot.skip(ftype)
9930 
      elif fid == 1:
9931 
        if ftype == TType.STRUCT:
9932 
          self.ex = TransactionServiceException()
9933 
          self.ex.read(iprot)
9934 
        else:
9935 
          iprot.skip(ftype)
9936 
      else:
9937 
        iprot.skip(ftype)
9938 
      iprot.readFieldEnd()
9939 
    iprot.readStructEnd()
9940 
 
9941 
  def write(self, oprot):
9942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9944 
      return
9945 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 9946 
    if self.success is not None:
94 ashish 9947 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9948 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9949 
      for iter112 in self.success:
9950 
        iter112.write(oprot)
94 ashish 9951 
      oprot.writeListEnd()
9952 
      oprot.writeFieldEnd()
3431 rajveer 9953 
    if self.ex is not None:
94 ashish 9954 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9955 
      self.ex.write(oprot)
9956 
      oprot.writeFieldEnd()
9957 
    oprot.writeFieldStop()
9958 
    oprot.writeStructEnd()
9959 
 
3431 rajveer 9960 
  def validate(self):
9961 
    return
9962 
 
9963 
 
94 ashish 9964 
  def __repr__(self):
9965 
    L = ['%s=%r' % (key, value)
9966 
      for key, value in self.__dict__.iteritems()]
9967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9968 
 
9969 
  def __eq__(self, other):
9970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9971 
 
9972 
  def __ne__(self, other):
9973 
    return not (self == other)
9974 
 
132 ashish 9975 
class getTransactionsForShoppingCartId_args:
9976 
  """
9977 
  Attributes:
9978 
   - shoppingCartId
9979 
  """
9980 
 
9981 
  thrift_spec = (
9982 
    None, # 0
9983 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
9984 
  )
9985 
 
9986 
  def __init__(self, shoppingCartId=None,):
9987 
    self.shoppingCartId = shoppingCartId
9988 
 
9989 
  def read(self, iprot):
9990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9992 
      return
9993 
    iprot.readStructBegin()
9994 
    while True:
9995 
      (fname, ftype, fid) = iprot.readFieldBegin()
9996 
      if ftype == TType.STOP:
9997 
        break
9998 
      if fid == 1:
9999 
        if ftype == TType.I64:
10000 
          self.shoppingCartId = iprot.readI64();
10001 
        else:
10002 
          iprot.skip(ftype)
10003 
      else:
10004 
        iprot.skip(ftype)
10005 
      iprot.readFieldEnd()
10006 
    iprot.readStructEnd()
10007 
 
10008 
  def write(self, oprot):
10009 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10010 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10011 
      return
10012 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 10013 
    if self.shoppingCartId is not None:
132 ashish 10014 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
10015 
      oprot.writeI64(self.shoppingCartId)
10016 
      oprot.writeFieldEnd()
10017 
    oprot.writeFieldStop()
10018 
    oprot.writeStructEnd()
10019 
 
3431 rajveer 10020 
  def validate(self):
10021 
    return
10022 
 
10023 
 
132 ashish 10024 
  def __repr__(self):
10025 
    L = ['%s=%r' % (key, value)
10026 
      for key, value in self.__dict__.iteritems()]
10027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10028 
 
10029 
  def __eq__(self, other):
10030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10031 
 
10032 
  def __ne__(self, other):
10033 
    return not (self == other)
10034 
 
10035 
class getTransactionsForShoppingCartId_result:
10036 
  """
10037 
  Attributes:
10038 
   - success
10039 
   - ex
10040 
  """
10041 
 
10042 
  thrift_spec = (
10043 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
10044 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10045 
  )
10046 
 
10047 
  def __init__(self, success=None, ex=None,):
10048 
    self.success = success
10049 
    self.ex = ex
10050 
 
10051 
  def read(self, iprot):
10052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10054 
      return
10055 
    iprot.readStructBegin()
10056 
    while True:
10057 
      (fname, ftype, fid) = iprot.readFieldBegin()
10058 
      if ftype == TType.STOP:
10059 
        break
10060 
      if fid == 0:
10061 
        if ftype == TType.LIST:
10062 
          self.success = []
6188 rajveer 10063 
          (_etype116, _size113) = iprot.readListBegin()
10064 
          for _i117 in xrange(_size113):
10065 
            _elem118 = Transaction()
10066 
            _elem118.read(iprot)
10067 
            self.success.append(_elem118)
132 ashish 10068 
          iprot.readListEnd()
10069 
        else:
10070 
          iprot.skip(ftype)
10071 
      elif fid == 1:
10072 
        if ftype == TType.STRUCT:
10073 
          self.ex = TransactionServiceException()
10074 
          self.ex.read(iprot)
10075 
        else:
10076 
          iprot.skip(ftype)
10077 
      else:
10078 
        iprot.skip(ftype)
10079 
      iprot.readFieldEnd()
10080 
    iprot.readStructEnd()
10081 
 
10082 
  def write(self, oprot):
10083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10085 
      return
10086 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 10087 
    if self.success is not None:
132 ashish 10088 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10089 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10090 
      for iter119 in self.success:
10091 
        iter119.write(oprot)
132 ashish 10092 
      oprot.writeListEnd()
10093 
      oprot.writeFieldEnd()
3431 rajveer 10094 
    if self.ex is not None:
132 ashish 10095 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10096 
      self.ex.write(oprot)
10097 
      oprot.writeFieldEnd()
10098 
    oprot.writeFieldStop()
10099 
    oprot.writeStructEnd()
10100 
 
3431 rajveer 10101 
  def validate(self):
10102 
    return
10103 
 
10104 
 
132 ashish 10105 
  def __repr__(self):
10106 
    L = ['%s=%r' % (key, value)
10107 
      for key, value in self.__dict__.iteritems()]
10108 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10109 
 
10110 
  def __eq__(self, other):
10111 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10112 
 
10113 
  def __ne__(self, other):
10114 
    return not (self == other)
10115 
 
94 ashish 10116 
class getTransactionStatus_args:
10117 
  """
10118 
  Attributes:
10119 
   - transactionId
10120 
  """
10121 
 
10122 
  thrift_spec = (
10123 
    None, # 0
10124 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10125 
  )
10126 
 
10127 
  def __init__(self, transactionId=None,):
10128 
    self.transactionId = transactionId
10129 
 
10130 
  def read(self, iprot):
10131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10133 
      return
10134 
    iprot.readStructBegin()
10135 
    while True:
10136 
      (fname, ftype, fid) = iprot.readFieldBegin()
10137 
      if ftype == TType.STOP:
10138 
        break
10139 
      if fid == 1:
10140 
        if ftype == TType.I64:
10141 
          self.transactionId = iprot.readI64();
10142 
        else:
10143 
          iprot.skip(ftype)
10144 
      else:
10145 
        iprot.skip(ftype)
10146 
      iprot.readFieldEnd()
10147 
    iprot.readStructEnd()
10148 
 
10149 
  def write(self, oprot):
10150 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10151 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10152 
      return
10153 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 10154 
    if self.transactionId is not None:
94 ashish 10155 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10156 
      oprot.writeI64(self.transactionId)
10157 
      oprot.writeFieldEnd()
10158 
    oprot.writeFieldStop()
10159 
    oprot.writeStructEnd()
10160 
 
3431 rajveer 10161 
  def validate(self):
10162 
    return
10163 
 
10164 
 
94 ashish 10165 
  def __repr__(self):
10166 
    L = ['%s=%r' % (key, value)
10167 
      for key, value in self.__dict__.iteritems()]
10168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10169 
 
10170 
  def __eq__(self, other):
10171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10172 
 
10173 
  def __ne__(self, other):
10174 
    return not (self == other)
10175 
 
10176 
class getTransactionStatus_result:
10177 
  """
10178 
  Attributes:
10179 
   - success
10180 
   - ex
10181 
  """
10182 
 
10183 
  thrift_spec = (
10184 
    (0, TType.I32, 'success', None, None, ), # 0
10185 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10186 
  )
10187 
 
10188 
  def __init__(self, success=None, ex=None,):
10189 
    self.success = success
10190 
    self.ex = ex
10191 
 
10192 
  def read(self, iprot):
10193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10195 
      return
10196 
    iprot.readStructBegin()
10197 
    while True:
10198 
      (fname, ftype, fid) = iprot.readFieldBegin()
10199 
      if ftype == TType.STOP:
10200 
        break
10201 
      if fid == 0:
10202 
        if ftype == TType.I32:
10203 
          self.success = iprot.readI32();
10204 
        else:
10205 
          iprot.skip(ftype)
10206 
      elif fid == 1:
10207 
        if ftype == TType.STRUCT:
10208 
          self.ex = TransactionServiceException()
10209 
          self.ex.read(iprot)
10210 
        else:
10211 
          iprot.skip(ftype)
10212 
      else:
10213 
        iprot.skip(ftype)
10214 
      iprot.readFieldEnd()
10215 
    iprot.readStructEnd()
10216 
 
10217 
  def write(self, oprot):
10218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10220 
      return
10221 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 10222 
    if self.success is not None:
94 ashish 10223 
      oprot.writeFieldBegin('success', TType.I32, 0)
10224 
      oprot.writeI32(self.success)
10225 
      oprot.writeFieldEnd()
3431 rajveer 10226 
    if self.ex is not None:
94 ashish 10227 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10228 
      self.ex.write(oprot)
10229 
      oprot.writeFieldEnd()
10230 
    oprot.writeFieldStop()
10231 
    oprot.writeStructEnd()
10232 
 
3431 rajveer 10233 
  def validate(self):
10234 
    return
10235 
 
10236 
 
94 ashish 10237 
  def __repr__(self):
10238 
    L = ['%s=%r' % (key, value)
10239 
      for key, value in self.__dict__.iteritems()]
10240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10241 
 
10242 
  def __eq__(self, other):
10243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10244 
 
10245 
  def __ne__(self, other):
10246 
    return not (self == other)
10247 
 
10248 
class changeTransactionStatus_args:
10249 
  """
10250 
  Attributes:
10251 
   - transactionId
10252 
   - status
10253 
   - description
5527 anupam.sin 10254 
   - pickUp
10255 
   - orderType
94 ashish 10256 
  """
10257 
 
10258 
  thrift_spec = (
10259 
    None, # 0
10260 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10261 
    (2, TType.I32, 'status', None, None, ), # 2
10262 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 10263 
    (4, TType.I64, 'pickUp', None, None, ), # 4
10264 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 10265 
  )
10266 
 
5527 anupam.sin 10267 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 10268 
    self.transactionId = transactionId
10269 
    self.status = status
10270 
    self.description = description
5527 anupam.sin 10271 
    self.pickUp = pickUp
10272 
    self.orderType = orderType
94 ashish 10273 
 
10274 
  def read(self, iprot):
10275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10277 
      return
10278 
    iprot.readStructBegin()
10279 
    while True:
10280 
      (fname, ftype, fid) = iprot.readFieldBegin()
10281 
      if ftype == TType.STOP:
10282 
        break
10283 
      if fid == 1:
10284 
        if ftype == TType.I64:
10285 
          self.transactionId = iprot.readI64();
10286 
        else:
10287 
          iprot.skip(ftype)
10288 
      elif fid == 2:
10289 
        if ftype == TType.I32:
10290 
          self.status = iprot.readI32();
10291 
        else:
10292 
          iprot.skip(ftype)
10293 
      elif fid == 3:
10294 
        if ftype == TType.STRING:
10295 
          self.description = iprot.readString();
10296 
        else:
10297 
          iprot.skip(ftype)
5387 rajveer 10298 
      elif fid == 4:
5527 anupam.sin 10299 
        if ftype == TType.I64:
10300 
          self.pickUp = iprot.readI64();
5387 rajveer 10301 
        else:
10302 
          iprot.skip(ftype)
5527 anupam.sin 10303 
      elif fid == 5:
10304 
        if ftype == TType.I32:
10305 
          self.orderType = iprot.readI32();
10306 
        else:
10307 
          iprot.skip(ftype)
94 ashish 10308 
      else:
10309 
        iprot.skip(ftype)
10310 
      iprot.readFieldEnd()
10311 
    iprot.readStructEnd()
10312 
 
10313 
  def write(self, oprot):
10314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10316 
      return
10317 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 10318 
    if self.transactionId is not None:
94 ashish 10319 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10320 
      oprot.writeI64(self.transactionId)
10321 
      oprot.writeFieldEnd()
3431 rajveer 10322 
    if self.status is not None:
94 ashish 10323 
      oprot.writeFieldBegin('status', TType.I32, 2)
10324 
      oprot.writeI32(self.status)
10325 
      oprot.writeFieldEnd()
3431 rajveer 10326 
    if self.description is not None:
94 ashish 10327 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10328 
      oprot.writeString(self.description)
10329 
      oprot.writeFieldEnd()
5527 anupam.sin 10330 
    if self.pickUp is not None:
10331 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
10332 
      oprot.writeI64(self.pickUp)
5387 rajveer 10333 
      oprot.writeFieldEnd()
5527 anupam.sin 10334 
    if self.orderType is not None:
10335 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
10336 
      oprot.writeI32(self.orderType)
10337 
      oprot.writeFieldEnd()
94 ashish 10338 
    oprot.writeFieldStop()
10339 
    oprot.writeStructEnd()
10340 
 
3431 rajveer 10341 
  def validate(self):
10342 
    return
10343 
 
10344 
 
94 ashish 10345 
  def __repr__(self):
10346 
    L = ['%s=%r' % (key, value)
10347 
      for key, value in self.__dict__.iteritems()]
10348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10349 
 
10350 
  def __eq__(self, other):
10351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10352 
 
10353 
  def __ne__(self, other):
10354 
    return not (self == other)
10355 
 
10356 
class changeTransactionStatus_result:
10357 
  """
10358 
  Attributes:
10359 
   - success
10360 
   - ex
10361 
  """
10362 
 
10363 
  thrift_spec = (
10364 
    (0, TType.BOOL, 'success', None, None, ), # 0
10365 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10366 
  )
10367 
 
10368 
  def __init__(self, success=None, ex=None,):
10369 
    self.success = success
10370 
    self.ex = ex
10371 
 
10372 
  def read(self, iprot):
10373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10375 
      return
10376 
    iprot.readStructBegin()
10377 
    while True:
10378 
      (fname, ftype, fid) = iprot.readFieldBegin()
10379 
      if ftype == TType.STOP:
10380 
        break
10381 
      if fid == 0:
10382 
        if ftype == TType.BOOL:
10383 
          self.success = iprot.readBool();
10384 
        else:
10385 
          iprot.skip(ftype)
10386 
      elif fid == 1:
10387 
        if ftype == TType.STRUCT:
10388 
          self.ex = TransactionServiceException()
10389 
          self.ex.read(iprot)
10390 
        else:
10391 
          iprot.skip(ftype)
10392 
      else:
10393 
        iprot.skip(ftype)
10394 
      iprot.readFieldEnd()
10395 
    iprot.readStructEnd()
10396 
 
10397 
  def write(self, oprot):
10398 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10399 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10400 
      return
10401 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 10402 
    if self.success is not None:
94 ashish 10403 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10404 
      oprot.writeBool(self.success)
10405 
      oprot.writeFieldEnd()
3431 rajveer 10406 
    if self.ex is not None:
94 ashish 10407 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10408 
      self.ex.write(oprot)
10409 
      oprot.writeFieldEnd()
10410 
    oprot.writeFieldStop()
10411 
    oprot.writeStructEnd()
10412 
 
3431 rajveer 10413 
  def validate(self):
10414 
    return
10415 
 
10416 
 
94 ashish 10417 
  def __repr__(self):
10418 
    L = ['%s=%r' % (key, value)
10419 
      for key, value in self.__dict__.iteritems()]
10420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10421 
 
10422 
  def __eq__(self, other):
10423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10424 
 
10425 
  def __ne__(self, other):
10426 
    return not (self == other)
10427 
 
1398 varun.gupt 10428 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 10429 
  """
10430 
  Attributes:
10431 
   - transactionId
10432 
  """
10433 
 
10434 
  thrift_spec = (
10435 
    None, # 0
10436 
    (1, TType.I64, 'transactionId', None, None, ), # 1
10437 
  )
10438 
 
10439 
  def __init__(self, transactionId=None,):
10440 
    self.transactionId = transactionId
10441 
 
10442 
  def read(self, iprot):
10443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10445 
      return
10446 
    iprot.readStructBegin()
10447 
    while True:
10448 
      (fname, ftype, fid) = iprot.readFieldBegin()
10449 
      if ftype == TType.STOP:
10450 
        break
10451 
      if fid == 1:
10452 
        if ftype == TType.I64:
10453 
          self.transactionId = iprot.readI64();
10454 
        else:
10455 
          iprot.skip(ftype)
10456 
      else:
10457 
        iprot.skip(ftype)
10458 
      iprot.readFieldEnd()
10459 
    iprot.readStructEnd()
10460 
 
10461 
  def write(self, oprot):
10462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10464 
      return
1398 varun.gupt 10465 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 10466 
    if self.transactionId is not None:
1382 varun.gupt 10467 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
10468 
      oprot.writeI64(self.transactionId)
10469 
      oprot.writeFieldEnd()
10470 
    oprot.writeFieldStop()
10471 
    oprot.writeStructEnd()
10472 
 
3431 rajveer 10473 
  def validate(self):
10474 
    return
10475 
 
10476 
 
1382 varun.gupt 10477 
  def __repr__(self):
10478 
    L = ['%s=%r' % (key, value)
10479 
      for key, value in self.__dict__.iteritems()]
10480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10481 
 
10482 
  def __eq__(self, other):
10483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10484 
 
10485 
  def __ne__(self, other):
10486 
    return not (self == other)
10487 
 
1398 varun.gupt 10488 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 10489 
  """
10490 
  Attributes:
10491 
   - success
10492 
   - ex
10493 
  """
10494 
 
10495 
  thrift_spec = (
10496 
    (0, TType.BOOL, 'success', None, None, ), # 0
10497 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10498 
  )
10499 
 
10500 
  def __init__(self, success=None, ex=None,):
10501 
    self.success = success
10502 
    self.ex = ex
10503 
 
10504 
  def read(self, iprot):
10505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10507 
      return
10508 
    iprot.readStructBegin()
10509 
    while True:
10510 
      (fname, ftype, fid) = iprot.readFieldBegin()
10511 
      if ftype == TType.STOP:
10512 
        break
10513 
      if fid == 0:
10514 
        if ftype == TType.BOOL:
10515 
          self.success = iprot.readBool();
10516 
        else:
10517 
          iprot.skip(ftype)
10518 
      elif fid == 1:
10519 
        if ftype == TType.STRUCT:
10520 
          self.ex = TransactionServiceException()
10521 
          self.ex.read(iprot)
10522 
        else:
10523 
          iprot.skip(ftype)
10524 
      else:
10525 
        iprot.skip(ftype)
10526 
      iprot.readFieldEnd()
10527 
    iprot.readStructEnd()
10528 
 
10529 
  def write(self, oprot):
10530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10532 
      return
1398 varun.gupt 10533 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 10534 
    if self.success is not None:
1382 varun.gupt 10535 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10536 
      oprot.writeBool(self.success)
10537 
      oprot.writeFieldEnd()
3431 rajveer 10538 
    if self.ex is not None:
1382 varun.gupt 10539 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10540 
      self.ex.write(oprot)
10541 
      oprot.writeFieldEnd()
10542 
    oprot.writeFieldStop()
10543 
    oprot.writeStructEnd()
10544 
 
3431 rajveer 10545 
  def validate(self):
10546 
    return
10547 
 
10548 
 
1382 varun.gupt 10549 
  def __repr__(self):
10550 
    L = ['%s=%r' % (key, value)
10551 
      for key, value in self.__dict__.iteritems()]
10552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10553 
 
10554 
  def __eq__(self, other):
10555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10556 
 
10557 
  def __ne__(self, other):
10558 
    return not (self == other)
10559 
 
483 rajveer 10560 
class getAllOrders_args:
94 ashish 10561 
  """
10562 
  Attributes:
4801 anupam.sin 10563 
   - statuses
483 rajveer 10564 
   - from_date
10565 
   - to_date
10566 
   - warehouse_id
94 ashish 10567 
  """
10568 
 
10569 
  thrift_spec = (
10570 
    None, # 0
4801 anupam.sin 10571 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 10572 
    (2, TType.I64, 'from_date', None, None, ), # 2
10573 
    (3, TType.I64, 'to_date', None, None, ), # 3
10574 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 10575 
  )
10576 
 
4801 anupam.sin 10577 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
10578 
    self.statuses = statuses
483 rajveer 10579 
    self.from_date = from_date
10580 
    self.to_date = to_date
10581 
    self.warehouse_id = warehouse_id
94 ashish 10582 
 
10583 
  def read(self, iprot):
10584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10586 
      return
10587 
    iprot.readStructBegin()
10588 
    while True:
10589 
      (fname, ftype, fid) = iprot.readFieldBegin()
10590 
      if ftype == TType.STOP:
10591 
        break
10592 
      if fid == 1:
4801 anupam.sin 10593 
        if ftype == TType.LIST:
10594 
          self.statuses = []
6188 rajveer 10595 
          (_etype123, _size120) = iprot.readListBegin()
10596 
          for _i124 in xrange(_size120):
10597 
            _elem125 = iprot.readI32();
10598 
            self.statuses.append(_elem125)
4801 anupam.sin 10599 
          iprot.readListEnd()
94 ashish 10600 
        else:
10601 
          iprot.skip(ftype)
483 rajveer 10602 
      elif fid == 2:
10603 
        if ftype == TType.I64:
10604 
          self.from_date = iprot.readI64();
94 ashish 10605 
        else:
10606 
          iprot.skip(ftype)
483 rajveer 10607 
      elif fid == 3:
10608 
        if ftype == TType.I64:
10609 
          self.to_date = iprot.readI64();
94 ashish 10610 
        else:
10611 
          iprot.skip(ftype)
483 rajveer 10612 
      elif fid == 4:
94 ashish 10613 
        if ftype == TType.I64:
483 rajveer 10614 
          self.warehouse_id = iprot.readI64();
94 ashish 10615 
        else:
10616 
          iprot.skip(ftype)
10617 
      else:
10618 
        iprot.skip(ftype)
10619 
      iprot.readFieldEnd()
10620 
    iprot.readStructEnd()
10621 
 
10622 
  def write(self, oprot):
10623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10625 
      return
483 rajveer 10626 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 10627 
    if self.statuses is not None:
10628 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10629 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10630 
      for iter126 in self.statuses:
10631 
        oprot.writeI32(iter126)
4801 anupam.sin 10632 
      oprot.writeListEnd()
94 ashish 10633 
      oprot.writeFieldEnd()
3431 rajveer 10634 
    if self.from_date is not None:
483 rajveer 10635 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10636 
      oprot.writeI64(self.from_date)
94 ashish 10637 
      oprot.writeFieldEnd()
3431 rajveer 10638 
    if self.to_date is not None:
483 rajveer 10639 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10640 
      oprot.writeI64(self.to_date)
94 ashish 10641 
      oprot.writeFieldEnd()
3431 rajveer 10642 
    if self.warehouse_id is not None:
483 rajveer 10643 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10644 
      oprot.writeI64(self.warehouse_id)
94 ashish 10645 
      oprot.writeFieldEnd()
10646 
    oprot.writeFieldStop()
10647 
    oprot.writeStructEnd()
10648 
 
3431 rajveer 10649 
  def validate(self):
10650 
    return
10651 
 
10652 
 
94 ashish 10653 
  def __repr__(self):
10654 
    L = ['%s=%r' % (key, value)
10655 
      for key, value in self.__dict__.iteritems()]
10656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10657 
 
10658 
  def __eq__(self, other):
10659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10660 
 
10661 
  def __ne__(self, other):
10662 
    return not (self == other)
10663 
 
483 rajveer 10664 
class getAllOrders_result:
94 ashish 10665 
  """
10666 
  Attributes:
10667 
   - success
10668 
   - ex
10669 
  """
10670 
 
10671 
  thrift_spec = (
483 rajveer 10672 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 10673 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10674 
  )
10675 
 
10676 
  def __init__(self, success=None, ex=None,):
10677 
    self.success = success
10678 
    self.ex = ex
10679 
 
10680 
  def read(self, iprot):
10681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10683 
      return
10684 
    iprot.readStructBegin()
10685 
    while True:
10686 
      (fname, ftype, fid) = iprot.readFieldBegin()
10687 
      if ftype == TType.STOP:
10688 
        break
10689 
      if fid == 0:
483 rajveer 10690 
        if ftype == TType.LIST:
10691 
          self.success = []
6188 rajveer 10692 
          (_etype130, _size127) = iprot.readListBegin()
10693 
          for _i131 in xrange(_size127):
10694 
            _elem132 = Order()
10695 
            _elem132.read(iprot)
10696 
            self.success.append(_elem132)
483 rajveer 10697 
          iprot.readListEnd()
94 ashish 10698 
        else:
10699 
          iprot.skip(ftype)
10700 
      elif fid == 1:
10701 
        if ftype == TType.STRUCT:
10702 
          self.ex = TransactionServiceException()
10703 
          self.ex.read(iprot)
10704 
        else:
10705 
          iprot.skip(ftype)
10706 
      else:
10707 
        iprot.skip(ftype)
10708 
      iprot.readFieldEnd()
10709 
    iprot.readStructEnd()
10710 
 
10711 
  def write(self, oprot):
10712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10714 
      return
483 rajveer 10715 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 10716 
    if self.success is not None:
483 rajveer 10717 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10718 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10719 
      for iter133 in self.success:
10720 
        iter133.write(oprot)
483 rajveer 10721 
      oprot.writeListEnd()
94 ashish 10722 
      oprot.writeFieldEnd()
3431 rajveer 10723 
    if self.ex is not None:
94 ashish 10724 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10725 
      self.ex.write(oprot)
10726 
      oprot.writeFieldEnd()
10727 
    oprot.writeFieldStop()
10728 
    oprot.writeStructEnd()
10729 
 
3431 rajveer 10730 
  def validate(self):
10731 
    return
10732 
 
10733 
 
94 ashish 10734 
  def __repr__(self):
10735 
    L = ['%s=%r' % (key, value)
10736 
      for key, value in self.__dict__.iteritems()]
10737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10738 
 
10739 
  def __eq__(self, other):
10740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10741 
 
10742 
  def __ne__(self, other):
10743 
    return not (self == other)
10744 
 
4133 chandransh 10745 
class getOrdersInBatch_args:
10746 
  """
10747 
  Attributes:
10748 
   - statuses
10749 
   - offset
10750 
   - limit
10751 
   - warehouse_id
10752 
  """
10753 
 
10754 
  thrift_spec = (
10755 
    None, # 0
10756 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10757 
    (2, TType.I64, 'offset', None, None, ), # 2
10758 
    (3, TType.I64, 'limit', None, None, ), # 3
10759 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10760 
  )
10761 
 
10762 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
10763 
    self.statuses = statuses
10764 
    self.offset = offset
10765 
    self.limit = limit
10766 
    self.warehouse_id = warehouse_id
10767 
 
10768 
  def read(self, iprot):
10769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10771 
      return
10772 
    iprot.readStructBegin()
10773 
    while True:
10774 
      (fname, ftype, fid) = iprot.readFieldBegin()
10775 
      if ftype == TType.STOP:
10776 
        break
10777 
      if fid == 1:
10778 
        if ftype == TType.LIST:
10779 
          self.statuses = []
6188 rajveer 10780 
          (_etype137, _size134) = iprot.readListBegin()
10781 
          for _i138 in xrange(_size134):
10782 
            _elem139 = iprot.readI32();
10783 
            self.statuses.append(_elem139)
4133 chandransh 10784 
          iprot.readListEnd()
10785 
        else:
10786 
          iprot.skip(ftype)
10787 
      elif fid == 2:
10788 
        if ftype == TType.I64:
10789 
          self.offset = iprot.readI64();
10790 
        else:
10791 
          iprot.skip(ftype)
10792 
      elif fid == 3:
10793 
        if ftype == TType.I64:
10794 
          self.limit = iprot.readI64();
10795 
        else:
10796 
          iprot.skip(ftype)
10797 
      elif fid == 4:
10798 
        if ftype == TType.I64:
10799 
          self.warehouse_id = iprot.readI64();
10800 
        else:
10801 
          iprot.skip(ftype)
10802 
      else:
10803 
        iprot.skip(ftype)
10804 
      iprot.readFieldEnd()
10805 
    iprot.readStructEnd()
10806 
 
10807 
  def write(self, oprot):
10808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10810 
      return
10811 
    oprot.writeStructBegin('getOrdersInBatch_args')
10812 
    if self.statuses is not None:
10813 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10814 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10815 
      for iter140 in self.statuses:
10816 
        oprot.writeI32(iter140)
4133 chandransh 10817 
      oprot.writeListEnd()
10818 
      oprot.writeFieldEnd()
10819 
    if self.offset is not None:
10820 
      oprot.writeFieldBegin('offset', TType.I64, 2)
10821 
      oprot.writeI64(self.offset)
10822 
      oprot.writeFieldEnd()
10823 
    if self.limit is not None:
10824 
      oprot.writeFieldBegin('limit', TType.I64, 3)
10825 
      oprot.writeI64(self.limit)
10826 
      oprot.writeFieldEnd()
10827 
    if self.warehouse_id is not None:
10828 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10829 
      oprot.writeI64(self.warehouse_id)
10830 
      oprot.writeFieldEnd()
10831 
    oprot.writeFieldStop()
10832 
    oprot.writeStructEnd()
10833 
 
10834 
  def validate(self):
10835 
    return
10836 
 
10837 
 
10838 
  def __repr__(self):
10839 
    L = ['%s=%r' % (key, value)
10840 
      for key, value in self.__dict__.iteritems()]
10841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10842 
 
10843 
  def __eq__(self, other):
10844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10845 
 
10846 
  def __ne__(self, other):
10847 
    return not (self == other)
10848 
 
10849 
class getOrdersInBatch_result:
10850 
  """
10851 
  Attributes:
10852 
   - success
10853 
   - ex
10854 
  """
10855 
 
10856 
  thrift_spec = (
10857 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10858 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10859 
  )
10860 
 
10861 
  def __init__(self, success=None, ex=None,):
10862 
    self.success = success
10863 
    self.ex = ex
10864 
 
10865 
  def read(self, iprot):
10866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10868 
      return
10869 
    iprot.readStructBegin()
10870 
    while True:
10871 
      (fname, ftype, fid) = iprot.readFieldBegin()
10872 
      if ftype == TType.STOP:
10873 
        break
10874 
      if fid == 0:
10875 
        if ftype == TType.LIST:
10876 
          self.success = []
6188 rajveer 10877 
          (_etype144, _size141) = iprot.readListBegin()
10878 
          for _i145 in xrange(_size141):
10879 
            _elem146 = Order()
10880 
            _elem146.read(iprot)
10881 
            self.success.append(_elem146)
4133 chandransh 10882 
          iprot.readListEnd()
10883 
        else:
10884 
          iprot.skip(ftype)
10885 
      elif fid == 1:
10886 
        if ftype == TType.STRUCT:
10887 
          self.ex = TransactionServiceException()
10888 
          self.ex.read(iprot)
10889 
        else:
10890 
          iprot.skip(ftype)
10891 
      else:
10892 
        iprot.skip(ftype)
10893 
      iprot.readFieldEnd()
10894 
    iprot.readStructEnd()
10895 
 
10896 
  def write(self, oprot):
10897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10899 
      return
10900 
    oprot.writeStructBegin('getOrdersInBatch_result')
10901 
    if self.success is not None:
10902 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10903 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10904 
      for iter147 in self.success:
10905 
        iter147.write(oprot)
4133 chandransh 10906 
      oprot.writeListEnd()
10907 
      oprot.writeFieldEnd()
10908 
    if self.ex is not None:
10909 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10910 
      self.ex.write(oprot)
10911 
      oprot.writeFieldEnd()
10912 
    oprot.writeFieldStop()
10913 
    oprot.writeStructEnd()
10914 
 
10915 
  def validate(self):
10916 
    return
10917 
 
10918 
 
10919 
  def __repr__(self):
10920 
    L = ['%s=%r' % (key, value)
10921 
      for key, value in self.__dict__.iteritems()]
10922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10923 
 
10924 
  def __eq__(self, other):
10925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10926 
 
10927 
  def __ne__(self, other):
10928 
    return not (self == other)
10929 
 
10930 
class getOrderCount_args:
10931 
  """
10932 
  Attributes:
10933 
   - statuses
10934 
   - warehouseId
10935 
  """
10936 
 
10937 
  thrift_spec = (
10938 
    None, # 0
10939 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10940 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10941 
  )
10942 
 
10943 
  def __init__(self, statuses=None, warehouseId=None,):
10944 
    self.statuses = statuses
10945 
    self.warehouseId = warehouseId
10946 
 
10947 
  def read(self, iprot):
10948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10950 
      return
10951 
    iprot.readStructBegin()
10952 
    while True:
10953 
      (fname, ftype, fid) = iprot.readFieldBegin()
10954 
      if ftype == TType.STOP:
10955 
        break
10956 
      if fid == 1:
10957 
        if ftype == TType.LIST:
10958 
          self.statuses = []
6188 rajveer 10959 
          (_etype151, _size148) = iprot.readListBegin()
10960 
          for _i152 in xrange(_size148):
10961 
            _elem153 = iprot.readI32();
10962 
            self.statuses.append(_elem153)
4133 chandransh 10963 
          iprot.readListEnd()
10964 
        else:
10965 
          iprot.skip(ftype)
10966 
      elif fid == 2:
10967 
        if ftype == TType.I64:
10968 
          self.warehouseId = iprot.readI64();
10969 
        else:
10970 
          iprot.skip(ftype)
10971 
      else:
10972 
        iprot.skip(ftype)
10973 
      iprot.readFieldEnd()
10974 
    iprot.readStructEnd()
10975 
 
10976 
  def write(self, oprot):
10977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10979 
      return
10980 
    oprot.writeStructBegin('getOrderCount_args')
10981 
    if self.statuses is not None:
10982 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10983 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10984 
      for iter154 in self.statuses:
10985 
        oprot.writeI32(iter154)
4133 chandransh 10986 
      oprot.writeListEnd()
10987 
      oprot.writeFieldEnd()
10988 
    if self.warehouseId is not None:
10989 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10990 
      oprot.writeI64(self.warehouseId)
10991 
      oprot.writeFieldEnd()
10992 
    oprot.writeFieldStop()
10993 
    oprot.writeStructEnd()
10994 
 
10995 
  def validate(self):
10996 
    return
10997 
 
10998 
 
10999 
  def __repr__(self):
11000 
    L = ['%s=%r' % (key, value)
11001 
      for key, value in self.__dict__.iteritems()]
11002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11003 
 
11004 
  def __eq__(self, other):
11005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11006 
 
11007 
  def __ne__(self, other):
11008 
    return not (self == other)
11009 
 
11010 
class getOrderCount_result:
11011 
  """
11012 
  Attributes:
11013 
   - success
11014 
   - ex
11015 
  """
11016 
 
11017 
  thrift_spec = (
11018 
    (0, TType.I32, 'success', None, None, ), # 0
11019 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11020 
  )
11021 
 
11022 
  def __init__(self, success=None, ex=None,):
11023 
    self.success = success
11024 
    self.ex = ex
11025 
 
11026 
  def read(self, iprot):
11027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11029 
      return
11030 
    iprot.readStructBegin()
11031 
    while True:
11032 
      (fname, ftype, fid) = iprot.readFieldBegin()
11033 
      if ftype == TType.STOP:
11034 
        break
11035 
      if fid == 0:
11036 
        if ftype == TType.I32:
11037 
          self.success = iprot.readI32();
11038 
        else:
11039 
          iprot.skip(ftype)
11040 
      elif fid == 1:
11041 
        if ftype == TType.STRUCT:
11042 
          self.ex = TransactionServiceException()
11043 
          self.ex.read(iprot)
11044 
        else:
11045 
          iprot.skip(ftype)
11046 
      else:
11047 
        iprot.skip(ftype)
11048 
      iprot.readFieldEnd()
11049 
    iprot.readStructEnd()
11050 
 
11051 
  def write(self, oprot):
11052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11054 
      return
11055 
    oprot.writeStructBegin('getOrderCount_result')
11056 
    if self.success is not None:
11057 
      oprot.writeFieldBegin('success', TType.I32, 0)
11058 
      oprot.writeI32(self.success)
11059 
      oprot.writeFieldEnd()
11060 
    if self.ex is not None:
11061 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11062 
      self.ex.write(oprot)
11063 
      oprot.writeFieldEnd()
11064 
    oprot.writeFieldStop()
11065 
    oprot.writeStructEnd()
11066 
 
11067 
  def validate(self):
11068 
    return
11069 
 
11070 
 
11071 
  def __repr__(self):
11072 
    L = ['%s=%r' % (key, value)
11073 
      for key, value in self.__dict__.iteritems()]
11074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11075 
 
11076 
  def __eq__(self, other):
11077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11078 
 
11079 
  def __ne__(self, other):
11080 
    return not (self == other)
11081 
 
999 varun.gupt 11082 
class getOrdersByBillingDate_args:
11083 
  """
11084 
  Attributes:
11085 
   - status
11086 
   - start_billing_date
11087 
   - end_billing_date
11088 
   - warehouse_id
11089 
  """
11090 
 
11091 
  thrift_spec = (
11092 
    None, # 0
11093 
    (1, TType.I32, 'status', None, None, ), # 1
11094 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
11095 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
11096 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
11097 
  )
11098 
 
11099 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
11100 
    self.status = status
11101 
    self.start_billing_date = start_billing_date
11102 
    self.end_billing_date = end_billing_date
11103 
    self.warehouse_id = warehouse_id
11104 
 
11105 
  def read(self, iprot):
11106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11108 
      return
11109 
    iprot.readStructBegin()
11110 
    while True:
11111 
      (fname, ftype, fid) = iprot.readFieldBegin()
11112 
      if ftype == TType.STOP:
11113 
        break
11114 
      if fid == 1:
11115 
        if ftype == TType.I32:
11116 
          self.status = iprot.readI32();
11117 
        else:
11118 
          iprot.skip(ftype)
11119 
      elif fid == 2:
11120 
        if ftype == TType.I64:
11121 
          self.start_billing_date = iprot.readI64();
11122 
        else:
11123 
          iprot.skip(ftype)
11124 
      elif fid == 3:
11125 
        if ftype == TType.I64:
11126 
          self.end_billing_date = iprot.readI64();
11127 
        else:
11128 
          iprot.skip(ftype)
11129 
      elif fid == 4:
11130 
        if ftype == TType.I64:
11131 
          self.warehouse_id = iprot.readI64();
11132 
        else:
11133 
          iprot.skip(ftype)
11134 
      else:
11135 
        iprot.skip(ftype)
11136 
      iprot.readFieldEnd()
11137 
    iprot.readStructEnd()
11138 
 
11139 
  def write(self, oprot):
11140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11142 
      return
11143 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 11144 
    if self.status is not None:
999 varun.gupt 11145 
      oprot.writeFieldBegin('status', TType.I32, 1)
11146 
      oprot.writeI32(self.status)
11147 
      oprot.writeFieldEnd()
3431 rajveer 11148 
    if self.start_billing_date is not None:
999 varun.gupt 11149 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
11150 
      oprot.writeI64(self.start_billing_date)
11151 
      oprot.writeFieldEnd()
3431 rajveer 11152 
    if self.end_billing_date is not None:
999 varun.gupt 11153 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
11154 
      oprot.writeI64(self.end_billing_date)
11155 
      oprot.writeFieldEnd()
3431 rajveer 11156 
    if self.warehouse_id is not None:
999 varun.gupt 11157 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
11158 
      oprot.writeI64(self.warehouse_id)
11159 
      oprot.writeFieldEnd()
11160 
    oprot.writeFieldStop()
11161 
    oprot.writeStructEnd()
11162 
 
3431 rajveer 11163 
  def validate(self):
11164 
    return
11165 
 
11166 
 
999 varun.gupt 11167 
  def __repr__(self):
11168 
    L = ['%s=%r' % (key, value)
11169 
      for key, value in self.__dict__.iteritems()]
11170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11171 
 
11172 
  def __eq__(self, other):
11173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11174 
 
11175 
  def __ne__(self, other):
11176 
    return not (self == other)
11177 
 
11178 
class getOrdersByBillingDate_result:
11179 
  """
11180 
  Attributes:
11181 
   - success
11182 
   - ex
11183 
  """
11184 
 
11185 
  thrift_spec = (
11186 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11187 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11188 
  )
11189 
 
11190 
  def __init__(self, success=None, ex=None,):
11191 
    self.success = success
11192 
    self.ex = ex
11193 
 
11194 
  def read(self, iprot):
11195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11197 
      return
11198 
    iprot.readStructBegin()
11199 
    while True:
11200 
      (fname, ftype, fid) = iprot.readFieldBegin()
11201 
      if ftype == TType.STOP:
11202 
        break
11203 
      if fid == 0:
11204 
        if ftype == TType.LIST:
11205 
          self.success = []
6188 rajveer 11206 
          (_etype158, _size155) = iprot.readListBegin()
11207 
          for _i159 in xrange(_size155):
11208 
            _elem160 = Order()
11209 
            _elem160.read(iprot)
11210 
            self.success.append(_elem160)
999 varun.gupt 11211 
          iprot.readListEnd()
11212 
        else:
11213 
          iprot.skip(ftype)
11214 
      elif fid == 1:
11215 
        if ftype == TType.STRUCT:
11216 
          self.ex = TransactionServiceException()
11217 
          self.ex.read(iprot)
11218 
        else:
11219 
          iprot.skip(ftype)
11220 
      else:
11221 
        iprot.skip(ftype)
11222 
      iprot.readFieldEnd()
11223 
    iprot.readStructEnd()
11224 
 
11225 
  def write(self, oprot):
11226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11228 
      return
11229 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 11230 
    if self.success is not None:
999 varun.gupt 11231 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11232 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11233 
      for iter161 in self.success:
11234 
        iter161.write(oprot)
999 varun.gupt 11235 
      oprot.writeListEnd()
11236 
      oprot.writeFieldEnd()
3431 rajveer 11237 
    if self.ex is not None:
999 varun.gupt 11238 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11239 
      self.ex.write(oprot)
11240 
      oprot.writeFieldEnd()
11241 
    oprot.writeFieldStop()
11242 
    oprot.writeStructEnd()
11243 
 
3431 rajveer 11244 
  def validate(self):
11245 
    return
11246 
 
11247 
 
999 varun.gupt 11248 
  def __repr__(self):
11249 
    L = ['%s=%r' % (key, value)
11250 
      for key, value in self.__dict__.iteritems()]
11251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11252 
 
11253 
  def __eq__(self, other):
11254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11255 
 
11256 
  def __ne__(self, other):
11257 
    return not (self == other)
11258 
 
3427 chandransh 11259 
class getOrdersByShippingDate_args:
11260 
  """
11261 
  Attributes:
11262 
   - fromShippingDate
11263 
   - toShippingDate
11264 
   - providerId
11265 
   - warehouseId
3451 chandransh 11266 
   - cod
3427 chandransh 11267 
  """
11268 
 
11269 
  thrift_spec = (
11270 
    None, # 0
11271 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
11272 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
11273 
    (3, TType.I64, 'providerId', None, None, ), # 3
11274 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 11275 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 11276 
  )
11277 
 
3451 chandransh 11278 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 11279 
    self.fromShippingDate = fromShippingDate
11280 
    self.toShippingDate = toShippingDate
11281 
    self.providerId = providerId
11282 
    self.warehouseId = warehouseId
3451 chandransh 11283 
    self.cod = cod
3427 chandransh 11284 
 
11285 
  def read(self, iprot):
11286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11288 
      return
11289 
    iprot.readStructBegin()
11290 
    while True:
11291 
      (fname, ftype, fid) = iprot.readFieldBegin()
11292 
      if ftype == TType.STOP:
11293 
        break
11294 
      if fid == 1:
11295 
        if ftype == TType.I64:
11296 
          self.fromShippingDate = iprot.readI64();
11297 
        else:
11298 
          iprot.skip(ftype)
11299 
      elif fid == 2:
11300 
        if ftype == TType.I64:
11301 
          self.toShippingDate = iprot.readI64();
11302 
        else:
11303 
          iprot.skip(ftype)
11304 
      elif fid == 3:
11305 
        if ftype == TType.I64:
11306 
          self.providerId = iprot.readI64();
11307 
        else:
11308 
          iprot.skip(ftype)
11309 
      elif fid == 4:
11310 
        if ftype == TType.I64:
11311 
          self.warehouseId = iprot.readI64();
11312 
        else:
11313 
          iprot.skip(ftype)
3451 chandransh 11314 
      elif fid == 5:
11315 
        if ftype == TType.BOOL:
11316 
          self.cod = iprot.readBool();
11317 
        else:
11318 
          iprot.skip(ftype)
3427 chandransh 11319 
      else:
11320 
        iprot.skip(ftype)
11321 
      iprot.readFieldEnd()
11322 
    iprot.readStructEnd()
11323 
 
11324 
  def write(self, oprot):
11325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11327 
      return
11328 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 11329 
    if self.fromShippingDate is not None:
3427 chandransh 11330 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
11331 
      oprot.writeI64(self.fromShippingDate)
11332 
      oprot.writeFieldEnd()
3431 rajveer 11333 
    if self.toShippingDate is not None:
3427 chandransh 11334 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
11335 
      oprot.writeI64(self.toShippingDate)
11336 
      oprot.writeFieldEnd()
3431 rajveer 11337 
    if self.providerId is not None:
3427 chandransh 11338 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
11339 
      oprot.writeI64(self.providerId)
11340 
      oprot.writeFieldEnd()
3431 rajveer 11341 
    if self.warehouseId is not None:
3427 chandransh 11342 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
11343 
      oprot.writeI64(self.warehouseId)
11344 
      oprot.writeFieldEnd()
3451 chandransh 11345 
    if self.cod is not None:
11346 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
11347 
      oprot.writeBool(self.cod)
11348 
      oprot.writeFieldEnd()
3427 chandransh 11349 
    oprot.writeFieldStop()
11350 
    oprot.writeStructEnd()
11351 
 
3431 rajveer 11352 
  def validate(self):
11353 
    return
11354 
 
11355 
 
3427 chandransh 11356 
  def __repr__(self):
11357 
    L = ['%s=%r' % (key, value)
11358 
      for key, value in self.__dict__.iteritems()]
11359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11360 
 
11361 
  def __eq__(self, other):
11362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11363 
 
11364 
  def __ne__(self, other):
11365 
    return not (self == other)
11366 
 
11367 
class getOrdersByShippingDate_result:
11368 
  """
11369 
  Attributes:
11370 
   - success
11371 
   - ex
11372 
  """
11373 
 
11374 
  thrift_spec = (
11375 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11376 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11377 
  )
11378 
 
11379 
  def __init__(self, success=None, ex=None,):
11380 
    self.success = success
11381 
    self.ex = ex
11382 
 
11383 
  def read(self, iprot):
11384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11386 
      return
11387 
    iprot.readStructBegin()
11388 
    while True:
11389 
      (fname, ftype, fid) = iprot.readFieldBegin()
11390 
      if ftype == TType.STOP:
11391 
        break
11392 
      if fid == 0:
11393 
        if ftype == TType.LIST:
11394 
          self.success = []
6188 rajveer 11395 
          (_etype165, _size162) = iprot.readListBegin()
11396 
          for _i166 in xrange(_size162):
11397 
            _elem167 = Order()
11398 
            _elem167.read(iprot)
11399 
            self.success.append(_elem167)
3427 chandransh 11400 
          iprot.readListEnd()
11401 
        else:
11402 
          iprot.skip(ftype)
11403 
      elif fid == 1:
11404 
        if ftype == TType.STRUCT:
11405 
          self.ex = TransactionServiceException()
11406 
          self.ex.read(iprot)
11407 
        else:
11408 
          iprot.skip(ftype)
11409 
      else:
11410 
        iprot.skip(ftype)
11411 
      iprot.readFieldEnd()
11412 
    iprot.readStructEnd()
11413 
 
11414 
  def write(self, oprot):
11415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11417 
      return
11418 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 11419 
    if self.success is not None:
3427 chandransh 11420 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11421 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11422 
      for iter168 in self.success:
11423 
        iter168.write(oprot)
3427 chandransh 11424 
      oprot.writeListEnd()
11425 
      oprot.writeFieldEnd()
3431 rajveer 11426 
    if self.ex is not None:
3427 chandransh 11427 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11428 
      self.ex.write(oprot)
11429 
      oprot.writeFieldEnd()
11430 
    oprot.writeFieldStop()
11431 
    oprot.writeStructEnd()
11432 
 
3431 rajveer 11433 
  def validate(self):
11434 
    return
11435 
 
11436 
 
3427 chandransh 11437 
  def __repr__(self):
11438 
    L = ['%s=%r' % (key, value)
11439 
      for key, value in self.__dict__.iteritems()]
11440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11441 
 
11442 
  def __eq__(self, other):
11443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11444 
 
11445 
  def __ne__(self, other):
11446 
    return not (self == other)
11447 
 
1382 varun.gupt 11448 
class getReturnableOrdersForCustomer_args:
11449 
  """
11450 
  Attributes:
11451 
   - customer_id
11452 
   - limit
11453 
  """
11454 
 
11455 
  thrift_spec = (
11456 
    None, # 0
11457 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11458 
    (2, TType.I64, 'limit', None, None, ), # 2
11459 
  )
11460 
 
11461 
  def __init__(self, customer_id=None, limit=None,):
11462 
    self.customer_id = customer_id
11463 
    self.limit = limit
11464 
 
11465 
  def read(self, iprot):
11466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11468 
      return
11469 
    iprot.readStructBegin()
11470 
    while True:
11471 
      (fname, ftype, fid) = iprot.readFieldBegin()
11472 
      if ftype == TType.STOP:
11473 
        break
11474 
      if fid == 1:
11475 
        if ftype == TType.I64:
11476 
          self.customer_id = iprot.readI64();
11477 
        else:
11478 
          iprot.skip(ftype)
11479 
      elif fid == 2:
11480 
        if ftype == TType.I64:
11481 
          self.limit = iprot.readI64();
11482 
        else:
11483 
          iprot.skip(ftype)
11484 
      else:
11485 
        iprot.skip(ftype)
11486 
      iprot.readFieldEnd()
11487 
    iprot.readStructEnd()
11488 
 
11489 
  def write(self, oprot):
11490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11492 
      return
11493 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 11494 
    if self.customer_id is not None:
1382 varun.gupt 11495 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11496 
      oprot.writeI64(self.customer_id)
11497 
      oprot.writeFieldEnd()
3431 rajveer 11498 
    if self.limit is not None:
1382 varun.gupt 11499 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11500 
      oprot.writeI64(self.limit)
11501 
      oprot.writeFieldEnd()
11502 
    oprot.writeFieldStop()
11503 
    oprot.writeStructEnd()
11504 
 
3431 rajveer 11505 
  def validate(self):
11506 
    return
11507 
 
11508 
 
1382 varun.gupt 11509 
  def __repr__(self):
11510 
    L = ['%s=%r' % (key, value)
11511 
      for key, value in self.__dict__.iteritems()]
11512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11513 
 
11514 
  def __eq__(self, other):
11515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11516 
 
11517 
  def __ne__(self, other):
11518 
    return not (self == other)
11519 
 
11520 
class getReturnableOrdersForCustomer_result:
11521 
  """
11522 
  Attributes:
11523 
   - success
11524 
   - ex
11525 
  """
11526 
 
11527 
  thrift_spec = (
11528 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11529 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11530 
  )
11531 
 
11532 
  def __init__(self, success=None, ex=None,):
11533 
    self.success = success
11534 
    self.ex = ex
11535 
 
11536 
  def read(self, iprot):
11537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11539 
      return
11540 
    iprot.readStructBegin()
11541 
    while True:
11542 
      (fname, ftype, fid) = iprot.readFieldBegin()
11543 
      if ftype == TType.STOP:
11544 
        break
11545 
      if fid == 0:
11546 
        if ftype == TType.LIST:
11547 
          self.success = []
6188 rajveer 11548 
          (_etype172, _size169) = iprot.readListBegin()
11549 
          for _i173 in xrange(_size169):
11550 
            _elem174 = iprot.readI64();
11551 
            self.success.append(_elem174)
1382 varun.gupt 11552 
          iprot.readListEnd()
11553 
        else:
11554 
          iprot.skip(ftype)
11555 
      elif fid == 1:
11556 
        if ftype == TType.STRUCT:
11557 
          self.ex = TransactionServiceException()
11558 
          self.ex.read(iprot)
11559 
        else:
11560 
          iprot.skip(ftype)
11561 
      else:
11562 
        iprot.skip(ftype)
11563 
      iprot.readFieldEnd()
11564 
    iprot.readStructEnd()
11565 
 
11566 
  def write(self, oprot):
11567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11569 
      return
11570 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 11571 
    if self.success is not None:
1382 varun.gupt 11572 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11573 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11574 
      for iter175 in self.success:
11575 
        oprot.writeI64(iter175)
1382 varun.gupt 11576 
      oprot.writeListEnd()
11577 
      oprot.writeFieldEnd()
3431 rajveer 11578 
    if self.ex is not None:
1382 varun.gupt 11579 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11580 
      self.ex.write(oprot)
11581 
      oprot.writeFieldEnd()
11582 
    oprot.writeFieldStop()
11583 
    oprot.writeStructEnd()
11584 
 
3431 rajveer 11585 
  def validate(self):
11586 
    return
11587 
 
11588 
 
1382 varun.gupt 11589 
  def __repr__(self):
11590 
    L = ['%s=%r' % (key, value)
11591 
      for key, value in self.__dict__.iteritems()]
11592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11593 
 
11594 
  def __eq__(self, other):
11595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11596 
 
11597 
  def __ne__(self, other):
11598 
    return not (self == other)
11599 
 
11600 
class getCancellableOrdersForCustomer_args:
11601 
  """
11602 
  Attributes:
11603 
   - customer_id
11604 
   - limit
11605 
  """
11606 
 
11607 
  thrift_spec = (
11608 
    None, # 0
11609 
    (1, TType.I64, 'customer_id', None, None, ), # 1
11610 
    (2, TType.I64, 'limit', None, None, ), # 2
11611 
  )
11612 
 
11613 
  def __init__(self, customer_id=None, limit=None,):
11614 
    self.customer_id = customer_id
11615 
    self.limit = limit
11616 
 
11617 
  def read(self, iprot):
11618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11620 
      return
11621 
    iprot.readStructBegin()
11622 
    while True:
11623 
      (fname, ftype, fid) = iprot.readFieldBegin()
11624 
      if ftype == TType.STOP:
11625 
        break
11626 
      if fid == 1:
11627 
        if ftype == TType.I64:
11628 
          self.customer_id = iprot.readI64();
11629 
        else:
11630 
          iprot.skip(ftype)
11631 
      elif fid == 2:
11632 
        if ftype == TType.I64:
11633 
          self.limit = iprot.readI64();
11634 
        else:
11635 
          iprot.skip(ftype)
11636 
      else:
11637 
        iprot.skip(ftype)
11638 
      iprot.readFieldEnd()
11639 
    iprot.readStructEnd()
11640 
 
11641 
  def write(self, oprot):
11642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11644 
      return
11645 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 11646 
    if self.customer_id is not None:
1382 varun.gupt 11647 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11648 
      oprot.writeI64(self.customer_id)
11649 
      oprot.writeFieldEnd()
3431 rajveer 11650 
    if self.limit is not None:
1382 varun.gupt 11651 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11652 
      oprot.writeI64(self.limit)
11653 
      oprot.writeFieldEnd()
11654 
    oprot.writeFieldStop()
11655 
    oprot.writeStructEnd()
11656 
 
3431 rajveer 11657 
  def validate(self):
11658 
    return
11659 
 
11660 
 
1382 varun.gupt 11661 
  def __repr__(self):
11662 
    L = ['%s=%r' % (key, value)
11663 
      for key, value in self.__dict__.iteritems()]
11664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11665 
 
11666 
  def __eq__(self, other):
11667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11668 
 
11669 
  def __ne__(self, other):
11670 
    return not (self == other)
11671 
 
11672 
class getCancellableOrdersForCustomer_result:
11673 
  """
11674 
  Attributes:
11675 
   - success
11676 
   - ex
11677 
  """
11678 
 
11679 
  thrift_spec = (
11680 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11681 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11682 
  )
11683 
 
11684 
  def __init__(self, success=None, ex=None,):
11685 
    self.success = success
11686 
    self.ex = ex
11687 
 
11688 
  def read(self, iprot):
11689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11691 
      return
11692 
    iprot.readStructBegin()
11693 
    while True:
11694 
      (fname, ftype, fid) = iprot.readFieldBegin()
11695 
      if ftype == TType.STOP:
11696 
        break
11697 
      if fid == 0:
11698 
        if ftype == TType.LIST:
11699 
          self.success = []
6188 rajveer 11700 
          (_etype179, _size176) = iprot.readListBegin()
11701 
          for _i180 in xrange(_size176):
11702 
            _elem181 = iprot.readI64();
11703 
            self.success.append(_elem181)
1382 varun.gupt 11704 
          iprot.readListEnd()
11705 
        else:
11706 
          iprot.skip(ftype)
11707 
      elif fid == 1:
11708 
        if ftype == TType.STRUCT:
11709 
          self.ex = TransactionServiceException()
11710 
          self.ex.read(iprot)
11711 
        else:
11712 
          iprot.skip(ftype)
11713 
      else:
11714 
        iprot.skip(ftype)
11715 
      iprot.readFieldEnd()
11716 
    iprot.readStructEnd()
11717 
 
11718 
  def write(self, oprot):
11719 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11720 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11721 
      return
11722 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 11723 
    if self.success is not None:
1382 varun.gupt 11724 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11725 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11726 
      for iter182 in self.success:
11727 
        oprot.writeI64(iter182)
1382 varun.gupt 11728 
      oprot.writeListEnd()
11729 
      oprot.writeFieldEnd()
3431 rajveer 11730 
    if self.ex is not None:
1382 varun.gupt 11731 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11732 
      self.ex.write(oprot)
11733 
      oprot.writeFieldEnd()
11734 
    oprot.writeFieldStop()
11735 
    oprot.writeStructEnd()
11736 
 
3431 rajveer 11737 
  def validate(self):
11738 
    return
11739 
 
11740 
 
1382 varun.gupt 11741 
  def __repr__(self):
11742 
    L = ['%s=%r' % (key, value)
11743 
      for key, value in self.__dict__.iteritems()]
11744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11745 
 
11746 
  def __eq__(self, other):
11747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11748 
 
11749 
  def __ne__(self, other):
11750 
    return not (self == other)
11751 
 
483 rajveer 11752 
class changeOrderStatus_args:
94 ashish 11753 
  """
11754 
  Attributes:
483 rajveer 11755 
   - orderId
11756 
   - status
11757 
   - description
94 ashish 11758 
  """
11759 
 
11760 
  thrift_spec = (
11761 
    None, # 0
483 rajveer 11762 
    (1, TType.I64, 'orderId', None, None, ), # 1
11763 
    (2, TType.I32, 'status', None, None, ), # 2
11764 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11765 
  )
11766 
 
483 rajveer 11767 
  def __init__(self, orderId=None, status=None, description=None,):
11768 
    self.orderId = orderId
11769 
    self.status = status
11770 
    self.description = description
94 ashish 11771 
 
11772 
  def read(self, iprot):
11773 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11774 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11775 
      return
11776 
    iprot.readStructBegin()
11777 
    while True:
11778 
      (fname, ftype, fid) = iprot.readFieldBegin()
11779 
      if ftype == TType.STOP:
11780 
        break
11781 
      if fid == 1:
11782 
        if ftype == TType.I64:
483 rajveer 11783 
          self.orderId = iprot.readI64();
94 ashish 11784 
        else:
11785 
          iprot.skip(ftype)
11786 
      elif fid == 2:
483 rajveer 11787 
        if ftype == TType.I32:
11788 
          self.status = iprot.readI32();
94 ashish 11789 
        else:
11790 
          iprot.skip(ftype)
483 rajveer 11791 
      elif fid == 3:
11792 
        if ftype == TType.STRING:
11793 
          self.description = iprot.readString();
11794 
        else:
11795 
          iprot.skip(ftype)
94 ashish 11796 
      else:
11797 
        iprot.skip(ftype)
11798 
      iprot.readFieldEnd()
11799 
    iprot.readStructEnd()
11800 
 
11801 
  def write(self, oprot):
11802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11804 
      return
483 rajveer 11805 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 11806 
    if self.orderId is not None:
483 rajveer 11807 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11808 
      oprot.writeI64(self.orderId)
94 ashish 11809 
      oprot.writeFieldEnd()
3431 rajveer 11810 
    if self.status is not None:
483 rajveer 11811 
      oprot.writeFieldBegin('status', TType.I32, 2)
11812 
      oprot.writeI32(self.status)
94 ashish 11813 
      oprot.writeFieldEnd()
3431 rajveer 11814 
    if self.description is not None:
483 rajveer 11815 
      oprot.writeFieldBegin('description', TType.STRING, 3)
11816 
      oprot.writeString(self.description)
11817 
      oprot.writeFieldEnd()
94 ashish 11818 
    oprot.writeFieldStop()
11819 
    oprot.writeStructEnd()
11820 
 
3431 rajveer 11821 
  def validate(self):
11822 
    return
11823 
 
11824 
 
94 ashish 11825 
  def __repr__(self):
11826 
    L = ['%s=%r' % (key, value)
11827 
      for key, value in self.__dict__.iteritems()]
11828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11829 
 
11830 
  def __eq__(self, other):
11831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11832 
 
11833 
  def __ne__(self, other):
11834 
    return not (self == other)
11835 
 
483 rajveer 11836 
class changeOrderStatus_result:
94 ashish 11837 
  """
11838 
  Attributes:
11839 
   - success
11840 
   - ex
11841 
  """
11842 
 
11843 
  thrift_spec = (
11844 
    (0, TType.BOOL, 'success', None, None, ), # 0
11845 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11846 
  )
11847 
 
11848 
  def __init__(self, success=None, ex=None,):
11849 
    self.success = success
11850 
    self.ex = ex
11851 
 
11852 
  def read(self, iprot):
11853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11855 
      return
11856 
    iprot.readStructBegin()
11857 
    while True:
11858 
      (fname, ftype, fid) = iprot.readFieldBegin()
11859 
      if ftype == TType.STOP:
11860 
        break
11861 
      if fid == 0:
11862 
        if ftype == TType.BOOL:
11863 
          self.success = iprot.readBool();
11864 
        else:
11865 
          iprot.skip(ftype)
11866 
      elif fid == 1:
11867 
        if ftype == TType.STRUCT:
11868 
          self.ex = TransactionServiceException()
11869 
          self.ex.read(iprot)
11870 
        else:
11871 
          iprot.skip(ftype)
11872 
      else:
11873 
        iprot.skip(ftype)
11874 
      iprot.readFieldEnd()
11875 
    iprot.readStructEnd()
11876 
 
11877 
  def write(self, oprot):
11878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11880 
      return
483 rajveer 11881 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 11882 
    if self.success is not None:
94 ashish 11883 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11884 
      oprot.writeBool(self.success)
11885 
      oprot.writeFieldEnd()
3431 rajveer 11886 
    if self.ex is not None:
94 ashish 11887 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11888 
      self.ex.write(oprot)
11889 
      oprot.writeFieldEnd()
11890 
    oprot.writeFieldStop()
11891 
    oprot.writeStructEnd()
11892 
 
3431 rajveer 11893 
  def validate(self):
11894 
    return
11895 
 
11896 
 
94 ashish 11897 
  def __repr__(self):
11898 
    L = ['%s=%r' % (key, value)
11899 
      for key, value in self.__dict__.iteritems()]
11900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11901 
 
11902 
  def __eq__(self, other):
11903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11904 
 
11905 
  def __ne__(self, other):
11906 
    return not (self == other)
11907 
 
3064 chandransh 11908 
class getOrdersForTransaction_args:
494 rajveer 11909 
  """
11910 
  Attributes:
3064 chandransh 11911 
   - transactionId
11912 
   - customerId
494 rajveer 11913 
  """
11914 
 
11915 
  thrift_spec = (
11916 
    None, # 0
3064 chandransh 11917 
    (1, TType.I64, 'transactionId', None, None, ), # 1
11918 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 11919 
  )
11920 
 
3064 chandransh 11921 
  def __init__(self, transactionId=None, customerId=None,):
11922 
    self.transactionId = transactionId
11923 
    self.customerId = customerId
494 rajveer 11924 
 
11925 
  def read(self, iprot):
11926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11928 
      return
11929 
    iprot.readStructBegin()
11930 
    while True:
11931 
      (fname, ftype, fid) = iprot.readFieldBegin()
11932 
      if ftype == TType.STOP:
11933 
        break
11934 
      if fid == 1:
11935 
        if ftype == TType.I64:
3064 chandransh 11936 
          self.transactionId = iprot.readI64();
494 rajveer 11937 
        else:
11938 
          iprot.skip(ftype)
11939 
      elif fid == 2:
3064 chandransh 11940 
        if ftype == TType.I64:
11941 
          self.customerId = iprot.readI64();
494 rajveer 11942 
        else:
11943 
          iprot.skip(ftype)
11944 
      else:
11945 
        iprot.skip(ftype)
11946 
      iprot.readFieldEnd()
11947 
    iprot.readStructEnd()
11948 
 
11949 
  def write(self, oprot):
11950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11952 
      return
3064 chandransh 11953 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 11954 
    if self.transactionId is not None:
3064 chandransh 11955 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
11956 
      oprot.writeI64(self.transactionId)
494 rajveer 11957 
      oprot.writeFieldEnd()
3431 rajveer 11958 
    if self.customerId is not None:
3064 chandransh 11959 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
11960 
      oprot.writeI64(self.customerId)
494 rajveer 11961 
      oprot.writeFieldEnd()
11962 
    oprot.writeFieldStop()
11963 
    oprot.writeStructEnd()
11964 
 
3431 rajveer 11965 
  def validate(self):
11966 
    return
11967 
 
11968 
 
494 rajveer 11969 
  def __repr__(self):
11970 
    L = ['%s=%r' % (key, value)
11971 
      for key, value in self.__dict__.iteritems()]
11972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11973 
 
11974 
  def __eq__(self, other):
11975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11976 
 
11977 
  def __ne__(self, other):
11978 
    return not (self == other)
11979 
 
3064 chandransh 11980 
class getOrdersForTransaction_result:
494 rajveer 11981 
  """
11982 
  Attributes:
11983 
   - success
11984 
   - ex
11985 
  """
11986 
 
11987 
  thrift_spec = (
3064 chandransh 11988 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 11989 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11990 
  )
11991 
 
11992 
  def __init__(self, success=None, ex=None,):
11993 
    self.success = success
11994 
    self.ex = ex
11995 
 
11996 
  def read(self, iprot):
11997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11999 
      return
12000 
    iprot.readStructBegin()
12001 
    while True:
12002 
      (fname, ftype, fid) = iprot.readFieldBegin()
12003 
      if ftype == TType.STOP:
12004 
        break
12005 
      if fid == 0:
3064 chandransh 12006 
        if ftype == TType.LIST:
12007 
          self.success = []
6188 rajveer 12008 
          (_etype186, _size183) = iprot.readListBegin()
12009 
          for _i187 in xrange(_size183):
12010 
            _elem188 = Order()
12011 
            _elem188.read(iprot)
12012 
            self.success.append(_elem188)
3064 chandransh 12013 
          iprot.readListEnd()
494 rajveer 12014 
        else:
12015 
          iprot.skip(ftype)
12016 
      elif fid == 1:
12017 
        if ftype == TType.STRUCT:
12018 
          self.ex = TransactionServiceException()
12019 
          self.ex.read(iprot)
12020 
        else:
12021 
          iprot.skip(ftype)
12022 
      else:
12023 
        iprot.skip(ftype)
12024 
      iprot.readFieldEnd()
12025 
    iprot.readStructEnd()
12026 
 
12027 
  def write(self, oprot):
12028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12030 
      return
3064 chandransh 12031 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 12032 
    if self.success is not None:
3064 chandransh 12033 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12034 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12035 
      for iter189 in self.success:
12036 
        iter189.write(oprot)
3064 chandransh 12037 
      oprot.writeListEnd()
494 rajveer 12038 
      oprot.writeFieldEnd()
3431 rajveer 12039 
    if self.ex is not None:
494 rajveer 12040 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12041 
      self.ex.write(oprot)
12042 
      oprot.writeFieldEnd()
12043 
    oprot.writeFieldStop()
12044 
    oprot.writeStructEnd()
12045 
 
3431 rajveer 12046 
  def validate(self):
12047 
    return
12048 
 
12049 
 
494 rajveer 12050 
  def __repr__(self):
12051 
    L = ['%s=%r' % (key, value)
12052 
      for key, value in self.__dict__.iteritems()]
12053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12054 
 
12055 
  def __eq__(self, other):
12056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12057 
 
12058 
  def __ne__(self, other):
12059 
    return not (self == other)
12060 
 
3064 chandransh 12061 
class getOrdersForCustomer_args:
1149 chandransh 12062 
  """
12063 
  Attributes:
3064 chandransh 12064 
   - customerId
12065 
   - from_date
12066 
   - to_date
12067 
   - statuses
1149 chandransh 12068 
  """
12069 
 
12070 
  thrift_spec = (
12071 
    None, # 0
3064 chandransh 12072 
    (1, TType.I64, 'customerId', None, None, ), # 1
12073 
    (2, TType.I64, 'from_date', None, None, ), # 2
12074 
    (3, TType.I64, 'to_date', None, None, ), # 3
12075 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 12076 
  )
12077 
 
3064 chandransh 12078 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
12079 
    self.customerId = customerId
12080 
    self.from_date = from_date
12081 
    self.to_date = to_date
12082 
    self.statuses = statuses
1149 chandransh 12083 
 
12084 
  def read(self, iprot):
12085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12087 
      return
12088 
    iprot.readStructBegin()
12089 
    while True:
12090 
      (fname, ftype, fid) = iprot.readFieldBegin()
12091 
      if ftype == TType.STOP:
12092 
        break
12093 
      if fid == 1:
12094 
        if ftype == TType.I64:
3064 chandransh 12095 
          self.customerId = iprot.readI64();
1149 chandransh 12096 
        else:
12097 
          iprot.skip(ftype)
12098 
      elif fid == 2:
12099 
        if ftype == TType.I64:
3064 chandransh 12100 
          self.from_date = iprot.readI64();
1149 chandransh 12101 
        else:
12102 
          iprot.skip(ftype)
2783 chandransh 12103 
      elif fid == 3:
12104 
        if ftype == TType.I64:
3064 chandransh 12105 
          self.to_date = iprot.readI64();
2783 chandransh 12106 
        else:
12107 
          iprot.skip(ftype)
12108 
      elif fid == 4:
3064 chandransh 12109 
        if ftype == TType.LIST:
12110 
          self.statuses = []
6188 rajveer 12111 
          (_etype193, _size190) = iprot.readListBegin()
12112 
          for _i194 in xrange(_size190):
12113 
            _elem195 = iprot.readI32();
12114 
            self.statuses.append(_elem195)
3064 chandransh 12115 
          iprot.readListEnd()
2783 chandransh 12116 
        else:
12117 
          iprot.skip(ftype)
1149 chandransh 12118 
      else:
12119 
        iprot.skip(ftype)
12120 
      iprot.readFieldEnd()
12121 
    iprot.readStructEnd()
12122 
 
12123 
  def write(self, oprot):
12124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12126 
      return
3064 chandransh 12127 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 12128 
    if self.customerId is not None:
3064 chandransh 12129 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
12130 
      oprot.writeI64(self.customerId)
1149 chandransh 12131 
      oprot.writeFieldEnd()
3431 rajveer 12132 
    if self.from_date is not None:
3064 chandransh 12133 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
12134 
      oprot.writeI64(self.from_date)
1149 chandransh 12135 
      oprot.writeFieldEnd()
3431 rajveer 12136 
    if self.to_date is not None:
3064 chandransh 12137 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
12138 
      oprot.writeI64(self.to_date)
2783 chandransh 12139 
      oprot.writeFieldEnd()
3431 rajveer 12140 
    if self.statuses is not None:
3064 chandransh 12141 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
12142 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 12143 
      for iter196 in self.statuses:
12144 
        oprot.writeI32(iter196)
3064 chandransh 12145 
      oprot.writeListEnd()
2783 chandransh 12146 
      oprot.writeFieldEnd()
1149 chandransh 12147 
    oprot.writeFieldStop()
12148 
    oprot.writeStructEnd()
12149 
 
3431 rajveer 12150 
  def validate(self):
12151 
    return
12152 
 
12153 
 
1149 chandransh 12154 
  def __repr__(self):
12155 
    L = ['%s=%r' % (key, value)
12156 
      for key, value in self.__dict__.iteritems()]
12157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12158 
 
12159 
  def __eq__(self, other):
12160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12161 
 
12162 
  def __ne__(self, other):
12163 
    return not (self == other)
12164 
 
3064 chandransh 12165 
class getOrdersForCustomer_result:
1149 chandransh 12166 
  """
12167 
  Attributes:
12168 
   - success
12169 
   - ex
12170 
  """
12171 
 
12172 
  thrift_spec = (
3064 chandransh 12173 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 12174 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12175 
  )
12176 
 
12177 
  def __init__(self, success=None, ex=None,):
12178 
    self.success = success
12179 
    self.ex = ex
12180 
 
12181 
  def read(self, iprot):
12182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12184 
      return
12185 
    iprot.readStructBegin()
12186 
    while True:
12187 
      (fname, ftype, fid) = iprot.readFieldBegin()
12188 
      if ftype == TType.STOP:
12189 
        break
12190 
      if fid == 0:
3064 chandransh 12191 
        if ftype == TType.LIST:
12192 
          self.success = []
6188 rajveer 12193 
          (_etype200, _size197) = iprot.readListBegin()
12194 
          for _i201 in xrange(_size197):
12195 
            _elem202 = Order()
12196 
            _elem202.read(iprot)
12197 
            self.success.append(_elem202)
3064 chandransh 12198 
          iprot.readListEnd()
1149 chandransh 12199 
        else:
12200 
          iprot.skip(ftype)
12201 
      elif fid == 1:
12202 
        if ftype == TType.STRUCT:
12203 
          self.ex = TransactionServiceException()
12204 
          self.ex.read(iprot)
12205 
        else:
12206 
          iprot.skip(ftype)
12207 
      else:
12208 
        iprot.skip(ftype)
12209 
      iprot.readFieldEnd()
12210 
    iprot.readStructEnd()
12211 
 
12212 
  def write(self, oprot):
12213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12215 
      return
3064 chandransh 12216 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 12217 
    if self.success is not None:
3064 chandransh 12218 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12219 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12220 
      for iter203 in self.success:
12221 
        iter203.write(oprot)
3064 chandransh 12222 
      oprot.writeListEnd()
1149 chandransh 12223 
      oprot.writeFieldEnd()
3431 rajveer 12224 
    if self.ex is not None:
1149 chandransh 12225 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12226 
      self.ex.write(oprot)
12227 
      oprot.writeFieldEnd()
12228 
    oprot.writeFieldStop()
12229 
    oprot.writeStructEnd()
12230 
 
3431 rajveer 12231 
  def validate(self):
12232 
    return
12233 
 
12234 
 
1149 chandransh 12235 
  def __repr__(self):
12236 
    L = ['%s=%r' % (key, value)
12237 
      for key, value in self.__dict__.iteritems()]
12238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12239 
 
12240 
  def __eq__(self, other):
12241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12242 
 
12243 
  def __ne__(self, other):
12244 
    return not (self == other)
12245 
 
3064 chandransh 12246 
class createOrder_args:
921 rajveer 12247 
  """
12248 
  Attributes:
3064 chandransh 12249 
   - order
921 rajveer 12250 
  """
12251 
 
12252 
  thrift_spec = (
12253 
    None, # 0
3064 chandransh 12254 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 12255 
  )
12256 
 
3064 chandransh 12257 
  def __init__(self, order=None,):
12258 
    self.order = order
921 rajveer 12259 
 
12260 
  def read(self, iprot):
12261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12263 
      return
12264 
    iprot.readStructBegin()
12265 
    while True:
12266 
      (fname, ftype, fid) = iprot.readFieldBegin()
12267 
      if ftype == TType.STOP:
12268 
        break
12269 
      if fid == 1:
3064 chandransh 12270 
        if ftype == TType.STRUCT:
12271 
          self.order = Order()
12272 
          self.order.read(iprot)
921 rajveer 12273 
        else:
12274 
          iprot.skip(ftype)
12275 
      else:
12276 
        iprot.skip(ftype)
12277 
      iprot.readFieldEnd()
12278 
    iprot.readStructEnd()
12279 
 
12280 
  def write(self, oprot):
12281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12283 
      return
3064 chandransh 12284 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 12285 
    if self.order is not None:
3064 chandransh 12286 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
12287 
      self.order.write(oprot)
921 rajveer 12288 
      oprot.writeFieldEnd()
12289 
    oprot.writeFieldStop()
12290 
    oprot.writeStructEnd()
12291 
 
3431 rajveer 12292 
  def validate(self):
12293 
    return
12294 
 
12295 
 
921 rajveer 12296 
  def __repr__(self):
12297 
    L = ['%s=%r' % (key, value)
12298 
      for key, value in self.__dict__.iteritems()]
12299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12300 
 
12301 
  def __eq__(self, other):
12302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12303 
 
12304 
  def __ne__(self, other):
12305 
    return not (self == other)
12306 
 
3064 chandransh 12307 
class createOrder_result:
921 rajveer 12308 
  """
12309 
  Attributes:
12310 
   - success
12311 
   - ex
12312 
  """
12313 
 
12314 
  thrift_spec = (
3064 chandransh 12315 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 12316 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12317 
  )
12318 
 
12319 
  def __init__(self, success=None, ex=None,):
12320 
    self.success = success
12321 
    self.ex = ex
12322 
 
12323 
  def read(self, iprot):
12324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12326 
      return
12327 
    iprot.readStructBegin()
12328 
    while True:
12329 
      (fname, ftype, fid) = iprot.readFieldBegin()
12330 
      if ftype == TType.STOP:
12331 
        break
12332 
      if fid == 0:
3064 chandransh 12333 
        if ftype == TType.I64:
12334 
          self.success = iprot.readI64();
921 rajveer 12335 
        else:
12336 
          iprot.skip(ftype)
12337 
      elif fid == 1:
12338 
        if ftype == TType.STRUCT:
12339 
          self.ex = TransactionServiceException()
12340 
          self.ex.read(iprot)
12341 
        else:
12342 
          iprot.skip(ftype)
12343 
      else:
12344 
        iprot.skip(ftype)
12345 
      iprot.readFieldEnd()
12346 
    iprot.readStructEnd()
12347 
 
12348 
  def write(self, oprot):
12349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12351 
      return
3064 chandransh 12352 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 12353 
    if self.success is not None:
3064 chandransh 12354 
      oprot.writeFieldBegin('success', TType.I64, 0)
12355 
      oprot.writeI64(self.success)
921 rajveer 12356 
      oprot.writeFieldEnd()
3431 rajveer 12357 
    if self.ex is not None:
921 rajveer 12358 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12359 
      self.ex.write(oprot)
12360 
      oprot.writeFieldEnd()
12361 
    oprot.writeFieldStop()
12362 
    oprot.writeStructEnd()
12363 
 
3431 rajveer 12364 
  def validate(self):
12365 
    return
12366 
 
12367 
 
921 rajveer 12368 
  def __repr__(self):
12369 
    L = ['%s=%r' % (key, value)
12370 
      for key, value in self.__dict__.iteritems()]
12371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12372 
 
12373 
  def __eq__(self, other):
12374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12375 
 
12376 
  def __ne__(self, other):
12377 
    return not (self == other)
12378 
 
3064 chandransh 12379 
class getOrder_args:
921 rajveer 12380 
  """
12381 
  Attributes:
3064 chandransh 12382 
   - id
921 rajveer 12383 
  """
12384 
 
12385 
  thrift_spec = (
12386 
    None, # 0
3064 chandransh 12387 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 12388 
  )
12389 
 
3064 chandransh 12390 
  def __init__(self, id=None,):
12391 
    self.id = id
921 rajveer 12392 
 
12393 
  def read(self, iprot):
12394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12396 
      return
12397 
    iprot.readStructBegin()
12398 
    while True:
12399 
      (fname, ftype, fid) = iprot.readFieldBegin()
12400 
      if ftype == TType.STOP:
12401 
        break
12402 
      if fid == 1:
12403 
        if ftype == TType.I64:
3064 chandransh 12404 
          self.id = iprot.readI64();
921 rajveer 12405 
        else:
12406 
          iprot.skip(ftype)
12407 
      else:
12408 
        iprot.skip(ftype)
12409 
      iprot.readFieldEnd()
12410 
    iprot.readStructEnd()
12411 
 
12412 
  def write(self, oprot):
12413 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12414 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12415 
      return
3064 chandransh 12416 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 12417 
    if self.id is not None:
3064 chandransh 12418 
      oprot.writeFieldBegin('id', TType.I64, 1)
12419 
      oprot.writeI64(self.id)
921 rajveer 12420 
      oprot.writeFieldEnd()
12421 
    oprot.writeFieldStop()
12422 
    oprot.writeStructEnd()
12423 
 
3431 rajveer 12424 
  def validate(self):
12425 
    return
12426 
 
12427 
 
921 rajveer 12428 
  def __repr__(self):
12429 
    L = ['%s=%r' % (key, value)
12430 
      for key, value in self.__dict__.iteritems()]
12431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12432 
 
12433 
  def __eq__(self, other):
12434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12435 
 
12436 
  def __ne__(self, other):
12437 
    return not (self == other)
12438 
 
3064 chandransh 12439 
class getOrder_result:
921 rajveer 12440 
  """
12441 
  Attributes:
12442 
   - success
12443 
   - ex
12444 
  """
12445 
 
12446 
  thrift_spec = (
3064 chandransh 12447 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 12448 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12449 
  )
12450 
 
12451 
  def __init__(self, success=None, ex=None,):
12452 
    self.success = success
12453 
    self.ex = ex
12454 
 
12455 
  def read(self, iprot):
12456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12458 
      return
12459 
    iprot.readStructBegin()
12460 
    while True:
12461 
      (fname, ftype, fid) = iprot.readFieldBegin()
12462 
      if ftype == TType.STOP:
12463 
        break
12464 
      if fid == 0:
3064 chandransh 12465 
        if ftype == TType.STRUCT:
12466 
          self.success = Order()
12467 
          self.success.read(iprot)
921 rajveer 12468 
        else:
12469 
          iprot.skip(ftype)
12470 
      elif fid == 1:
12471 
        if ftype == TType.STRUCT:
12472 
          self.ex = TransactionServiceException()
12473 
          self.ex.read(iprot)
12474 
        else:
12475 
          iprot.skip(ftype)
12476 
      else:
12477 
        iprot.skip(ftype)
12478 
      iprot.readFieldEnd()
12479 
    iprot.readStructEnd()
12480 
 
12481 
  def write(self, oprot):
12482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12484 
      return
3064 chandransh 12485 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 12486 
    if self.success is not None:
3064 chandransh 12487 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12488 
      self.success.write(oprot)
921 rajveer 12489 
      oprot.writeFieldEnd()
3431 rajveer 12490 
    if self.ex is not None:
921 rajveer 12491 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12492 
      self.ex.write(oprot)
12493 
      oprot.writeFieldEnd()
12494 
    oprot.writeFieldStop()
12495 
    oprot.writeStructEnd()
12496 
 
3431 rajveer 12497 
  def validate(self):
12498 
    return
12499 
 
12500 
 
921 rajveer 12501 
  def __repr__(self):
12502 
    L = ['%s=%r' % (key, value)
12503 
      for key, value in self.__dict__.iteritems()]
12504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12505 
 
12506 
  def __eq__(self, other):
12507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12508 
 
12509 
  def __ne__(self, other):
12510 
    return not (self == other)
12511 
 
3064 chandransh 12512 
class getLineItemsForOrder_args:
94 ashish 12513 
  """
12514 
  Attributes:
3064 chandransh 12515 
   - orderId
94 ashish 12516 
  """
12517 
 
12518 
  thrift_spec = (
12519 
    None, # 0
3064 chandransh 12520 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 12521 
  )
12522 
 
3064 chandransh 12523 
  def __init__(self, orderId=None,):
12524 
    self.orderId = orderId
94 ashish 12525 
 
12526 
  def read(self, iprot):
12527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12529 
      return
12530 
    iprot.readStructBegin()
12531 
    while True:
12532 
      (fname, ftype, fid) = iprot.readFieldBegin()
12533 
      if ftype == TType.STOP:
12534 
        break
12535 
      if fid == 1:
12536 
        if ftype == TType.I64:
3064 chandransh 12537 
          self.orderId = iprot.readI64();
94 ashish 12538 
        else:
12539 
          iprot.skip(ftype)
12540 
      else:
12541 
        iprot.skip(ftype)
12542 
      iprot.readFieldEnd()
12543 
    iprot.readStructEnd()
12544 
 
12545 
  def write(self, oprot):
12546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12548 
      return
3064 chandransh 12549 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 12550 
    if self.orderId is not None:
3064 chandransh 12551 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12552 
      oprot.writeI64(self.orderId)
94 ashish 12553 
      oprot.writeFieldEnd()
12554 
    oprot.writeFieldStop()
12555 
    oprot.writeStructEnd()
12556 
 
3431 rajveer 12557 
  def validate(self):
12558 
    return
12559 
 
12560 
 
94 ashish 12561 
  def __repr__(self):
12562 
    L = ['%s=%r' % (key, value)
12563 
      for key, value in self.__dict__.iteritems()]
12564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12565 
 
12566 
  def __eq__(self, other):
12567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12568 
 
12569 
  def __ne__(self, other):
12570 
    return not (self == other)
12571 
 
3064 chandransh 12572 
class getLineItemsForOrder_result:
94 ashish 12573 
  """
12574 
  Attributes:
12575 
   - success
12576 
   - ex
12577 
  """
12578 
 
12579 
  thrift_spec = (
3064 chandransh 12580 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 12581 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12582 
  )
12583 
 
12584 
  def __init__(self, success=None, ex=None,):
12585 
    self.success = success
12586 
    self.ex = ex
12587 
 
12588 
  def read(self, iprot):
12589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12591 
      return
12592 
    iprot.readStructBegin()
12593 
    while True:
12594 
      (fname, ftype, fid) = iprot.readFieldBegin()
12595 
      if ftype == TType.STOP:
12596 
        break
12597 
      if fid == 0:
483 rajveer 12598 
        if ftype == TType.LIST:
12599 
          self.success = []
6188 rajveer 12600 
          (_etype207, _size204) = iprot.readListBegin()
12601 
          for _i208 in xrange(_size204):
12602 
            _elem209 = LineItem()
12603 
            _elem209.read(iprot)
12604 
            self.success.append(_elem209)
483 rajveer 12605 
          iprot.readListEnd()
94 ashish 12606 
        else:
12607 
          iprot.skip(ftype)
12608 
      elif fid == 1:
12609 
        if ftype == TType.STRUCT:
12610 
          self.ex = TransactionServiceException()
12611 
          self.ex.read(iprot)
12612 
        else:
12613 
          iprot.skip(ftype)
12614 
      else:
12615 
        iprot.skip(ftype)
12616 
      iprot.readFieldEnd()
12617 
    iprot.readStructEnd()
12618 
 
12619 
  def write(self, oprot):
12620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12622 
      return
3064 chandransh 12623 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 12624 
    if self.success is not None:
483 rajveer 12625 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12626 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12627 
      for iter210 in self.success:
12628 
        iter210.write(oprot)
483 rajveer 12629 
      oprot.writeListEnd()
94 ashish 12630 
      oprot.writeFieldEnd()
3431 rajveer 12631 
    if self.ex is not None:
94 ashish 12632 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12633 
      self.ex.write(oprot)
12634 
      oprot.writeFieldEnd()
12635 
    oprot.writeFieldStop()
12636 
    oprot.writeStructEnd()
12637 
 
3431 rajveer 12638 
  def validate(self):
12639 
    return
12640 
 
12641 
 
94 ashish 12642 
  def __repr__(self):
12643 
    L = ['%s=%r' % (key, value)
12644 
      for key, value in self.__dict__.iteritems()]
12645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12646 
 
12647 
  def __eq__(self, other):
12648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12649 
 
12650 
  def __ne__(self, other):
12651 
    return not (self == other)
12652 
 
4999 phani.kuma 12653 
class getOrderList_args:
12654 
  """
12655 
  Attributes:
12656 
   - order_ids
12657 
  """
12658 
 
12659 
  thrift_spec = (
12660 
    None, # 0
12661 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12662 
  )
12663 
 
12664 
  def __init__(self, order_ids=None,):
12665 
    self.order_ids = order_ids
12666 
 
12667 
  def read(self, iprot):
12668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12670 
      return
12671 
    iprot.readStructBegin()
12672 
    while True:
12673 
      (fname, ftype, fid) = iprot.readFieldBegin()
12674 
      if ftype == TType.STOP:
12675 
        break
12676 
      if fid == 1:
12677 
        if ftype == TType.LIST:
12678 
          self.order_ids = []
6188 rajveer 12679 
          (_etype214, _size211) = iprot.readListBegin()
12680 
          for _i215 in xrange(_size211):
12681 
            _elem216 = iprot.readI64();
12682 
            self.order_ids.append(_elem216)
4999 phani.kuma 12683 
          iprot.readListEnd()
12684 
        else:
12685 
          iprot.skip(ftype)
12686 
      else:
12687 
        iprot.skip(ftype)
12688 
      iprot.readFieldEnd()
12689 
    iprot.readStructEnd()
12690 
 
12691 
  def write(self, oprot):
12692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12694 
      return
12695 
    oprot.writeStructBegin('getOrderList_args')
12696 
    if self.order_ids is not None:
12697 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12698 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12699 
      for iter217 in self.order_ids:
12700 
        oprot.writeI64(iter217)
4999 phani.kuma 12701 
      oprot.writeListEnd()
12702 
      oprot.writeFieldEnd()
12703 
    oprot.writeFieldStop()
12704 
    oprot.writeStructEnd()
12705 
 
12706 
  def validate(self):
12707 
    return
12708 
 
12709 
 
12710 
  def __repr__(self):
12711 
    L = ['%s=%r' % (key, value)
12712 
      for key, value in self.__dict__.iteritems()]
12713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12714 
 
12715 
  def __eq__(self, other):
12716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12717 
 
12718 
  def __ne__(self, other):
12719 
    return not (self == other)
12720 
 
12721 
class getOrderList_result:
12722 
  """
12723 
  Attributes:
12724 
   - success
12725 
  """
12726 
 
12727 
  thrift_spec = (
12728 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12729 
  )
12730 
 
12731 
  def __init__(self, success=None,):
12732 
    self.success = success
12733 
 
12734 
  def read(self, iprot):
12735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12737 
      return
12738 
    iprot.readStructBegin()
12739 
    while True:
12740 
      (fname, ftype, fid) = iprot.readFieldBegin()
12741 
      if ftype == TType.STOP:
12742 
        break
12743 
      if fid == 0:
12744 
        if ftype == TType.LIST:
12745 
          self.success = []
6188 rajveer 12746 
          (_etype221, _size218) = iprot.readListBegin()
12747 
          for _i222 in xrange(_size218):
12748 
            _elem223 = Order()
12749 
            _elem223.read(iprot)
12750 
            self.success.append(_elem223)
4999 phani.kuma 12751 
          iprot.readListEnd()
12752 
        else:
12753 
          iprot.skip(ftype)
12754 
      else:
12755 
        iprot.skip(ftype)
12756 
      iprot.readFieldEnd()
12757 
    iprot.readStructEnd()
12758 
 
12759 
  def write(self, oprot):
12760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12762 
      return
12763 
    oprot.writeStructBegin('getOrderList_result')
12764 
    if self.success is not None:
12765 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12766 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12767 
      for iter224 in self.success:
12768 
        iter224.write(oprot)
4999 phani.kuma 12769 
      oprot.writeListEnd()
12770 
      oprot.writeFieldEnd()
12771 
    oprot.writeFieldStop()
12772 
    oprot.writeStructEnd()
12773 
 
12774 
  def validate(self):
12775 
    return
12776 
 
12777 
 
12778 
  def __repr__(self):
12779 
    L = ['%s=%r' % (key, value)
12780 
      for key, value in self.__dict__.iteritems()]
12781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12782 
 
12783 
  def __eq__(self, other):
12784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12785 
 
12786 
  def __ne__(self, other):
12787 
    return not (self == other)
12788 
 
5386 phani.kuma 12789 
class getOrderListForVendor_args:
12790 
  """
12791 
  Attributes:
12792 
   - order_ids
12793 
   - vendorId
12794 
  """
12795 
 
12796 
  thrift_spec = (
12797 
    None, # 0
12798 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12799 
    (2, TType.I64, 'vendorId', None, None, ), # 2
12800 
  )
12801 
 
12802 
  def __init__(self, order_ids=None, vendorId=None,):
12803 
    self.order_ids = order_ids
12804 
    self.vendorId = vendorId
12805 
 
12806 
  def read(self, iprot):
12807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12809 
      return
12810 
    iprot.readStructBegin()
12811 
    while True:
12812 
      (fname, ftype, fid) = iprot.readFieldBegin()
12813 
      if ftype == TType.STOP:
12814 
        break
12815 
      if fid == 1:
12816 
        if ftype == TType.LIST:
12817 
          self.order_ids = []
6188 rajveer 12818 
          (_etype228, _size225) = iprot.readListBegin()
12819 
          for _i229 in xrange(_size225):
12820 
            _elem230 = iprot.readI64();
12821 
            self.order_ids.append(_elem230)
5386 phani.kuma 12822 
          iprot.readListEnd()
12823 
        else:
12824 
          iprot.skip(ftype)
12825 
      elif fid == 2:
12826 
        if ftype == TType.I64:
12827 
          self.vendorId = iprot.readI64();
12828 
        else:
12829 
          iprot.skip(ftype)
12830 
      else:
12831 
        iprot.skip(ftype)
12832 
      iprot.readFieldEnd()
12833 
    iprot.readStructEnd()
12834 
 
12835 
  def write(self, oprot):
12836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12838 
      return
12839 
    oprot.writeStructBegin('getOrderListForVendor_args')
12840 
    if self.order_ids is not None:
12841 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12842 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12843 
      for iter231 in self.order_ids:
12844 
        oprot.writeI64(iter231)
5386 phani.kuma 12845 
      oprot.writeListEnd()
12846 
      oprot.writeFieldEnd()
12847 
    if self.vendorId is not None:
12848 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
12849 
      oprot.writeI64(self.vendorId)
12850 
      oprot.writeFieldEnd()
12851 
    oprot.writeFieldStop()
12852 
    oprot.writeStructEnd()
12853 
 
12854 
  def validate(self):
12855 
    return
12856 
 
12857 
 
12858 
  def __repr__(self):
12859 
    L = ['%s=%r' % (key, value)
12860 
      for key, value in self.__dict__.iteritems()]
12861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12862 
 
12863 
  def __eq__(self, other):
12864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12865 
 
12866 
  def __ne__(self, other):
12867 
    return not (self == other)
12868 
 
12869 
class getOrderListForVendor_result:
12870 
  """
12871 
  Attributes:
12872 
   - success
12873 
  """
12874 
 
12875 
  thrift_spec = (
12876 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12877 
  )
12878 
 
12879 
  def __init__(self, success=None,):
12880 
    self.success = success
12881 
 
12882 
  def read(self, iprot):
12883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12885 
      return
12886 
    iprot.readStructBegin()
12887 
    while True:
12888 
      (fname, ftype, fid) = iprot.readFieldBegin()
12889 
      if ftype == TType.STOP:
12890 
        break
12891 
      if fid == 0:
12892 
        if ftype == TType.LIST:
12893 
          self.success = []
6188 rajveer 12894 
          (_etype235, _size232) = iprot.readListBegin()
12895 
          for _i236 in xrange(_size232):
12896 
            _elem237 = Order()
12897 
            _elem237.read(iprot)
12898 
            self.success.append(_elem237)
5386 phani.kuma 12899 
          iprot.readListEnd()
12900 
        else:
12901 
          iprot.skip(ftype)
12902 
      else:
12903 
        iprot.skip(ftype)
12904 
      iprot.readFieldEnd()
12905 
    iprot.readStructEnd()
12906 
 
12907 
  def write(self, oprot):
12908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12910 
      return
12911 
    oprot.writeStructBegin('getOrderListForVendor_result')
12912 
    if self.success is not None:
12913 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12914 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12915 
      for iter238 in self.success:
12916 
        iter238.write(oprot)
5386 phani.kuma 12917 
      oprot.writeListEnd()
12918 
      oprot.writeFieldEnd()
12919 
    oprot.writeFieldStop()
12920 
    oprot.writeStructEnd()
12921 
 
12922 
  def validate(self):
12923 
    return
12924 
 
12925 
 
12926 
  def __repr__(self):
12927 
    L = ['%s=%r' % (key, value)
12928 
      for key, value in self.__dict__.iteritems()]
12929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12930 
 
12931 
  def __eq__(self, other):
12932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12933 
 
12934 
  def __ne__(self, other):
12935 
    return not (self == other)
12936 
 
3064 chandransh 12937 
class getOrderForCustomer_args:
94 ashish 12938 
  """
12939 
  Attributes:
3064 chandransh 12940 
   - orderId
483 rajveer 12941 
   - customerId
94 ashish 12942 
  """
12943 
 
12944 
  thrift_spec = (
12945 
    None, # 0
3064 chandransh 12946 
    (1, TType.I64, 'orderId', None, None, ), # 1
12947 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 12948 
  )
12949 
 
3064 chandransh 12950 
  def __init__(self, orderId=None, customerId=None,):
12951 
    self.orderId = orderId
483 rajveer 12952 
    self.customerId = customerId
94 ashish 12953 
 
12954 
  def read(self, iprot):
12955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12957 
      return
12958 
    iprot.readStructBegin()
12959 
    while True:
12960 
      (fname, ftype, fid) = iprot.readFieldBegin()
12961 
      if ftype == TType.STOP:
12962 
        break
12963 
      if fid == 1:
12964 
        if ftype == TType.I64:
3064 chandransh 12965 
          self.orderId = iprot.readI64();
94 ashish 12966 
        else:
12967 
          iprot.skip(ftype)
12968 
      elif fid == 2:
12969 
        if ftype == TType.I64:
3064 chandransh 12970 
          self.customerId = iprot.readI64();
94 ashish 12971 
        else:
12972 
          iprot.skip(ftype)
12973 
      else:
12974 
        iprot.skip(ftype)
12975 
      iprot.readFieldEnd()
12976 
    iprot.readStructEnd()
12977 
 
12978 
  def write(self, oprot):
12979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12981 
      return
3064 chandransh 12982 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 12983 
    if self.orderId is not None:
3064 chandransh 12984 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12985 
      oprot.writeI64(self.orderId)
12986 
      oprot.writeFieldEnd()
3431 rajveer 12987 
    if self.customerId is not None:
3064 chandransh 12988 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 12989 
      oprot.writeI64(self.customerId)
94 ashish 12990 
      oprot.writeFieldEnd()
12991 
    oprot.writeFieldStop()
12992 
    oprot.writeStructEnd()
12993 
 
3431 rajveer 12994 
  def validate(self):
12995 
    return
12996 
 
12997 
 
94 ashish 12998 
  def __repr__(self):
12999 
    L = ['%s=%r' % (key, value)
13000 
      for key, value in self.__dict__.iteritems()]
13001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13002 
 
13003 
  def __eq__(self, other):
13004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13005 
 
13006 
  def __ne__(self, other):
13007 
    return not (self == other)
13008 
 
3064 chandransh 13009 
class getOrderForCustomer_result:
94 ashish 13010 
  """
13011 
  Attributes:
13012 
   - success
13013 
   - ex
13014 
  """
13015 
 
13016 
  thrift_spec = (
3064 chandransh 13017 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 13018 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13019 
  )
13020 
 
13021 
  def __init__(self, success=None, ex=None,):
13022 
    self.success = success
13023 
    self.ex = ex
13024 
 
13025 
  def read(self, iprot):
13026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13028 
      return
13029 
    iprot.readStructBegin()
13030 
    while True:
13031 
      (fname, ftype, fid) = iprot.readFieldBegin()
13032 
      if ftype == TType.STOP:
13033 
        break
13034 
      if fid == 0:
3064 chandransh 13035 
        if ftype == TType.STRUCT:
13036 
          self.success = Order()
13037 
          self.success.read(iprot)
94 ashish 13038 
        else:
13039 
          iprot.skip(ftype)
13040 
      elif fid == 1:
13041 
        if ftype == TType.STRUCT:
13042 
          self.ex = TransactionServiceException()
13043 
          self.ex.read(iprot)
13044 
        else:
13045 
          iprot.skip(ftype)
13046 
      else:
13047 
        iprot.skip(ftype)
13048 
      iprot.readFieldEnd()
13049 
    iprot.readStructEnd()
13050 
 
13051 
  def write(self, oprot):
13052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13054 
      return
3064 chandransh 13055 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 13056 
    if self.success is not None:
3064 chandransh 13057 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
13058 
      self.success.write(oprot)
94 ashish 13059 
      oprot.writeFieldEnd()
3431 rajveer 13060 
    if self.ex is not None:
94 ashish 13061 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13062 
      self.ex.write(oprot)
13063 
      oprot.writeFieldEnd()
13064 
    oprot.writeFieldStop()
13065 
    oprot.writeStructEnd()
13066 
 
3431 rajveer 13067 
  def validate(self):
13068 
    return
13069 
 
13070 
 
94 ashish 13071 
  def __repr__(self):
13072 
    L = ['%s=%r' % (key, value)
13073 
      for key, value in self.__dict__.iteritems()]
13074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13075 
 
13076 
  def __eq__(self, other):
13077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13078 
 
13079 
  def __ne__(self, other):
13080 
    return not (self == other)
13081 
 
3064 chandransh 13082 
class getAlerts_args:
94 ashish 13083 
  """
13084 
  Attributes:
4394 rajveer 13085 
   - type
4444 rajveer 13086 
   - warehouseId
4394 rajveer 13087 
   - status
13088 
   - timestamp
94 ashish 13089 
  """
13090 
 
13091 
  thrift_spec = (
13092 
    None, # 0
4394 rajveer 13093 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 13094 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13095 
    (3, TType.I64, 'status', None, None, ), # 3
13096 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 13097 
  )
13098 
 
4444 rajveer 13099 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 13100 
    self.type = type
4444 rajveer 13101 
    self.warehouseId = warehouseId
4394 rajveer 13102 
    self.status = status
13103 
    self.timestamp = timestamp
94 ashish 13104 
 
13105 
  def read(self, iprot):
13106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13108 
      return
13109 
    iprot.readStructBegin()
13110 
    while True:
13111 
      (fname, ftype, fid) = iprot.readFieldBegin()
13112 
      if ftype == TType.STOP:
13113 
        break
13114 
      if fid == 1:
3064 chandransh 13115 
        if ftype == TType.I64:
4394 rajveer 13116 
          self.type = iprot.readI64();
94 ashish 13117 
        else:
13118 
          iprot.skip(ftype)
3064 chandransh 13119 
      elif fid == 2:
4394 rajveer 13120 
        if ftype == TType.I64:
4444 rajveer 13121 
          self.warehouseId = iprot.readI64();
3064 chandransh 13122 
        else:
13123 
          iprot.skip(ftype)
4394 rajveer 13124 
      elif fid == 3:
13125 
        if ftype == TType.I64:
4444 rajveer 13126 
          self.status = iprot.readI64();
13127 
        else:
13128 
          iprot.skip(ftype)
13129 
      elif fid == 4:
13130 
        if ftype == TType.I64:
4394 rajveer 13131 
          self.timestamp = iprot.readI64();
13132 
        else:
13133 
          iprot.skip(ftype)
94 ashish 13134 
      else:
13135 
        iprot.skip(ftype)
13136 
      iprot.readFieldEnd()
13137 
    iprot.readStructEnd()
13138 
 
13139 
  def write(self, oprot):
13140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13142 
      return
3064 chandransh 13143 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 13144 
    if self.type is not None:
13145 
      oprot.writeFieldBegin('type', TType.I64, 1)
13146 
      oprot.writeI64(self.type)
94 ashish 13147 
      oprot.writeFieldEnd()
4444 rajveer 13148 
    if self.warehouseId is not None:
13149 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13150 
      oprot.writeI64(self.warehouseId)
13151 
      oprot.writeFieldEnd()
4394 rajveer 13152 
    if self.status is not None:
4444 rajveer 13153 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 13154 
      oprot.writeI64(self.status)
3064 chandransh 13155 
      oprot.writeFieldEnd()
4394 rajveer 13156 
    if self.timestamp is not None:
4444 rajveer 13157 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 13158 
      oprot.writeI64(self.timestamp)
13159 
      oprot.writeFieldEnd()
94 ashish 13160 
    oprot.writeFieldStop()
13161 
    oprot.writeStructEnd()
13162 
 
3431 rajveer 13163 
  def validate(self):
13164 
    return
13165 
 
13166 
 
94 ashish 13167 
  def __repr__(self):
13168 
    L = ['%s=%r' % (key, value)
13169 
      for key, value in self.__dict__.iteritems()]
13170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13171 
 
13172 
  def __eq__(self, other):
13173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13174 
 
13175 
  def __ne__(self, other):
13176 
    return not (self == other)
13177 
 
3064 chandransh 13178 
class getAlerts_result:
94 ashish 13179 
  """
13180 
  Attributes:
13181 
   - success
13182 
  """
13183 
 
13184 
  thrift_spec = (
3064 chandransh 13185 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 13186 
  )
13187 
 
3064 chandransh 13188 
  def __init__(self, success=None,):
94 ashish 13189 
    self.success = success
13190 
 
13191 
  def read(self, iprot):
13192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13194 
      return
13195 
    iprot.readStructBegin()
13196 
    while True:
13197 
      (fname, ftype, fid) = iprot.readFieldBegin()
13198 
      if ftype == TType.STOP:
13199 
        break
13200 
      if fid == 0:
3064 chandransh 13201 
        if ftype == TType.LIST:
13202 
          self.success = []
6188 rajveer 13203 
          (_etype242, _size239) = iprot.readListBegin()
13204 
          for _i243 in xrange(_size239):
13205 
            _elem244 = Alert()
13206 
            _elem244.read(iprot)
13207 
            self.success.append(_elem244)
3064 chandransh 13208 
          iprot.readListEnd()
94 ashish 13209 
        else:
13210 
          iprot.skip(ftype)
13211 
      else:
13212 
        iprot.skip(ftype)
13213 
      iprot.readFieldEnd()
13214 
    iprot.readStructEnd()
13215 
 
13216 
  def write(self, oprot):
13217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13219 
      return
3064 chandransh 13220 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 13221 
    if self.success is not None:
3064 chandransh 13222 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13223 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13224 
      for iter245 in self.success:
13225 
        iter245.write(oprot)
3064 chandransh 13226 
      oprot.writeListEnd()
94 ashish 13227 
      oprot.writeFieldEnd()
13228 
    oprot.writeFieldStop()
13229 
    oprot.writeStructEnd()
13230 
 
3431 rajveer 13231 
  def validate(self):
13232 
    return
13233 
 
13234 
 
94 ashish 13235 
  def __repr__(self):
13236 
    L = ['%s=%r' % (key, value)
13237 
      for key, value in self.__dict__.iteritems()]
13238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13239 
 
13240 
  def __eq__(self, other):
13241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13242 
 
13243 
  def __ne__(self, other):
13244 
    return not (self == other)
13245 
 
4394 rajveer 13246 
class addAlert_args:
94 ashish 13247 
  """
13248 
  Attributes:
3064 chandransh 13249 
   - type
4444 rajveer 13250 
   - warehouseId
4394 rajveer 13251 
   - description
94 ashish 13252 
  """
13253 
 
13254 
  thrift_spec = (
13255 
    None, # 0
4394 rajveer 13256 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 13257 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
13258 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 13259 
  )
13260 
 
4444 rajveer 13261 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 13262 
    self.type = type
4444 rajveer 13263 
    self.warehouseId = warehouseId
4394 rajveer 13264 
    self.description = description
94 ashish 13265 
 
13266 
  def read(self, iprot):
13267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13269 
      return
13270 
    iprot.readStructBegin()
13271 
    while True:
13272 
      (fname, ftype, fid) = iprot.readFieldBegin()
13273 
      if ftype == TType.STOP:
13274 
        break
13275 
      if fid == 1:
13276 
        if ftype == TType.I64:
4394 rajveer 13277 
          self.type = iprot.readI64();
94 ashish 13278 
        else:
13279 
          iprot.skip(ftype)
3064 chandransh 13280 
      elif fid == 2:
4444 rajveer 13281 
        if ftype == TType.I64:
13282 
          self.warehouseId = iprot.readI64();
13283 
        else:
13284 
          iprot.skip(ftype)
13285 
      elif fid == 3:
3064 chandransh 13286 
        if ftype == TType.STRING:
4394 rajveer 13287 
          self.description = iprot.readString();
3064 chandransh 13288 
        else:
13289 
          iprot.skip(ftype)
94 ashish 13290 
      else:
13291 
        iprot.skip(ftype)
13292 
      iprot.readFieldEnd()
13293 
    iprot.readStructEnd()
13294 
 
13295 
  def write(self, oprot):
13296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13298 
      return
4394 rajveer 13299 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 13300 
    if self.type is not None:
4394 rajveer 13301 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 13302 
      oprot.writeI64(self.type)
13303 
      oprot.writeFieldEnd()
4444 rajveer 13304 
    if self.warehouseId is not None:
13305 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
13306 
      oprot.writeI64(self.warehouseId)
13307 
      oprot.writeFieldEnd()
4394 rajveer 13308 
    if self.description is not None:
4444 rajveer 13309 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 13310 
      oprot.writeString(self.description)
3064 chandransh 13311 
      oprot.writeFieldEnd()
94 ashish 13312 
    oprot.writeFieldStop()
13313 
    oprot.writeStructEnd()
13314 
 
3431 rajveer 13315 
  def validate(self):
13316 
    return
13317 
 
13318 
 
94 ashish 13319 
  def __repr__(self):
13320 
    L = ['%s=%r' % (key, value)
13321 
      for key, value in self.__dict__.iteritems()]
13322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13323 
 
13324 
  def __eq__(self, other):
13325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13326 
 
13327 
  def __ne__(self, other):
13328 
    return not (self == other)
13329 
 
4394 rajveer 13330 
class addAlert_result:
3064 chandransh 13331 
 
13332 
  thrift_spec = (
13333 
  )
13334 
 
13335 
  def read(self, iprot):
13336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13338 
      return
13339 
    iprot.readStructBegin()
13340 
    while True:
13341 
      (fname, ftype, fid) = iprot.readFieldBegin()
13342 
      if ftype == TType.STOP:
13343 
        break
13344 
      else:
13345 
        iprot.skip(ftype)
13346 
      iprot.readFieldEnd()
13347 
    iprot.readStructEnd()
13348 
 
13349 
  def write(self, oprot):
13350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13352 
      return
4394 rajveer 13353 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 13354 
    oprot.writeFieldStop()
13355 
    oprot.writeStructEnd()
13356 
 
3431 rajveer 13357 
  def validate(self):
13358 
    return
13359 
 
13360 
 
3064 chandransh 13361 
  def __repr__(self):
13362 
    L = ['%s=%r' % (key, value)
13363 
      for key, value in self.__dict__.iteritems()]
13364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13365 
 
13366 
  def __eq__(self, other):
13367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13368 
 
13369 
  def __ne__(self, other):
13370 
    return not (self == other)
13371 
 
4444 rajveer 13372 
class markAlertsAsSeen_args:
13373 
  """
13374 
  Attributes:
13375 
   - warehouseId
13376 
  """
13377 
 
13378 
  thrift_spec = (
13379 
    None, # 0
13380 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13381 
  )
13382 
 
13383 
  def __init__(self, warehouseId=None,):
13384 
    self.warehouseId = warehouseId
13385 
 
13386 
  def read(self, iprot):
13387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13389 
      return
13390 
    iprot.readStructBegin()
13391 
    while True:
13392 
      (fname, ftype, fid) = iprot.readFieldBegin()
13393 
      if ftype == TType.STOP:
13394 
        break
13395 
      if fid == 1:
13396 
        if ftype == TType.I64:
13397 
          self.warehouseId = iprot.readI64();
13398 
        else:
13399 
          iprot.skip(ftype)
13400 
      else:
13401 
        iprot.skip(ftype)
13402 
      iprot.readFieldEnd()
13403 
    iprot.readStructEnd()
13404 
 
13405 
  def write(self, oprot):
13406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13408 
      return
13409 
    oprot.writeStructBegin('markAlertsAsSeen_args')
13410 
    if self.warehouseId is not None:
13411 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13412 
      oprot.writeI64(self.warehouseId)
13413 
      oprot.writeFieldEnd()
13414 
    oprot.writeFieldStop()
13415 
    oprot.writeStructEnd()
13416 
 
13417 
  def validate(self):
13418 
    return
13419 
 
13420 
 
13421 
  def __repr__(self):
13422 
    L = ['%s=%r' % (key, value)
13423 
      for key, value in self.__dict__.iteritems()]
13424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13425 
 
13426 
  def __eq__(self, other):
13427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13428 
 
13429 
  def __ne__(self, other):
13430 
    return not (self == other)
13431 
 
13432 
class markAlertsAsSeen_result:
13433 
 
13434 
  thrift_spec = (
13435 
  )
13436 
 
13437 
  def read(self, iprot):
13438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13440 
      return
13441 
    iprot.readStructBegin()
13442 
    while True:
13443 
      (fname, ftype, fid) = iprot.readFieldBegin()
13444 
      if ftype == TType.STOP:
13445 
        break
13446 
      else:
13447 
        iprot.skip(ftype)
13448 
      iprot.readFieldEnd()
13449 
    iprot.readStructEnd()
13450 
 
13451 
  def write(self, oprot):
13452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13454 
      return
13455 
    oprot.writeStructBegin('markAlertsAsSeen_result')
13456 
    oprot.writeFieldStop()
13457 
    oprot.writeStructEnd()
13458 
 
13459 
  def validate(self):
13460 
    return
13461 
 
13462 
 
13463 
  def __repr__(self):
13464 
    L = ['%s=%r' % (key, value)
13465 
      for key, value in self.__dict__.iteritems()]
13466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13467 
 
13468 
  def __eq__(self, other):
13469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13470 
 
13471 
  def __ne__(self, other):
13472 
    return not (self == other)
13473 
 
3064 chandransh 13474 
class getValidOrderCount_args:
13475 
 
13476 
  thrift_spec = (
13477 
  )
13478 
 
13479 
  def read(self, iprot):
13480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13482 
      return
13483 
    iprot.readStructBegin()
13484 
    while True:
13485 
      (fname, ftype, fid) = iprot.readFieldBegin()
13486 
      if ftype == TType.STOP:
13487 
        break
13488 
      else:
13489 
        iprot.skip(ftype)
13490 
      iprot.readFieldEnd()
13491 
    iprot.readStructEnd()
13492 
 
13493 
  def write(self, oprot):
13494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13496 
      return
13497 
    oprot.writeStructBegin('getValidOrderCount_args')
13498 
    oprot.writeFieldStop()
13499 
    oprot.writeStructEnd()
13500 
 
3431 rajveer 13501 
  def validate(self):
13502 
    return
13503 
 
13504 
 
3064 chandransh 13505 
  def __repr__(self):
13506 
    L = ['%s=%r' % (key, value)
13507 
      for key, value in self.__dict__.iteritems()]
13508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13509 
 
13510 
  def __eq__(self, other):
13511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13512 
 
13513 
  def __ne__(self, other):
13514 
    return not (self == other)
13515 
 
13516 
class getValidOrderCount_result:
94 ashish 13517 
  """
13518 
  Attributes:
13519 
   - success
13520 
  """
13521 
 
13522 
  thrift_spec = (
3064 chandransh 13523 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13524 
  )
13525 
 
3064 chandransh 13526 
  def __init__(self, success=None,):
94 ashish 13527 
    self.success = success
13528 
 
13529 
  def read(self, iprot):
13530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13532 
      return
13533 
    iprot.readStructBegin()
13534 
    while True:
13535 
      (fname, ftype, fid) = iprot.readFieldBegin()
13536 
      if ftype == TType.STOP:
13537 
        break
13538 
      if fid == 0:
3064 chandransh 13539 
        if ftype == TType.I64:
13540 
          self.success = iprot.readI64();
94 ashish 13541 
        else:
13542 
          iprot.skip(ftype)
13543 
      else:
13544 
        iprot.skip(ftype)
13545 
      iprot.readFieldEnd()
13546 
    iprot.readStructEnd()
13547 
 
13548 
  def write(self, oprot):
13549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13551 
      return
3064 chandransh 13552 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 13553 
    if self.success is not None:
3064 chandransh 13554 
      oprot.writeFieldBegin('success', TType.I64, 0)
13555 
      oprot.writeI64(self.success)
94 ashish 13556 
      oprot.writeFieldEnd()
13557 
    oprot.writeFieldStop()
13558 
    oprot.writeStructEnd()
13559 
 
3431 rajveer 13560 
  def validate(self):
13561 
    return
13562 
 
13563 
 
94 ashish 13564 
  def __repr__(self):
13565 
    L = ['%s=%r' % (key, value)
13566 
      for key, value in self.__dict__.iteritems()]
13567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13568 
 
13569 
  def __eq__(self, other):
13570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13571 
 
13572 
  def __ne__(self, other):
13573 
    return not (self == other)
13574 
 
3064 chandransh 13575 
class getNoOfCustomersWithSuccessfulTransaction_args:
13576 
 
13577 
  thrift_spec = (
13578 
  )
13579 
 
13580 
  def read(self, iprot):
13581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13583 
      return
13584 
    iprot.readStructBegin()
13585 
    while True:
13586 
      (fname, ftype, fid) = iprot.readFieldBegin()
13587 
      if ftype == TType.STOP:
13588 
        break
13589 
      else:
13590 
        iprot.skip(ftype)
13591 
      iprot.readFieldEnd()
13592 
    iprot.readStructEnd()
13593 
 
13594 
  def write(self, oprot):
13595 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13596 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13597 
      return
13598 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
13599 
    oprot.writeFieldStop()
13600 
    oprot.writeStructEnd()
13601 
 
3431 rajveer 13602 
  def validate(self):
13603 
    return
13604 
 
13605 
 
3064 chandransh 13606 
  def __repr__(self):
13607 
    L = ['%s=%r' % (key, value)
13608 
      for key, value in self.__dict__.iteritems()]
13609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13610 
 
13611 
  def __eq__(self, other):
13612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13613 
 
13614 
  def __ne__(self, other):
13615 
    return not (self == other)
13616 
 
13617 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 13618 
  """
13619 
  Attributes:
3064 chandransh 13620 
   - success
94 ashish 13621 
  """
13622 
 
13623 
  thrift_spec = (
3064 chandransh 13624 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13625 
  )
13626 
 
3064 chandransh 13627 
  def __init__(self, success=None,):
13628 
    self.success = success
94 ashish 13629 
 
13630 
  def read(self, iprot):
13631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13633 
      return
13634 
    iprot.readStructBegin()
13635 
    while True:
13636 
      (fname, ftype, fid) = iprot.readFieldBegin()
13637 
      if ftype == TType.STOP:
13638 
        break
3064 chandransh 13639 
      if fid == 0:
94 ashish 13640 
        if ftype == TType.I64:
3064 chandransh 13641 
          self.success = iprot.readI64();
94 ashish 13642 
        else:
13643 
          iprot.skip(ftype)
13644 
      else:
13645 
        iprot.skip(ftype)
13646 
      iprot.readFieldEnd()
13647 
    iprot.readStructEnd()
13648 
 
13649 
  def write(self, oprot):
13650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13652 
      return
3064 chandransh 13653 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 13654 
    if self.success is not None:
3064 chandransh 13655 
      oprot.writeFieldBegin('success', TType.I64, 0)
13656 
      oprot.writeI64(self.success)
94 ashish 13657 
      oprot.writeFieldEnd()
13658 
    oprot.writeFieldStop()
13659 
    oprot.writeStructEnd()
13660 
 
3431 rajveer 13661 
  def validate(self):
13662 
    return
13663 
 
13664 
 
94 ashish 13665 
  def __repr__(self):
13666 
    L = ['%s=%r' % (key, value)
13667 
      for key, value in self.__dict__.iteritems()]
13668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13669 
 
13670 
  def __eq__(self, other):
13671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13672 
 
13673 
  def __ne__(self, other):
13674 
    return not (self == other)
13675 
 
3064 chandransh 13676 
class getValidOrdersAmountRange_args:
13677 
 
13678 
  thrift_spec = (
13679 
  )
13680 
 
13681 
  def read(self, iprot):
13682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13684 
      return
13685 
    iprot.readStructBegin()
13686 
    while True:
13687 
      (fname, ftype, fid) = iprot.readFieldBegin()
13688 
      if ftype == TType.STOP:
13689 
        break
13690 
      else:
13691 
        iprot.skip(ftype)
13692 
      iprot.readFieldEnd()
13693 
    iprot.readStructEnd()
13694 
 
13695 
  def write(self, oprot):
13696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13698 
      return
13699 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
13700 
    oprot.writeFieldStop()
13701 
    oprot.writeStructEnd()
13702 
 
3431 rajveer 13703 
  def validate(self):
13704 
    return
13705 
 
13706 
 
3064 chandransh 13707 
  def __repr__(self):
13708 
    L = ['%s=%r' % (key, value)
13709 
      for key, value in self.__dict__.iteritems()]
13710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13711 
 
13712 
  def __eq__(self, other):
13713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13714 
 
13715 
  def __ne__(self, other):
13716 
    return not (self == other)
13717 
 
13718 
class getValidOrdersAmountRange_result:
94 ashish 13719 
  """
13720 
  Attributes:
13721 
   - success
13722 
  """
13723 
 
13724 
  thrift_spec = (
3064 chandransh 13725 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 13726 
  )
13727 
 
3064 chandransh 13728 
  def __init__(self, success=None,):
94 ashish 13729 
    self.success = success
13730 
 
13731 
  def read(self, iprot):
13732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13734 
      return
13735 
    iprot.readStructBegin()
13736 
    while True:
13737 
      (fname, ftype, fid) = iprot.readFieldBegin()
13738 
      if ftype == TType.STOP:
13739 
        break
13740 
      if fid == 0:
483 rajveer 13741 
        if ftype == TType.LIST:
13742 
          self.success = []
6188 rajveer 13743 
          (_etype249, _size246) = iprot.readListBegin()
13744 
          for _i250 in xrange(_size246):
13745 
            _elem251 = iprot.readDouble();
13746 
            self.success.append(_elem251)
483 rajveer 13747 
          iprot.readListEnd()
94 ashish 13748 
        else:
13749 
          iprot.skip(ftype)
13750 
      else:
13751 
        iprot.skip(ftype)
13752 
      iprot.readFieldEnd()
13753 
    iprot.readStructEnd()
13754 
 
13755 
  def write(self, oprot):
13756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13758 
      return
3064 chandransh 13759 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 13760 
    if self.success is not None:
483 rajveer 13761 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 13762 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 13763 
      for iter252 in self.success:
13764 
        oprot.writeDouble(iter252)
483 rajveer 13765 
      oprot.writeListEnd()
94 ashish 13766 
      oprot.writeFieldEnd()
13767 
    oprot.writeFieldStop()
13768 
    oprot.writeStructEnd()
13769 
 
3431 rajveer 13770 
  def validate(self):
13771 
    return
13772 
 
13773 
 
94 ashish 13774 
  def __repr__(self):
13775 
    L = ['%s=%r' % (key, value)
13776 
      for key, value in self.__dict__.iteritems()]
13777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13778 
 
13779 
  def __eq__(self, other):
13780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13781 
 
13782 
  def __ne__(self, other):
13783 
    return not (self == other)
13784 
 
3064 chandransh 13785 
class getValidOrders_args:
1528 ankur.sing 13786 
  """
13787 
  Attributes:
3064 chandransh 13788 
   - limit
5874 rajveer 13789 
   - onlyStore
1528 ankur.sing 13790 
  """
13791 
 
13792 
  thrift_spec = (
13793 
    None, # 0
3064 chandransh 13794 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 13795 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 13796 
  )
13797 
 
5874 rajveer 13798 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 13799 
    self.limit = limit
5874 rajveer 13800 
    self.onlyStore = onlyStore
1528 ankur.sing 13801 
 
13802 
  def read(self, iprot):
13803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13805 
      return
13806 
    iprot.readStructBegin()
13807 
    while True:
13808 
      (fname, ftype, fid) = iprot.readFieldBegin()
13809 
      if ftype == TType.STOP:
13810 
        break
13811 
      if fid == 1:
13812 
        if ftype == TType.I64:
3064 chandransh 13813 
          self.limit = iprot.readI64();
1528 ankur.sing 13814 
        else:
13815 
          iprot.skip(ftype)
5874 rajveer 13816 
      elif fid == 2:
13817 
        if ftype == TType.BOOL:
13818 
          self.onlyStore = iprot.readBool();
13819 
        else:
13820 
          iprot.skip(ftype)
1528 ankur.sing 13821 
      else:
13822 
        iprot.skip(ftype)
13823 
      iprot.readFieldEnd()
13824 
    iprot.readStructEnd()
13825 
 
13826 
  def write(self, oprot):
13827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13829 
      return
3064 chandransh 13830 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 13831 
    if self.limit is not None:
3064 chandransh 13832 
      oprot.writeFieldBegin('limit', TType.I64, 1)
13833 
      oprot.writeI64(self.limit)
1528 ankur.sing 13834 
      oprot.writeFieldEnd()
5874 rajveer 13835 
    if self.onlyStore is not None:
13836 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
13837 
      oprot.writeBool(self.onlyStore)
13838 
      oprot.writeFieldEnd()
1528 ankur.sing 13839 
    oprot.writeFieldStop()
13840 
    oprot.writeStructEnd()
13841 
 
3431 rajveer 13842 
  def validate(self):
13843 
    return
13844 
 
13845 
 
1528 ankur.sing 13846 
  def __repr__(self):
13847 
    L = ['%s=%r' % (key, value)
13848 
      for key, value in self.__dict__.iteritems()]
13849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13850 
 
13851 
  def __eq__(self, other):
13852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13853 
 
13854 
  def __ne__(self, other):
13855 
    return not (self == other)
13856 
 
3064 chandransh 13857 
class getValidOrders_result:
1528 ankur.sing 13858 
  """
13859 
  Attributes:
13860 
   - success
13861 
  """
13862 
 
13863 
  thrift_spec = (
3064 chandransh 13864 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 13865 
  )
13866 
 
3064 chandransh 13867 
  def __init__(self, success=None,):
1528 ankur.sing 13868 
    self.success = success
13869 
 
13870 
  def read(self, iprot):
13871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13873 
      return
13874 
    iprot.readStructBegin()
13875 
    while True:
13876 
      (fname, ftype, fid) = iprot.readFieldBegin()
13877 
      if ftype == TType.STOP:
13878 
        break
13879 
      if fid == 0:
3064 chandransh 13880 
        if ftype == TType.LIST:
13881 
          self.success = []
6188 rajveer 13882 
          (_etype256, _size253) = iprot.readListBegin()
13883 
          for _i257 in xrange(_size253):
13884 
            _elem258 = Order()
13885 
            _elem258.read(iprot)
13886 
            self.success.append(_elem258)
3064 chandransh 13887 
          iprot.readListEnd()
1528 ankur.sing 13888 
        else:
13889 
          iprot.skip(ftype)
13890 
      else:
13891 
        iprot.skip(ftype)
13892 
      iprot.readFieldEnd()
13893 
    iprot.readStructEnd()
13894 
 
13895 
  def write(self, oprot):
13896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13898 
      return
3064 chandransh 13899 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 13900 
    if self.success is not None:
3064 chandransh 13901 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13902 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13903 
      for iter259 in self.success:
13904 
        iter259.write(oprot)
3064 chandransh 13905 
      oprot.writeListEnd()
1528 ankur.sing 13906 
      oprot.writeFieldEnd()
13907 
    oprot.writeFieldStop()
13908 
    oprot.writeStructEnd()
13909 
 
3431 rajveer 13910 
  def validate(self):
13911 
    return
13912 
 
13913 
 
1528 ankur.sing 13914 
  def __repr__(self):
13915 
    L = ['%s=%r' % (key, value)
13916 
      for key, value in self.__dict__.iteritems()]
13917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13918 
 
13919 
  def __eq__(self, other):
13920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13921 
 
13922 
  def __ne__(self, other):
13923 
    return not (self == other)
13924 
 
1220 chandransh 13925 
class batchOrders_args:
13926 
  """
13927 
  Attributes:
13928 
   - warehouseId
13929 
  """
13930 
 
13931 
  thrift_spec = (
13932 
    None, # 0
13933 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13934 
  )
13935 
 
13936 
  def __init__(self, warehouseId=None,):
13937 
    self.warehouseId = warehouseId
13938 
 
13939 
  def read(self, iprot):
13940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13942 
      return
13943 
    iprot.readStructBegin()
13944 
    while True:
13945 
      (fname, ftype, fid) = iprot.readFieldBegin()
13946 
      if ftype == TType.STOP:
13947 
        break
13948 
      if fid == 1:
13949 
        if ftype == TType.I64:
13950 
          self.warehouseId = iprot.readI64();
13951 
        else:
13952 
          iprot.skip(ftype)
13953 
      else:
13954 
        iprot.skip(ftype)
13955 
      iprot.readFieldEnd()
13956 
    iprot.readStructEnd()
13957 
 
13958 
  def write(self, oprot):
13959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13961 
      return
13962 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 13963 
    if self.warehouseId is not None:
1220 chandransh 13964 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13965 
      oprot.writeI64(self.warehouseId)
13966 
      oprot.writeFieldEnd()
13967 
    oprot.writeFieldStop()
13968 
    oprot.writeStructEnd()
13969 
 
3431 rajveer 13970 
  def validate(self):
13971 
    return
13972 
 
13973 
 
1220 chandransh 13974 
  def __repr__(self):
13975 
    L = ['%s=%r' % (key, value)
13976 
      for key, value in self.__dict__.iteritems()]
13977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13978 
 
13979 
  def __eq__(self, other):
13980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13981 
 
13982 
  def __ne__(self, other):
13983 
    return not (self == other)
13984 
 
13985 
class batchOrders_result:
13986 
  """
13987 
  Attributes:
13988 
   - success
13989 
   - ex
13990 
  """
13991 
 
13992 
  thrift_spec = (
13993 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13994 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13995 
  )
13996 
 
13997 
  def __init__(self, success=None, ex=None,):
13998 
    self.success = success
13999 
    self.ex = ex
14000 
 
14001 
  def read(self, iprot):
14002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14004 
      return
14005 
    iprot.readStructBegin()
14006 
    while True:
14007 
      (fname, ftype, fid) = iprot.readFieldBegin()
14008 
      if ftype == TType.STOP:
14009 
        break
14010 
      if fid == 0:
14011 
        if ftype == TType.LIST:
14012 
          self.success = []
6188 rajveer 14013 
          (_etype263, _size260) = iprot.readListBegin()
14014 
          for _i264 in xrange(_size260):
14015 
            _elem265 = Order()
14016 
            _elem265.read(iprot)
14017 
            self.success.append(_elem265)
1220 chandransh 14018 
          iprot.readListEnd()
14019 
        else:
14020 
          iprot.skip(ftype)
14021 
      elif fid == 1:
14022 
        if ftype == TType.STRUCT:
14023 
          self.ex = TransactionServiceException()
14024 
          self.ex.read(iprot)
14025 
        else:
14026 
          iprot.skip(ftype)
14027 
      else:
14028 
        iprot.skip(ftype)
14029 
      iprot.readFieldEnd()
14030 
    iprot.readStructEnd()
14031 
 
14032 
  def write(self, oprot):
14033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14035 
      return
14036 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 14037 
    if self.success is not None:
1220 chandransh 14038 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14039 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14040 
      for iter266 in self.success:
14041 
        iter266.write(oprot)
1220 chandransh 14042 
      oprot.writeListEnd()
14043 
      oprot.writeFieldEnd()
3431 rajveer 14044 
    if self.ex is not None:
1220 chandransh 14045 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14046 
      self.ex.write(oprot)
14047 
      oprot.writeFieldEnd()
14048 
    oprot.writeFieldStop()
14049 
    oprot.writeStructEnd()
14050 
 
3431 rajveer 14051 
  def validate(self):
14052 
    return
14053 
 
14054 
 
1220 chandransh 14055 
  def __repr__(self):
14056 
    L = ['%s=%r' % (key, value)
14057 
      for key, value in self.__dict__.iteritems()]
14058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14059 
 
14060 
  def __eq__(self, other):
14061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14062 
 
14063 
  def __ne__(self, other):
14064 
    return not (self == other)
14065 
 
1208 chandransh 14066 
class markOrderAsOutOfStock_args:
14067 
  """
14068 
  Attributes:
14069 
   - orderId
14070 
  """
14071 
 
14072 
  thrift_spec = (
14073 
    None, # 0
14074 
    (1, TType.I64, 'orderId', None, None, ), # 1
14075 
  )
14076 
 
14077 
  def __init__(self, orderId=None,):
14078 
    self.orderId = orderId
14079 
 
14080 
  def read(self, iprot):
14081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14083 
      return
14084 
    iprot.readStructBegin()
14085 
    while True:
14086 
      (fname, ftype, fid) = iprot.readFieldBegin()
14087 
      if ftype == TType.STOP:
14088 
        break
14089 
      if fid == 1:
14090 
        if ftype == TType.I64:
14091 
          self.orderId = iprot.readI64();
14092 
        else:
14093 
          iprot.skip(ftype)
14094 
      else:
14095 
        iprot.skip(ftype)
14096 
      iprot.readFieldEnd()
14097 
    iprot.readStructEnd()
14098 
 
14099 
  def write(self, oprot):
14100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14102 
      return
14103 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 14104 
    if self.orderId is not None:
1208 chandransh 14105 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14106 
      oprot.writeI64(self.orderId)
14107 
      oprot.writeFieldEnd()
14108 
    oprot.writeFieldStop()
14109 
    oprot.writeStructEnd()
14110 
 
3431 rajveer 14111 
  def validate(self):
14112 
    return
14113 
 
14114 
 
1208 chandransh 14115 
  def __repr__(self):
14116 
    L = ['%s=%r' % (key, value)
14117 
      for key, value in self.__dict__.iteritems()]
14118 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14119 
 
14120 
  def __eq__(self, other):
14121 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14122 
 
14123 
  def __ne__(self, other):
14124 
    return not (self == other)
14125 
 
14126 
class markOrderAsOutOfStock_result:
14127 
  """
14128 
  Attributes:
14129 
   - success
14130 
   - ex
14131 
  """
14132 
 
14133 
  thrift_spec = (
14134 
    (0, TType.BOOL, 'success', None, None, ), # 0
14135 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14136 
  )
14137 
 
14138 
  def __init__(self, success=None, ex=None,):
14139 
    self.success = success
14140 
    self.ex = ex
14141 
 
14142 
  def read(self, iprot):
14143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14145 
      return
14146 
    iprot.readStructBegin()
14147 
    while True:
14148 
      (fname, ftype, fid) = iprot.readFieldBegin()
14149 
      if ftype == TType.STOP:
14150 
        break
14151 
      if fid == 0:
14152 
        if ftype == TType.BOOL:
14153 
          self.success = iprot.readBool();
14154 
        else:
14155 
          iprot.skip(ftype)
14156 
      elif fid == 1:
14157 
        if ftype == TType.STRUCT:
14158 
          self.ex = TransactionServiceException()
14159 
          self.ex.read(iprot)
14160 
        else:
14161 
          iprot.skip(ftype)
14162 
      else:
14163 
        iprot.skip(ftype)
14164 
      iprot.readFieldEnd()
14165 
    iprot.readStructEnd()
14166 
 
14167 
  def write(self, oprot):
14168 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14169 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14170 
      return
14171 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 14172 
    if self.success is not None:
1208 chandransh 14173 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14174 
      oprot.writeBool(self.success)
14175 
      oprot.writeFieldEnd()
3431 rajveer 14176 
    if self.ex is not None:
1208 chandransh 14177 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14178 
      self.ex.write(oprot)
14179 
      oprot.writeFieldEnd()
14180 
    oprot.writeFieldStop()
14181 
    oprot.writeStructEnd()
14182 
 
3431 rajveer 14183 
  def validate(self):
14184 
    return
14185 
 
14186 
 
1208 chandransh 14187 
  def __repr__(self):
14188 
    L = ['%s=%r' % (key, value)
14189 
      for key, value in self.__dict__.iteritems()]
14190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14191 
 
14192 
  def __eq__(self, other):
14193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14194 
 
14195 
  def __ne__(self, other):
14196 
    return not (self == other)
14197 
 
3064 chandransh 14198 
class verifyOrder_args:
759 chandransh 14199 
  """
14200 
  Attributes:
3064 chandransh 14201 
   - orderId
759 chandransh 14202 
  """
14203 
 
14204 
  thrift_spec = (
14205 
    None, # 0
3064 chandransh 14206 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 14207 
  )
14208 
 
3064 chandransh 14209 
  def __init__(self, orderId=None,):
14210 
    self.orderId = orderId
759 chandransh 14211 
 
14212 
  def read(self, iprot):
14213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14215 
      return
14216 
    iprot.readStructBegin()
14217 
    while True:
14218 
      (fname, ftype, fid) = iprot.readFieldBegin()
14219 
      if ftype == TType.STOP:
14220 
        break
14221 
      if fid == 1:
14222 
        if ftype == TType.I64:
3064 chandransh 14223 
          self.orderId = iprot.readI64();
759 chandransh 14224 
        else:
14225 
          iprot.skip(ftype)
14226 
      else:
14227 
        iprot.skip(ftype)
14228 
      iprot.readFieldEnd()
14229 
    iprot.readStructEnd()
14230 
 
14231 
  def write(self, oprot):
14232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14234 
      return
3064 chandransh 14235 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 14236 
    if self.orderId is not None:
3064 chandransh 14237 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14238 
      oprot.writeI64(self.orderId)
759 chandransh 14239 
      oprot.writeFieldEnd()
14240 
    oprot.writeFieldStop()
14241 
    oprot.writeStructEnd()
14242 
 
3431 rajveer 14243 
  def validate(self):
14244 
    return
14245 
 
14246 
 
759 chandransh 14247 
  def __repr__(self):
14248 
    L = ['%s=%r' % (key, value)
14249 
      for key, value in self.__dict__.iteritems()]
14250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14251 
 
14252 
  def __eq__(self, other):
14253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14254 
 
14255 
  def __ne__(self, other):
14256 
    return not (self == other)
14257 
 
3064 chandransh 14258 
class verifyOrder_result:
759 chandransh 14259 
  """
14260 
  Attributes:
14261 
   - success
14262 
   - ex
14263 
  """
14264 
 
14265 
  thrift_spec = (
14266 
    (0, TType.BOOL, 'success', None, None, ), # 0
14267 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14268 
  )
14269 
 
14270 
  def __init__(self, success=None, ex=None,):
14271 
    self.success = success
14272 
    self.ex = ex
14273 
 
14274 
  def read(self, iprot):
14275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14277 
      return
14278 
    iprot.readStructBegin()
14279 
    while True:
14280 
      (fname, ftype, fid) = iprot.readFieldBegin()
14281 
      if ftype == TType.STOP:
14282 
        break
14283 
      if fid == 0:
14284 
        if ftype == TType.BOOL:
14285 
          self.success = iprot.readBool();
14286 
        else:
14287 
          iprot.skip(ftype)
14288 
      elif fid == 1:
14289 
        if ftype == TType.STRUCT:
14290 
          self.ex = TransactionServiceException()
14291 
          self.ex.read(iprot)
14292 
        else:
14293 
          iprot.skip(ftype)
14294 
      else:
14295 
        iprot.skip(ftype)
14296 
      iprot.readFieldEnd()
14297 
    iprot.readStructEnd()
14298 
 
14299 
  def write(self, oprot):
14300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14302 
      return
3064 chandransh 14303 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 14304 
    if self.success is not None:
759 chandransh 14305 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14306 
      oprot.writeBool(self.success)
14307 
      oprot.writeFieldEnd()
3431 rajveer 14308 
    if self.ex is not None:
759 chandransh 14309 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14310 
      self.ex.write(oprot)
14311 
      oprot.writeFieldEnd()
14312 
    oprot.writeFieldStop()
14313 
    oprot.writeStructEnd()
14314 
 
3431 rajveer 14315 
  def validate(self):
14316 
    return
14317 
 
14318 
 
759 chandransh 14319 
  def __repr__(self):
14320 
    L = ['%s=%r' % (key, value)
14321 
      for key, value in self.__dict__.iteritems()]
14322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14323 
 
14324 
  def __eq__(self, other):
14325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14326 
 
14327 
  def __ne__(self, other):
14328 
    return not (self == other)
14329 
 
3064 chandransh 14330 
class acceptOrder_args:
1113 chandransh 14331 
  """
14332 
  Attributes:
3064 chandransh 14333 
   - orderId
1113 chandransh 14334 
  """
14335 
 
14336 
  thrift_spec = (
14337 
    None, # 0
3064 chandransh 14338 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 14339 
  )
14340 
 
3064 chandransh 14341 
  def __init__(self, orderId=None,):
14342 
    self.orderId = orderId
1113 chandransh 14343 
 
14344 
  def read(self, iprot):
14345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14347 
      return
14348 
    iprot.readStructBegin()
14349 
    while True:
14350 
      (fname, ftype, fid) = iprot.readFieldBegin()
14351 
      if ftype == TType.STOP:
14352 
        break
14353 
      if fid == 1:
14354 
        if ftype == TType.I64:
3064 chandransh 14355 
          self.orderId = iprot.readI64();
1113 chandransh 14356 
        else:
14357 
          iprot.skip(ftype)
14358 
      else:
14359 
        iprot.skip(ftype)
14360 
      iprot.readFieldEnd()
14361 
    iprot.readStructEnd()
14362 
 
14363 
  def write(self, oprot):
14364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14366 
      return
3064 chandransh 14367 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 14368 
    if self.orderId is not None:
3064 chandransh 14369 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14370 
      oprot.writeI64(self.orderId)
1113 chandransh 14371 
      oprot.writeFieldEnd()
14372 
    oprot.writeFieldStop()
14373 
    oprot.writeStructEnd()
14374 
 
3431 rajveer 14375 
  def validate(self):
14376 
    return
14377 
 
14378 
 
1113 chandransh 14379 
  def __repr__(self):
14380 
    L = ['%s=%r' % (key, value)
14381 
      for key, value in self.__dict__.iteritems()]
14382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14383 
 
14384 
  def __eq__(self, other):
14385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14386 
 
14387 
  def __ne__(self, other):
14388 
    return not (self == other)
14389 
 
3064 chandransh 14390 
class acceptOrder_result:
1113 chandransh 14391 
  """
14392 
  Attributes:
14393 
   - success
14394 
   - ex
14395 
  """
14396 
 
14397 
  thrift_spec = (
3064 chandransh 14398 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 14399 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14400 
  )
14401 
 
14402 
  def __init__(self, success=None, ex=None,):
14403 
    self.success = success
14404 
    self.ex = ex
14405 
 
14406 
  def read(self, iprot):
14407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14409 
      return
14410 
    iprot.readStructBegin()
14411 
    while True:
14412 
      (fname, ftype, fid) = iprot.readFieldBegin()
14413 
      if ftype == TType.STOP:
14414 
        break
14415 
      if fid == 0:
3064 chandransh 14416 
        if ftype == TType.BOOL:
14417 
          self.success = iprot.readBool();
1113 chandransh 14418 
        else:
14419 
          iprot.skip(ftype)
14420 
      elif fid == 1:
14421 
        if ftype == TType.STRUCT:
14422 
          self.ex = TransactionServiceException()
14423 
          self.ex.read(iprot)
14424 
        else:
14425 
          iprot.skip(ftype)
14426 
      else:
14427 
        iprot.skip(ftype)
14428 
      iprot.readFieldEnd()
14429 
    iprot.readStructEnd()
14430 
 
14431 
  def write(self, oprot):
14432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14434 
      return
3064 chandransh 14435 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 14436 
    if self.success is not None:
3064 chandransh 14437 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14438 
      oprot.writeBool(self.success)
1113 chandransh 14439 
      oprot.writeFieldEnd()
3431 rajveer 14440 
    if self.ex is not None:
1113 chandransh 14441 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14442 
      self.ex.write(oprot)
14443 
      oprot.writeFieldEnd()
14444 
    oprot.writeFieldStop()
14445 
    oprot.writeStructEnd()
14446 
 
3431 rajveer 14447 
  def validate(self):
14448 
    return
14449 
 
14450 
 
1113 chandransh 14451 
  def __repr__(self):
14452 
    L = ['%s=%r' % (key, value)
14453 
      for key, value in self.__dict__.iteritems()]
14454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14455 
 
14456 
  def __eq__(self, other):
14457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14458 
 
14459 
  def __ne__(self, other):
14460 
    return not (self == other)
14461 
 
3064 chandransh 14462 
class addBillingDetails_args:
1135 chandransh 14463 
  """
14464 
  Attributes:
3064 chandransh 14465 
   - orderId
14466 
   - invoice_number
4658 mandeep.dh 14467 
   - serialNumber
4283 anupam.sin 14468 
   - itemNumber
7190 amar.kumar 14469 
   - freebieWarehouseId
3064 chandransh 14470 
   - billed_by
4264 rajveer 14471 
   - jacketNumber
4283 anupam.sin 14472 
   - billingType
5110 mandeep.dh 14473 
   - fulfilmentWarehouseId
4763 rajveer 14474 
   - authorize
1135 chandransh 14475 
  """
14476 
 
14477 
  thrift_spec = (
14478 
    None, # 0
3064 chandransh 14479 
    (1, TType.I64, 'orderId', None, None, ), # 1
14480 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 14481 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
14482 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
7190 amar.kumar 14483 
    (5, TType.I64, 'freebieWarehouseId', None, None, ), # 5
14484 
    (6, TType.STRING, 'billed_by', None, None, ), # 6
14485 
    (7, TType.I64, 'jacketNumber', None, None, ), # 7
14486 
    (8, TType.I64, 'billingType', None, None, ), # 8
14487 
    (9, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 9
14488 
    (10, TType.BOOL, 'authorize', None, None, ), # 10
1135 chandransh 14489 
  )
14490 
 
7190 amar.kumar 14491 
  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 14492 
    self.orderId = orderId
14493 
    self.invoice_number = invoice_number
4658 mandeep.dh 14494 
    self.serialNumber = serialNumber
4283 anupam.sin 14495 
    self.itemNumber = itemNumber
7190 amar.kumar 14496 
    self.freebieWarehouseId = freebieWarehouseId
3064 chandransh 14497 
    self.billed_by = billed_by
4264 rajveer 14498 
    self.jacketNumber = jacketNumber
4283 anupam.sin 14499 
    self.billingType = billingType
5110 mandeep.dh 14500 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 14501 
    self.authorize = authorize
1135 chandransh 14502 
 
14503 
  def read(self, iprot):
14504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14506 
      return
14507 
    iprot.readStructBegin()
14508 
    while True:
14509 
      (fname, ftype, fid) = iprot.readFieldBegin()
14510 
      if ftype == TType.STOP:
14511 
        break
14512 
      if fid == 1:
14513 
        if ftype == TType.I64:
3064 chandransh 14514 
          self.orderId = iprot.readI64();
1135 chandransh 14515 
        else:
14516 
          iprot.skip(ftype)
14517 
      elif fid == 2:
3064 chandransh 14518 
        if ftype == TType.STRING:
14519 
          self.invoice_number = iprot.readString();
1135 chandransh 14520 
        else:
14521 
          iprot.skip(ftype)
3064 chandransh 14522 
      elif fid == 3:
5411 rajveer 14523 
        if ftype == TType.LIST:
14524 
          self.serialNumber = []
6188 rajveer 14525 
          (_etype270, _size267) = iprot.readListBegin()
14526 
          for _i271 in xrange(_size267):
14527 
            _elem272 = iprot.readString();
14528 
            self.serialNumber.append(_elem272)
5411 rajveer 14529 
          iprot.readListEnd()
3064 chandransh 14530 
        else:
14531 
          iprot.skip(ftype)
14532 
      elif fid == 4:
5411 rajveer 14533 
        if ftype == TType.LIST:
14534 
          self.itemNumber = []
6188 rajveer 14535 
          (_etype276, _size273) = iprot.readListBegin()
14536 
          for _i277 in xrange(_size273):
14537 
            _elem278 = iprot.readString();
14538 
            self.itemNumber.append(_elem278)
5411 rajveer 14539 
          iprot.readListEnd()
3064 chandransh 14540 
        else:
14541 
          iprot.skip(ftype)
14542 
      elif fid == 5:
7190 amar.kumar 14543 
        if ftype == TType.I64:
14544 
          self.freebieWarehouseId = iprot.readI64();
14545 
        else:
14546 
          iprot.skip(ftype)
14547 
      elif fid == 6:
3064 chandransh 14548 
        if ftype == TType.STRING:
4283 anupam.sin 14549 
          self.billed_by = iprot.readString();
3064 chandransh 14550 
        else:
14551 
          iprot.skip(ftype)
7190 amar.kumar 14552 
      elif fid == 7:
3064 chandransh 14553 
        if ftype == TType.I64:
4283 anupam.sin 14554 
          self.jacketNumber = iprot.readI64();
14555 
        else:
14556 
          iprot.skip(ftype)
7190 amar.kumar 14557 
      elif fid == 8:
4283 anupam.sin 14558 
        if ftype == TType.I64:
3064 chandransh 14559 
          self.billingType = iprot.readI64();
14560 
        else:
14561 
          iprot.skip(ftype)
7190 amar.kumar 14562 
      elif fid == 9:
4283 anupam.sin 14563 
        if ftype == TType.I64:
5110 mandeep.dh 14564 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 14565 
        else:
14566 
          iprot.skip(ftype)
7190 amar.kumar 14567 
      elif fid == 10:
4763 rajveer 14568 
        if ftype == TType.BOOL:
14569 
          self.authorize = iprot.readBool();
14570 
        else:
14571 
          iprot.skip(ftype)
1246 chandransh 14572 
      else:
14573 
        iprot.skip(ftype)
14574 
      iprot.readFieldEnd()
14575 
    iprot.readStructEnd()
14576 
 
14577 
  def write(self, oprot):
14578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14580 
      return
4283 anupam.sin 14581 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 14582 
    if self.orderId is not None:
3064 chandransh 14583 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14584 
      oprot.writeI64(self.orderId)
1246 chandransh 14585 
      oprot.writeFieldEnd()
4283 anupam.sin 14586 
    if self.invoice_number is not None:
14587 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
14588 
      oprot.writeString(self.invoice_number)
1246 chandransh 14589 
      oprot.writeFieldEnd()
4658 mandeep.dh 14590 
    if self.serialNumber is not None:
5411 rajveer 14591 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
14592 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 14593 
      for iter279 in self.serialNumber:
14594 
        oprot.writeString(iter279)
5411 rajveer 14595 
      oprot.writeListEnd()
3064 chandransh 14596 
      oprot.writeFieldEnd()
3431 rajveer 14597 
    if self.itemNumber is not None:
5411 rajveer 14598 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
14599 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 14600 
      for iter280 in self.itemNumber:
14601 
        oprot.writeString(iter280)
5411 rajveer 14602 
      oprot.writeListEnd()
3064 chandransh 14603 
      oprot.writeFieldEnd()
7190 amar.kumar 14604 
    if self.freebieWarehouseId is not None:
14605 
      oprot.writeFieldBegin('freebieWarehouseId', TType.I64, 5)
14606 
      oprot.writeI64(self.freebieWarehouseId)
14607 
      oprot.writeFieldEnd()
4283 anupam.sin 14608 
    if self.billed_by is not None:
7190 amar.kumar 14609 
      oprot.writeFieldBegin('billed_by', TType.STRING, 6)
4283 anupam.sin 14610 
      oprot.writeString(self.billed_by)
3064 chandransh 14611 
      oprot.writeFieldEnd()
4283 anupam.sin 14612 
    if self.jacketNumber is not None:
7190 amar.kumar 14613 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 7)
4283 anupam.sin 14614 
      oprot.writeI64(self.jacketNumber)
14615 
      oprot.writeFieldEnd()
3431 rajveer 14616 
    if self.billingType is not None:
7190 amar.kumar 14617 
      oprot.writeFieldBegin('billingType', TType.I64, 8)
3064 chandransh 14618 
      oprot.writeI64(self.billingType)
14619 
      oprot.writeFieldEnd()
5110 mandeep.dh 14620 
    if self.fulfilmentWarehouseId is not None:
7190 amar.kumar 14621 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 9)
5110 mandeep.dh 14622 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 14623 
      oprot.writeFieldEnd()
4763 rajveer 14624 
    if self.authorize is not None:
7190 amar.kumar 14625 
      oprot.writeFieldBegin('authorize', TType.BOOL, 10)
4763 rajveer 14626 
      oprot.writeBool(self.authorize)
14627 
      oprot.writeFieldEnd()
1246 chandransh 14628 
    oprot.writeFieldStop()
14629 
    oprot.writeStructEnd()
14630 
 
3431 rajveer 14631 
  def validate(self):
14632 
    return
14633 
 
14634 
 
1246 chandransh 14635 
  def __repr__(self):
14636 
    L = ['%s=%r' % (key, value)
14637 
      for key, value in self.__dict__.iteritems()]
14638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14639 
 
14640 
  def __eq__(self, other):
14641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14642 
 
14643 
  def __ne__(self, other):
14644 
    return not (self == other)
14645 
 
4283 anupam.sin 14646 
class addBillingDetails_result:
1246 chandransh 14647 
  """
14648 
  Attributes:
3064 chandransh 14649 
   - success
1246 chandransh 14650 
   - ex
14651 
  """
14652 
 
14653 
  thrift_spec = (
3064 chandransh 14654 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 14655 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14656 
  )
14657 
 
3064 chandransh 14658 
  def __init__(self, success=None, ex=None,):
14659 
    self.success = success
1246 chandransh 14660 
    self.ex = ex
14661 
 
14662 
  def read(self, iprot):
14663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14665 
      return
14666 
    iprot.readStructBegin()
14667 
    while True:
14668 
      (fname, ftype, fid) = iprot.readFieldBegin()
14669 
      if ftype == TType.STOP:
14670 
        break
3064 chandransh 14671 
      if fid == 0:
14672 
        if ftype == TType.BOOL:
14673 
          self.success = iprot.readBool();
14674 
        else:
14675 
          iprot.skip(ftype)
14676 
      elif fid == 1:
1246 chandransh 14677 
        if ftype == TType.STRUCT:
14678 
          self.ex = TransactionServiceException()
14679 
          self.ex.read(iprot)
14680 
        else:
14681 
          iprot.skip(ftype)
14682 
      else:
14683 
        iprot.skip(ftype)
14684 
      iprot.readFieldEnd()
14685 
    iprot.readStructEnd()
14686 
 
14687 
  def write(self, oprot):
14688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14690 
      return
4283 anupam.sin 14691 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 14692 
    if self.success is not None:
3064 chandransh 14693 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14694 
      oprot.writeBool(self.success)
14695 
      oprot.writeFieldEnd()
3431 rajveer 14696 
    if self.ex is not None:
1246 chandransh 14697 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14698 
      self.ex.write(oprot)
14699 
      oprot.writeFieldEnd()
14700 
    oprot.writeFieldStop()
14701 
    oprot.writeStructEnd()
14702 
 
3431 rajveer 14703 
  def validate(self):
14704 
    return
14705 
 
14706 
 
1246 chandransh 14707 
  def __repr__(self):
14708 
    L = ['%s=%r' % (key, value)
14709 
      for key, value in self.__dict__.iteritems()]
14710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14711 
 
14712 
  def __eq__(self, other):
14713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14714 
 
14715 
  def __ne__(self, other):
14716 
    return not (self == other)
14717 
 
4579 rajveer 14718 
class addInvoiceNumber_args:
14719 
  """
14720 
  Attributes:
14721 
   - orderId
14722 
   - invoiceNumber
4763 rajveer 14723 
   - color
6756 amar.kumar 14724 
   - serialNumber
14725 
   - itemNumber
4579 rajveer 14726 
  """
14727 
 
14728 
  thrift_spec = (
14729 
    None, # 0
14730 
    (1, TType.I64, 'orderId', None, None, ), # 1
14731 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 14732 
    (3, TType.STRING, 'color', None, None, ), # 3
6756 amar.kumar 14733 
    (4, TType.STRING, 'serialNumber', None, None, ), # 4
14734 
    (5, TType.STRING, 'itemNumber', None, None, ), # 5
4579 rajveer 14735 
  )
14736 
 
6756 amar.kumar 14737 
  def __init__(self, orderId=None, invoiceNumber=None, color=None, serialNumber=None, itemNumber=None,):
4579 rajveer 14738 
    self.orderId = orderId
14739 
    self.invoiceNumber = invoiceNumber
4763 rajveer 14740 
    self.color = color
6756 amar.kumar 14741 
    self.serialNumber = serialNumber
14742 
    self.itemNumber = itemNumber
4579 rajveer 14743 
 
14744 
  def read(self, iprot):
14745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14747 
      return
14748 
    iprot.readStructBegin()
14749 
    while True:
14750 
      (fname, ftype, fid) = iprot.readFieldBegin()
14751 
      if ftype == TType.STOP:
14752 
        break
14753 
      if fid == 1:
14754 
        if ftype == TType.I64:
14755 
          self.orderId = iprot.readI64();
14756 
        else:
14757 
          iprot.skip(ftype)
14758 
      elif fid == 2:
14759 
        if ftype == TType.STRING:
14760 
          self.invoiceNumber = iprot.readString();
14761 
        else:
14762 
          iprot.skip(ftype)
4763 rajveer 14763 
      elif fid == 3:
14764 
        if ftype == TType.STRING:
14765 
          self.color = iprot.readString();
14766 
        else:
14767 
          iprot.skip(ftype)
6756 amar.kumar 14768 
      elif fid == 4:
14769 
        if ftype == TType.STRING:
14770 
          self.serialNumber = iprot.readString();
14771 
        else:
14772 
          iprot.skip(ftype)
14773 
      elif fid == 5:
14774 
        if ftype == TType.STRING:
14775 
          self.itemNumber = iprot.readString();
14776 
        else:
14777 
          iprot.skip(ftype)
4579 rajveer 14778 
      else:
14779 
        iprot.skip(ftype)
14780 
      iprot.readFieldEnd()
14781 
    iprot.readStructEnd()
14782 
 
14783 
  def write(self, oprot):
14784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14786 
      return
14787 
    oprot.writeStructBegin('addInvoiceNumber_args')
14788 
    if self.orderId is not None:
14789 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14790 
      oprot.writeI64(self.orderId)
14791 
      oprot.writeFieldEnd()
14792 
    if self.invoiceNumber is not None:
14793 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
14794 
      oprot.writeString(self.invoiceNumber)
14795 
      oprot.writeFieldEnd()
4763 rajveer 14796 
    if self.color is not None:
14797 
      oprot.writeFieldBegin('color', TType.STRING, 3)
14798 
      oprot.writeString(self.color)
14799 
      oprot.writeFieldEnd()
6756 amar.kumar 14800 
    if self.serialNumber is not None:
14801 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 4)
14802 
      oprot.writeString(self.serialNumber)
14803 
      oprot.writeFieldEnd()
14804 
    if self.itemNumber is not None:
14805 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 5)
14806 
      oprot.writeString(self.itemNumber)
14807 
      oprot.writeFieldEnd()
4579 rajveer 14808 
    oprot.writeFieldStop()
14809 
    oprot.writeStructEnd()
14810 
 
14811 
  def validate(self):
14812 
    return
14813 
 
14814 
 
14815 
  def __repr__(self):
14816 
    L = ['%s=%r' % (key, value)
14817 
      for key, value in self.__dict__.iteritems()]
14818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14819 
 
14820 
  def __eq__(self, other):
14821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14822 
 
14823 
  def __ne__(self, other):
14824 
    return not (self == other)
14825 
 
14826 
class addInvoiceNumber_result:
14827 
  """
14828 
  Attributes:
14829 
   - ex
14830 
  """
14831 
 
14832 
  thrift_spec = (
14833 
    None, # 0
14834 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14835 
  )
14836 
 
14837 
  def __init__(self, ex=None,):
14838 
    self.ex = ex
14839 
 
14840 
  def read(self, iprot):
14841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14843 
      return
14844 
    iprot.readStructBegin()
14845 
    while True:
14846 
      (fname, ftype, fid) = iprot.readFieldBegin()
14847 
      if ftype == TType.STOP:
14848 
        break
14849 
      if fid == 1:
14850 
        if ftype == TType.STRUCT:
14851 
          self.ex = TransactionServiceException()
14852 
          self.ex.read(iprot)
14853 
        else:
14854 
          iprot.skip(ftype)
14855 
      else:
14856 
        iprot.skip(ftype)
14857 
      iprot.readFieldEnd()
14858 
    iprot.readStructEnd()
14859 
 
14860 
  def write(self, oprot):
14861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14863 
      return
14864 
    oprot.writeStructBegin('addInvoiceNumber_result')
14865 
    if self.ex is not None:
14866 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14867 
      self.ex.write(oprot)
14868 
      oprot.writeFieldEnd()
14869 
    oprot.writeFieldStop()
14870 
    oprot.writeStructEnd()
14871 
 
14872 
  def validate(self):
14873 
    return
14874 
 
14875 
 
14876 
  def __repr__(self):
14877 
    L = ['%s=%r' % (key, value)
14878 
      for key, value in self.__dict__.iteritems()]
14879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14880 
 
14881 
  def __eq__(self, other):
14882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14883 
 
14884 
  def __ne__(self, other):
14885 
    return not (self == other)
14886 
 
4910 phani.kuma 14887 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 14888 
  """
14889 
  Attributes:
3064 chandransh 14890 
   - warehouseId
1408 ankur.sing 14891 
   - providerId
3064 chandransh 14892 
   - cod
4910 phani.kuma 14893 
   - orderIds
1408 ankur.sing 14894 
  """
14895 
 
14896 
  thrift_spec = (
14897 
    None, # 0
3064 chandransh 14898 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14899 
    (2, TType.I64, 'providerId', None, None, ), # 2
14900 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 14901 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 14902 
  )
14903 
 
4910 phani.kuma 14904 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 14905 
    self.warehouseId = warehouseId
1408 ankur.sing 14906 
    self.providerId = providerId
3064 chandransh 14907 
    self.cod = cod
4910 phani.kuma 14908 
    self.orderIds = orderIds
1408 ankur.sing 14909 
 
14910 
  def read(self, iprot):
14911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14913 
      return
14914 
    iprot.readStructBegin()
14915 
    while True:
14916 
      (fname, ftype, fid) = iprot.readFieldBegin()
14917 
      if ftype == TType.STOP:
14918 
        break
14919 
      if fid == 1:
14920 
        if ftype == TType.I64:
3064 chandransh 14921 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 14922 
        else:
14923 
          iprot.skip(ftype)
14924 
      elif fid == 2:
14925 
        if ftype == TType.I64:
3064 chandransh 14926 
          self.providerId = iprot.readI64();
1408 ankur.sing 14927 
        else:
14928 
          iprot.skip(ftype)
3064 chandransh 14929 
      elif fid == 3:
14930 
        if ftype == TType.BOOL:
14931 
          self.cod = iprot.readBool();
14932 
        else:
14933 
          iprot.skip(ftype)
4910 phani.kuma 14934 
      elif fid == 4:
14935 
        if ftype == TType.LIST:
14936 
          self.orderIds = []
6188 rajveer 14937 
          (_etype284, _size281) = iprot.readListBegin()
14938 
          for _i285 in xrange(_size281):
14939 
            _elem286 = iprot.readI64();
14940 
            self.orderIds.append(_elem286)
4910 phani.kuma 14941 
          iprot.readListEnd()
14942 
        else:
14943 
          iprot.skip(ftype)
1408 ankur.sing 14944 
      else:
14945 
        iprot.skip(ftype)
14946 
      iprot.readFieldEnd()
14947 
    iprot.readStructEnd()
14948 
 
14949 
  def write(self, oprot):
14950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14952 
      return
4910 phani.kuma 14953 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 14954 
    if self.warehouseId is not None:
3064 chandransh 14955 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14956 
      oprot.writeI64(self.warehouseId)
14957 
      oprot.writeFieldEnd()
3431 rajveer 14958 
    if self.providerId is not None:
3064 chandransh 14959 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 14960 
      oprot.writeI64(self.providerId)
14961 
      oprot.writeFieldEnd()
3431 rajveer 14962 
    if self.cod is not None:
3064 chandransh 14963 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
14964 
      oprot.writeBool(self.cod)
1408 ankur.sing 14965 
      oprot.writeFieldEnd()
4910 phani.kuma 14966 
    if self.orderIds is not None:
14967 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
14968 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14969 
      for iter287 in self.orderIds:
14970 
        oprot.writeI64(iter287)
4910 phani.kuma 14971 
      oprot.writeListEnd()
14972 
      oprot.writeFieldEnd()
1408 ankur.sing 14973 
    oprot.writeFieldStop()
14974 
    oprot.writeStructEnd()
14975 
 
3431 rajveer 14976 
  def validate(self):
14977 
    return
14978 
 
14979 
 
1408 ankur.sing 14980 
  def __repr__(self):
14981 
    L = ['%s=%r' % (key, value)
14982 
      for key, value in self.__dict__.iteritems()]
14983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14984 
 
14985 
  def __eq__(self, other):
14986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14987 
 
14988 
  def __ne__(self, other):
14989 
    return not (self == other)
14990 
 
4910 phani.kuma 14991 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 14992 
  """
14993 
  Attributes:
14994 
   - success
3064 chandransh 14995 
   - ex
1408 ankur.sing 14996 
  """
14997 
 
14998 
  thrift_spec = (
3064 chandransh 14999 
    (0, TType.BOOL, 'success', None, None, ), # 0
15000 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 15001 
  )
15002 
 
3064 chandransh 15003 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 15004 
    self.success = success
3064 chandransh 15005 
    self.ex = ex
1408 ankur.sing 15006 
 
15007 
  def read(self, iprot):
15008 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15009 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15010 
      return
15011 
    iprot.readStructBegin()
15012 
    while True:
15013 
      (fname, ftype, fid) = iprot.readFieldBegin()
15014 
      if ftype == TType.STOP:
15015 
        break
15016 
      if fid == 0:
3064 chandransh 15017 
        if ftype == TType.BOOL:
15018 
          self.success = iprot.readBool();
1408 ankur.sing 15019 
        else:
15020 
          iprot.skip(ftype)
3064 chandransh 15021 
      elif fid == 1:
15022 
        if ftype == TType.STRUCT:
15023 
          self.ex = TransactionServiceException()
15024 
          self.ex.read(iprot)
15025 
        else:
15026 
          iprot.skip(ftype)
1408 ankur.sing 15027 
      else:
15028 
        iprot.skip(ftype)
15029 
      iprot.readFieldEnd()
15030 
    iprot.readStructEnd()
15031 
 
15032 
  def write(self, oprot):
15033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15035 
      return
4910 phani.kuma 15036 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 15037 
    if self.success is not None:
3064 chandransh 15038 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15039 
      oprot.writeBool(self.success)
1408 ankur.sing 15040 
      oprot.writeFieldEnd()
3431 rajveer 15041 
    if self.ex is not None:
3064 chandransh 15042 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15043 
      self.ex.write(oprot)
15044 
      oprot.writeFieldEnd()
1408 ankur.sing 15045 
    oprot.writeFieldStop()
15046 
    oprot.writeStructEnd()
15047 
 
3431 rajveer 15048 
  def validate(self):
15049 
    return
15050 
 
15051 
 
1408 ankur.sing 15052 
  def __repr__(self):
15053 
    L = ['%s=%r' % (key, value)
15054 
      for key, value in self.__dict__.iteritems()]
15055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15056 
 
15057 
  def __eq__(self, other):
15058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15059 
 
15060 
  def __ne__(self, other):
15061 
    return not (self == other)
15062 
 
5676 rajveer 15063 
class markOrdersAsReturnedFromStore_args:
15064 
  """
15065 
  Attributes:
15066 
   - providerId
15067 
   - orderIds
5713 rajveer 15068 
   - awbs
5676 rajveer 15069 
  """
15070 
 
15071 
  thrift_spec = (
15072 
    None, # 0
15073 
    (1, TType.I64, 'providerId', None, None, ), # 1
15074 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 15075 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 15076 
  )
15077 
 
5713 rajveer 15078 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 15079 
    self.providerId = providerId
15080 
    self.orderIds = orderIds
5713 rajveer 15081 
    self.awbs = awbs
5676 rajveer 15082 
 
15083 
  def read(self, iprot):
15084 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15085 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15086 
      return
15087 
    iprot.readStructBegin()
15088 
    while True:
15089 
      (fname, ftype, fid) = iprot.readFieldBegin()
15090 
      if ftype == TType.STOP:
15091 
        break
15092 
      if fid == 1:
15093 
        if ftype == TType.I64:
15094 
          self.providerId = iprot.readI64();
15095 
        else:
15096 
          iprot.skip(ftype)
15097 
      elif fid == 2:
15098 
        if ftype == TType.LIST:
15099 
          self.orderIds = []
6188 rajveer 15100 
          (_etype291, _size288) = iprot.readListBegin()
15101 
          for _i292 in xrange(_size288):
15102 
            _elem293 = iprot.readI64();
15103 
            self.orderIds.append(_elem293)
5676 rajveer 15104 
          iprot.readListEnd()
15105 
        else:
15106 
          iprot.skip(ftype)
5713 rajveer 15107 
      elif fid == 3:
15108 
        if ftype == TType.LIST:
15109 
          self.awbs = []
6188 rajveer 15110 
          (_etype297, _size294) = iprot.readListBegin()
15111 
          for _i298 in xrange(_size294):
15112 
            _elem299 = iprot.readString();
15113 
            self.awbs.append(_elem299)
5713 rajveer 15114 
          iprot.readListEnd()
15115 
        else:
15116 
          iprot.skip(ftype)
5676 rajveer 15117 
      else:
15118 
        iprot.skip(ftype)
15119 
      iprot.readFieldEnd()
15120 
    iprot.readStructEnd()
15121 
 
15122 
  def write(self, oprot):
15123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15125 
      return
15126 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
15127 
    if self.providerId is not None:
15128 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15129 
      oprot.writeI64(self.providerId)
15130 
      oprot.writeFieldEnd()
15131 
    if self.orderIds is not None:
15132 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
15133 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 15134 
      for iter300 in self.orderIds:
15135 
        oprot.writeI64(iter300)
5676 rajveer 15136 
      oprot.writeListEnd()
15137 
      oprot.writeFieldEnd()
5713 rajveer 15138 
    if self.awbs is not None:
15139 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
15140 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 15141 
      for iter301 in self.awbs:
15142 
        oprot.writeString(iter301)
5713 rajveer 15143 
      oprot.writeListEnd()
15144 
      oprot.writeFieldEnd()
5676 rajveer 15145 
    oprot.writeFieldStop()
15146 
    oprot.writeStructEnd()
15147 
 
15148 
  def validate(self):
15149 
    return
15150 
 
15151 
 
15152 
  def __repr__(self):
15153 
    L = ['%s=%r' % (key, value)
15154 
      for key, value in self.__dict__.iteritems()]
15155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15156 
 
15157 
  def __eq__(self, other):
15158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15159 
 
15160 
  def __ne__(self, other):
15161 
    return not (self == other)
15162 
 
15163 
class markOrdersAsReturnedFromStore_result:
15164 
  """
15165 
  Attributes:
15166 
   - success
15167 
   - ex
15168 
  """
15169 
 
15170 
  thrift_spec = (
15171 
    (0, TType.BOOL, 'success', None, None, ), # 0
15172 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15173 
  )
15174 
 
15175 
  def __init__(self, success=None, ex=None,):
15176 
    self.success = success
15177 
    self.ex = ex
15178 
 
15179 
  def read(self, iprot):
15180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15182 
      return
15183 
    iprot.readStructBegin()
15184 
    while True:
15185 
      (fname, ftype, fid) = iprot.readFieldBegin()
15186 
      if ftype == TType.STOP:
15187 
        break
15188 
      if fid == 0:
15189 
        if ftype == TType.BOOL:
15190 
          self.success = iprot.readBool();
15191 
        else:
15192 
          iprot.skip(ftype)
15193 
      elif fid == 1:
15194 
        if ftype == TType.STRUCT:
15195 
          self.ex = TransactionServiceException()
15196 
          self.ex.read(iprot)
15197 
        else:
15198 
          iprot.skip(ftype)
15199 
      else:
15200 
        iprot.skip(ftype)
15201 
      iprot.readFieldEnd()
15202 
    iprot.readStructEnd()
15203 
 
15204 
  def write(self, oprot):
15205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15207 
      return
15208 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
15209 
    if self.success is not None:
15210 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
15211 
      oprot.writeBool(self.success)
15212 
      oprot.writeFieldEnd()
15213 
    if self.ex is not None:
15214 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15215 
      self.ex.write(oprot)
15216 
      oprot.writeFieldEnd()
15217 
    oprot.writeFieldStop()
15218 
    oprot.writeStructEnd()
15219 
 
15220 
  def validate(self):
15221 
    return
15222 
 
15223 
 
15224 
  def __repr__(self):
15225 
    L = ['%s=%r' % (key, value)
15226 
      for key, value in self.__dict__.iteritems()]
15227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15228 
 
15229 
  def __eq__(self, other):
15230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15231 
 
15232 
  def __ne__(self, other):
15233 
    return not (self == other)
15234 
 
4910 phani.kuma 15235 
class markOrdersAsPickedUp_args:
4410 rajveer 15236 
  """
15237 
  Attributes:
15238 
   - providerId
4910 phani.kuma 15239 
   - pickupDetails
4410 rajveer 15240 
  """
15241 
 
15242 
  thrift_spec = (
15243 
    None, # 0
4910 phani.kuma 15244 
    (1, TType.I64, 'providerId', None, None, ), # 1
15245 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 15246 
  )
15247 
 
4910 phani.kuma 15248 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 15249 
    self.providerId = providerId
4910 phani.kuma 15250 
    self.pickupDetails = pickupDetails
4410 rajveer 15251 
 
15252 
  def read(self, iprot):
15253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15255 
      return
15256 
    iprot.readStructBegin()
15257 
    while True:
15258 
      (fname, ftype, fid) = iprot.readFieldBegin()
15259 
      if ftype == TType.STOP:
15260 
        break
15261 
      if fid == 1:
15262 
        if ftype == TType.I64:
4910 phani.kuma 15263 
          self.providerId = iprot.readI64();
4410 rajveer 15264 
        else:
15265 
          iprot.skip(ftype)
15266 
      elif fid == 2:
4910 phani.kuma 15267 
        if ftype == TType.MAP:
15268 
          self.pickupDetails = {}
6188 rajveer 15269 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
15270 
          for _i306 in xrange(_size302):
15271 
            _key307 = iprot.readString();
15272 
            _val308 = iprot.readString();
15273 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 15274 
          iprot.readMapEnd()
4410 rajveer 15275 
        else:
15276 
          iprot.skip(ftype)
15277 
      else:
15278 
        iprot.skip(ftype)
15279 
      iprot.readFieldEnd()
15280 
    iprot.readStructEnd()
15281 
 
15282 
  def write(self, oprot):
15283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15285 
      return
4910 phani.kuma 15286 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 15287 
    if self.providerId is not None:
4910 phani.kuma 15288 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 15289 
      oprot.writeI64(self.providerId)
15290 
      oprot.writeFieldEnd()
4910 phani.kuma 15291 
    if self.pickupDetails is not None:
15292 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
15293 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 15294 
      for kiter309,viter310 in self.pickupDetails.items():
15295 
        oprot.writeString(kiter309)
15296 
        oprot.writeString(viter310)
4910 phani.kuma 15297 
      oprot.writeMapEnd()
4410 rajveer 15298 
      oprot.writeFieldEnd()
15299 
    oprot.writeFieldStop()
15300 
    oprot.writeStructEnd()
15301 
 
15302 
  def validate(self):
15303 
    return
15304 
 
15305 
 
15306 
  def __repr__(self):
15307 
    L = ['%s=%r' % (key, value)
15308 
      for key, value in self.__dict__.iteritems()]
15309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15310 
 
15311 
  def __eq__(self, other):
15312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15313 
 
15314 
  def __ne__(self, other):
15315 
    return not (self == other)
15316 
 
4910 phani.kuma 15317 
class markOrdersAsPickedUp_result:
4410 rajveer 15318 
  """
15319 
  Attributes:
15320 
   - ex
15321 
  """
15322 
 
15323 
  thrift_spec = (
4910 phani.kuma 15324 
    None, # 0
4410 rajveer 15325 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15326 
  )
15327 
 
4910 phani.kuma 15328 
  def __init__(self, ex=None,):
4410 rajveer 15329 
    self.ex = ex
15330 
 
15331 
  def read(self, iprot):
15332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15334 
      return
15335 
    iprot.readStructBegin()
15336 
    while True:
15337 
      (fname, ftype, fid) = iprot.readFieldBegin()
15338 
      if ftype == TType.STOP:
15339 
        break
4910 phani.kuma 15340 
      if fid == 1:
4410 rajveer 15341 
        if ftype == TType.STRUCT:
15342 
          self.ex = TransactionServiceException()
15343 
          self.ex.read(iprot)
15344 
        else:
15345 
          iprot.skip(ftype)
15346 
      else:
15347 
        iprot.skip(ftype)
15348 
      iprot.readFieldEnd()
15349 
    iprot.readStructEnd()
15350 
 
15351 
  def write(self, oprot):
15352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15354 
      return
4910 phani.kuma 15355 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 15356 
    if self.ex is not None:
15357 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15358 
      self.ex.write(oprot)
15359 
      oprot.writeFieldEnd()
15360 
    oprot.writeFieldStop()
15361 
    oprot.writeStructEnd()
15362 
 
15363 
  def validate(self):
15364 
    return
15365 
 
15366 
 
15367 
  def __repr__(self):
15368 
    L = ['%s=%r' % (key, value)
15369 
      for key, value in self.__dict__.iteritems()]
15370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15371 
 
15372 
  def __eq__(self, other):
15373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15374 
 
15375 
  def __ne__(self, other):
15376 
    return not (self == other)
15377 
 
4910 phani.kuma 15378 
class getOrdersNotPickedUp_args:
304 ashish 15379 
  """
15380 
  Attributes:
3064 chandransh 15381 
   - providerId
304 ashish 15382 
  """
94 ashish 15383 
 
304 ashish 15384 
  thrift_spec = (
15385 
    None, # 0
3064 chandransh 15386 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 15387 
  )
15388 
 
4910 phani.kuma 15389 
  def __init__(self, providerId=None,):
3064 chandransh 15390 
    self.providerId = providerId
304 ashish 15391 
 
15392 
  def read(self, iprot):
15393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15395 
      return
15396 
    iprot.readStructBegin()
15397 
    while True:
15398 
      (fname, ftype, fid) = iprot.readFieldBegin()
15399 
      if ftype == TType.STOP:
15400 
        break
15401 
      if fid == 1:
15402 
        if ftype == TType.I64:
3064 chandransh 15403 
          self.providerId = iprot.readI64();
304 ashish 15404 
        else:
15405 
          iprot.skip(ftype)
15406 
      else:
15407 
        iprot.skip(ftype)
15408 
      iprot.readFieldEnd()
15409 
    iprot.readStructEnd()
15410 
 
15411 
  def write(self, oprot):
15412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15414 
      return
4910 phani.kuma 15415 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 15416 
    if self.providerId is not None:
3064 chandransh 15417 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15418 
      oprot.writeI64(self.providerId)
304 ashish 15419 
      oprot.writeFieldEnd()
15420 
    oprot.writeFieldStop()
15421 
    oprot.writeStructEnd()
15422 
 
3431 rajveer 15423 
  def validate(self):
15424 
    return
15425 
 
15426 
 
304 ashish 15427 
  def __repr__(self):
15428 
    L = ['%s=%r' % (key, value)
15429 
      for key, value in self.__dict__.iteritems()]
15430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15431 
 
15432 
  def __eq__(self, other):
15433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15434 
 
15435 
  def __ne__(self, other):
15436 
    return not (self == other)
15437 
 
4910 phani.kuma 15438 
class getOrdersNotPickedUp_result:
304 ashish 15439 
  """
15440 
  Attributes:
15441 
   - success
15442 
  """
15443 
 
15444 
  thrift_spec = (
3064 chandransh 15445 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 15446 
  )
15447 
 
4910 phani.kuma 15448 
  def __init__(self, success=None,):
304 ashish 15449 
    self.success = success
15450 
 
15451 
  def read(self, iprot):
15452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15454 
      return
15455 
    iprot.readStructBegin()
15456 
    while True:
15457 
      (fname, ftype, fid) = iprot.readFieldBegin()
15458 
      if ftype == TType.STOP:
15459 
        break
15460 
      if fid == 0:
15461 
        if ftype == TType.LIST:
15462 
          self.success = []
6188 rajveer 15463 
          (_etype314, _size311) = iprot.readListBegin()
15464 
          for _i315 in xrange(_size311):
15465 
            _elem316 = Order()
15466 
            _elem316.read(iprot)
15467 
            self.success.append(_elem316)
304 ashish 15468 
          iprot.readListEnd()
15469 
        else:
15470 
          iprot.skip(ftype)
15471 
      else:
15472 
        iprot.skip(ftype)
15473 
      iprot.readFieldEnd()
15474 
    iprot.readStructEnd()
15475 
 
15476 
  def write(self, oprot):
15477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15479 
      return
4910 phani.kuma 15480 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 15481 
    if self.success is not None:
304 ashish 15482 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15483 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15484 
      for iter317 in self.success:
15485 
        iter317.write(oprot)
304 ashish 15486 
      oprot.writeListEnd()
15487 
      oprot.writeFieldEnd()
15488 
    oprot.writeFieldStop()
15489 
    oprot.writeStructEnd()
15490 
 
3431 rajveer 15491 
  def validate(self):
15492 
    return
15493 
 
15494 
 
304 ashish 15495 
  def __repr__(self):
15496 
    L = ['%s=%r' % (key, value)
15497 
      for key, value in self.__dict__.iteritems()]
15498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15499 
 
15500 
  def __eq__(self, other):
15501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15502 
 
15503 
  def __ne__(self, other):
15504 
    return not (self == other)
15505 
 
3064 chandransh 15506 
class markOrdersAsDelivered_args:
304 ashish 15507 
  """
15508 
  Attributes:
3064 chandransh 15509 
   - providerId
15510 
   - deliveredOrders
304 ashish 15511 
  """
15512 
 
15513 
  thrift_spec = (
15514 
    None, # 0
3064 chandransh 15515 
    (1, TType.I64, 'providerId', None, None, ), # 1
15516 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 15517 
  )
15518 
 
3064 chandransh 15519 
  def __init__(self, providerId=None, deliveredOrders=None,):
15520 
    self.providerId = providerId
15521 
    self.deliveredOrders = deliveredOrders
304 ashish 15522 
 
15523 
  def read(self, iprot):
15524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15526 
      return
15527 
    iprot.readStructBegin()
15528 
    while True:
15529 
      (fname, ftype, fid) = iprot.readFieldBegin()
15530 
      if ftype == TType.STOP:
15531 
        break
15532 
      if fid == 1:
15533 
        if ftype == TType.I64:
3064 chandransh 15534 
          self.providerId = iprot.readI64();
304 ashish 15535 
        else:
15536 
          iprot.skip(ftype)
15537 
      elif fid == 2:
3064 chandransh 15538 
        if ftype == TType.MAP:
15539 
          self.deliveredOrders = {}
6188 rajveer 15540 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
15541 
          for _i322 in xrange(_size318):
15542 
            _key323 = iprot.readString();
15543 
            _val324 = iprot.readString();
15544 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 15545 
          iprot.readMapEnd()
304 ashish 15546 
        else:
15547 
          iprot.skip(ftype)
15548 
      else:
15549 
        iprot.skip(ftype)
15550 
      iprot.readFieldEnd()
15551 
    iprot.readStructEnd()
15552 
 
15553 
  def write(self, oprot):
15554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15556 
      return
3064 chandransh 15557 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 15558 
    if self.providerId is not None:
3064 chandransh 15559 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15560 
      oprot.writeI64(self.providerId)
304 ashish 15561 
      oprot.writeFieldEnd()
3431 rajveer 15562 
    if self.deliveredOrders is not None:
3064 chandransh 15563 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
15564 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 15565 
      for kiter325,viter326 in self.deliveredOrders.items():
15566 
        oprot.writeString(kiter325)
15567 
        oprot.writeString(viter326)
3064 chandransh 15568 
      oprot.writeMapEnd()
304 ashish 15569 
      oprot.writeFieldEnd()
15570 
    oprot.writeFieldStop()
15571 
    oprot.writeStructEnd()
15572 
 
3431 rajveer 15573 
  def validate(self):
15574 
    return
15575 
 
15576 
 
304 ashish 15577 
  def __repr__(self):
15578 
    L = ['%s=%r' % (key, value)
15579 
      for key, value in self.__dict__.iteritems()]
15580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15581 
 
15582 
  def __eq__(self, other):
15583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15584 
 
15585 
  def __ne__(self, other):
15586 
    return not (self == other)
15587 
 
3064 chandransh 15588 
class markOrdersAsDelivered_result:
15589 
  """
15590 
  Attributes:
15591 
   - ex
15592 
  """
304 ashish 15593 
 
15594 
  thrift_spec = (
3064 chandransh 15595 
    None, # 0
15596 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 15597 
  )
15598 
 
3064 chandransh 15599 
  def __init__(self, ex=None,):
15600 
    self.ex = ex
304 ashish 15601 
 
1596 ankur.sing 15602 
  def read(self, iprot):
15603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15605 
      return
15606 
    iprot.readStructBegin()
15607 
    while True:
15608 
      (fname, ftype, fid) = iprot.readFieldBegin()
15609 
      if ftype == TType.STOP:
15610 
        break
3064 chandransh 15611 
      if fid == 1:
15612 
        if ftype == TType.STRUCT:
15613 
          self.ex = TransactionServiceException()
15614 
          self.ex.read(iprot)
15615 
        else:
15616 
          iprot.skip(ftype)
1596 ankur.sing 15617 
      else:
15618 
        iprot.skip(ftype)
15619 
      iprot.readFieldEnd()
15620 
    iprot.readStructEnd()
15621 
 
15622 
  def write(self, oprot):
15623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15625 
      return
3064 chandransh 15626 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 15627 
    if self.ex is not None:
3064 chandransh 15628 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15629 
      self.ex.write(oprot)
15630 
      oprot.writeFieldEnd()
1596 ankur.sing 15631 
    oprot.writeFieldStop()
15632 
    oprot.writeStructEnd()
15633 
 
3431 rajveer 15634 
  def validate(self):
15635 
    return
15636 
 
15637 
 
1596 ankur.sing 15638 
  def __repr__(self):
15639 
    L = ['%s=%r' % (key, value)
15640 
      for key, value in self.__dict__.iteritems()]
15641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15642 
 
15643 
  def __eq__(self, other):
15644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15645 
 
15646 
  def __ne__(self, other):
15647 
    return not (self == other)
15648 
 
4910 phani.kuma 15649 
class markAsRTOrders_args:
1596 ankur.sing 15650 
  """
15651 
  Attributes:
3064 chandransh 15652 
   - providerId
15653 
   - returnedOrders
1596 ankur.sing 15654 
  """
15655 
 
15656 
  thrift_spec = (
3064 chandransh 15657 
    None, # 0
15658 
    (1, TType.I64, 'providerId', None, None, ), # 1
15659 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 15660 
  )
15661 
 
3064 chandransh 15662 
  def __init__(self, providerId=None, returnedOrders=None,):
15663 
    self.providerId = providerId
15664 
    self.returnedOrders = returnedOrders
1596 ankur.sing 15665 
 
15666 
  def read(self, iprot):
15667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15669 
      return
15670 
    iprot.readStructBegin()
15671 
    while True:
15672 
      (fname, ftype, fid) = iprot.readFieldBegin()
15673 
      if ftype == TType.STOP:
15674 
        break
3064 chandransh 15675 
      if fid == 1:
1596 ankur.sing 15676 
        if ftype == TType.I64:
3064 chandransh 15677 
          self.providerId = iprot.readI64();
1596 ankur.sing 15678 
        else:
15679 
          iprot.skip(ftype)
3064 chandransh 15680 
      elif fid == 2:
15681 
        if ftype == TType.MAP:
15682 
          self.returnedOrders = {}
6188 rajveer 15683 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
15684 
          for _i331 in xrange(_size327):
15685 
            _key332 = iprot.readString();
15686 
            _val333 = iprot.readString();
15687 
            self.returnedOrders[_key332] = _val333
3064 chandransh 15688 
          iprot.readMapEnd()
15689 
        else:
15690 
          iprot.skip(ftype)
1596 ankur.sing 15691 
      else:
15692 
        iprot.skip(ftype)
15693 
      iprot.readFieldEnd()
15694 
    iprot.readStructEnd()
15695 
 
15696 
  def write(self, oprot):
15697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15699 
      return
4910 phani.kuma 15700 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 15701 
    if self.providerId is not None:
3064 chandransh 15702 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15703 
      oprot.writeI64(self.providerId)
1596 ankur.sing 15704 
      oprot.writeFieldEnd()
3431 rajveer 15705 
    if self.returnedOrders is not None:
3064 chandransh 15706 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
15707 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 15708 
      for kiter334,viter335 in self.returnedOrders.items():
15709 
        oprot.writeString(kiter334)
15710 
        oprot.writeString(viter335)
3064 chandransh 15711 
      oprot.writeMapEnd()
15712 
      oprot.writeFieldEnd()
1596 ankur.sing 15713 
    oprot.writeFieldStop()
15714 
    oprot.writeStructEnd()
15715 
 
3431 rajveer 15716 
  def validate(self):
15717 
    return
15718 
 
15719 
 
1596 ankur.sing 15720 
  def __repr__(self):
15721 
    L = ['%s=%r' % (key, value)
15722 
      for key, value in self.__dict__.iteritems()]
15723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15724 
 
15725 
  def __eq__(self, other):
15726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15727 
 
15728 
  def __ne__(self, other):
15729 
    return not (self == other)
15730 
 
4910 phani.kuma 15731 
class markAsRTOrders_result:
3064 chandransh 15732 
  """
15733 
  Attributes:
15734 
   - ex
15735 
  """
1596 ankur.sing 15736 
 
1627 ankur.sing 15737 
  thrift_spec = (
3064 chandransh 15738 
    None, # 0
15739 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15740 
  )
15741 
 
3064 chandransh 15742 
  def __init__(self, ex=None,):
15743 
    self.ex = ex
15744 
 
1627 ankur.sing 15745 
  def read(self, iprot):
15746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15748 
      return
15749 
    iprot.readStructBegin()
15750 
    while True:
15751 
      (fname, ftype, fid) = iprot.readFieldBegin()
15752 
      if ftype == TType.STOP:
15753 
        break
3064 chandransh 15754 
      if fid == 1:
15755 
        if ftype == TType.STRUCT:
15756 
          self.ex = TransactionServiceException()
15757 
          self.ex.read(iprot)
15758 
        else:
15759 
          iprot.skip(ftype)
1627 ankur.sing 15760 
      else:
15761 
        iprot.skip(ftype)
15762 
      iprot.readFieldEnd()
15763 
    iprot.readStructEnd()
15764 
 
15765 
  def write(self, oprot):
15766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15768 
      return
4910 phani.kuma 15769 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 15770 
    if self.ex is not None:
3064 chandransh 15771 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15772 
      self.ex.write(oprot)
15773 
      oprot.writeFieldEnd()
1627 ankur.sing 15774 
    oprot.writeFieldStop()
15775 
    oprot.writeStructEnd()
15776 
 
3431 rajveer 15777 
  def validate(self):
15778 
    return
15779 
 
15780 
 
1627 ankur.sing 15781 
  def __repr__(self):
15782 
    L = ['%s=%r' % (key, value)
15783 
      for key, value in self.__dict__.iteritems()]
15784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15785 
 
15786 
  def __eq__(self, other):
15787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15788 
 
15789 
  def __ne__(self, other):
15790 
    return not (self == other)
15791 
 
4910 phani.kuma 15792 
class getRTOrders_args:
15793 
  """
15794 
  Attributes:
15795 
   - providerId
15796 
  """
15797 
 
15798 
  thrift_spec = (
15799 
    None, # 0
15800 
    (1, TType.I64, 'providerId', None, None, ), # 1
15801 
  )
15802 
 
15803 
  def __init__(self, providerId=None,):
15804 
    self.providerId = providerId
15805 
 
15806 
  def read(self, iprot):
15807 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15808 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15809 
      return
15810 
    iprot.readStructBegin()
15811 
    while True:
15812 
      (fname, ftype, fid) = iprot.readFieldBegin()
15813 
      if ftype == TType.STOP:
15814 
        break
15815 
      if fid == 1:
15816 
        if ftype == TType.I64:
15817 
          self.providerId = iprot.readI64();
15818 
        else:
15819 
          iprot.skip(ftype)
15820 
      else:
15821 
        iprot.skip(ftype)
15822 
      iprot.readFieldEnd()
15823 
    iprot.readStructEnd()
15824 
 
15825 
  def write(self, oprot):
15826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15828 
      return
15829 
    oprot.writeStructBegin('getRTOrders_args')
15830 
    if self.providerId is not None:
15831 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15832 
      oprot.writeI64(self.providerId)
15833 
      oprot.writeFieldEnd()
15834 
    oprot.writeFieldStop()
15835 
    oprot.writeStructEnd()
15836 
 
15837 
  def validate(self):
15838 
    return
15839 
 
15840 
 
15841 
  def __repr__(self):
15842 
    L = ['%s=%r' % (key, value)
15843 
      for key, value in self.__dict__.iteritems()]
15844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15845 
 
15846 
  def __eq__(self, other):
15847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15848 
 
15849 
  def __ne__(self, other):
15850 
    return not (self == other)
15851 
 
15852 
class getRTOrders_result:
15853 
  """
15854 
  Attributes:
15855 
   - success
15856 
  """
15857 
 
15858 
  thrift_spec = (
15859 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15860 
  )
15861 
 
15862 
  def __init__(self, success=None,):
15863 
    self.success = success
15864 
 
15865 
  def read(self, iprot):
15866 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15867 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15868 
      return
15869 
    iprot.readStructBegin()
15870 
    while True:
15871 
      (fname, ftype, fid) = iprot.readFieldBegin()
15872 
      if ftype == TType.STOP:
15873 
        break
15874 
      if fid == 0:
15875 
        if ftype == TType.LIST:
15876 
          self.success = []
6188 rajveer 15877 
          (_etype339, _size336) = iprot.readListBegin()
15878 
          for _i340 in xrange(_size336):
15879 
            _elem341 = Order()
15880 
            _elem341.read(iprot)
15881 
            self.success.append(_elem341)
4910 phani.kuma 15882 
          iprot.readListEnd()
15883 
        else:
15884 
          iprot.skip(ftype)
15885 
      else:
15886 
        iprot.skip(ftype)
15887 
      iprot.readFieldEnd()
15888 
    iprot.readStructEnd()
15889 
 
15890 
  def write(self, oprot):
15891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15893 
      return
15894 
    oprot.writeStructBegin('getRTOrders_result')
15895 
    if self.success is not None:
15896 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15897 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15898 
      for iter342 in self.success:
15899 
        iter342.write(oprot)
4910 phani.kuma 15900 
      oprot.writeListEnd()
15901 
      oprot.writeFieldEnd()
15902 
    oprot.writeFieldStop()
15903 
    oprot.writeStructEnd()
15904 
 
15905 
  def validate(self):
15906 
    return
15907 
 
15908 
 
15909 
  def __repr__(self):
15910 
    L = ['%s=%r' % (key, value)
15911 
      for key, value in self.__dict__.iteritems()]
15912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15913 
 
15914 
  def __eq__(self, other):
15915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15916 
 
15917 
  def __ne__(self, other):
15918 
    return not (self == other)
15919 
 
3064 chandransh 15920 
class updateNonDeliveryReason_args:
1627 ankur.sing 15921 
  """
15922 
  Attributes:
3064 chandransh 15923 
   - providerId
15924 
   - undeliveredOrders
1627 ankur.sing 15925 
  """
15926 
 
15927 
  thrift_spec = (
3064 chandransh 15928 
    None, # 0
15929 
    (1, TType.I64, 'providerId', None, None, ), # 1
15930 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 15931 
  )
15932 
 
3064 chandransh 15933 
  def __init__(self, providerId=None, undeliveredOrders=None,):
15934 
    self.providerId = providerId
15935 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 15936 
 
15937 
  def read(self, iprot):
15938 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15939 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15940 
      return
15941 
    iprot.readStructBegin()
15942 
    while True:
15943 
      (fname, ftype, fid) = iprot.readFieldBegin()
15944 
      if ftype == TType.STOP:
15945 
        break
3064 chandransh 15946 
      if fid == 1:
1627 ankur.sing 15947 
        if ftype == TType.I64:
3064 chandransh 15948 
          self.providerId = iprot.readI64();
1627 ankur.sing 15949 
        else:
15950 
          iprot.skip(ftype)
3064 chandransh 15951 
      elif fid == 2:
15952 
        if ftype == TType.MAP:
15953 
          self.undeliveredOrders = {}
6188 rajveer 15954 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
15955 
          for _i347 in xrange(_size343):
15956 
            _key348 = iprot.readString();
15957 
            _val349 = iprot.readString();
15958 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 15959 
          iprot.readMapEnd()
15960 
        else:
15961 
          iprot.skip(ftype)
1627 ankur.sing 15962 
      else:
15963 
        iprot.skip(ftype)
15964 
      iprot.readFieldEnd()
15965 
    iprot.readStructEnd()
15966 
 
15967 
  def write(self, oprot):
15968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15970 
      return
3064 chandransh 15971 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 15972 
    if self.providerId is not None:
3064 chandransh 15973 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15974 
      oprot.writeI64(self.providerId)
1627 ankur.sing 15975 
      oprot.writeFieldEnd()
3431 rajveer 15976 
    if self.undeliveredOrders is not None:
3064 chandransh 15977 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
15978 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 15979 
      for kiter350,viter351 in self.undeliveredOrders.items():
15980 
        oprot.writeString(kiter350)
15981 
        oprot.writeString(viter351)
3064 chandransh 15982 
      oprot.writeMapEnd()
15983 
      oprot.writeFieldEnd()
1627 ankur.sing 15984 
    oprot.writeFieldStop()
15985 
    oprot.writeStructEnd()
15986 
 
3431 rajveer 15987 
  def validate(self):
15988 
    return
15989 
 
15990 
 
1627 ankur.sing 15991 
  def __repr__(self):
15992 
    L = ['%s=%r' % (key, value)
15993 
      for key, value in self.__dict__.iteritems()]
15994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15995 
 
15996 
  def __eq__(self, other):
15997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15998 
 
15999 
  def __ne__(self, other):
16000 
    return not (self == other)
16001 
 
3064 chandransh 16002 
class updateNonDeliveryReason_result:
1627 ankur.sing 16003 
  """
16004 
  Attributes:
3064 chandransh 16005 
   - ex
1627 ankur.sing 16006 
  """
16007 
 
16008 
  thrift_spec = (
4910 phani.kuma 16009 
    None, # 0
3064 chandransh 16010 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 16011 
  )
16012 
 
4910 phani.kuma 16013 
  def __init__(self, ex=None,):
3064 chandransh 16014 
    self.ex = ex
1627 ankur.sing 16015 
 
16016 
  def read(self, iprot):
16017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16019 
      return
16020 
    iprot.readStructBegin()
16021 
    while True:
16022 
      (fname, ftype, fid) = iprot.readFieldBegin()
16023 
      if ftype == TType.STOP:
16024 
        break
4910 phani.kuma 16025 
      if fid == 1:
16026 
        if ftype == TType.STRUCT:
16027 
          self.ex = TransactionServiceException()
16028 
          self.ex.read(iprot)
16029 
        else:
16030 
          iprot.skip(ftype)
16031 
      else:
16032 
        iprot.skip(ftype)
16033 
      iprot.readFieldEnd()
16034 
    iprot.readStructEnd()
16035 
 
16036 
  def write(self, oprot):
16037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16039 
      return
16040 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
16041 
    if self.ex is not None:
16042 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16043 
      self.ex.write(oprot)
16044 
      oprot.writeFieldEnd()
16045 
    oprot.writeFieldStop()
16046 
    oprot.writeStructEnd()
16047 
 
16048 
  def validate(self):
16049 
    return
16050 
 
16051 
 
16052 
  def __repr__(self):
16053 
    L = ['%s=%r' % (key, value)
16054 
      for key, value in self.__dict__.iteritems()]
16055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16056 
 
16057 
  def __eq__(self, other):
16058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16059 
 
16060 
  def __ne__(self, other):
16061 
    return not (self == other)
16062 
 
16063 
class getNonDeliveredOrdersbyCourier_args:
16064 
  """
16065 
  Attributes:
16066 
   - providerId
16067 
  """
16068 
 
16069 
  thrift_spec = (
16070 
    None, # 0
16071 
    (1, TType.I64, 'providerId', None, None, ), # 1
16072 
  )
16073 
 
16074 
  def __init__(self, providerId=None,):
16075 
    self.providerId = providerId
16076 
 
16077 
  def read(self, iprot):
16078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16080 
      return
16081 
    iprot.readStructBegin()
16082 
    while True:
16083 
      (fname, ftype, fid) = iprot.readFieldBegin()
16084 
      if ftype == TType.STOP:
16085 
        break
16086 
      if fid == 1:
16087 
        if ftype == TType.I64:
16088 
          self.providerId = iprot.readI64();
16089 
        else:
16090 
          iprot.skip(ftype)
16091 
      else:
16092 
        iprot.skip(ftype)
16093 
      iprot.readFieldEnd()
16094 
    iprot.readStructEnd()
16095 
 
16096 
  def write(self, oprot):
16097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16099 
      return
16100 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
16101 
    if self.providerId is not None:
16102 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16103 
      oprot.writeI64(self.providerId)
16104 
      oprot.writeFieldEnd()
16105 
    oprot.writeFieldStop()
16106 
    oprot.writeStructEnd()
16107 
 
16108 
  def validate(self):
16109 
    return
16110 
 
16111 
 
16112 
  def __repr__(self):
16113 
    L = ['%s=%r' % (key, value)
16114 
      for key, value in self.__dict__.iteritems()]
16115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16116 
 
16117 
  def __eq__(self, other):
16118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16119 
 
16120 
  def __ne__(self, other):
16121 
    return not (self == other)
16122 
 
16123 
class getNonDeliveredOrdersbyCourier_result:
16124 
  """
16125 
  Attributes:
16126 
   - success
16127 
  """
16128 
 
16129 
  thrift_spec = (
16130 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16131 
  )
16132 
 
16133 
  def __init__(self, success=None,):
16134 
    self.success = success
16135 
 
16136 
  def read(self, iprot):
16137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16139 
      return
16140 
    iprot.readStructBegin()
16141 
    while True:
16142 
      (fname, ftype, fid) = iprot.readFieldBegin()
16143 
      if ftype == TType.STOP:
16144 
        break
4581 phani.kuma 16145 
      if fid == 0:
16146 
        if ftype == TType.LIST:
16147 
          self.success = []
6188 rajveer 16148 
          (_etype355, _size352) = iprot.readListBegin()
16149 
          for _i356 in xrange(_size352):
16150 
            _elem357 = Order()
16151 
            _elem357.read(iprot)
16152 
            self.success.append(_elem357)
4581 phani.kuma 16153 
          iprot.readListEnd()
16154 
        else:
16155 
          iprot.skip(ftype)
4910 phani.kuma 16156 
      else:
16157 
        iprot.skip(ftype)
16158 
      iprot.readFieldEnd()
16159 
    iprot.readStructEnd()
16160 
 
16161 
  def write(self, oprot):
16162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16164 
      return
16165 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
16166 
    if self.success is not None:
16167 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16168 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16169 
      for iter358 in self.success:
16170 
        iter358.write(oprot)
4910 phani.kuma 16171 
      oprot.writeListEnd()
16172 
      oprot.writeFieldEnd()
16173 
    oprot.writeFieldStop()
16174 
    oprot.writeStructEnd()
16175 
 
16176 
  def validate(self):
16177 
    return
16178 
 
16179 
 
16180 
  def __repr__(self):
16181 
    L = ['%s=%r' % (key, value)
16182 
      for key, value in self.__dict__.iteritems()]
16183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16184 
 
16185 
  def __eq__(self, other):
16186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16187 
 
16188 
  def __ne__(self, other):
16189 
    return not (self == other)
16190 
 
16191 
class markOrdersAsLocalConnected_args:
16192 
  """
16193 
  Attributes:
16194 
   - providerId
16195 
   - local_connected_orders
16196 
  """
16197 
 
16198 
  thrift_spec = (
16199 
    None, # 0
16200 
    (1, TType.I64, 'providerId', None, None, ), # 1
16201 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16202 
  )
16203 
 
16204 
  def __init__(self, providerId=None, local_connected_orders=None,):
16205 
    self.providerId = providerId
16206 
    self.local_connected_orders = local_connected_orders
16207 
 
16208 
  def read(self, iprot):
16209 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16210 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16211 
      return
16212 
    iprot.readStructBegin()
16213 
    while True:
16214 
      (fname, ftype, fid) = iprot.readFieldBegin()
16215 
      if ftype == TType.STOP:
16216 
        break
16217 
      if fid == 1:
16218 
        if ftype == TType.I64:
16219 
          self.providerId = iprot.readI64();
16220 
        else:
16221 
          iprot.skip(ftype)
16222 
      elif fid == 2:
16223 
        if ftype == TType.MAP:
16224 
          self.local_connected_orders = {}
6188 rajveer 16225 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
16226 
          for _i363 in xrange(_size359):
16227 
            _key364 = iprot.readString();
16228 
            _val365 = iprot.readString();
16229 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 16230 
          iprot.readMapEnd()
16231 
        else:
16232 
          iprot.skip(ftype)
16233 
      else:
16234 
        iprot.skip(ftype)
16235 
      iprot.readFieldEnd()
16236 
    iprot.readStructEnd()
16237 
 
16238 
  def write(self, oprot):
16239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16241 
      return
16242 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
16243 
    if self.providerId is not None:
16244 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16245 
      oprot.writeI64(self.providerId)
16246 
      oprot.writeFieldEnd()
16247 
    if self.local_connected_orders is not None:
16248 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
16249 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 16250 
      for kiter366,viter367 in self.local_connected_orders.items():
16251 
        oprot.writeString(kiter366)
16252 
        oprot.writeString(viter367)
4910 phani.kuma 16253 
      oprot.writeMapEnd()
16254 
      oprot.writeFieldEnd()
16255 
    oprot.writeFieldStop()
16256 
    oprot.writeStructEnd()
16257 
 
16258 
  def validate(self):
16259 
    return
16260 
 
16261 
 
16262 
  def __repr__(self):
16263 
    L = ['%s=%r' % (key, value)
16264 
      for key, value in self.__dict__.iteritems()]
16265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16266 
 
16267 
  def __eq__(self, other):
16268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16269 
 
16270 
  def __ne__(self, other):
16271 
    return not (self == other)
16272 
 
16273 
class markOrdersAsLocalConnected_result:
16274 
  """
16275 
  Attributes:
16276 
   - ex
16277 
  """
16278 
 
16279 
  thrift_spec = (
16280 
    None, # 0
16281 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16282 
  )
16283 
 
16284 
  def __init__(self, ex=None,):
16285 
    self.ex = ex
16286 
 
16287 
  def read(self, iprot):
16288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16290 
      return
16291 
    iprot.readStructBegin()
16292 
    while True:
16293 
      (fname, ftype, fid) = iprot.readFieldBegin()
16294 
      if ftype == TType.STOP:
16295 
        break
16296 
      if fid == 1:
3064 chandransh 16297 
        if ftype == TType.STRUCT:
16298 
          self.ex = TransactionServiceException()
16299 
          self.ex.read(iprot)
1627 ankur.sing 16300 
        else:
16301 
          iprot.skip(ftype)
16302 
      else:
16303 
        iprot.skip(ftype)
16304 
      iprot.readFieldEnd()
16305 
    iprot.readStructEnd()
16306 
 
16307 
  def write(self, oprot):
16308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16310 
      return
4910 phani.kuma 16311 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
16312 
    if self.ex is not None:
16313 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16314 
      self.ex.write(oprot)
16315 
      oprot.writeFieldEnd()
16316 
    oprot.writeFieldStop()
16317 
    oprot.writeStructEnd()
16318 
 
16319 
  def validate(self):
16320 
    return
16321 
 
16322 
 
16323 
  def __repr__(self):
16324 
    L = ['%s=%r' % (key, value)
16325 
      for key, value in self.__dict__.iteritems()]
16326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16327 
 
16328 
  def __eq__(self, other):
16329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16330 
 
16331 
  def __ne__(self, other):
16332 
    return not (self == other)
16333 
 
16334 
class getOrdersNotLocalConnected_args:
16335 
  """
16336 
  Attributes:
16337 
   - providerId
16338 
  """
16339 
 
16340 
  thrift_spec = (
16341 
    None, # 0
16342 
    (1, TType.I64, 'providerId', None, None, ), # 1
16343 
  )
16344 
 
16345 
  def __init__(self, providerId=None,):
16346 
    self.providerId = providerId
16347 
 
16348 
  def read(self, iprot):
16349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16351 
      return
16352 
    iprot.readStructBegin()
16353 
    while True:
16354 
      (fname, ftype, fid) = iprot.readFieldBegin()
16355 
      if ftype == TType.STOP:
16356 
        break
16357 
      if fid == 1:
16358 
        if ftype == TType.I64:
16359 
          self.providerId = iprot.readI64();
16360 
        else:
16361 
          iprot.skip(ftype)
16362 
      else:
16363 
        iprot.skip(ftype)
16364 
      iprot.readFieldEnd()
16365 
    iprot.readStructEnd()
16366 
 
16367 
  def write(self, oprot):
16368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16370 
      return
16371 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
16372 
    if self.providerId is not None:
16373 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16374 
      oprot.writeI64(self.providerId)
16375 
      oprot.writeFieldEnd()
16376 
    oprot.writeFieldStop()
16377 
    oprot.writeStructEnd()
16378 
 
16379 
  def validate(self):
16380 
    return
16381 
 
16382 
 
16383 
  def __repr__(self):
16384 
    L = ['%s=%r' % (key, value)
16385 
      for key, value in self.__dict__.iteritems()]
16386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16387 
 
16388 
  def __eq__(self, other):
16389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16390 
 
16391 
  def __ne__(self, other):
16392 
    return not (self == other)
16393 
 
16394 
class getOrdersNotLocalConnected_result:
16395 
  """
16396 
  Attributes:
16397 
   - success
16398 
  """
16399 
 
16400 
  thrift_spec = (
16401 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16402 
  )
16403 
 
16404 
  def __init__(self, success=None,):
16405 
    self.success = success
16406 
 
16407 
  def read(self, iprot):
16408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16410 
      return
16411 
    iprot.readStructBegin()
16412 
    while True:
16413 
      (fname, ftype, fid) = iprot.readFieldBegin()
16414 
      if ftype == TType.STOP:
16415 
        break
16416 
      if fid == 0:
16417 
        if ftype == TType.LIST:
16418 
          self.success = []
6188 rajveer 16419 
          (_etype371, _size368) = iprot.readListBegin()
16420 
          for _i372 in xrange(_size368):
16421 
            _elem373 = Order()
16422 
            _elem373.read(iprot)
16423 
            self.success.append(_elem373)
4910 phani.kuma 16424 
          iprot.readListEnd()
16425 
        else:
16426 
          iprot.skip(ftype)
16427 
      else:
16428 
        iprot.skip(ftype)
16429 
      iprot.readFieldEnd()
16430 
    iprot.readStructEnd()
16431 
 
16432 
  def write(self, oprot):
16433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16435 
      return
16436 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 16437 
    if self.success is not None:
16438 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16439 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16440 
      for iter374 in self.success:
16441 
        iter374.write(oprot)
4581 phani.kuma 16442 
      oprot.writeListEnd()
16443 
      oprot.writeFieldEnd()
4910 phani.kuma 16444 
    oprot.writeFieldStop()
16445 
    oprot.writeStructEnd()
16446 
 
16447 
  def validate(self):
16448 
    return
16449 
 
16450 
 
16451 
  def __repr__(self):
16452 
    L = ['%s=%r' % (key, value)
16453 
      for key, value in self.__dict__.iteritems()]
16454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16455 
 
16456 
  def __eq__(self, other):
16457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16458 
 
16459 
  def __ne__(self, other):
16460 
    return not (self == other)
16461 
 
16462 
class markOrdersAsDestinationCityReached_args:
16463 
  """
16464 
  Attributes:
16465 
   - providerId
16466 
   - destination_city_reached_orders
16467 
  """
16468 
 
16469 
  thrift_spec = (
16470 
    None, # 0
16471 
    (1, TType.I64, 'providerId', None, None, ), # 1
16472 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16473 
  )
16474 
 
16475 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
16476 
    self.providerId = providerId
16477 
    self.destination_city_reached_orders = destination_city_reached_orders
16478 
 
16479 
  def read(self, iprot):
16480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16482 
      return
16483 
    iprot.readStructBegin()
16484 
    while True:
16485 
      (fname, ftype, fid) = iprot.readFieldBegin()
16486 
      if ftype == TType.STOP:
16487 
        break
16488 
      if fid == 1:
16489 
        if ftype == TType.I64:
16490 
          self.providerId = iprot.readI64();
16491 
        else:
16492 
          iprot.skip(ftype)
16493 
      elif fid == 2:
16494 
        if ftype == TType.MAP:
16495 
          self.destination_city_reached_orders = {}
6188 rajveer 16496 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
16497 
          for _i379 in xrange(_size375):
16498 
            _key380 = iprot.readString();
16499 
            _val381 = iprot.readString();
16500 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 16501 
          iprot.readMapEnd()
16502 
        else:
16503 
          iprot.skip(ftype)
16504 
      else:
16505 
        iprot.skip(ftype)
16506 
      iprot.readFieldEnd()
16507 
    iprot.readStructEnd()
16508 
 
16509 
  def write(self, oprot):
16510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16512 
      return
16513 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
16514 
    if self.providerId is not None:
16515 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16516 
      oprot.writeI64(self.providerId)
16517 
      oprot.writeFieldEnd()
16518 
    if self.destination_city_reached_orders is not None:
16519 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
16520 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 16521 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
16522 
        oprot.writeString(kiter382)
16523 
        oprot.writeString(viter383)
4910 phani.kuma 16524 
      oprot.writeMapEnd()
16525 
      oprot.writeFieldEnd()
16526 
    oprot.writeFieldStop()
16527 
    oprot.writeStructEnd()
16528 
 
16529 
  def validate(self):
16530 
    return
16531 
 
16532 
 
16533 
  def __repr__(self):
16534 
    L = ['%s=%r' % (key, value)
16535 
      for key, value in self.__dict__.iteritems()]
16536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16537 
 
16538 
  def __eq__(self, other):
16539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16540 
 
16541 
  def __ne__(self, other):
16542 
    return not (self == other)
16543 
 
16544 
class markOrdersAsDestinationCityReached_result:
16545 
  """
16546 
  Attributes:
16547 
   - ex
16548 
  """
16549 
 
16550 
  thrift_spec = (
16551 
    None, # 0
16552 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16553 
  )
16554 
 
16555 
  def __init__(self, ex=None,):
16556 
    self.ex = ex
16557 
 
16558 
  def read(self, iprot):
16559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16561 
      return
16562 
    iprot.readStructBegin()
16563 
    while True:
16564 
      (fname, ftype, fid) = iprot.readFieldBegin()
16565 
      if ftype == TType.STOP:
16566 
        break
16567 
      if fid == 1:
16568 
        if ftype == TType.STRUCT:
16569 
          self.ex = TransactionServiceException()
16570 
          self.ex.read(iprot)
16571 
        else:
16572 
          iprot.skip(ftype)
16573 
      else:
16574 
        iprot.skip(ftype)
16575 
      iprot.readFieldEnd()
16576 
    iprot.readStructEnd()
16577 
 
16578 
  def write(self, oprot):
16579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16581 
      return
16582 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 16583 
    if self.ex is not None:
3064 chandransh 16584 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16585 
      self.ex.write(oprot)
1627 ankur.sing 16586 
      oprot.writeFieldEnd()
16587 
    oprot.writeFieldStop()
16588 
    oprot.writeStructEnd()
16589 
 
3431 rajveer 16590 
  def validate(self):
16591 
    return
16592 
 
16593 
 
1627 ankur.sing 16594 
  def __repr__(self):
16595 
    L = ['%s=%r' % (key, value)
16596 
      for key, value in self.__dict__.iteritems()]
16597 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16598 
 
16599 
  def __eq__(self, other):
16600 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16601 
 
16602 
  def __ne__(self, other):
16603 
    return not (self == other)
16604 
 
4910 phani.kuma 16605 
class markOrdersAsFirstDeliveryAttempted_args:
16606 
  """
16607 
  Attributes:
16608 
   - providerId
16609 
   - first_atdl_orders
16610 
  """
16611 
 
16612 
  thrift_spec = (
16613 
    None, # 0
16614 
    (1, TType.I64, 'providerId', None, None, ), # 1
16615 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
16616 
  )
16617 
 
16618 
  def __init__(self, providerId=None, first_atdl_orders=None,):
16619 
    self.providerId = providerId
16620 
    self.first_atdl_orders = first_atdl_orders
16621 
 
16622 
  def read(self, iprot):
16623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16625 
      return
16626 
    iprot.readStructBegin()
16627 
    while True:
16628 
      (fname, ftype, fid) = iprot.readFieldBegin()
16629 
      if ftype == TType.STOP:
16630 
        break
16631 
      if fid == 1:
16632 
        if ftype == TType.I64:
16633 
          self.providerId = iprot.readI64();
16634 
        else:
16635 
          iprot.skip(ftype)
16636 
      elif fid == 2:
16637 
        if ftype == TType.MAP:
16638 
          self.first_atdl_orders = {}
6188 rajveer 16639 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
16640 
          for _i388 in xrange(_size384):
16641 
            _key389 = iprot.readString();
16642 
            _val390 = iprot.readString();
16643 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 16644 
          iprot.readMapEnd()
16645 
        else:
16646 
          iprot.skip(ftype)
16647 
      else:
16648 
        iprot.skip(ftype)
16649 
      iprot.readFieldEnd()
16650 
    iprot.readStructEnd()
16651 
 
16652 
  def write(self, oprot):
16653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16655 
      return
16656 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
16657 
    if self.providerId is not None:
16658 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16659 
      oprot.writeI64(self.providerId)
16660 
      oprot.writeFieldEnd()
16661 
    if self.first_atdl_orders is not None:
16662 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
16663 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 16664 
      for kiter391,viter392 in self.first_atdl_orders.items():
16665 
        oprot.writeString(kiter391)
16666 
        oprot.writeString(viter392)
4910 phani.kuma 16667 
      oprot.writeMapEnd()
16668 
      oprot.writeFieldEnd()
16669 
    oprot.writeFieldStop()
16670 
    oprot.writeStructEnd()
16671 
 
16672 
  def validate(self):
16673 
    return
16674 
 
16675 
 
16676 
  def __repr__(self):
16677 
    L = ['%s=%r' % (key, value)
16678 
      for key, value in self.__dict__.iteritems()]
16679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16680 
 
16681 
  def __eq__(self, other):
16682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16683 
 
16684 
  def __ne__(self, other):
16685 
    return not (self == other)
16686 
 
16687 
class markOrdersAsFirstDeliveryAttempted_result:
16688 
  """
16689 
  Attributes:
16690 
   - ex
16691 
  """
16692 
 
16693 
  thrift_spec = (
16694 
    None, # 0
16695 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16696 
  )
16697 
 
16698 
  def __init__(self, ex=None,):
16699 
    self.ex = ex
16700 
 
16701 
  def read(self, iprot):
16702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16704 
      return
16705 
    iprot.readStructBegin()
16706 
    while True:
16707 
      (fname, ftype, fid) = iprot.readFieldBegin()
16708 
      if ftype == TType.STOP:
16709 
        break
16710 
      if fid == 1:
16711 
        if ftype == TType.STRUCT:
16712 
          self.ex = TransactionServiceException()
16713 
          self.ex.read(iprot)
16714 
        else:
16715 
          iprot.skip(ftype)
16716 
      else:
16717 
        iprot.skip(ftype)
16718 
      iprot.readFieldEnd()
16719 
    iprot.readStructEnd()
16720 
 
16721 
  def write(self, oprot):
16722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16724 
      return
16725 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
16726 
    if self.ex is not None:
16727 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16728 
      self.ex.write(oprot)
16729 
      oprot.writeFieldEnd()
16730 
    oprot.writeFieldStop()
16731 
    oprot.writeStructEnd()
16732 
 
16733 
  def validate(self):
16734 
    return
16735 
 
16736 
 
16737 
  def __repr__(self):
16738 
    L = ['%s=%r' % (key, value)
16739 
      for key, value in self.__dict__.iteritems()]
16740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16741 
 
16742 
  def __eq__(self, other):
16743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16744 
 
16745 
  def __ne__(self, other):
16746 
    return not (self == other)
16747 
 
3064 chandransh 16748 
class getUndeliveredOrders_args:
1886 ankur.sing 16749 
  """
16750 
  Attributes:
3064 chandransh 16751 
   - providerId
16752 
   - warehouseId
1886 ankur.sing 16753 
  """
1627 ankur.sing 16754 
 
1886 ankur.sing 16755 
  thrift_spec = (
16756 
    None, # 0
3064 chandransh 16757 
    (1, TType.I64, 'providerId', None, None, ), # 1
16758 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 16759 
  )
16760 
 
3064 chandransh 16761 
  def __init__(self, providerId=None, warehouseId=None,):
16762 
    self.providerId = providerId
16763 
    self.warehouseId = warehouseId
1886 ankur.sing 16764 
 
16765 
  def read(self, iprot):
16766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16768 
      return
16769 
    iprot.readStructBegin()
16770 
    while True:
16771 
      (fname, ftype, fid) = iprot.readFieldBegin()
16772 
      if ftype == TType.STOP:
16773 
        break
16774 
      if fid == 1:
16775 
        if ftype == TType.I64:
3064 chandransh 16776 
          self.providerId = iprot.readI64();
1886 ankur.sing 16777 
        else:
16778 
          iprot.skip(ftype)
3064 chandransh 16779 
      elif fid == 2:
16780 
        if ftype == TType.I64:
16781 
          self.warehouseId = iprot.readI64();
16782 
        else:
16783 
          iprot.skip(ftype)
1886 ankur.sing 16784 
      else:
16785 
        iprot.skip(ftype)
16786 
      iprot.readFieldEnd()
16787 
    iprot.readStructEnd()
16788 
 
16789 
  def write(self, oprot):
16790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16792 
      return
3064 chandransh 16793 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 16794 
    if self.providerId is not None:
3064 chandransh 16795 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16796 
      oprot.writeI64(self.providerId)
1886 ankur.sing 16797 
      oprot.writeFieldEnd()
3431 rajveer 16798 
    if self.warehouseId is not None:
3064 chandransh 16799 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16800 
      oprot.writeI64(self.warehouseId)
16801 
      oprot.writeFieldEnd()
1886 ankur.sing 16802 
    oprot.writeFieldStop()
16803 
    oprot.writeStructEnd()
16804 
 
3431 rajveer 16805 
  def validate(self):
16806 
    return
16807 
 
16808 
 
1886 ankur.sing 16809 
  def __repr__(self):
16810 
    L = ['%s=%r' % (key, value)
16811 
      for key, value in self.__dict__.iteritems()]
16812 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16813 
 
16814 
  def __eq__(self, other):
16815 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16816 
 
16817 
  def __ne__(self, other):
16818 
    return not (self == other)
16819 
 
3064 chandransh 16820 
class getUndeliveredOrders_result:
1886 ankur.sing 16821 
  """
16822 
  Attributes:
16823 
   - success
16824 
  """
16825 
 
16826 
  thrift_spec = (
16827 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16828 
  )
16829 
 
16830 
  def __init__(self, success=None,):
16831 
    self.success = success
16832 
 
16833 
  def read(self, iprot):
16834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16836 
      return
16837 
    iprot.readStructBegin()
16838 
    while True:
16839 
      (fname, ftype, fid) = iprot.readFieldBegin()
16840 
      if ftype == TType.STOP:
16841 
        break
16842 
      if fid == 0:
16843 
        if ftype == TType.LIST:
16844 
          self.success = []
6188 rajveer 16845 
          (_etype396, _size393) = iprot.readListBegin()
16846 
          for _i397 in xrange(_size393):
16847 
            _elem398 = Order()
16848 
            _elem398.read(iprot)
16849 
            self.success.append(_elem398)
1886 ankur.sing 16850 
          iprot.readListEnd()
16851 
        else:
16852 
          iprot.skip(ftype)
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
3064 chandransh 16862 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 16863 
    if self.success is not None:
1886 ankur.sing 16864 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16865 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16866 
      for iter399 in self.success:
16867 
        iter399.write(oprot)
1886 ankur.sing 16868 
      oprot.writeListEnd()
16869 
      oprot.writeFieldEnd()
16870 
    oprot.writeFieldStop()
16871 
    oprot.writeStructEnd()
16872 
 
3431 rajveer 16873 
  def validate(self):
16874 
    return
16875 
 
16876 
 
1886 ankur.sing 16877 
  def __repr__(self):
16878 
    L = ['%s=%r' % (key, value)
16879 
      for key, value in self.__dict__.iteritems()]
16880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16881 
 
16882 
  def __eq__(self, other):
16883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16884 
 
16885 
  def __ne__(self, other):
16886 
    return not (self == other)
16887 
 
4783 phani.kuma 16888 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
16889 
 
16890 
  thrift_spec = (
16891 
  )
16892 
 
16893 
  def read(self, iprot):
16894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16896 
      return
16897 
    iprot.readStructBegin()
16898 
    while True:
16899 
      (fname, ftype, fid) = iprot.readFieldBegin()
16900 
      if ftype == TType.STOP:
16901 
        break
16902 
      else:
16903 
        iprot.skip(ftype)
16904 
      iprot.readFieldEnd()
16905 
    iprot.readStructEnd()
16906 
 
16907 
  def write(self, oprot):
16908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16910 
      return
16911 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
16912 
    oprot.writeFieldStop()
16913 
    oprot.writeStructEnd()
16914 
 
16915 
  def validate(self):
16916 
    return
16917 
 
16918 
 
16919 
  def __repr__(self):
16920 
    L = ['%s=%r' % (key, value)
16921 
      for key, value in self.__dict__.iteritems()]
16922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16923 
 
16924 
  def __eq__(self, other):
16925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16926 
 
16927 
  def __ne__(self, other):
16928 
    return not (self == other)
16929 
 
16930 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
16931 
  """
16932 
  Attributes:
16933 
   - success
16934 
  """
16935 
 
16936 
  thrift_spec = (
16937 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16938 
  )
16939 
 
16940 
  def __init__(self, success=None,):
16941 
    self.success = success
16942 
 
16943 
  def read(self, iprot):
16944 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16945 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16946 
      return
16947 
    iprot.readStructBegin()
16948 
    while True:
16949 
      (fname, ftype, fid) = iprot.readFieldBegin()
16950 
      if ftype == TType.STOP:
16951 
        break
16952 
      if fid == 0:
16953 
        if ftype == TType.LIST:
16954 
          self.success = []
6188 rajveer 16955 
          (_etype403, _size400) = iprot.readListBegin()
16956 
          for _i404 in xrange(_size400):
16957 
            _elem405 = Order()
16958 
            _elem405.read(iprot)
16959 
            self.success.append(_elem405)
4783 phani.kuma 16960 
          iprot.readListEnd()
16961 
        else:
16962 
          iprot.skip(ftype)
16963 
      else:
16964 
        iprot.skip(ftype)
16965 
      iprot.readFieldEnd()
16966 
    iprot.readStructEnd()
16967 
 
16968 
  def write(self, oprot):
16969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16971 
      return
16972 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
16973 
    if self.success is not None:
16974 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16975 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16976 
      for iter406 in self.success:
16977 
        iter406.write(oprot)
4783 phani.kuma 16978 
      oprot.writeListEnd()
16979 
      oprot.writeFieldEnd()
16980 
    oprot.writeFieldStop()
16981 
    oprot.writeStructEnd()
16982 
 
16983 
  def validate(self):
16984 
    return
16985 
 
16986 
 
16987 
  def __repr__(self):
16988 
    L = ['%s=%r' % (key, value)
16989 
      for key, value in self.__dict__.iteritems()]
16990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16991 
 
16992 
  def __eq__(self, other):
16993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16994 
 
16995 
  def __ne__(self, other):
16996 
    return not (self == other)
16997 
 
2536 chandransh 16998 
class toggleDOAFlag_args:
16999 
  """
17000 
  Attributes:
17001 
   - orderId
17002 
  """
1886 ankur.sing 17003 
 
2536 chandransh 17004 
  thrift_spec = (
17005 
    None, # 0
17006 
    (1, TType.I64, 'orderId', None, None, ), # 1
17007 
  )
17008 
 
17009 
  def __init__(self, orderId=None,):
17010 
    self.orderId = orderId
17011 
 
17012 
  def read(self, iprot):
17013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17015 
      return
17016 
    iprot.readStructBegin()
17017 
    while True:
17018 
      (fname, ftype, fid) = iprot.readFieldBegin()
17019 
      if ftype == TType.STOP:
17020 
        break
17021 
      if fid == 1:
17022 
        if ftype == TType.I64:
17023 
          self.orderId = iprot.readI64();
17024 
        else:
17025 
          iprot.skip(ftype)
17026 
      else:
17027 
        iprot.skip(ftype)
17028 
      iprot.readFieldEnd()
17029 
    iprot.readStructEnd()
17030 
 
17031 
  def write(self, oprot):
17032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17034 
      return
17035 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 17036 
    if self.orderId is not None:
2536 chandransh 17037 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17038 
      oprot.writeI64(self.orderId)
17039 
      oprot.writeFieldEnd()
17040 
    oprot.writeFieldStop()
17041 
    oprot.writeStructEnd()
17042 
 
3431 rajveer 17043 
  def validate(self):
17044 
    return
17045 
 
17046 
 
2536 chandransh 17047 
  def __repr__(self):
17048 
    L = ['%s=%r' % (key, value)
17049 
      for key, value in self.__dict__.iteritems()]
17050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17051 
 
17052 
  def __eq__(self, other):
17053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17054 
 
17055 
  def __ne__(self, other):
17056 
    return not (self == other)
17057 
 
17058 
class toggleDOAFlag_result:
17059 
  """
17060 
  Attributes:
17061 
   - success
17062 
   - ex
17063 
  """
17064 
 
17065 
  thrift_spec = (
17066 
    (0, TType.BOOL, 'success', None, None, ), # 0
17067 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17068 
  )
17069 
 
17070 
  def __init__(self, success=None, ex=None,):
17071 
    self.success = success
17072 
    self.ex = ex
17073 
 
17074 
  def read(self, iprot):
17075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17077 
      return
17078 
    iprot.readStructBegin()
17079 
    while True:
17080 
      (fname, ftype, fid) = iprot.readFieldBegin()
17081 
      if ftype == TType.STOP:
17082 
        break
17083 
      if fid == 0:
17084 
        if ftype == TType.BOOL:
17085 
          self.success = iprot.readBool();
17086 
        else:
17087 
          iprot.skip(ftype)
17088 
      elif fid == 1:
17089 
        if ftype == TType.STRUCT:
17090 
          self.ex = TransactionServiceException()
17091 
          self.ex.read(iprot)
17092 
        else:
17093 
          iprot.skip(ftype)
17094 
      else:
17095 
        iprot.skip(ftype)
17096 
      iprot.readFieldEnd()
17097 
    iprot.readStructEnd()
17098 
 
17099 
  def write(self, oprot):
17100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17102 
      return
17103 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 17104 
    if self.success is not None:
2536 chandransh 17105 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17106 
      oprot.writeBool(self.success)
17107 
      oprot.writeFieldEnd()
3431 rajveer 17108 
    if self.ex is not None:
2536 chandransh 17109 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17110 
      self.ex.write(oprot)
17111 
      oprot.writeFieldEnd()
17112 
    oprot.writeFieldStop()
17113 
    oprot.writeStructEnd()
17114 
 
3431 rajveer 17115 
  def validate(self):
17116 
    return
17117 
 
17118 
 
2536 chandransh 17119 
  def __repr__(self):
17120 
    L = ['%s=%r' % (key, value)
17121 
      for key, value in self.__dict__.iteritems()]
17122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17123 
 
17124 
  def __eq__(self, other):
17125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17126 
 
17127 
  def __ne__(self, other):
17128 
    return not (self == other)
17129 
 
4712 rajveer 17130 
class markOrderAsDelivered_args:
17131 
  """
17132 
  Attributes:
17133 
   - orderId
17134 
   - deliveryTimestamp
17135 
   - receiver
17136 
  """
17137 
 
17138 
  thrift_spec = None
17139 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
17140 
    self.orderId = orderId
17141 
    self.deliveryTimestamp = deliveryTimestamp
17142 
    self.receiver = receiver
17143 
 
17144 
  def read(self, iprot):
17145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17147 
      return
17148 
    iprot.readStructBegin()
17149 
    while True:
17150 
      (fname, ftype, fid) = iprot.readFieldBegin()
17151 
      if ftype == TType.STOP:
17152 
        break
17153 
      if fid == 1:
17154 
        if ftype == TType.I64:
17155 
          self.orderId = iprot.readI64();
17156 
        else:
17157 
          iprot.skip(ftype)
17158 
      elif fid == 2:
17159 
        if ftype == TType.I64:
17160 
          self.deliveryTimestamp = iprot.readI64();
17161 
        else:
17162 
          iprot.skip(ftype)
17163 
      elif fid == -1:
17164 
        if ftype == TType.STRING:
17165 
          self.receiver = iprot.readString();
17166 
        else:
17167 
          iprot.skip(ftype)
17168 
      else:
17169 
        iprot.skip(ftype)
17170 
      iprot.readFieldEnd()
17171 
    iprot.readStructEnd()
17172 
 
17173 
  def write(self, oprot):
17174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17176 
      return
17177 
    oprot.writeStructBegin('markOrderAsDelivered_args')
17178 
    if self.receiver is not None:
17179 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
17180 
      oprot.writeString(self.receiver)
17181 
      oprot.writeFieldEnd()
17182 
    if self.orderId is not None:
17183 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17184 
      oprot.writeI64(self.orderId)
17185 
      oprot.writeFieldEnd()
17186 
    if self.deliveryTimestamp is not None:
17187 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
17188 
      oprot.writeI64(self.deliveryTimestamp)
17189 
      oprot.writeFieldEnd()
17190 
    oprot.writeFieldStop()
17191 
    oprot.writeStructEnd()
17192 
 
17193 
  def validate(self):
17194 
    return
17195 
 
17196 
 
17197 
  def __repr__(self):
17198 
    L = ['%s=%r' % (key, value)
17199 
      for key, value in self.__dict__.iteritems()]
17200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17201 
 
17202 
  def __eq__(self, other):
17203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17204 
 
17205 
  def __ne__(self, other):
17206 
    return not (self == other)
17207 
 
17208 
class markOrderAsDelivered_result:
17209 
  """
17210 
  Attributes:
17211 
   - ex
17212 
  """
17213 
 
17214 
  thrift_spec = (
17215 
    None, # 0
17216 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17217 
  )
17218 
 
17219 
  def __init__(self, ex=None,):
17220 
    self.ex = ex
17221 
 
17222 
  def read(self, iprot):
17223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17225 
      return
17226 
    iprot.readStructBegin()
17227 
    while True:
17228 
      (fname, ftype, fid) = iprot.readFieldBegin()
17229 
      if ftype == TType.STOP:
17230 
        break
17231 
      if fid == 1:
17232 
        if ftype == TType.STRUCT:
17233 
          self.ex = TransactionServiceException()
17234 
          self.ex.read(iprot)
17235 
        else:
17236 
          iprot.skip(ftype)
17237 
      else:
17238 
        iprot.skip(ftype)
17239 
      iprot.readFieldEnd()
17240 
    iprot.readStructEnd()
17241 
 
17242 
  def write(self, oprot):
17243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17245 
      return
17246 
    oprot.writeStructBegin('markOrderAsDelivered_result')
17247 
    if self.ex is not None:
17248 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17249 
      self.ex.write(oprot)
17250 
      oprot.writeFieldEnd()
17251 
    oprot.writeFieldStop()
17252 
    oprot.writeStructEnd()
17253 
 
17254 
  def validate(self):
17255 
    return
17256 
 
17257 
 
17258 
  def __repr__(self):
17259 
    L = ['%s=%r' % (key, value)
17260 
      for key, value in self.__dict__.iteritems()]
17261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17262 
 
17263 
  def __eq__(self, other):
17264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17265 
 
17266 
  def __ne__(self, other):
17267 
    return not (self == other)
17268 
 
5553 rajveer 17269 
class markOrderAsReceivedAtStore_args:
17270 
  """
17271 
  Attributes:
17272 
   - orderId
17273 
   - deliveryTimestamp
17274 
  """
17275 
 
17276 
  thrift_spec = (
17277 
    None, # 0
17278 
    (1, TType.I64, 'orderId', None, None, ), # 1
17279 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
17280 
  )
17281 
 
17282 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
17283 
    self.orderId = orderId
17284 
    self.deliveryTimestamp = deliveryTimestamp
17285 
 
17286 
  def read(self, iprot):
17287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17289 
      return
17290 
    iprot.readStructBegin()
17291 
    while True:
17292 
      (fname, ftype, fid) = iprot.readFieldBegin()
17293 
      if ftype == TType.STOP:
17294 
        break
17295 
      if fid == 1:
17296 
        if ftype == TType.I64:
17297 
          self.orderId = iprot.readI64();
17298 
        else:
17299 
          iprot.skip(ftype)
17300 
      elif fid == 2:
17301 
        if ftype == TType.I64:
17302 
          self.deliveryTimestamp = iprot.readI64();
17303 
        else:
17304 
          iprot.skip(ftype)
17305 
      else:
17306 
        iprot.skip(ftype)
17307 
      iprot.readFieldEnd()
17308 
    iprot.readStructEnd()
17309 
 
17310 
  def write(self, oprot):
17311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17313 
      return
17314 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
17315 
    if self.orderId is not None:
17316 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17317 
      oprot.writeI64(self.orderId)
17318 
      oprot.writeFieldEnd()
17319 
    if self.deliveryTimestamp is not None:
17320 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
17321 
      oprot.writeI64(self.deliveryTimestamp)
17322 
      oprot.writeFieldEnd()
17323 
    oprot.writeFieldStop()
17324 
    oprot.writeStructEnd()
17325 
 
17326 
  def validate(self):
17327 
    return
17328 
 
17329 
 
17330 
  def __repr__(self):
17331 
    L = ['%s=%r' % (key, value)
17332 
      for key, value in self.__dict__.iteritems()]
17333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17334 
 
17335 
  def __eq__(self, other):
17336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17337 
 
17338 
  def __ne__(self, other):
17339 
    return not (self == other)
17340 
 
17341 
class markOrderAsReceivedAtStore_result:
17342 
  """
17343 
  Attributes:
17344 
   - ex
17345 
  """
17346 
 
17347 
  thrift_spec = (
17348 
    None, # 0
17349 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17350 
  )
17351 
 
17352 
  def __init__(self, ex=None,):
17353 
    self.ex = ex
17354 
 
17355 
  def read(self, iprot):
17356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17358 
      return
17359 
    iprot.readStructBegin()
17360 
    while True:
17361 
      (fname, ftype, fid) = iprot.readFieldBegin()
17362 
      if ftype == TType.STOP:
17363 
        break
17364 
      if fid == 1:
17365 
        if ftype == TType.STRUCT:
17366 
          self.ex = TransactionServiceException()
17367 
          self.ex.read(iprot)
17368 
        else:
17369 
          iprot.skip(ftype)
17370 
      else:
17371 
        iprot.skip(ftype)
17372 
      iprot.readFieldEnd()
17373 
    iprot.readStructEnd()
17374 
 
17375 
  def write(self, oprot):
17376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17378 
      return
17379 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
17380 
    if self.ex is not None:
17381 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17382 
      self.ex.write(oprot)
17383 
      oprot.writeFieldEnd()
17384 
    oprot.writeFieldStop()
17385 
    oprot.writeStructEnd()
17386 
 
17387 
  def validate(self):
17388 
    return
17389 
 
17390 
 
17391 
  def __repr__(self):
17392 
    L = ['%s=%r' % (key, value)
17393 
      for key, value in self.__dict__.iteritems()]
17394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17395 
 
17396 
  def __eq__(self, other):
17397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17398 
 
17399 
  def __ne__(self, other):
17400 
    return not (self == other)
17401 
 
4454 rajveer 17402 
class markOrderDoaRequestReceived_args:
17403 
  """
17404 
  Attributes:
17405 
   - orderId
17406 
  """
17407 
 
17408 
  thrift_spec = (
17409 
    None, # 0
17410 
    (1, TType.I64, 'orderId', None, None, ), # 1
17411 
  )
17412 
 
17413 
  def __init__(self, orderId=None,):
17414 
    self.orderId = orderId
17415 
 
17416 
  def read(self, iprot):
17417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17419 
      return
17420 
    iprot.readStructBegin()
17421 
    while True:
17422 
      (fname, ftype, fid) = iprot.readFieldBegin()
17423 
      if ftype == TType.STOP:
17424 
        break
17425 
      if fid == 1:
17426 
        if ftype == TType.I64:
17427 
          self.orderId = iprot.readI64();
17428 
        else:
17429 
          iprot.skip(ftype)
17430 
      else:
17431 
        iprot.skip(ftype)
17432 
      iprot.readFieldEnd()
17433 
    iprot.readStructEnd()
17434 
 
17435 
  def write(self, oprot):
17436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17438 
      return
17439 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
17440 
    if self.orderId is not None:
17441 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17442 
      oprot.writeI64(self.orderId)
17443 
      oprot.writeFieldEnd()
17444 
    oprot.writeFieldStop()
17445 
    oprot.writeStructEnd()
17446 
 
17447 
  def validate(self):
17448 
    return
17449 
 
17450 
 
17451 
  def __repr__(self):
17452 
    L = ['%s=%r' % (key, value)
17453 
      for key, value in self.__dict__.iteritems()]
17454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17455 
 
17456 
  def __eq__(self, other):
17457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17458 
 
17459 
  def __ne__(self, other):
17460 
    return not (self == other)
17461 
 
17462 
class markOrderDoaRequestReceived_result:
17463 
  """
17464 
  Attributes:
17465 
   - success
17466 
   - ex
17467 
  """
17468 
 
17469 
  thrift_spec = (
17470 
    (0, TType.BOOL, 'success', None, None, ), # 0
17471 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17472 
  )
17473 
 
17474 
  def __init__(self, success=None, ex=None,):
17475 
    self.success = success
17476 
    self.ex = ex
17477 
 
17478 
  def read(self, iprot):
17479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17481 
      return
17482 
    iprot.readStructBegin()
17483 
    while True:
17484 
      (fname, ftype, fid) = iprot.readFieldBegin()
17485 
      if ftype == TType.STOP:
17486 
        break
17487 
      if fid == 0:
17488 
        if ftype == TType.BOOL:
17489 
          self.success = iprot.readBool();
17490 
        else:
17491 
          iprot.skip(ftype)
17492 
      elif fid == 1:
17493 
        if ftype == TType.STRUCT:
17494 
          self.ex = TransactionServiceException()
17495 
          self.ex.read(iprot)
17496 
        else:
17497 
          iprot.skip(ftype)
17498 
      else:
17499 
        iprot.skip(ftype)
17500 
      iprot.readFieldEnd()
17501 
    iprot.readStructEnd()
17502 
 
17503 
  def write(self, oprot):
17504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17506 
      return
17507 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
17508 
    if self.success is not None:
17509 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17510 
      oprot.writeBool(self.success)
17511 
      oprot.writeFieldEnd()
17512 
    if self.ex is not None:
17513 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17514 
      self.ex.write(oprot)
17515 
      oprot.writeFieldEnd()
17516 
    oprot.writeFieldStop()
17517 
    oprot.writeStructEnd()
17518 
 
17519 
  def validate(self):
17520 
    return
17521 
 
17522 
 
17523 
  def __repr__(self):
17524 
    L = ['%s=%r' % (key, value)
17525 
      for key, value in self.__dict__.iteritems()]
17526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17527 
 
17528 
  def __eq__(self, other):
17529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17530 
 
17531 
  def __ne__(self, other):
17532 
    return not (self == other)
17533 
 
17534 
class markOrderDoaRequestAuthorized_args:
17535 
  """
17536 
  Attributes:
17537 
   - orderId
17538 
   - isAuthorized
17539 
  """
17540 
 
17541 
  thrift_spec = (
17542 
    None, # 0
17543 
    (1, TType.I64, 'orderId', None, None, ), # 1
17544 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17545 
  )
17546 
 
17547 
  def __init__(self, orderId=None, isAuthorized=None,):
17548 
    self.orderId = orderId
17549 
    self.isAuthorized = isAuthorized
17550 
 
17551 
  def read(self, iprot):
17552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17554 
      return
17555 
    iprot.readStructBegin()
17556 
    while True:
17557 
      (fname, ftype, fid) = iprot.readFieldBegin()
17558 
      if ftype == TType.STOP:
17559 
        break
17560 
      if fid == 1:
17561 
        if ftype == TType.I64:
17562 
          self.orderId = iprot.readI64();
17563 
        else:
17564 
          iprot.skip(ftype)
17565 
      elif fid == 2:
17566 
        if ftype == TType.BOOL:
17567 
          self.isAuthorized = iprot.readBool();
17568 
        else:
17569 
          iprot.skip(ftype)
17570 
      else:
17571 
        iprot.skip(ftype)
17572 
      iprot.readFieldEnd()
17573 
    iprot.readStructEnd()
17574 
 
17575 
  def write(self, oprot):
17576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17578 
      return
17579 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
17580 
    if self.orderId is not None:
17581 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17582 
      oprot.writeI64(self.orderId)
17583 
      oprot.writeFieldEnd()
17584 
    if self.isAuthorized is not None:
17585 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17586 
      oprot.writeBool(self.isAuthorized)
17587 
      oprot.writeFieldEnd()
17588 
    oprot.writeFieldStop()
17589 
    oprot.writeStructEnd()
17590 
 
17591 
  def validate(self):
17592 
    return
17593 
 
17594 
 
17595 
  def __repr__(self):
17596 
    L = ['%s=%r' % (key, value)
17597 
      for key, value in self.__dict__.iteritems()]
17598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17599 
 
17600 
  def __eq__(self, other):
17601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17602 
 
17603 
  def __ne__(self, other):
17604 
    return not (self == other)
17605 
 
17606 
class markOrderDoaRequestAuthorized_result:
17607 
  """
17608 
  Attributes:
17609 
   - success
17610 
   - ex
17611 
  """
17612 
 
17613 
  thrift_spec = (
17614 
    (0, TType.BOOL, 'success', None, None, ), # 0
17615 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17616 
  )
17617 
 
17618 
  def __init__(self, success=None, ex=None,):
17619 
    self.success = success
17620 
    self.ex = ex
17621 
 
17622 
  def read(self, iprot):
17623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17625 
      return
17626 
    iprot.readStructBegin()
17627 
    while True:
17628 
      (fname, ftype, fid) = iprot.readFieldBegin()
17629 
      if ftype == TType.STOP:
17630 
        break
17631 
      if fid == 0:
17632 
        if ftype == TType.BOOL:
17633 
          self.success = iprot.readBool();
17634 
        else:
17635 
          iprot.skip(ftype)
17636 
      elif fid == 1:
17637 
        if ftype == TType.STRUCT:
17638 
          self.ex = TransactionServiceException()
17639 
          self.ex.read(iprot)
17640 
        else:
17641 
          iprot.skip(ftype)
17642 
      else:
17643 
        iprot.skip(ftype)
17644 
      iprot.readFieldEnd()
17645 
    iprot.readStructEnd()
17646 
 
17647 
  def write(self, oprot):
17648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17650 
      return
17651 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
17652 
    if self.success is not None:
17653 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17654 
      oprot.writeBool(self.success)
17655 
      oprot.writeFieldEnd()
17656 
    if self.ex is not None:
17657 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17658 
      self.ex.write(oprot)
17659 
      oprot.writeFieldEnd()
17660 
    oprot.writeFieldStop()
17661 
    oprot.writeStructEnd()
17662 
 
17663 
  def validate(self):
17664 
    return
17665 
 
17666 
 
17667 
  def __repr__(self):
17668 
    L = ['%s=%r' % (key, value)
17669 
      for key, value in self.__dict__.iteritems()]
17670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17671 
 
17672 
  def __eq__(self, other):
17673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17674 
 
17675 
  def __ne__(self, other):
17676 
    return not (self == other)
17677 
 
4488 rajveer 17678 
class markOrderReturnRequestReceived_args:
17679 
  """
17680 
  Attributes:
17681 
   - orderId
17682 
  """
17683 
 
17684 
  thrift_spec = (
17685 
    None, # 0
17686 
    (1, TType.I64, 'orderId', None, None, ), # 1
17687 
  )
17688 
 
17689 
  def __init__(self, orderId=None,):
17690 
    self.orderId = orderId
17691 
 
17692 
  def read(self, iprot):
17693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17695 
      return
17696 
    iprot.readStructBegin()
17697 
    while True:
17698 
      (fname, ftype, fid) = iprot.readFieldBegin()
17699 
      if ftype == TType.STOP:
17700 
        break
17701 
      if fid == 1:
17702 
        if ftype == TType.I64:
17703 
          self.orderId = iprot.readI64();
17704 
        else:
17705 
          iprot.skip(ftype)
17706 
      else:
17707 
        iprot.skip(ftype)
17708 
      iprot.readFieldEnd()
17709 
    iprot.readStructEnd()
17710 
 
17711 
  def write(self, oprot):
17712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17714 
      return
17715 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
17716 
    if self.orderId is not None:
17717 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17718 
      oprot.writeI64(self.orderId)
17719 
      oprot.writeFieldEnd()
17720 
    oprot.writeFieldStop()
17721 
    oprot.writeStructEnd()
17722 
 
17723 
  def validate(self):
17724 
    return
17725 
 
17726 
 
17727 
  def __repr__(self):
17728 
    L = ['%s=%r' % (key, value)
17729 
      for key, value in self.__dict__.iteritems()]
17730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17731 
 
17732 
  def __eq__(self, other):
17733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17734 
 
17735 
  def __ne__(self, other):
17736 
    return not (self == other)
17737 
 
17738 
class markOrderReturnRequestReceived_result:
17739 
  """
17740 
  Attributes:
17741 
   - success
17742 
   - ex
17743 
  """
17744 
 
17745 
  thrift_spec = (
17746 
    (0, TType.BOOL, 'success', None, None, ), # 0
17747 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17748 
  )
17749 
 
17750 
  def __init__(self, success=None, ex=None,):
17751 
    self.success = success
17752 
    self.ex = ex
17753 
 
17754 
  def read(self, iprot):
17755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17757 
      return
17758 
    iprot.readStructBegin()
17759 
    while True:
17760 
      (fname, ftype, fid) = iprot.readFieldBegin()
17761 
      if ftype == TType.STOP:
17762 
        break
17763 
      if fid == 0:
17764 
        if ftype == TType.BOOL:
17765 
          self.success = iprot.readBool();
17766 
        else:
17767 
          iprot.skip(ftype)
17768 
      elif fid == 1:
17769 
        if ftype == TType.STRUCT:
17770 
          self.ex = TransactionServiceException()
17771 
          self.ex.read(iprot)
17772 
        else:
17773 
          iprot.skip(ftype)
17774 
      else:
17775 
        iprot.skip(ftype)
17776 
      iprot.readFieldEnd()
17777 
    iprot.readStructEnd()
17778 
 
17779 
  def write(self, oprot):
17780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17782 
      return
17783 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
17784 
    if self.success is not None:
17785 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17786 
      oprot.writeBool(self.success)
17787 
      oprot.writeFieldEnd()
17788 
    if self.ex is not None:
17789 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17790 
      self.ex.write(oprot)
17791 
      oprot.writeFieldEnd()
17792 
    oprot.writeFieldStop()
17793 
    oprot.writeStructEnd()
17794 
 
17795 
  def validate(self):
17796 
    return
17797 
 
17798 
 
17799 
  def __repr__(self):
17800 
    L = ['%s=%r' % (key, value)
17801 
      for key, value in self.__dict__.iteritems()]
17802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17803 
 
17804 
  def __eq__(self, other):
17805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17806 
 
17807 
  def __ne__(self, other):
17808 
    return not (self == other)
17809 
 
17810 
class markOrderReturnRequestAuthorized_args:
17811 
  """
17812 
  Attributes:
17813 
   - orderId
17814 
   - isAuthorized
17815 
  """
17816 
 
17817 
  thrift_spec = (
17818 
    None, # 0
17819 
    (1, TType.I64, 'orderId', None, None, ), # 1
17820 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17821 
  )
17822 
 
17823 
  def __init__(self, orderId=None, isAuthorized=None,):
17824 
    self.orderId = orderId
17825 
    self.isAuthorized = isAuthorized
17826 
 
17827 
  def read(self, iprot):
17828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17830 
      return
17831 
    iprot.readStructBegin()
17832 
    while True:
17833 
      (fname, ftype, fid) = iprot.readFieldBegin()
17834 
      if ftype == TType.STOP:
17835 
        break
17836 
      if fid == 1:
17837 
        if ftype == TType.I64:
17838 
          self.orderId = iprot.readI64();
17839 
        else:
17840 
          iprot.skip(ftype)
17841 
      elif fid == 2:
17842 
        if ftype == TType.BOOL:
17843 
          self.isAuthorized = iprot.readBool();
17844 
        else:
17845 
          iprot.skip(ftype)
17846 
      else:
17847 
        iprot.skip(ftype)
17848 
      iprot.readFieldEnd()
17849 
    iprot.readStructEnd()
17850 
 
17851 
  def write(self, oprot):
17852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17854 
      return
17855 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
17856 
    if self.orderId is not None:
17857 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17858 
      oprot.writeI64(self.orderId)
17859 
      oprot.writeFieldEnd()
17860 
    if self.isAuthorized is not None:
17861 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17862 
      oprot.writeBool(self.isAuthorized)
17863 
      oprot.writeFieldEnd()
17864 
    oprot.writeFieldStop()
17865 
    oprot.writeStructEnd()
17866 
 
17867 
  def validate(self):
17868 
    return
17869 
 
17870 
 
17871 
  def __repr__(self):
17872 
    L = ['%s=%r' % (key, value)
17873 
      for key, value in self.__dict__.iteritems()]
17874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17875 
 
17876 
  def __eq__(self, other):
17877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17878 
 
17879 
  def __ne__(self, other):
17880 
    return not (self == other)
17881 
 
17882 
class markOrderReturnRequestAuthorized_result:
17883 
  """
17884 
  Attributes:
17885 
   - success
17886 
   - ex
17887 
  """
17888 
 
17889 
  thrift_spec = (
17890 
    (0, TType.BOOL, 'success', None, None, ), # 0
17891 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17892 
  )
17893 
 
17894 
  def __init__(self, success=None, ex=None,):
17895 
    self.success = success
17896 
    self.ex = ex
17897 
 
17898 
  def read(self, iprot):
17899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17901 
      return
17902 
    iprot.readStructBegin()
17903 
    while True:
17904 
      (fname, ftype, fid) = iprot.readFieldBegin()
17905 
      if ftype == TType.STOP:
17906 
        break
17907 
      if fid == 0:
17908 
        if ftype == TType.BOOL:
17909 
          self.success = iprot.readBool();
17910 
        else:
17911 
          iprot.skip(ftype)
17912 
      elif fid == 1:
17913 
        if ftype == TType.STRUCT:
17914 
          self.ex = TransactionServiceException()
17915 
          self.ex.read(iprot)
17916 
        else:
17917 
          iprot.skip(ftype)
17918 
      else:
17919 
        iprot.skip(ftype)
17920 
      iprot.readFieldEnd()
17921 
    iprot.readStructEnd()
17922 
 
17923 
  def write(self, oprot):
17924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17926 
      return
17927 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
17928 
    if self.success is not None:
17929 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17930 
      oprot.writeBool(self.success)
17931 
      oprot.writeFieldEnd()
17932 
    if self.ex is not None:
17933 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17934 
      self.ex.write(oprot)
17935 
      oprot.writeFieldEnd()
17936 
    oprot.writeFieldStop()
17937 
    oprot.writeStructEnd()
17938 
 
17939 
  def validate(self):
17940 
    return
17941 
 
17942 
 
17943 
  def __repr__(self):
17944 
    L = ['%s=%r' % (key, value)
17945 
      for key, value in self.__dict__.iteritems()]
17946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17947 
 
17948 
  def __eq__(self, other):
17949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17950 
 
17951 
  def __ne__(self, other):
17952 
    return not (self == other)
17953 
 
2536 chandransh 17954 
class requestPickupNumber_args:
17955 
  """
17956 
  Attributes:
17957 
   - orderId
4579 rajveer 17958 
   - providerId
2536 chandransh 17959 
  """
17960 
 
17961 
  thrift_spec = (
17962 
    None, # 0
17963 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 17964 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 17965 
  )
17966 
 
4579 rajveer 17967 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 17968 
    self.orderId = orderId
4579 rajveer 17969 
    self.providerId = providerId
2536 chandransh 17970 
 
17971 
  def read(self, iprot):
17972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17974 
      return
17975 
    iprot.readStructBegin()
17976 
    while True:
17977 
      (fname, ftype, fid) = iprot.readFieldBegin()
17978 
      if ftype == TType.STOP:
17979 
        break
17980 
      if fid == 1:
17981 
        if ftype == TType.I64:
17982 
          self.orderId = iprot.readI64();
17983 
        else:
17984 
          iprot.skip(ftype)
4579 rajveer 17985 
      elif fid == 2:
17986 
        if ftype == TType.I64:
17987 
          self.providerId = iprot.readI64();
17988 
        else:
17989 
          iprot.skip(ftype)
2536 chandransh 17990 
      else:
17991 
        iprot.skip(ftype)
17992 
      iprot.readFieldEnd()
17993 
    iprot.readStructEnd()
17994 
 
17995 
  def write(self, oprot):
17996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17998 
      return
17999 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 18000 
    if self.orderId is not None:
2536 chandransh 18001 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18002 
      oprot.writeI64(self.orderId)
18003 
      oprot.writeFieldEnd()
4579 rajveer 18004 
    if self.providerId is not None:
18005 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
18006 
      oprot.writeI64(self.providerId)
18007 
      oprot.writeFieldEnd()
2536 chandransh 18008 
    oprot.writeFieldStop()
18009 
    oprot.writeStructEnd()
18010 
 
3431 rajveer 18011 
  def validate(self):
18012 
    return
18013 
 
18014 
 
2536 chandransh 18015 
  def __repr__(self):
18016 
    L = ['%s=%r' % (key, value)
18017 
      for key, value in self.__dict__.iteritems()]
18018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18019 
 
18020 
  def __eq__(self, other):
18021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18022 
 
18023 
  def __ne__(self, other):
18024 
    return not (self == other)
18025 
 
18026 
class requestPickupNumber_result:
18027 
  """
18028 
  Attributes:
18029 
   - success
18030 
   - ex
18031 
  """
18032 
 
18033 
  thrift_spec = (
18034 
    (0, TType.BOOL, 'success', None, None, ), # 0
18035 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18036 
  )
18037 
 
18038 
  def __init__(self, success=None, ex=None,):
18039 
    self.success = success
18040 
    self.ex = ex
18041 
 
18042 
  def read(self, iprot):
18043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18045 
      return
18046 
    iprot.readStructBegin()
18047 
    while True:
18048 
      (fname, ftype, fid) = iprot.readFieldBegin()
18049 
      if ftype == TType.STOP:
18050 
        break
18051 
      if fid == 0:
18052 
        if ftype == TType.BOOL:
18053 
          self.success = iprot.readBool();
18054 
        else:
18055 
          iprot.skip(ftype)
18056 
      elif fid == 1:
18057 
        if ftype == TType.STRUCT:
18058 
          self.ex = TransactionServiceException()
18059 
          self.ex.read(iprot)
18060 
        else:
18061 
          iprot.skip(ftype)
18062 
      else:
18063 
        iprot.skip(ftype)
18064 
      iprot.readFieldEnd()
18065 
    iprot.readStructEnd()
18066 
 
18067 
  def write(self, oprot):
18068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18070 
      return
18071 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 18072 
    if self.success is not None:
2536 chandransh 18073 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18074 
      oprot.writeBool(self.success)
18075 
      oprot.writeFieldEnd()
3431 rajveer 18076 
    if self.ex is not None:
2536 chandransh 18077 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18078 
      self.ex.write(oprot)
18079 
      oprot.writeFieldEnd()
18080 
    oprot.writeFieldStop()
18081 
    oprot.writeStructEnd()
18082 
 
3431 rajveer 18083 
  def validate(self):
18084 
    return
18085 
 
18086 
 
2536 chandransh 18087 
  def __repr__(self):
18088 
    L = ['%s=%r' % (key, value)
18089 
      for key, value in self.__dict__.iteritems()]
18090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18091 
 
18092 
  def __eq__(self, other):
18093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18094 
 
18095 
  def __ne__(self, other):
18096 
    return not (self == other)
18097 
 
18098 
class authorizePickup_args:
18099 
  """
18100 
  Attributes:
18101 
   - orderId
18102 
   - pickupNumber
4602 rajveer 18103 
   - providerId
2536 chandransh 18104 
  """
18105 
 
18106 
  thrift_spec = (
18107 
    None, # 0
18108 
    (1, TType.I64, 'orderId', None, None, ), # 1
18109 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 18110 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 18111 
  )
18112 
 
4602 rajveer 18113 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 18114 
    self.orderId = orderId
18115 
    self.pickupNumber = pickupNumber
4602 rajveer 18116 
    self.providerId = providerId
2536 chandransh 18117 
 
18118 
  def read(self, iprot):
18119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18121 
      return
18122 
    iprot.readStructBegin()
18123 
    while True:
18124 
      (fname, ftype, fid) = iprot.readFieldBegin()
18125 
      if ftype == TType.STOP:
18126 
        break
18127 
      if fid == 1:
18128 
        if ftype == TType.I64:
18129 
          self.orderId = iprot.readI64();
18130 
        else:
18131 
          iprot.skip(ftype)
18132 
      elif fid == 2:
18133 
        if ftype == TType.STRING:
18134 
          self.pickupNumber = iprot.readString();
18135 
        else:
18136 
          iprot.skip(ftype)
4602 rajveer 18137 
      elif fid == 3:
18138 
        if ftype == TType.I64:
18139 
          self.providerId = iprot.readI64();
18140 
        else:
18141 
          iprot.skip(ftype)
2536 chandransh 18142 
      else:
18143 
        iprot.skip(ftype)
18144 
      iprot.readFieldEnd()
18145 
    iprot.readStructEnd()
18146 
 
18147 
  def write(self, oprot):
18148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18150 
      return
18151 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 18152 
    if self.orderId is not None:
2536 chandransh 18153 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18154 
      oprot.writeI64(self.orderId)
18155 
      oprot.writeFieldEnd()
3431 rajveer 18156 
    if self.pickupNumber is not None:
2536 chandransh 18157 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
18158 
      oprot.writeString(self.pickupNumber)
18159 
      oprot.writeFieldEnd()
4602 rajveer 18160 
    if self.providerId is not None:
18161 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
18162 
      oprot.writeI64(self.providerId)
18163 
      oprot.writeFieldEnd()
2536 chandransh 18164 
    oprot.writeFieldStop()
18165 
    oprot.writeStructEnd()
18166 
 
3431 rajveer 18167 
  def validate(self):
18168 
    return
18169 
 
18170 
 
2536 chandransh 18171 
  def __repr__(self):
18172 
    L = ['%s=%r' % (key, value)
18173 
      for key, value in self.__dict__.iteritems()]
18174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18175 
 
18176 
  def __eq__(self, other):
18177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18178 
 
18179 
  def __ne__(self, other):
18180 
    return not (self == other)
18181 
 
18182 
class authorizePickup_result:
18183 
  """
18184 
  Attributes:
18185 
   - success
18186 
   - ex
18187 
  """
18188 
 
18189 
  thrift_spec = (
18190 
    (0, TType.BOOL, 'success', None, None, ), # 0
18191 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18192 
  )
18193 
 
18194 
  def __init__(self, success=None, ex=None,):
18195 
    self.success = success
18196 
    self.ex = ex
18197 
 
18198 
  def read(self, iprot):
18199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18201 
      return
18202 
    iprot.readStructBegin()
18203 
    while True:
18204 
      (fname, ftype, fid) = iprot.readFieldBegin()
18205 
      if ftype == TType.STOP:
18206 
        break
18207 
      if fid == 0:
18208 
        if ftype == TType.BOOL:
18209 
          self.success = iprot.readBool();
18210 
        else:
18211 
          iprot.skip(ftype)
18212 
      elif fid == 1:
18213 
        if ftype == TType.STRUCT:
18214 
          self.ex = TransactionServiceException()
18215 
          self.ex.read(iprot)
18216 
        else:
18217 
          iprot.skip(ftype)
18218 
      else:
18219 
        iprot.skip(ftype)
18220 
      iprot.readFieldEnd()
18221 
    iprot.readStructEnd()
18222 
 
18223 
  def write(self, oprot):
18224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18226 
      return
18227 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 18228 
    if self.success is not None:
2536 chandransh 18229 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18230 
      oprot.writeBool(self.success)
18231 
      oprot.writeFieldEnd()
3431 rajveer 18232 
    if self.ex is not None:
2536 chandransh 18233 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18234 
      self.ex.write(oprot)
18235 
      oprot.writeFieldEnd()
18236 
    oprot.writeFieldStop()
18237 
    oprot.writeStructEnd()
18238 
 
3431 rajveer 18239 
  def validate(self):
18240 
    return
18241 
 
18242 
 
2536 chandransh 18243 
  def __repr__(self):
18244 
    L = ['%s=%r' % (key, value)
18245 
      for key, value in self.__dict__.iteritems()]
18246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18247 
 
18248 
  def __eq__(self, other):
18249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18250 
 
18251 
  def __ne__(self, other):
18252 
    return not (self == other)
18253 
 
2764 chandransh 18254 
class markDoasAsPickedUp_args:
18255 
  """
18256 
  Attributes:
18257 
   - providerId
18258 
   - pickupDetails
18259 
  """
18260 
 
18261 
  thrift_spec = (
18262 
    None, # 0
18263 
    (1, TType.I64, 'providerId', None, None, ), # 1
18264 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
18265 
  )
18266 
 
18267 
  def __init__(self, providerId=None, pickupDetails=None,):
18268 
    self.providerId = providerId
18269 
    self.pickupDetails = pickupDetails
18270 
 
18271 
  def read(self, iprot):
18272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18274 
      return
18275 
    iprot.readStructBegin()
18276 
    while True:
18277 
      (fname, ftype, fid) = iprot.readFieldBegin()
18278 
      if ftype == TType.STOP:
18279 
        break
18280 
      if fid == 1:
18281 
        if ftype == TType.I64:
18282 
          self.providerId = iprot.readI64();
18283 
        else:
18284 
          iprot.skip(ftype)
18285 
      elif fid == 2:
18286 
        if ftype == TType.MAP:
18287 
          self.pickupDetails = {}
6188 rajveer 18288 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
18289 
          for _i411 in xrange(_size407):
18290 
            _key412 = iprot.readString();
18291 
            _val413 = iprot.readString();
18292 
            self.pickupDetails[_key412] = _val413
2764 chandransh 18293 
          iprot.readMapEnd()
18294 
        else:
18295 
          iprot.skip(ftype)
18296 
      else:
18297 
        iprot.skip(ftype)
18298 
      iprot.readFieldEnd()
18299 
    iprot.readStructEnd()
18300 
 
18301 
  def write(self, oprot):
18302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18304 
      return
18305 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 18306 
    if self.providerId is not None:
2764 chandransh 18307 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18308 
      oprot.writeI64(self.providerId)
18309 
      oprot.writeFieldEnd()
3431 rajveer 18310 
    if self.pickupDetails is not None:
2764 chandransh 18311 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
18312 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 18313 
      for kiter414,viter415 in self.pickupDetails.items():
18314 
        oprot.writeString(kiter414)
18315 
        oprot.writeString(viter415)
2764 chandransh 18316 
      oprot.writeMapEnd()
18317 
      oprot.writeFieldEnd()
18318 
    oprot.writeFieldStop()
18319 
    oprot.writeStructEnd()
18320 
 
3431 rajveer 18321 
  def validate(self):
18322 
    return
18323 
 
18324 
 
2764 chandransh 18325 
  def __repr__(self):
18326 
    L = ['%s=%r' % (key, value)
18327 
      for key, value in self.__dict__.iteritems()]
18328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18329 
 
18330 
  def __eq__(self, other):
18331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18332 
 
18333 
  def __ne__(self, other):
18334 
    return not (self == other)
18335 
 
18336 
class markDoasAsPickedUp_result:
4910 phani.kuma 18337 
 
18338 
  thrift_spec = (
18339 
  )
18340 
 
18341 
  def read(self, iprot):
18342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18344 
      return
18345 
    iprot.readStructBegin()
18346 
    while True:
18347 
      (fname, ftype, fid) = iprot.readFieldBegin()
18348 
      if ftype == TType.STOP:
18349 
        break
18350 
      else:
18351 
        iprot.skip(ftype)
18352 
      iprot.readFieldEnd()
18353 
    iprot.readStructEnd()
18354 
 
18355 
  def write(self, oprot):
18356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18358 
      return
18359 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
18360 
    oprot.writeFieldStop()
18361 
    oprot.writeStructEnd()
18362 
 
18363 
  def validate(self):
18364 
    return
18365 
 
18366 
 
18367 
  def __repr__(self):
18368 
    L = ['%s=%r' % (key, value)
18369 
      for key, value in self.__dict__.iteritems()]
18370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18371 
 
18372 
  def __eq__(self, other):
18373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18374 
 
18375 
  def __ne__(self, other):
18376 
    return not (self == other)
18377 
 
18378 
class getDoasNotPickedUp_args:
2764 chandransh 18379 
  """
18380 
  Attributes:
4910 phani.kuma 18381 
   - providerId
18382 
  """
18383 
 
18384 
  thrift_spec = (
18385 
    None, # 0
18386 
    (1, TType.I64, 'providerId', None, None, ), # 1
18387 
  )
18388 
 
18389 
  def __init__(self, providerId=None,):
18390 
    self.providerId = providerId
18391 
 
18392 
  def read(self, iprot):
18393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18395 
      return
18396 
    iprot.readStructBegin()
18397 
    while True:
18398 
      (fname, ftype, fid) = iprot.readFieldBegin()
18399 
      if ftype == TType.STOP:
18400 
        break
18401 
      if fid == 1:
18402 
        if ftype == TType.I64:
18403 
          self.providerId = iprot.readI64();
18404 
        else:
18405 
          iprot.skip(ftype)
18406 
      else:
18407 
        iprot.skip(ftype)
18408 
      iprot.readFieldEnd()
18409 
    iprot.readStructEnd()
18410 
 
18411 
  def write(self, oprot):
18412 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18413 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18414 
      return
18415 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
18416 
    if self.providerId is not None:
18417 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18418 
      oprot.writeI64(self.providerId)
18419 
      oprot.writeFieldEnd()
18420 
    oprot.writeFieldStop()
18421 
    oprot.writeStructEnd()
18422 
 
18423 
  def validate(self):
18424 
    return
18425 
 
18426 
 
18427 
  def __repr__(self):
18428 
    L = ['%s=%r' % (key, value)
18429 
      for key, value in self.__dict__.iteritems()]
18430 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18431 
 
18432 
  def __eq__(self, other):
18433 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18434 
 
18435 
  def __ne__(self, other):
18436 
    return not (self == other)
18437 
 
18438 
class getDoasNotPickedUp_result:
18439 
  """
18440 
  Attributes:
2764 chandransh 18441 
   - success
18442 
  """
18443 
 
18444 
  thrift_spec = (
18445 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18446 
  )
18447 
 
18448 
  def __init__(self, success=None,):
18449 
    self.success = success
18450 
 
18451 
  def read(self, iprot):
18452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18454 
      return
18455 
    iprot.readStructBegin()
18456 
    while True:
18457 
      (fname, ftype, fid) = iprot.readFieldBegin()
18458 
      if ftype == TType.STOP:
18459 
        break
18460 
      if fid == 0:
18461 
        if ftype == TType.LIST:
18462 
          self.success = []
6188 rajveer 18463 
          (_etype419, _size416) = iprot.readListBegin()
18464 
          for _i420 in xrange(_size416):
18465 
            _elem421 = Order()
18466 
            _elem421.read(iprot)
18467 
            self.success.append(_elem421)
2764 chandransh 18468 
          iprot.readListEnd()
18469 
        else:
18470 
          iprot.skip(ftype)
18471 
      else:
18472 
        iprot.skip(ftype)
18473 
      iprot.readFieldEnd()
18474 
    iprot.readStructEnd()
18475 
 
18476 
  def write(self, oprot):
18477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18479 
      return
4910 phani.kuma 18480 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 18481 
    if self.success is not None:
2764 chandransh 18482 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18483 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18484 
      for iter422 in self.success:
18485 
        iter422.write(oprot)
2764 chandransh 18486 
      oprot.writeListEnd()
18487 
      oprot.writeFieldEnd()
18488 
    oprot.writeFieldStop()
18489 
    oprot.writeStructEnd()
18490 
 
3431 rajveer 18491 
  def validate(self):
18492 
    return
18493 
 
18494 
 
2764 chandransh 18495 
  def __repr__(self):
18496 
    L = ['%s=%r' % (key, value)
18497 
      for key, value in self.__dict__.iteritems()]
18498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18499 
 
18500 
  def __eq__(self, other):
18501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18502 
 
18503 
  def __ne__(self, other):
18504 
    return not (self == other)
18505 
 
4741 phani.kuma 18506 
class markReturnOrdersAsPickedUp_args:
18507 
  """
18508 
  Attributes:
18509 
   - providerId
18510 
   - pickupDetails
18511 
  """
18512 
 
18513 
  thrift_spec = (
18514 
    None, # 0
18515 
    (1, TType.I64, 'providerId', None, None, ), # 1
18516 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
18517 
  )
18518 
 
18519 
  def __init__(self, providerId=None, pickupDetails=None,):
18520 
    self.providerId = providerId
18521 
    self.pickupDetails = pickupDetails
18522 
 
18523 
  def read(self, iprot):
18524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18526 
      return
18527 
    iprot.readStructBegin()
18528 
    while True:
18529 
      (fname, ftype, fid) = iprot.readFieldBegin()
18530 
      if ftype == TType.STOP:
18531 
        break
18532 
      if fid == 1:
18533 
        if ftype == TType.I64:
18534 
          self.providerId = iprot.readI64();
18535 
        else:
18536 
          iprot.skip(ftype)
18537 
      elif fid == 2:
18538 
        if ftype == TType.MAP:
18539 
          self.pickupDetails = {}
6188 rajveer 18540 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
18541 
          for _i427 in xrange(_size423):
18542 
            _key428 = iprot.readString();
18543 
            _val429 = iprot.readString();
18544 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 18545 
          iprot.readMapEnd()
18546 
        else:
18547 
          iprot.skip(ftype)
18548 
      else:
18549 
        iprot.skip(ftype)
18550 
      iprot.readFieldEnd()
18551 
    iprot.readStructEnd()
18552 
 
18553 
  def write(self, oprot):
18554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18556 
      return
18557 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
18558 
    if self.providerId is not None:
18559 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18560 
      oprot.writeI64(self.providerId)
18561 
      oprot.writeFieldEnd()
18562 
    if self.pickupDetails is not None:
18563 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
18564 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 18565 
      for kiter430,viter431 in self.pickupDetails.items():
18566 
        oprot.writeString(kiter430)
18567 
        oprot.writeString(viter431)
4741 phani.kuma 18568 
      oprot.writeMapEnd()
18569 
      oprot.writeFieldEnd()
18570 
    oprot.writeFieldStop()
18571 
    oprot.writeStructEnd()
18572 
 
18573 
  def validate(self):
18574 
    return
18575 
 
18576 
 
18577 
  def __repr__(self):
18578 
    L = ['%s=%r' % (key, value)
18579 
      for key, value in self.__dict__.iteritems()]
18580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18581 
 
18582 
  def __eq__(self, other):
18583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18584 
 
18585 
  def __ne__(self, other):
18586 
    return not (self == other)
18587 
 
18588 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 18589 
 
18590 
  thrift_spec = (
18591 
  )
18592 
 
18593 
  def read(self, iprot):
18594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18596 
      return
18597 
    iprot.readStructBegin()
18598 
    while True:
18599 
      (fname, ftype, fid) = iprot.readFieldBegin()
18600 
      if ftype == TType.STOP:
18601 
        break
18602 
      else:
18603 
        iprot.skip(ftype)
18604 
      iprot.readFieldEnd()
18605 
    iprot.readStructEnd()
18606 
 
18607 
  def write(self, oprot):
18608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18610 
      return
18611 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
18612 
    oprot.writeFieldStop()
18613 
    oprot.writeStructEnd()
18614 
 
18615 
  def validate(self):
18616 
    return
18617 
 
18618 
 
18619 
  def __repr__(self):
18620 
    L = ['%s=%r' % (key, value)
18621 
      for key, value in self.__dict__.iteritems()]
18622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18623 
 
18624 
  def __eq__(self, other):
18625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18626 
 
18627 
  def __ne__(self, other):
18628 
    return not (self == other)
18629 
 
18630 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 18631 
  """
18632 
  Attributes:
4910 phani.kuma 18633 
   - providerId
18634 
  """
18635 
 
18636 
  thrift_spec = (
18637 
    None, # 0
18638 
    (1, TType.I64, 'providerId', None, None, ), # 1
18639 
  )
18640 
 
18641 
  def __init__(self, providerId=None,):
18642 
    self.providerId = providerId
18643 
 
18644 
  def read(self, iprot):
18645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18647 
      return
18648 
    iprot.readStructBegin()
18649 
    while True:
18650 
      (fname, ftype, fid) = iprot.readFieldBegin()
18651 
      if ftype == TType.STOP:
18652 
        break
18653 
      if fid == 1:
18654 
        if ftype == TType.I64:
18655 
          self.providerId = iprot.readI64();
18656 
        else:
18657 
          iprot.skip(ftype)
18658 
      else:
18659 
        iprot.skip(ftype)
18660 
      iprot.readFieldEnd()
18661 
    iprot.readStructEnd()
18662 
 
18663 
  def write(self, oprot):
18664 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18665 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18666 
      return
18667 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
18668 
    if self.providerId is not None:
18669 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18670 
      oprot.writeI64(self.providerId)
18671 
      oprot.writeFieldEnd()
18672 
    oprot.writeFieldStop()
18673 
    oprot.writeStructEnd()
18674 
 
18675 
  def validate(self):
18676 
    return
18677 
 
18678 
 
18679 
  def __repr__(self):
18680 
    L = ['%s=%r' % (key, value)
18681 
      for key, value in self.__dict__.iteritems()]
18682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18683 
 
18684 
  def __eq__(self, other):
18685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18686 
 
18687 
  def __ne__(self, other):
18688 
    return not (self == other)
18689 
 
18690 
class getReturnOrdersNotPickedUp_result:
18691 
  """
18692 
  Attributes:
4741 phani.kuma 18693 
   - success
18694 
  """
18695 
 
18696 
  thrift_spec = (
18697 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18698 
  )
18699 
 
18700 
  def __init__(self, success=None,):
18701 
    self.success = success
18702 
 
18703 
  def read(self, iprot):
18704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18706 
      return
18707 
    iprot.readStructBegin()
18708 
    while True:
18709 
      (fname, ftype, fid) = iprot.readFieldBegin()
18710 
      if ftype == TType.STOP:
18711 
        break
18712 
      if fid == 0:
18713 
        if ftype == TType.LIST:
18714 
          self.success = []
6188 rajveer 18715 
          (_etype435, _size432) = iprot.readListBegin()
18716 
          for _i436 in xrange(_size432):
18717 
            _elem437 = Order()
18718 
            _elem437.read(iprot)
18719 
            self.success.append(_elem437)
4741 phani.kuma 18720 
          iprot.readListEnd()
18721 
        else:
18722 
          iprot.skip(ftype)
18723 
      else:
18724 
        iprot.skip(ftype)
18725 
      iprot.readFieldEnd()
18726 
    iprot.readStructEnd()
18727 
 
18728 
  def write(self, oprot):
18729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18731 
      return
4910 phani.kuma 18732 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 18733 
    if self.success is not None:
18734 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18735 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18736 
      for iter438 in self.success:
18737 
        iter438.write(oprot)
4741 phani.kuma 18738 
      oprot.writeListEnd()
18739 
      oprot.writeFieldEnd()
18740 
    oprot.writeFieldStop()
18741 
    oprot.writeStructEnd()
18742 
 
18743 
  def validate(self):
18744 
    return
18745 
 
18746 
 
18747 
  def __repr__(self):
18748 
    L = ['%s=%r' % (key, value)
18749 
      for key, value in self.__dict__.iteritems()]
18750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18751 
 
18752 
  def __eq__(self, other):
18753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18754 
 
18755 
  def __ne__(self, other):
18756 
    return not (self == other)
18757 
 
2616 chandransh 18758 
class receiveReturn_args:
2591 chandransh 18759 
  """
18760 
  Attributes:
18761 
   - orderId
4479 rajveer 18762 
   - receiveCondition
2591 chandransh 18763 
  """
2536 chandransh 18764 
 
2591 chandransh 18765 
  thrift_spec = (
18766 
    None, # 0
18767 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 18768 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 18769 
  )
18770 
 
4479 rajveer 18771 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 18772 
    self.orderId = orderId
4479 rajveer 18773 
    self.receiveCondition = receiveCondition
2591 chandransh 18774 
 
18775 
  def read(self, iprot):
18776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18778 
      return
18779 
    iprot.readStructBegin()
18780 
    while True:
18781 
      (fname, ftype, fid) = iprot.readFieldBegin()
18782 
      if ftype == TType.STOP:
18783 
        break
18784 
      if fid == 1:
18785 
        if ftype == TType.I64:
18786 
          self.orderId = iprot.readI64();
18787 
        else:
18788 
          iprot.skip(ftype)
4479 rajveer 18789 
      elif fid == 2:
18790 
        if ftype == TType.I64:
18791 
          self.receiveCondition = iprot.readI64();
18792 
        else:
18793 
          iprot.skip(ftype)
2591 chandransh 18794 
      else:
18795 
        iprot.skip(ftype)
18796 
      iprot.readFieldEnd()
18797 
    iprot.readStructEnd()
18798 
 
18799 
  def write(self, oprot):
18800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18802 
      return
2616 chandransh 18803 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 18804 
    if self.orderId is not None:
2591 chandransh 18805 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18806 
      oprot.writeI64(self.orderId)
18807 
      oprot.writeFieldEnd()
4479 rajveer 18808 
    if self.receiveCondition is not None:
18809 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
18810 
      oprot.writeI64(self.receiveCondition)
18811 
      oprot.writeFieldEnd()
2591 chandransh 18812 
    oprot.writeFieldStop()
18813 
    oprot.writeStructEnd()
18814 
 
3431 rajveer 18815 
  def validate(self):
18816 
    return
18817 
 
18818 
 
2591 chandransh 18819 
  def __repr__(self):
18820 
    L = ['%s=%r' % (key, value)
18821 
      for key, value in self.__dict__.iteritems()]
18822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18823 
 
18824 
  def __eq__(self, other):
18825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18826 
 
18827 
  def __ne__(self, other):
18828 
    return not (self == other)
18829 
 
2616 chandransh 18830 
class receiveReturn_result:
2591 chandransh 18831 
  """
18832 
  Attributes:
18833 
   - success
18834 
   - ex
18835 
  """
18836 
 
18837 
  thrift_spec = (
18838 
    (0, TType.BOOL, 'success', None, None, ), # 0
18839 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18840 
  )
18841 
 
18842 
  def __init__(self, success=None, ex=None,):
18843 
    self.success = success
18844 
    self.ex = ex
18845 
 
18846 
  def read(self, iprot):
18847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18849 
      return
18850 
    iprot.readStructBegin()
18851 
    while True:
18852 
      (fname, ftype, fid) = iprot.readFieldBegin()
18853 
      if ftype == TType.STOP:
18854 
        break
18855 
      if fid == 0:
18856 
        if ftype == TType.BOOL:
18857 
          self.success = iprot.readBool();
18858 
        else:
18859 
          iprot.skip(ftype)
18860 
      elif fid == 1:
18861 
        if ftype == TType.STRUCT:
18862 
          self.ex = TransactionServiceException()
18863 
          self.ex.read(iprot)
18864 
        else:
18865 
          iprot.skip(ftype)
18866 
      else:
18867 
        iprot.skip(ftype)
18868 
      iprot.readFieldEnd()
18869 
    iprot.readStructEnd()
18870 
 
18871 
  def write(self, oprot):
18872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18874 
      return
2616 chandransh 18875 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 18876 
    if self.success is not None:
2591 chandransh 18877 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18878 
      oprot.writeBool(self.success)
18879 
      oprot.writeFieldEnd()
3431 rajveer 18880 
    if self.ex is not None:
2591 chandransh 18881 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18882 
      self.ex.write(oprot)
18883 
      oprot.writeFieldEnd()
18884 
    oprot.writeFieldStop()
18885 
    oprot.writeStructEnd()
18886 
 
3431 rajveer 18887 
  def validate(self):
18888 
    return
18889 
 
18890 
 
2591 chandransh 18891 
  def __repr__(self):
18892 
    L = ['%s=%r' % (key, value)
18893 
      for key, value in self.__dict__.iteritems()]
18894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18895 
 
18896 
  def __eq__(self, other):
18897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18898 
 
18899 
  def __ne__(self, other):
18900 
    return not (self == other)
18901 
 
18902 
class validateDoa_args:
18903 
  """
18904 
  Attributes:
18905 
   - orderId
18906 
   - isValid
18907 
  """
18908 
 
18909 
  thrift_spec = (
18910 
    None, # 0
18911 
    (1, TType.I64, 'orderId', None, None, ), # 1
18912 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
18913 
  )
18914 
 
18915 
  def __init__(self, orderId=None, isValid=None,):
18916 
    self.orderId = orderId
18917 
    self.isValid = isValid
18918 
 
18919 
  def read(self, iprot):
18920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18922 
      return
18923 
    iprot.readStructBegin()
18924 
    while True:
18925 
      (fname, ftype, fid) = iprot.readFieldBegin()
18926 
      if ftype == TType.STOP:
18927 
        break
18928 
      if fid == 1:
18929 
        if ftype == TType.I64:
18930 
          self.orderId = iprot.readI64();
18931 
        else:
18932 
          iprot.skip(ftype)
18933 
      elif fid == 2:
18934 
        if ftype == TType.BOOL:
18935 
          self.isValid = iprot.readBool();
18936 
        else:
18937 
          iprot.skip(ftype)
18938 
      else:
18939 
        iprot.skip(ftype)
18940 
      iprot.readFieldEnd()
18941 
    iprot.readStructEnd()
18942 
 
18943 
  def write(self, oprot):
18944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18946 
      return
18947 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 18948 
    if self.orderId is not None:
2591 chandransh 18949 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18950 
      oprot.writeI64(self.orderId)
18951 
      oprot.writeFieldEnd()
3431 rajveer 18952 
    if self.isValid is not None:
2591 chandransh 18953 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
18954 
      oprot.writeBool(self.isValid)
18955 
      oprot.writeFieldEnd()
18956 
    oprot.writeFieldStop()
18957 
    oprot.writeStructEnd()
18958 
 
3431 rajveer 18959 
  def validate(self):
18960 
    return
18961 
 
18962 
 
2591 chandransh 18963 
  def __repr__(self):
18964 
    L = ['%s=%r' % (key, value)
18965 
      for key, value in self.__dict__.iteritems()]
18966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18967 
 
18968 
  def __eq__(self, other):
18969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18970 
 
18971 
  def __ne__(self, other):
18972 
    return not (self == other)
18973 
 
18974 
class validateDoa_result:
18975 
  """
18976 
  Attributes:
18977 
   - success
18978 
   - ex
18979 
  """
18980 
 
18981 
  thrift_spec = (
18982 
    (0, TType.BOOL, 'success', None, None, ), # 0
18983 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18984 
  )
18985 
 
18986 
  def __init__(self, success=None, ex=None,):
18987 
    self.success = success
18988 
    self.ex = ex
18989 
 
18990 
  def read(self, iprot):
18991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18993 
      return
18994 
    iprot.readStructBegin()
18995 
    while True:
18996 
      (fname, ftype, fid) = iprot.readFieldBegin()
18997 
      if ftype == TType.STOP:
18998 
        break
18999 
      if fid == 0:
19000 
        if ftype == TType.BOOL:
19001 
          self.success = iprot.readBool();
19002 
        else:
19003 
          iprot.skip(ftype)
19004 
      elif fid == 1:
19005 
        if ftype == TType.STRUCT:
19006 
          self.ex = TransactionServiceException()
19007 
          self.ex.read(iprot)
19008 
        else:
19009 
          iprot.skip(ftype)
19010 
      else:
19011 
        iprot.skip(ftype)
19012 
      iprot.readFieldEnd()
19013 
    iprot.readStructEnd()
19014 
 
19015 
  def write(self, oprot):
19016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19018 
      return
19019 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 19020 
    if self.success is not None:
2591 chandransh 19021 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19022 
      oprot.writeBool(self.success)
19023 
      oprot.writeFieldEnd()
3431 rajveer 19024 
    if self.ex is not None:
2591 chandransh 19025 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19026 
      self.ex.write(oprot)
19027 
      oprot.writeFieldEnd()
19028 
    oprot.writeFieldStop()
19029 
    oprot.writeStructEnd()
19030 
 
3431 rajveer 19031 
  def validate(self):
19032 
    return
19033 
 
19034 
 
2591 chandransh 19035 
  def __repr__(self):
19036 
    L = ['%s=%r' % (key, value)
19037 
      for key, value in self.__dict__.iteritems()]
19038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19039 
 
19040 
  def __eq__(self, other):
19041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19042 
 
19043 
  def __ne__(self, other):
19044 
    return not (self == other)
19045 
 
4495 rajveer 19046 
class validateReturnProduct_args:
19047 
  """
19048 
  Attributes:
19049 
   - orderId
19050 
   - isUsable
19051 
  """
19052 
 
19053 
  thrift_spec = (
19054 
    None, # 0
19055 
    (1, TType.I64, 'orderId', None, None, ), # 1
19056 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
19057 
  )
19058 
 
19059 
  def __init__(self, orderId=None, isUsable=None,):
19060 
    self.orderId = orderId
19061 
    self.isUsable = isUsable
19062 
 
19063 
  def read(self, iprot):
19064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19066 
      return
19067 
    iprot.readStructBegin()
19068 
    while True:
19069 
      (fname, ftype, fid) = iprot.readFieldBegin()
19070 
      if ftype == TType.STOP:
19071 
        break
19072 
      if fid == 1:
19073 
        if ftype == TType.I64:
19074 
          self.orderId = iprot.readI64();
19075 
        else:
19076 
          iprot.skip(ftype)
19077 
      elif fid == 2:
19078 
        if ftype == TType.BOOL:
19079 
          self.isUsable = iprot.readBool();
19080 
        else:
19081 
          iprot.skip(ftype)
19082 
      else:
19083 
        iprot.skip(ftype)
19084 
      iprot.readFieldEnd()
19085 
    iprot.readStructEnd()
19086 
 
19087 
  def write(self, oprot):
19088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19090 
      return
19091 
    oprot.writeStructBegin('validateReturnProduct_args')
19092 
    if self.orderId is not None:
19093 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19094 
      oprot.writeI64(self.orderId)
19095 
      oprot.writeFieldEnd()
19096 
    if self.isUsable is not None:
19097 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
19098 
      oprot.writeBool(self.isUsable)
19099 
      oprot.writeFieldEnd()
19100 
    oprot.writeFieldStop()
19101 
    oprot.writeStructEnd()
19102 
 
19103 
  def validate(self):
19104 
    return
19105 
 
19106 
 
19107 
  def __repr__(self):
19108 
    L = ['%s=%r' % (key, value)
19109 
      for key, value in self.__dict__.iteritems()]
19110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19111 
 
19112 
  def __eq__(self, other):
19113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19114 
 
19115 
  def __ne__(self, other):
19116 
    return not (self == other)
19117 
 
19118 
class validateReturnProduct_result:
19119 
  """
19120 
  Attributes:
19121 
   - success
19122 
   - ex
19123 
  """
19124 
 
19125 
  thrift_spec = (
19126 
    (0, TType.BOOL, 'success', None, None, ), # 0
19127 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19128 
  )
19129 
 
19130 
  def __init__(self, success=None, ex=None,):
19131 
    self.success = success
19132 
    self.ex = ex
19133 
 
19134 
  def read(self, iprot):
19135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19137 
      return
19138 
    iprot.readStructBegin()
19139 
    while True:
19140 
      (fname, ftype, fid) = iprot.readFieldBegin()
19141 
      if ftype == TType.STOP:
19142 
        break
19143 
      if fid == 0:
19144 
        if ftype == TType.BOOL:
19145 
          self.success = iprot.readBool();
19146 
        else:
19147 
          iprot.skip(ftype)
19148 
      elif fid == 1:
19149 
        if ftype == TType.STRUCT:
19150 
          self.ex = TransactionServiceException()
19151 
          self.ex.read(iprot)
19152 
        else:
19153 
          iprot.skip(ftype)
19154 
      else:
19155 
        iprot.skip(ftype)
19156 
      iprot.readFieldEnd()
19157 
    iprot.readStructEnd()
19158 
 
19159 
  def write(self, oprot):
19160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19162 
      return
19163 
    oprot.writeStructBegin('validateReturnProduct_result')
19164 
    if self.success is not None:
19165 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19166 
      oprot.writeBool(self.success)
19167 
      oprot.writeFieldEnd()
19168 
    if self.ex is not None:
19169 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19170 
      self.ex.write(oprot)
19171 
      oprot.writeFieldEnd()
19172 
    oprot.writeFieldStop()
19173 
    oprot.writeStructEnd()
19174 
 
19175 
  def validate(self):
19176 
    return
19177 
 
19178 
 
19179 
  def __repr__(self):
19180 
    L = ['%s=%r' % (key, value)
19181 
      for key, value in self.__dict__.iteritems()]
19182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19183 
 
19184 
  def __eq__(self, other):
19185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19186 
 
19187 
  def __ne__(self, other):
19188 
    return not (self == other)
19189 
 
2616 chandransh 19190 
class reshipOrder_args:
19191 
  """
19192 
  Attributes:
19193 
   - orderId
19194 
  """
2591 chandransh 19195 
 
2616 chandransh 19196 
  thrift_spec = (
19197 
    None, # 0
19198 
    (1, TType.I64, 'orderId', None, None, ), # 1
19199 
  )
19200 
 
19201 
  def __init__(self, orderId=None,):
19202 
    self.orderId = orderId
19203 
 
19204 
  def read(self, iprot):
19205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19207 
      return
19208 
    iprot.readStructBegin()
19209 
    while True:
19210 
      (fname, ftype, fid) = iprot.readFieldBegin()
19211 
      if ftype == TType.STOP:
19212 
        break
19213 
      if fid == 1:
19214 
        if ftype == TType.I64:
19215 
          self.orderId = iprot.readI64();
19216 
        else:
19217 
          iprot.skip(ftype)
19218 
      else:
19219 
        iprot.skip(ftype)
19220 
      iprot.readFieldEnd()
19221 
    iprot.readStructEnd()
19222 
 
19223 
  def write(self, oprot):
19224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19226 
      return
19227 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 19228 
    if self.orderId is not None:
2616 chandransh 19229 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19230 
      oprot.writeI64(self.orderId)
19231 
      oprot.writeFieldEnd()
19232 
    oprot.writeFieldStop()
19233 
    oprot.writeStructEnd()
19234 
 
3431 rajveer 19235 
  def validate(self):
19236 
    return
19237 
 
19238 
 
2616 chandransh 19239 
  def __repr__(self):
19240 
    L = ['%s=%r' % (key, value)
19241 
      for key, value in self.__dict__.iteritems()]
19242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19243 
 
19244 
  def __eq__(self, other):
19245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19246 
 
19247 
  def __ne__(self, other):
19248 
    return not (self == other)
19249 
 
19250 
class reshipOrder_result:
19251 
  """
19252 
  Attributes:
19253 
   - success
19254 
   - ex
19255 
  """
19256 
 
19257 
  thrift_spec = (
19258 
    (0, TType.I64, 'success', None, None, ), # 0
19259 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19260 
  )
19261 
 
19262 
  def __init__(self, success=None, ex=None,):
19263 
    self.success = success
19264 
    self.ex = ex
19265 
 
19266 
  def read(self, iprot):
19267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19269 
      return
19270 
    iprot.readStructBegin()
19271 
    while True:
19272 
      (fname, ftype, fid) = iprot.readFieldBegin()
19273 
      if ftype == TType.STOP:
19274 
        break
19275 
      if fid == 0:
19276 
        if ftype == TType.I64:
19277 
          self.success = iprot.readI64();
19278 
        else:
19279 
          iprot.skip(ftype)
19280 
      elif fid == 1:
19281 
        if ftype == TType.STRUCT:
19282 
          self.ex = TransactionServiceException()
19283 
          self.ex.read(iprot)
19284 
        else:
19285 
          iprot.skip(ftype)
19286 
      else:
19287 
        iprot.skip(ftype)
19288 
      iprot.readFieldEnd()
19289 
    iprot.readStructEnd()
19290 
 
19291 
  def write(self, oprot):
19292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19294 
      return
19295 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 19296 
    if self.success is not None:
2616 chandransh 19297 
      oprot.writeFieldBegin('success', TType.I64, 0)
19298 
      oprot.writeI64(self.success)
19299 
      oprot.writeFieldEnd()
3431 rajveer 19300 
    if self.ex is not None:
2616 chandransh 19301 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19302 
      self.ex.write(oprot)
19303 
      oprot.writeFieldEnd()
19304 
    oprot.writeFieldStop()
19305 
    oprot.writeStructEnd()
19306 
 
3431 rajveer 19307 
  def validate(self):
19308 
    return
19309 
 
19310 
 
2616 chandransh 19311 
  def __repr__(self):
19312 
    L = ['%s=%r' % (key, value)
19313 
      for key, value in self.__dict__.iteritems()]
19314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19315 
 
19316 
  def __eq__(self, other):
19317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19318 
 
19319 
  def __ne__(self, other):
19320 
    return not (self == other)
19321 
 
19322 
class refundOrder_args:
19323 
  """
19324 
  Attributes:
19325 
   - orderId
3226 chandransh 19326 
   - refundedBy
19327 
   - reason
2616 chandransh 19328 
  """
19329 
 
19330 
  thrift_spec = (
19331 
    None, # 0
19332 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 19333 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
19334 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 19335 
  )
19336 
 
3226 chandransh 19337 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 19338 
    self.orderId = orderId
3226 chandransh 19339 
    self.refundedBy = refundedBy
19340 
    self.reason = reason
2616 chandransh 19341 
 
19342 
  def read(self, iprot):
19343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19345 
      return
19346 
    iprot.readStructBegin()
19347 
    while True:
19348 
      (fname, ftype, fid) = iprot.readFieldBegin()
19349 
      if ftype == TType.STOP:
19350 
        break
19351 
      if fid == 1:
19352 
        if ftype == TType.I64:
19353 
          self.orderId = iprot.readI64();
19354 
        else:
19355 
          iprot.skip(ftype)
3226 chandransh 19356 
      elif fid == 2:
19357 
        if ftype == TType.STRING:
19358 
          self.refundedBy = iprot.readString();
19359 
        else:
19360 
          iprot.skip(ftype)
19361 
      elif fid == 3:
19362 
        if ftype == TType.STRING:
19363 
          self.reason = iprot.readString();
19364 
        else:
19365 
          iprot.skip(ftype)
2616 chandransh 19366 
      else:
19367 
        iprot.skip(ftype)
19368 
      iprot.readFieldEnd()
19369 
    iprot.readStructEnd()
19370 
 
19371 
  def write(self, oprot):
19372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19374 
      return
19375 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 19376 
    if self.orderId is not None:
2616 chandransh 19377 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19378 
      oprot.writeI64(self.orderId)
19379 
      oprot.writeFieldEnd()
3431 rajveer 19380 
    if self.refundedBy is not None:
3226 chandransh 19381 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
19382 
      oprot.writeString(self.refundedBy)
19383 
      oprot.writeFieldEnd()
3431 rajveer 19384 
    if self.reason is not None:
3226 chandransh 19385 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
19386 
      oprot.writeString(self.reason)
19387 
      oprot.writeFieldEnd()
2616 chandransh 19388 
    oprot.writeFieldStop()
19389 
    oprot.writeStructEnd()
19390 
 
3431 rajveer 19391 
  def validate(self):
19392 
    return
19393 
 
19394 
 
2616 chandransh 19395 
  def __repr__(self):
19396 
    L = ['%s=%r' % (key, value)
19397 
      for key, value in self.__dict__.iteritems()]
19398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19399 
 
19400 
  def __eq__(self, other):
19401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19402 
 
19403 
  def __ne__(self, other):
19404 
    return not (self == other)
19405 
 
19406 
class refundOrder_result:
19407 
  """
19408 
  Attributes:
19409 
   - success
19410 
   - ex
19411 
  """
19412 
 
19413 
  thrift_spec = (
19414 
    (0, TType.BOOL, 'success', None, None, ), # 0
19415 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19416 
  )
19417 
 
19418 
  def __init__(self, success=None, ex=None,):
19419 
    self.success = success
19420 
    self.ex = ex
19421 
 
19422 
  def read(self, iprot):
19423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19425 
      return
19426 
    iprot.readStructBegin()
19427 
    while True:
19428 
      (fname, ftype, fid) = iprot.readFieldBegin()
19429 
      if ftype == TType.STOP:
19430 
        break
19431 
      if fid == 0:
19432 
        if ftype == TType.BOOL:
19433 
          self.success = iprot.readBool();
19434 
        else:
19435 
          iprot.skip(ftype)
19436 
      elif fid == 1:
19437 
        if ftype == TType.STRUCT:
19438 
          self.ex = TransactionServiceException()
19439 
          self.ex.read(iprot)
19440 
        else:
19441 
          iprot.skip(ftype)
19442 
      else:
19443 
        iprot.skip(ftype)
19444 
      iprot.readFieldEnd()
19445 
    iprot.readStructEnd()
19446 
 
19447 
  def write(self, oprot):
19448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19450 
      return
19451 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 19452 
    if self.success is not None:
2616 chandransh 19453 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19454 
      oprot.writeBool(self.success)
19455 
      oprot.writeFieldEnd()
3431 rajveer 19456 
    if self.ex is not None:
2616 chandransh 19457 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19458 
      self.ex.write(oprot)
19459 
      oprot.writeFieldEnd()
19460 
    oprot.writeFieldStop()
19461 
    oprot.writeStructEnd()
19462 
 
3431 rajveer 19463 
  def validate(self):
19464 
    return
19465 
 
19466 
 
2616 chandransh 19467 
  def __repr__(self):
19468 
    L = ['%s=%r' % (key, value)
19469 
      for key, value in self.__dict__.iteritems()]
19470 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19471 
 
19472 
  def __eq__(self, other):
19473 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19474 
 
19475 
  def __ne__(self, other):
19476 
    return not (self == other)
19477 
 
2690 chandransh 19478 
class getReturnOrders_args:
19479 
  """
19480 
  Attributes:
19481 
   - warehouseId
19482 
   - fromDate
19483 
   - toDate
19484 
  """
2616 chandransh 19485 
 
2690 chandransh 19486 
  thrift_spec = (
19487 
    None, # 0
19488 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
19489 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19490 
    (3, TType.I64, 'toDate', None, None, ), # 3
19491 
  )
19492 
 
19493 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
19494 
    self.warehouseId = warehouseId
19495 
    self.fromDate = fromDate
19496 
    self.toDate = toDate
19497 
 
19498 
  def read(self, iprot):
19499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19501 
      return
19502 
    iprot.readStructBegin()
19503 
    while True:
19504 
      (fname, ftype, fid) = iprot.readFieldBegin()
19505 
      if ftype == TType.STOP:
19506 
        break
19507 
      if fid == 1:
19508 
        if ftype == TType.I64:
19509 
          self.warehouseId = iprot.readI64();
19510 
        else:
19511 
          iprot.skip(ftype)
19512 
      elif fid == 2:
19513 
        if ftype == TType.I64:
19514 
          self.fromDate = iprot.readI64();
19515 
        else:
19516 
          iprot.skip(ftype)
19517 
      elif fid == 3:
19518 
        if ftype == TType.I64:
19519 
          self.toDate = iprot.readI64();
19520 
        else:
19521 
          iprot.skip(ftype)
19522 
      else:
19523 
        iprot.skip(ftype)
19524 
      iprot.readFieldEnd()
19525 
    iprot.readStructEnd()
19526 
 
19527 
  def write(self, oprot):
19528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19530 
      return
19531 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 19532 
    if self.warehouseId is not None:
2690 chandransh 19533 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
19534 
      oprot.writeI64(self.warehouseId)
19535 
      oprot.writeFieldEnd()
3431 rajveer 19536 
    if self.fromDate is not None:
2690 chandransh 19537 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19538 
      oprot.writeI64(self.fromDate)
19539 
      oprot.writeFieldEnd()
3431 rajveer 19540 
    if self.toDate is not None:
2690 chandransh 19541 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19542 
      oprot.writeI64(self.toDate)
19543 
      oprot.writeFieldEnd()
19544 
    oprot.writeFieldStop()
19545 
    oprot.writeStructEnd()
19546 
 
3431 rajveer 19547 
  def validate(self):
19548 
    return
19549 
 
19550 
 
2690 chandransh 19551 
  def __repr__(self):
19552 
    L = ['%s=%r' % (key, value)
19553 
      for key, value in self.__dict__.iteritems()]
19554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19555 
 
19556 
  def __eq__(self, other):
19557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19558 
 
19559 
  def __ne__(self, other):
19560 
    return not (self == other)
19561 
 
19562 
class getReturnOrders_result:
19563 
  """
19564 
  Attributes:
19565 
   - success
19566 
  """
19567 
 
19568 
  thrift_spec = (
19569 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19570 
  )
19571 
 
19572 
  def __init__(self, success=None,):
19573 
    self.success = success
19574 
 
19575 
  def read(self, iprot):
19576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19578 
      return
19579 
    iprot.readStructBegin()
19580 
    while True:
19581 
      (fname, ftype, fid) = iprot.readFieldBegin()
19582 
      if ftype == TType.STOP:
19583 
        break
19584 
      if fid == 0:
19585 
        if ftype == TType.LIST:
19586 
          self.success = []
6188 rajveer 19587 
          (_etype442, _size439) = iprot.readListBegin()
19588 
          for _i443 in xrange(_size439):
19589 
            _elem444 = ReturnOrder()
19590 
            _elem444.read(iprot)
19591 
            self.success.append(_elem444)
2690 chandransh 19592 
          iprot.readListEnd()
19593 
        else:
19594 
          iprot.skip(ftype)
19595 
      else:
19596 
        iprot.skip(ftype)
19597 
      iprot.readFieldEnd()
19598 
    iprot.readStructEnd()
19599 
 
19600 
  def write(self, oprot):
19601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19603 
      return
19604 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 19605 
    if self.success is not None:
2690 chandransh 19606 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19607 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19608 
      for iter445 in self.success:
19609 
        iter445.write(oprot)
2690 chandransh 19610 
      oprot.writeListEnd()
19611 
      oprot.writeFieldEnd()
19612 
    oprot.writeFieldStop()
19613 
    oprot.writeStructEnd()
19614 
 
3431 rajveer 19615 
  def validate(self):
19616 
    return
19617 
 
19618 
 
2690 chandransh 19619 
  def __repr__(self):
19620 
    L = ['%s=%r' % (key, value)
19621 
      for key, value in self.__dict__.iteritems()]
19622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19623 
 
19624 
  def __eq__(self, other):
19625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19626 
 
19627 
  def __ne__(self, other):
19628 
    return not (self == other)
19629 
 
5481 phani.kuma 19630 
class getAllReturnOrders_args:
19631 
  """
19632 
  Attributes:
19633 
   - onlyNotProcessed
19634 
   - fromDate
19635 
   - toDate
19636 
  """
19637 
 
19638 
  thrift_spec = (
19639 
    None, # 0
19640 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
19641 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19642 
    (3, TType.I64, 'toDate', None, None, ), # 3
19643 
  )
19644 
 
19645 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
19646 
    self.onlyNotProcessed = onlyNotProcessed
19647 
    self.fromDate = fromDate
19648 
    self.toDate = toDate
19649 
 
19650 
  def read(self, iprot):
19651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19653 
      return
19654 
    iprot.readStructBegin()
19655 
    while True:
19656 
      (fname, ftype, fid) = iprot.readFieldBegin()
19657 
      if ftype == TType.STOP:
19658 
        break
19659 
      if fid == 1:
19660 
        if ftype == TType.BOOL:
19661 
          self.onlyNotProcessed = iprot.readBool();
19662 
        else:
19663 
          iprot.skip(ftype)
19664 
      elif fid == 2:
19665 
        if ftype == TType.I64:
19666 
          self.fromDate = iprot.readI64();
19667 
        else:
19668 
          iprot.skip(ftype)
19669 
      elif fid == 3:
19670 
        if ftype == TType.I64:
19671 
          self.toDate = iprot.readI64();
19672 
        else:
19673 
          iprot.skip(ftype)
19674 
      else:
19675 
        iprot.skip(ftype)
19676 
      iprot.readFieldEnd()
19677 
    iprot.readStructEnd()
19678 
 
19679 
  def write(self, oprot):
19680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19682 
      return
19683 
    oprot.writeStructBegin('getAllReturnOrders_args')
19684 
    if self.onlyNotProcessed is not None:
19685 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
19686 
      oprot.writeBool(self.onlyNotProcessed)
19687 
      oprot.writeFieldEnd()
19688 
    if self.fromDate is not None:
19689 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19690 
      oprot.writeI64(self.fromDate)
19691 
      oprot.writeFieldEnd()
19692 
    if self.toDate is not None:
19693 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19694 
      oprot.writeI64(self.toDate)
19695 
      oprot.writeFieldEnd()
19696 
    oprot.writeFieldStop()
19697 
    oprot.writeStructEnd()
19698 
 
19699 
  def validate(self):
19700 
    return
19701 
 
19702 
 
19703 
  def __repr__(self):
19704 
    L = ['%s=%r' % (key, value)
19705 
      for key, value in self.__dict__.iteritems()]
19706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19707 
 
19708 
  def __eq__(self, other):
19709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19710 
 
19711 
  def __ne__(self, other):
19712 
    return not (self == other)
19713 
 
19714 
class getAllReturnOrders_result:
19715 
  """
19716 
  Attributes:
19717 
   - success
19718 
  """
19719 
 
19720 
  thrift_spec = (
19721 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19722 
  )
19723 
 
19724 
  def __init__(self, success=None,):
19725 
    self.success = success
19726 
 
19727 
  def read(self, iprot):
19728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19730 
      return
19731 
    iprot.readStructBegin()
19732 
    while True:
19733 
      (fname, ftype, fid) = iprot.readFieldBegin()
19734 
      if ftype == TType.STOP:
19735 
        break
19736 
      if fid == 0:
19737 
        if ftype == TType.LIST:
19738 
          self.success = []
6188 rajveer 19739 
          (_etype449, _size446) = iprot.readListBegin()
19740 
          for _i450 in xrange(_size446):
19741 
            _elem451 = ReturnOrder()
19742 
            _elem451.read(iprot)
19743 
            self.success.append(_elem451)
5481 phani.kuma 19744 
          iprot.readListEnd()
19745 
        else:
19746 
          iprot.skip(ftype)
19747 
      else:
19748 
        iprot.skip(ftype)
19749 
      iprot.readFieldEnd()
19750 
    iprot.readStructEnd()
19751 
 
19752 
  def write(self, oprot):
19753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19755 
      return
19756 
    oprot.writeStructBegin('getAllReturnOrders_result')
19757 
    if self.success is not None:
19758 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19759 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19760 
      for iter452 in self.success:
19761 
        iter452.write(oprot)
5481 phani.kuma 19762 
      oprot.writeListEnd()
19763 
      oprot.writeFieldEnd()
19764 
    oprot.writeFieldStop()
19765 
    oprot.writeStructEnd()
19766 
 
19767 
  def validate(self):
19768 
    return
19769 
 
19770 
 
19771 
  def __repr__(self):
19772 
    L = ['%s=%r' % (key, value)
19773 
      for key, value in self.__dict__.iteritems()]
19774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19775 
 
19776 
  def __eq__(self, other):
19777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19778 
 
19779 
  def __ne__(self, other):
19780 
    return not (self == other)
19781 
 
2700 chandransh 19782 
class getReturnOrder_args:
19783 
  """
19784 
  Attributes:
19785 
   - id
19786 
  """
19787 
 
19788 
  thrift_spec = (
19789 
    None, # 0
19790 
    (1, TType.I64, 'id', None, None, ), # 1
19791 
  )
19792 
 
19793 
  def __init__(self, id=None,):
19794 
    self.id = id
19795 
 
19796 
  def read(self, iprot):
19797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19799 
      return
19800 
    iprot.readStructBegin()
19801 
    while True:
19802 
      (fname, ftype, fid) = iprot.readFieldBegin()
19803 
      if ftype == TType.STOP:
19804 
        break
19805 
      if fid == 1:
19806 
        if ftype == TType.I64:
19807 
          self.id = iprot.readI64();
19808 
        else:
19809 
          iprot.skip(ftype)
19810 
      else:
19811 
        iprot.skip(ftype)
19812 
      iprot.readFieldEnd()
19813 
    iprot.readStructEnd()
19814 
 
19815 
  def write(self, oprot):
19816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19818 
      return
19819 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 19820 
    if self.id is not None:
2700 chandransh 19821 
      oprot.writeFieldBegin('id', TType.I64, 1)
19822 
      oprot.writeI64(self.id)
19823 
      oprot.writeFieldEnd()
19824 
    oprot.writeFieldStop()
19825 
    oprot.writeStructEnd()
19826 
 
3431 rajveer 19827 
  def validate(self):
19828 
    return
19829 
 
19830 
 
2700 chandransh 19831 
  def __repr__(self):
19832 
    L = ['%s=%r' % (key, value)
19833 
      for key, value in self.__dict__.iteritems()]
19834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19835 
 
19836 
  def __eq__(self, other):
19837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19838 
 
19839 
  def __ne__(self, other):
19840 
    return not (self == other)
19841 
 
19842 
class getReturnOrder_result:
19843 
  """
19844 
  Attributes:
19845 
   - success
19846 
   - ex
19847 
  """
19848 
 
19849 
  thrift_spec = (
19850 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
19851 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19852 
  )
19853 
 
19854 
  def __init__(self, success=None, ex=None,):
19855 
    self.success = success
19856 
    self.ex = ex
19857 
 
19858 
  def read(self, iprot):
19859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19861 
      return
19862 
    iprot.readStructBegin()
19863 
    while True:
19864 
      (fname, ftype, fid) = iprot.readFieldBegin()
19865 
      if ftype == TType.STOP:
19866 
        break
19867 
      if fid == 0:
19868 
        if ftype == TType.STRUCT:
19869 
          self.success = ReturnOrder()
19870 
          self.success.read(iprot)
19871 
        else:
19872 
          iprot.skip(ftype)
19873 
      elif fid == 1:
19874 
        if ftype == TType.STRUCT:
19875 
          self.ex = TransactionServiceException()
19876 
          self.ex.read(iprot)
19877 
        else:
19878 
          iprot.skip(ftype)
19879 
      else:
19880 
        iprot.skip(ftype)
19881 
      iprot.readFieldEnd()
19882 
    iprot.readStructEnd()
19883 
 
19884 
  def write(self, oprot):
19885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19887 
      return
19888 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 19889 
    if self.success is not None:
2700 chandransh 19890 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19891 
      self.success.write(oprot)
19892 
      oprot.writeFieldEnd()
3431 rajveer 19893 
    if self.ex is not None:
2700 chandransh 19894 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19895 
      self.ex.write(oprot)
19896 
      oprot.writeFieldEnd()
19897 
    oprot.writeFieldStop()
19898 
    oprot.writeStructEnd()
19899 
 
3431 rajveer 19900 
  def validate(self):
19901 
    return
19902 
 
19903 
 
2700 chandransh 19904 
  def __repr__(self):
19905 
    L = ['%s=%r' % (key, value)
19906 
      for key, value in self.__dict__.iteritems()]
19907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19908 
 
19909 
  def __eq__(self, other):
19910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19911 
 
19912 
  def __ne__(self, other):
19913 
    return not (self == other)
19914 
 
2690 chandransh 19915 
class processReturn_args:
19916 
  """
19917 
  Attributes:
19918 
   - returnOrderId
19919 
  """
19920 
 
19921 
  thrift_spec = (
19922 
    None, # 0
19923 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
19924 
  )
19925 
 
19926 
  def __init__(self, returnOrderId=None,):
19927 
    self.returnOrderId = returnOrderId
19928 
 
19929 
  def read(self, iprot):
19930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19932 
      return
19933 
    iprot.readStructBegin()
19934 
    while True:
19935 
      (fname, ftype, fid) = iprot.readFieldBegin()
19936 
      if ftype == TType.STOP:
19937 
        break
19938 
      if fid == 1:
19939 
        if ftype == TType.I64:
19940 
          self.returnOrderId = iprot.readI64();
19941 
        else:
19942 
          iprot.skip(ftype)
19943 
      else:
19944 
        iprot.skip(ftype)
19945 
      iprot.readFieldEnd()
19946 
    iprot.readStructEnd()
19947 
 
19948 
  def write(self, oprot):
19949 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19950 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19951 
      return
19952 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 19953 
    if self.returnOrderId is not None:
2690 chandransh 19954 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
19955 
      oprot.writeI64(self.returnOrderId)
19956 
      oprot.writeFieldEnd()
19957 
    oprot.writeFieldStop()
19958 
    oprot.writeStructEnd()
19959 
 
3431 rajveer 19960 
  def validate(self):
19961 
    return
19962 
 
19963 
 
2690 chandransh 19964 
  def __repr__(self):
19965 
    L = ['%s=%r' % (key, value)
19966 
      for key, value in self.__dict__.iteritems()]
19967 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19968 
 
19969 
  def __eq__(self, other):
19970 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19971 
 
19972 
  def __ne__(self, other):
19973 
    return not (self == other)
19974 
 
19975 
class processReturn_result:
19976 
  """
19977 
  Attributes:
19978 
   - ex
19979 
  """
19980 
 
19981 
  thrift_spec = (
19982 
    None, # 0
19983 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19984 
  )
19985 
 
19986 
  def __init__(self, ex=None,):
19987 
    self.ex = ex
19988 
 
19989 
  def read(self, iprot):
19990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19992 
      return
19993 
    iprot.readStructBegin()
19994 
    while True:
19995 
      (fname, ftype, fid) = iprot.readFieldBegin()
19996 
      if ftype == TType.STOP:
19997 
        break
19998 
      if fid == 1:
19999 
        if ftype == TType.STRUCT:
20000 
          self.ex = TransactionServiceException()
20001 
          self.ex.read(iprot)
20002 
        else:
20003 
          iprot.skip(ftype)
20004 
      else:
20005 
        iprot.skip(ftype)
20006 
      iprot.readFieldEnd()
20007 
    iprot.readStructEnd()
20008 
 
20009 
  def write(self, oprot):
20010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20012 
      return
20013 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 20014 
    if self.ex is not None:
2690 chandransh 20015 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20016 
      self.ex.write(oprot)
20017 
      oprot.writeFieldEnd()
20018 
    oprot.writeFieldStop()
20019 
    oprot.writeStructEnd()
20020 
 
3431 rajveer 20021 
  def validate(self):
20022 
    return
20023 
 
20024 
 
2690 chandransh 20025 
  def __repr__(self):
20026 
    L = ['%s=%r' % (key, value)
20027 
      for key, value in self.__dict__.iteritems()]
20028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20029 
 
20030 
  def __eq__(self, other):
20031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20032 
 
20033 
  def __ne__(self, other):
20034 
    return not (self == other)
20035 
 
3451 chandransh 20036 
class updateWeight_args:
20037 
  """
20038 
  Attributes:
20039 
   - orderId
20040 
   - weight
20041 
  """
20042 
 
20043 
  thrift_spec = (
20044 
    None, # 0
20045 
    (1, TType.I64, 'orderId', None, None, ), # 1
20046 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
20047 
  )
20048 
 
20049 
  def __init__(self, orderId=None, weight=None,):
20050 
    self.orderId = orderId
20051 
    self.weight = weight
20052 
 
20053 
  def read(self, iprot):
20054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20056 
      return
20057 
    iprot.readStructBegin()
20058 
    while True:
20059 
      (fname, ftype, fid) = iprot.readFieldBegin()
20060 
      if ftype == TType.STOP:
20061 
        break
20062 
      if fid == 1:
20063 
        if ftype == TType.I64:
20064 
          self.orderId = iprot.readI64();
20065 
        else:
20066 
          iprot.skip(ftype)
20067 
      elif fid == 2:
20068 
        if ftype == TType.DOUBLE:
20069 
          self.weight = iprot.readDouble();
20070 
        else:
20071 
          iprot.skip(ftype)
20072 
      else:
20073 
        iprot.skip(ftype)
20074 
      iprot.readFieldEnd()
20075 
    iprot.readStructEnd()
20076 
 
20077 
  def write(self, oprot):
20078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20080 
      return
20081 
    oprot.writeStructBegin('updateWeight_args')
20082 
    if self.orderId is not None:
20083 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20084 
      oprot.writeI64(self.orderId)
20085 
      oprot.writeFieldEnd()
20086 
    if self.weight is not None:
20087 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
20088 
      oprot.writeDouble(self.weight)
20089 
      oprot.writeFieldEnd()
20090 
    oprot.writeFieldStop()
20091 
    oprot.writeStructEnd()
20092 
 
20093 
  def validate(self):
20094 
    return
20095 
 
20096 
 
20097 
  def __repr__(self):
20098 
    L = ['%s=%r' % (key, value)
20099 
      for key, value in self.__dict__.iteritems()]
20100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20101 
 
20102 
  def __eq__(self, other):
20103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20104 
 
20105 
  def __ne__(self, other):
20106 
    return not (self == other)
20107 
 
20108 
class updateWeight_result:
20109 
  """
20110 
  Attributes:
20111 
   - success
20112 
   - ex
20113 
  """
20114 
 
20115 
  thrift_spec = (
20116 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20117 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20118 
  )
20119 
 
20120 
  def __init__(self, success=None, ex=None,):
20121 
    self.success = success
20122 
    self.ex = ex
20123 
 
20124 
  def read(self, iprot):
20125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20127 
      return
20128 
    iprot.readStructBegin()
20129 
    while True:
20130 
      (fname, ftype, fid) = iprot.readFieldBegin()
20131 
      if ftype == TType.STOP:
20132 
        break
20133 
      if fid == 0:
20134 
        if ftype == TType.STRUCT:
20135 
          self.success = Order()
20136 
          self.success.read(iprot)
20137 
        else:
20138 
          iprot.skip(ftype)
20139 
      elif fid == 1:
20140 
        if ftype == TType.STRUCT:
20141 
          self.ex = TransactionServiceException()
20142 
          self.ex.read(iprot)
20143 
        else:
20144 
          iprot.skip(ftype)
20145 
      else:
20146 
        iprot.skip(ftype)
20147 
      iprot.readFieldEnd()
20148 
    iprot.readStructEnd()
20149 
 
20150 
  def write(self, oprot):
20151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20153 
      return
20154 
    oprot.writeStructBegin('updateWeight_result')
20155 
    if self.success is not None:
20156 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20157 
      self.success.write(oprot)
20158 
      oprot.writeFieldEnd()
20159 
    if self.ex is not None:
20160 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20161 
      self.ex.write(oprot)
20162 
      oprot.writeFieldEnd()
20163 
    oprot.writeFieldStop()
20164 
    oprot.writeStructEnd()
20165 
 
20166 
  def validate(self):
20167 
    return
20168 
 
20169 
 
20170 
  def __repr__(self):
20171 
    L = ['%s=%r' % (key, value)
20172 
      for key, value in self.__dict__.iteritems()]
20173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20174 
 
20175 
  def __eq__(self, other):
20176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20177 
 
20178 
  def __ne__(self, other):
20179 
    return not (self == other)
3469 chandransh 20180 
 
20181 
class changeItem_args:
20182 
  """
20183 
  Attributes:
20184 
   - orderId
20185 
   - itemId
20186 
  """
20187 
 
20188 
  thrift_spec = (
20189 
    None, # 0
20190 
    (1, TType.I64, 'orderId', None, None, ), # 1
20191 
    (2, TType.I64, 'itemId', None, None, ), # 2
20192 
  )
20193 
 
20194 
  def __init__(self, orderId=None, itemId=None,):
20195 
    self.orderId = orderId
20196 
    self.itemId = itemId
20197 
 
20198 
  def read(self, iprot):
20199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20201 
      return
20202 
    iprot.readStructBegin()
20203 
    while True:
20204 
      (fname, ftype, fid) = iprot.readFieldBegin()
20205 
      if ftype == TType.STOP:
20206 
        break
20207 
      if fid == 1:
20208 
        if ftype == TType.I64:
20209 
          self.orderId = iprot.readI64();
20210 
        else:
20211 
          iprot.skip(ftype)
20212 
      elif fid == 2:
20213 
        if ftype == TType.I64:
20214 
          self.itemId = iprot.readI64();
20215 
        else:
20216 
          iprot.skip(ftype)
20217 
      else:
20218 
        iprot.skip(ftype)
20219 
      iprot.readFieldEnd()
20220 
    iprot.readStructEnd()
20221 
 
20222 
  def write(self, oprot):
20223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20225 
      return
20226 
    oprot.writeStructBegin('changeItem_args')
20227 
    if self.orderId is not None:
20228 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20229 
      oprot.writeI64(self.orderId)
20230 
      oprot.writeFieldEnd()
20231 
    if self.itemId is not None:
20232 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
20233 
      oprot.writeI64(self.itemId)
20234 
      oprot.writeFieldEnd()
20235 
    oprot.writeFieldStop()
20236 
    oprot.writeStructEnd()
20237 
 
20238 
  def validate(self):
20239 
    return
20240 
 
20241 
 
20242 
  def __repr__(self):
20243 
    L = ['%s=%r' % (key, value)
20244 
      for key, value in self.__dict__.iteritems()]
20245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20246 
 
20247 
  def __eq__(self, other):
20248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20249 
 
20250 
  def __ne__(self, other):
20251 
    return not (self == other)
20252 
 
20253 
class changeItem_result:
20254 
  """
20255 
  Attributes:
20256 
   - success
20257 
   - ex
20258 
  """
20259 
 
20260 
  thrift_spec = (
20261 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20262 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20263 
  )
20264 
 
20265 
  def __init__(self, success=None, ex=None,):
20266 
    self.success = success
20267 
    self.ex = ex
20268 
 
20269 
  def read(self, iprot):
20270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20272 
      return
20273 
    iprot.readStructBegin()
20274 
    while True:
20275 
      (fname, ftype, fid) = iprot.readFieldBegin()
20276 
      if ftype == TType.STOP:
20277 
        break
20278 
      if fid == 0:
20279 
        if ftype == TType.STRUCT:
20280 
          self.success = Order()
20281 
          self.success.read(iprot)
20282 
        else:
20283 
          iprot.skip(ftype)
20284 
      elif fid == 1:
20285 
        if ftype == TType.STRUCT:
20286 
          self.ex = TransactionServiceException()
20287 
          self.ex.read(iprot)
20288 
        else:
20289 
          iprot.skip(ftype)
20290 
      else:
20291 
        iprot.skip(ftype)
20292 
      iprot.readFieldEnd()
20293 
    iprot.readStructEnd()
20294 
 
20295 
  def write(self, oprot):
20296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20298 
      return
20299 
    oprot.writeStructBegin('changeItem_result')
20300 
    if self.success is not None:
20301 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20302 
      self.success.write(oprot)
20303 
      oprot.writeFieldEnd()
20304 
    if self.ex is not None:
20305 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20306 
      self.ex.write(oprot)
20307 
      oprot.writeFieldEnd()
20308 
    oprot.writeFieldStop()
20309 
    oprot.writeStructEnd()
20310 
 
20311 
  def validate(self):
20312 
    return
20313 
 
20314 
 
20315 
  def __repr__(self):
20316 
    L = ['%s=%r' % (key, value)
20317 
      for key, value in self.__dict__.iteritems()]
20318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20319 
 
20320 
  def __eq__(self, other):
20321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20322 
 
20323 
  def __ne__(self, other):
20324 
    return not (self == other)
20325 
 
20326 
class shiftToWarehouse_args:
20327 
  """
20328 
  Attributes:
20329 
   - orderId
20330 
   - warehouseId
20331 
  """
20332 
 
20333 
  thrift_spec = (
20334 
    None, # 0
20335 
    (1, TType.I64, 'orderId', None, None, ), # 1
20336 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
20337 
  )
20338 
 
20339 
  def __init__(self, orderId=None, warehouseId=None,):
20340 
    self.orderId = orderId
20341 
    self.warehouseId = warehouseId
20342 
 
20343 
  def read(self, iprot):
20344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20346 
      return
20347 
    iprot.readStructBegin()
20348 
    while True:
20349 
      (fname, ftype, fid) = iprot.readFieldBegin()
20350 
      if ftype == TType.STOP:
20351 
        break
20352 
      if fid == 1:
20353 
        if ftype == TType.I64:
20354 
          self.orderId = iprot.readI64();
20355 
        else:
20356 
          iprot.skip(ftype)
20357 
      elif fid == 2:
20358 
        if ftype == TType.I64:
20359 
          self.warehouseId = iprot.readI64();
20360 
        else:
20361 
          iprot.skip(ftype)
20362 
      else:
20363 
        iprot.skip(ftype)
20364 
      iprot.readFieldEnd()
20365 
    iprot.readStructEnd()
20366 
 
20367 
  def write(self, oprot):
20368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20370 
      return
20371 
    oprot.writeStructBegin('shiftToWarehouse_args')
20372 
    if self.orderId is not None:
20373 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20374 
      oprot.writeI64(self.orderId)
20375 
      oprot.writeFieldEnd()
20376 
    if self.warehouseId is not None:
20377 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
20378 
      oprot.writeI64(self.warehouseId)
20379 
      oprot.writeFieldEnd()
20380 
    oprot.writeFieldStop()
20381 
    oprot.writeStructEnd()
20382 
 
20383 
  def validate(self):
20384 
    return
20385 
 
20386 
 
20387 
  def __repr__(self):
20388 
    L = ['%s=%r' % (key, value)
20389 
      for key, value in self.__dict__.iteritems()]
20390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20391 
 
20392 
  def __eq__(self, other):
20393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20394 
 
20395 
  def __ne__(self, other):
20396 
    return not (self == other)
20397 
 
20398 
class shiftToWarehouse_result:
20399 
  """
20400 
  Attributes:
20401 
   - success
20402 
   - ex
20403 
  """
20404 
 
20405 
  thrift_spec = (
20406 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
20407 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20408 
  )
20409 
 
20410 
  def __init__(self, success=None, ex=None,):
20411 
    self.success = success
20412 
    self.ex = ex
20413 
 
20414 
  def read(self, iprot):
20415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20417 
      return
20418 
    iprot.readStructBegin()
20419 
    while True:
20420 
      (fname, ftype, fid) = iprot.readFieldBegin()
20421 
      if ftype == TType.STOP:
20422 
        break
20423 
      if fid == 0:
20424 
        if ftype == TType.STRUCT:
20425 
          self.success = Order()
20426 
          self.success.read(iprot)
20427 
        else:
20428 
          iprot.skip(ftype)
20429 
      elif fid == 1:
20430 
        if ftype == TType.STRUCT:
20431 
          self.ex = TransactionServiceException()
20432 
          self.ex.read(iprot)
20433 
        else:
20434 
          iprot.skip(ftype)
20435 
      else:
20436 
        iprot.skip(ftype)
20437 
      iprot.readFieldEnd()
20438 
    iprot.readStructEnd()
20439 
 
20440 
  def write(self, oprot):
20441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20443 
      return
20444 
    oprot.writeStructBegin('shiftToWarehouse_result')
20445 
    if self.success is not None:
20446 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
20447 
      self.success.write(oprot)
20448 
      oprot.writeFieldEnd()
20449 
    if self.ex is not None:
20450 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20451 
      self.ex.write(oprot)
20452 
      oprot.writeFieldEnd()
20453 
    oprot.writeFieldStop()
20454 
    oprot.writeStructEnd()
20455 
 
20456 
  def validate(self):
20457 
    return
20458 
 
20459 
 
20460 
  def __repr__(self):
20461 
    L = ['%s=%r' % (key, value)
20462 
      for key, value in self.__dict__.iteritems()]
20463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20464 
 
20465 
  def __eq__(self, other):
20466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20467 
 
20468 
  def __ne__(self, other):
20469 
    return not (self == other)
3553 chandransh 20470 
 
20471 
class addDelayReason_args:
20472 
  """
20473 
  Attributes:
20474 
   - orderId
20475 
   - delayReason
3986 chandransh 20476 
   - furtherDelay
4647 rajveer 20477 
   - delayReasonText
3553 chandransh 20478 
  """
20479 
 
20480 
  thrift_spec = (
20481 
    None, # 0
20482 
    (1, TType.I64, 'orderId', None, None, ), # 1
20483 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 20484 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 20485 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 20486 
  )
20487 
 
4647 rajveer 20488 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 20489 
    self.orderId = orderId
20490 
    self.delayReason = delayReason
3986 chandransh 20491 
    self.furtherDelay = furtherDelay
4647 rajveer 20492 
    self.delayReasonText = delayReasonText
3553 chandransh 20493 
 
20494 
  def read(self, iprot):
20495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20497 
      return
20498 
    iprot.readStructBegin()
20499 
    while True:
20500 
      (fname, ftype, fid) = iprot.readFieldBegin()
20501 
      if ftype == TType.STOP:
20502 
        break
20503 
      if fid == 1:
20504 
        if ftype == TType.I64:
20505 
          self.orderId = iprot.readI64();
20506 
        else:
20507 
          iprot.skip(ftype)
20508 
      elif fid == 2:
20509 
        if ftype == TType.I32:
20510 
          self.delayReason = iprot.readI32();
20511 
        else:
20512 
          iprot.skip(ftype)
3986 chandransh 20513 
      elif fid == 3:
20514 
        if ftype == TType.I64:
20515 
          self.furtherDelay = iprot.readI64();
20516 
        else:
20517 
          iprot.skip(ftype)
4647 rajveer 20518 
      elif fid == 4:
20519 
        if ftype == TType.STRING:
20520 
          self.delayReasonText = iprot.readString();
20521 
        else:
20522 
          iprot.skip(ftype)
3553 chandransh 20523 
      else:
20524 
        iprot.skip(ftype)
20525 
      iprot.readFieldEnd()
20526 
    iprot.readStructEnd()
20527 
 
20528 
  def write(self, oprot):
20529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20531 
      return
20532 
    oprot.writeStructBegin('addDelayReason_args')
20533 
    if self.orderId is not None:
20534 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20535 
      oprot.writeI64(self.orderId)
20536 
      oprot.writeFieldEnd()
20537 
    if self.delayReason is not None:
20538 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
20539 
      oprot.writeI32(self.delayReason)
20540 
      oprot.writeFieldEnd()
3986 chandransh 20541 
    if self.furtherDelay is not None:
20542 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
20543 
      oprot.writeI64(self.furtherDelay)
20544 
      oprot.writeFieldEnd()
4647 rajveer 20545 
    if self.delayReasonText is not None:
20546 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
20547 
      oprot.writeString(self.delayReasonText)
20548 
      oprot.writeFieldEnd()
3553 chandransh 20549 
    oprot.writeFieldStop()
20550 
    oprot.writeStructEnd()
20551 
 
20552 
  def validate(self):
20553 
    return
20554 
 
20555 
 
20556 
  def __repr__(self):
20557 
    L = ['%s=%r' % (key, value)
20558 
      for key, value in self.__dict__.iteritems()]
20559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20560 
 
20561 
  def __eq__(self, other):
20562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20563 
 
20564 
  def __ne__(self, other):
20565 
    return not (self == other)
20566 
 
20567 
class addDelayReason_result:
20568 
  """
20569 
  Attributes:
20570 
   - success
20571 
   - ex
20572 
  """
20573 
 
20574 
  thrift_spec = (
20575 
    (0, TType.BOOL, 'success', None, None, ), # 0
20576 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20577 
  )
20578 
 
20579 
  def __init__(self, success=None, ex=None,):
20580 
    self.success = success
20581 
    self.ex = ex
20582 
 
20583 
  def read(self, iprot):
20584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20586 
      return
20587 
    iprot.readStructBegin()
20588 
    while True:
20589 
      (fname, ftype, fid) = iprot.readFieldBegin()
20590 
      if ftype == TType.STOP:
20591 
        break
20592 
      if fid == 0:
20593 
        if ftype == TType.BOOL:
20594 
          self.success = iprot.readBool();
20595 
        else:
20596 
          iprot.skip(ftype)
20597 
      elif fid == 1:
20598 
        if ftype == TType.STRUCT:
20599 
          self.ex = TransactionServiceException()
20600 
          self.ex.read(iprot)
20601 
        else:
20602 
          iprot.skip(ftype)
20603 
      else:
20604 
        iprot.skip(ftype)
20605 
      iprot.readFieldEnd()
20606 
    iprot.readStructEnd()
20607 
 
20608 
  def write(self, oprot):
20609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20611 
      return
20612 
    oprot.writeStructBegin('addDelayReason_result')
20613 
    if self.success is not None:
20614 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
20615 
      oprot.writeBool(self.success)
20616 
      oprot.writeFieldEnd()
20617 
    if self.ex is not None:
20618 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20619 
      self.ex.write(oprot)
20620 
      oprot.writeFieldEnd()
20621 
    oprot.writeFieldStop()
20622 
    oprot.writeStructEnd()
20623 
 
20624 
  def validate(self):
20625 
    return
20626 
 
20627 
 
20628 
  def __repr__(self):
20629 
    L = ['%s=%r' % (key, value)
20630 
      for key, value in self.__dict__.iteritems()]
20631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20632 
 
20633 
  def __eq__(self, other):
20634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20635 
 
20636 
  def __ne__(self, other):
20637 
    return not (self == other)
3956 chandransh 20638 
 
20639 
class reconcileCodCollection_args:
20640 
  """
20641 
  Attributes:
20642 
   - collectedAmountMap
20643 
   - xferBy
20644 
   - xferTxnId
20645 
   - xferDate
20646 
  """
20647 
 
20648 
  thrift_spec = (
20649 
    None, # 0
20650 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
20651 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
20652 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
20653 
    (4, TType.I64, 'xferDate', None, None, ), # 4
20654 
  )
20655 
 
20656 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
20657 
    self.collectedAmountMap = collectedAmountMap
20658 
    self.xferBy = xferBy
20659 
    self.xferTxnId = xferTxnId
20660 
    self.xferDate = xferDate
20661 
 
20662 
  def read(self, iprot):
20663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20665 
      return
20666 
    iprot.readStructBegin()
20667 
    while True:
20668 
      (fname, ftype, fid) = iprot.readFieldBegin()
20669 
      if ftype == TType.STOP:
20670 
        break
20671 
      if fid == 1:
20672 
        if ftype == TType.MAP:
20673 
          self.collectedAmountMap = {}
6188 rajveer 20674 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
20675 
          for _i457 in xrange(_size453):
20676 
            _key458 = iprot.readString();
20677 
            _val459 = iprot.readDouble();
20678 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 20679 
          iprot.readMapEnd()
20680 
        else:
20681 
          iprot.skip(ftype)
20682 
      elif fid == 2:
20683 
        if ftype == TType.STRING:
20684 
          self.xferBy = iprot.readString();
20685 
        else:
20686 
          iprot.skip(ftype)
20687 
      elif fid == 3:
20688 
        if ftype == TType.STRING:
20689 
          self.xferTxnId = iprot.readString();
20690 
        else:
20691 
          iprot.skip(ftype)
20692 
      elif fid == 4:
20693 
        if ftype == TType.I64:
20694 
          self.xferDate = iprot.readI64();
20695 
        else:
20696 
          iprot.skip(ftype)
20697 
      else:
20698 
        iprot.skip(ftype)
20699 
      iprot.readFieldEnd()
20700 
    iprot.readStructEnd()
20701 
 
20702 
  def write(self, oprot):
20703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20705 
      return
20706 
    oprot.writeStructBegin('reconcileCodCollection_args')
20707 
    if self.collectedAmountMap is not None:
20708 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
20709 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 20710 
      for kiter460,viter461 in self.collectedAmountMap.items():
20711 
        oprot.writeString(kiter460)
20712 
        oprot.writeDouble(viter461)
3956 chandransh 20713 
      oprot.writeMapEnd()
20714 
      oprot.writeFieldEnd()
20715 
    if self.xferBy is not None:
20716 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
20717 
      oprot.writeString(self.xferBy)
20718 
      oprot.writeFieldEnd()
20719 
    if self.xferTxnId is not None:
20720 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
20721 
      oprot.writeString(self.xferTxnId)
20722 
      oprot.writeFieldEnd()
20723 
    if self.xferDate is not None:
20724 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
20725 
      oprot.writeI64(self.xferDate)
20726 
      oprot.writeFieldEnd()
20727 
    oprot.writeFieldStop()
20728 
    oprot.writeStructEnd()
20729 
 
20730 
  def validate(self):
20731 
    return
20732 
 
20733 
 
20734 
  def __repr__(self):
20735 
    L = ['%s=%r' % (key, value)
20736 
      for key, value in self.__dict__.iteritems()]
20737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20738 
 
20739 
  def __eq__(self, other):
20740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20741 
 
20742 
  def __ne__(self, other):
20743 
    return not (self == other)
20744 
 
20745 
class reconcileCodCollection_result:
20746 
  """
20747 
  Attributes:
20748 
   - success
20749 
   - ex
20750 
  """
20751 
 
20752 
  thrift_spec = (
20753 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
20754 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20755 
  )
20756 
 
20757 
  def __init__(self, success=None, ex=None,):
20758 
    self.success = success
20759 
    self.ex = ex
20760 
 
20761 
  def read(self, iprot):
20762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20764 
      return
20765 
    iprot.readStructBegin()
20766 
    while True:
20767 
      (fname, ftype, fid) = iprot.readFieldBegin()
20768 
      if ftype == TType.STOP:
20769 
        break
20770 
      if fid == 0:
20771 
        if ftype == TType.MAP:
20772 
          self.success = {}
6188 rajveer 20773 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20774 
          for _i466 in xrange(_size462):
20775 
            _key467 = iprot.readString();
20776 
            _val468 = iprot.readString();
20777 
            self.success[_key467] = _val468
3956 chandransh 20778 
          iprot.readMapEnd()
20779 
        else:
20780 
          iprot.skip(ftype)
20781 
      elif fid == 1:
20782 
        if ftype == TType.STRUCT:
20783 
          self.ex = TransactionServiceException()
20784 
          self.ex.read(iprot)
20785 
        else:
20786 
          iprot.skip(ftype)
20787 
      else:
20788 
        iprot.skip(ftype)
20789 
      iprot.readFieldEnd()
20790 
    iprot.readStructEnd()
20791 
 
20792 
  def write(self, oprot):
20793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20795 
      return
20796 
    oprot.writeStructBegin('reconcileCodCollection_result')
20797 
    if self.success is not None:
20798 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20799 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 20800 
      for kiter469,viter470 in self.success.items():
20801 
        oprot.writeString(kiter469)
20802 
        oprot.writeString(viter470)
3956 chandransh 20803 
      oprot.writeMapEnd()
20804 
      oprot.writeFieldEnd()
20805 
    if self.ex is not None:
20806 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20807 
      self.ex.write(oprot)
20808 
      oprot.writeFieldEnd()
20809 
    oprot.writeFieldStop()
20810 
    oprot.writeStructEnd()
20811 
 
20812 
  def validate(self):
20813 
    return
20814 
 
20815 
 
20816 
  def __repr__(self):
20817 
    L = ['%s=%r' % (key, value)
20818 
      for key, value in self.__dict__.iteritems()]
20819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20820 
 
20821 
  def __eq__(self, other):
20822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20823 
 
20824 
  def __ne__(self, other):
20825 
    return not (self == other)
4008 mandeep.dh 20826 
 
20827 
class getTransactionsRequiringExtraProcessing_args:
20828 
  """
20829 
  Attributes:
20830 
   - category
20831 
  """
20832 
 
20833 
  thrift_spec = (
20834 
    None, # 0
20835 
    (1, TType.I32, 'category', None, None, ), # 1
20836 
  )
20837 
 
20838 
  def __init__(self, category=None,):
20839 
    self.category = category
20840 
 
20841 
  def read(self, iprot):
20842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20844 
      return
20845 
    iprot.readStructBegin()
20846 
    while True:
20847 
      (fname, ftype, fid) = iprot.readFieldBegin()
20848 
      if ftype == TType.STOP:
20849 
        break
20850 
      if fid == 1:
20851 
        if ftype == TType.I32:
20852 
          self.category = iprot.readI32();
20853 
        else:
20854 
          iprot.skip(ftype)
20855 
      else:
20856 
        iprot.skip(ftype)
20857 
      iprot.readFieldEnd()
20858 
    iprot.readStructEnd()
20859 
 
20860 
  def write(self, oprot):
20861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20863 
      return
20864 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
20865 
    if self.category is not None:
20866 
      oprot.writeFieldBegin('category', TType.I32, 1)
20867 
      oprot.writeI32(self.category)
20868 
      oprot.writeFieldEnd()
20869 
    oprot.writeFieldStop()
20870 
    oprot.writeStructEnd()
20871 
 
20872 
  def validate(self):
20873 
    return
20874 
 
20875 
 
20876 
  def __repr__(self):
20877 
    L = ['%s=%r' % (key, value)
20878 
      for key, value in self.__dict__.iteritems()]
20879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20880 
 
20881 
  def __eq__(self, other):
20882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20883 
 
20884 
  def __ne__(self, other):
20885 
    return not (self == other)
20886 
 
20887 
class getTransactionsRequiringExtraProcessing_result:
20888 
  """
20889 
  Attributes:
20890 
   - success
20891 
  """
20892 
 
20893 
  thrift_spec = (
20894 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
20895 
  )
20896 
 
20897 
  def __init__(self, success=None,):
20898 
    self.success = success
20899 
 
20900 
  def read(self, iprot):
20901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20903 
      return
20904 
    iprot.readStructBegin()
20905 
    while True:
20906 
      (fname, ftype, fid) = iprot.readFieldBegin()
20907 
      if ftype == TType.STOP:
20908 
        break
20909 
      if fid == 0:
20910 
        if ftype == TType.LIST:
20911 
          self.success = []
6188 rajveer 20912 
          (_etype474, _size471) = iprot.readListBegin()
20913 
          for _i475 in xrange(_size471):
20914 
            _elem476 = iprot.readI64();
20915 
            self.success.append(_elem476)
4008 mandeep.dh 20916 
          iprot.readListEnd()
20917 
        else:
20918 
          iprot.skip(ftype)
20919 
      else:
20920 
        iprot.skip(ftype)
20921 
      iprot.readFieldEnd()
20922 
    iprot.readStructEnd()
20923 
 
20924 
  def write(self, oprot):
20925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20927 
      return
20928 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
20929 
    if self.success is not None:
20930 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20931 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 20932 
      for iter477 in self.success:
20933 
        oprot.writeI64(iter477)
4008 mandeep.dh 20934 
      oprot.writeListEnd()
20935 
      oprot.writeFieldEnd()
20936 
    oprot.writeFieldStop()
20937 
    oprot.writeStructEnd()
20938 
 
20939 
  def validate(self):
20940 
    return
20941 
 
20942 
 
20943 
  def __repr__(self):
20944 
    L = ['%s=%r' % (key, value)
20945 
      for key, value in self.__dict__.iteritems()]
20946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20947 
 
20948 
  def __eq__(self, other):
20949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20950 
 
20951 
  def __ne__(self, other):
20952 
    return not (self == other)
20953 
 
20954 
class markTransactionAsProcessed_args:
20955 
  """
20956 
  Attributes:
20957 
   - transactionId
20958 
   - category
20959 
  """
20960 
 
20961 
  thrift_spec = (
20962 
    None, # 0
20963 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20964 
    (2, TType.I32, 'category', None, None, ), # 2
20965 
  )
20966 
 
20967 
  def __init__(self, transactionId=None, category=None,):
20968 
    self.transactionId = transactionId
20969 
    self.category = category
20970 
 
20971 
  def read(self, iprot):
20972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20974 
      return
20975 
    iprot.readStructBegin()
20976 
    while True:
20977 
      (fname, ftype, fid) = iprot.readFieldBegin()
20978 
      if ftype == TType.STOP:
20979 
        break
20980 
      if fid == 1:
20981 
        if ftype == TType.I64:
20982 
          self.transactionId = iprot.readI64();
20983 
        else:
20984 
          iprot.skip(ftype)
20985 
      elif fid == 2:
20986 
        if ftype == TType.I32:
20987 
          self.category = iprot.readI32();
20988 
        else:
20989 
          iprot.skip(ftype)
20990 
      else:
20991 
        iprot.skip(ftype)
20992 
      iprot.readFieldEnd()
20993 
    iprot.readStructEnd()
20994 
 
20995 
  def write(self, oprot):
20996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20998 
      return
20999 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
21000 
    if self.transactionId is not None:
21001 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21002 
      oprot.writeI64(self.transactionId)
21003 
      oprot.writeFieldEnd()
21004 
    if self.category is not None:
21005 
      oprot.writeFieldBegin('category', TType.I32, 2)
21006 
      oprot.writeI32(self.category)
21007 
      oprot.writeFieldEnd()
21008 
    oprot.writeFieldStop()
21009 
    oprot.writeStructEnd()
21010 
 
21011 
  def validate(self):
21012 
    return
21013 
 
21014 
 
21015 
  def __repr__(self):
21016 
    L = ['%s=%r' % (key, value)
21017 
      for key, value in self.__dict__.iteritems()]
21018 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21019 
 
21020 
  def __eq__(self, other):
21021 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21022 
 
21023 
  def __ne__(self, other):
21024 
    return not (self == other)
21025 
 
21026 
class markTransactionAsProcessed_result:
21027 
 
21028 
  thrift_spec = (
21029 
  )
21030 
 
21031 
  def read(self, iprot):
21032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21034 
      return
21035 
    iprot.readStructBegin()
21036 
    while True:
21037 
      (fname, ftype, fid) = iprot.readFieldBegin()
21038 
      if ftype == TType.STOP:
21039 
        break
21040 
      else:
21041 
        iprot.skip(ftype)
21042 
      iprot.readFieldEnd()
21043 
    iprot.readStructEnd()
21044 
 
21045 
  def write(self, oprot):
21046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21048 
      return
21049 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
21050 
    oprot.writeFieldStop()
21051 
    oprot.writeStructEnd()
21052 
 
21053 
  def validate(self):
21054 
    return
21055 
 
21056 
 
21057 
  def __repr__(self):
21058 
    L = ['%s=%r' % (key, value)
21059 
      for key, value in self.__dict__.iteritems()]
21060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21061 
 
21062 
  def __eq__(self, other):
21063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21064 
 
21065 
  def __ne__(self, other):
21066 
    return not (self == other)
4018 chandransh 21067 
 
21068 
class getItemWiseRiskyOrdersCount_args:
21069 
 
21070 
  thrift_spec = (
21071 
  )
21072 
 
21073 
  def read(self, iprot):
21074 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21075 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21076 
      return
21077 
    iprot.readStructBegin()
21078 
    while True:
21079 
      (fname, ftype, fid) = iprot.readFieldBegin()
21080 
      if ftype == TType.STOP:
21081 
        break
21082 
      else:
21083 
        iprot.skip(ftype)
21084 
      iprot.readFieldEnd()
21085 
    iprot.readStructEnd()
21086 
 
21087 
  def write(self, oprot):
21088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21090 
      return
21091 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
21092 
    oprot.writeFieldStop()
21093 
    oprot.writeStructEnd()
21094 
 
21095 
  def validate(self):
21096 
    return
21097 
 
21098 
 
21099 
  def __repr__(self):
21100 
    L = ['%s=%r' % (key, value)
21101 
      for key, value in self.__dict__.iteritems()]
21102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21103 
 
21104 
  def __eq__(self, other):
21105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21106 
 
21107 
  def __ne__(self, other):
21108 
    return not (self == other)
21109 
 
21110 
class getItemWiseRiskyOrdersCount_result:
21111 
  """
21112 
  Attributes:
21113 
   - success
21114 
  """
21115 
 
21116 
  thrift_spec = (
21117 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
21118 
  )
21119 
 
21120 
  def __init__(self, success=None,):
21121 
    self.success = success
21122 
 
21123 
  def read(self, iprot):
21124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21126 
      return
21127 
    iprot.readStructBegin()
21128 
    while True:
21129 
      (fname, ftype, fid) = iprot.readFieldBegin()
21130 
      if ftype == TType.STOP:
21131 
        break
21132 
      if fid == 0:
21133 
        if ftype == TType.MAP:
21134 
          self.success = {}
6188 rajveer 21135 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
21136 
          for _i482 in xrange(_size478):
21137 
            _key483 = iprot.readI64();
21138 
            _val484 = iprot.readI64();
21139 
            self.success[_key483] = _val484
4018 chandransh 21140 
          iprot.readMapEnd()
21141 
        else:
21142 
          iprot.skip(ftype)
21143 
      else:
21144 
        iprot.skip(ftype)
21145 
      iprot.readFieldEnd()
21146 
    iprot.readStructEnd()
21147 
 
21148 
  def write(self, oprot):
21149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21151 
      return
21152 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
21153 
    if self.success is not None:
21154 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21155 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 21156 
      for kiter485,viter486 in self.success.items():
21157 
        oprot.writeI64(kiter485)
21158 
        oprot.writeI64(viter486)
4018 chandransh 21159 
      oprot.writeMapEnd()
21160 
      oprot.writeFieldEnd()
21161 
    oprot.writeFieldStop()
21162 
    oprot.writeStructEnd()
21163 
 
21164 
  def validate(self):
21165 
    return
21166 
 
21167 
 
21168 
  def __repr__(self):
21169 
    L = ['%s=%r' % (key, value)
21170 
      for key, value in self.__dict__.iteritems()]
21171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21172 
 
21173 
  def __eq__(self, other):
21174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21175 
 
21176 
  def __ne__(self, other):
21177 
    return not (self == other)
4247 rajveer 21178 
 
4295 varun.gupt 21179 
class getOrdersForItemIds_args:
21180 
  """
21181 
  Attributes:
21182 
   - itemIds
21183 
  """
21184 
 
21185 
  thrift_spec = (
21186 
    None, # 0
21187 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
21188 
  )
21189 
 
21190 
  def __init__(self, itemIds=None,):
21191 
    self.itemIds = itemIds
21192 
 
21193 
  def read(self, iprot):
21194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21196 
      return
21197 
    iprot.readStructBegin()
21198 
    while True:
21199 
      (fname, ftype, fid) = iprot.readFieldBegin()
21200 
      if ftype == TType.STOP:
21201 
        break
21202 
      if fid == 1:
21203 
        if ftype == TType.LIST:
21204 
          self.itemIds = []
6188 rajveer 21205 
          (_etype490, _size487) = iprot.readListBegin()
21206 
          for _i491 in xrange(_size487):
21207 
            _elem492 = iprot.readI64();
21208 
            self.itemIds.append(_elem492)
4295 varun.gupt 21209 
          iprot.readListEnd()
21210 
        else:
21211 
          iprot.skip(ftype)
21212 
      else:
21213 
        iprot.skip(ftype)
21214 
      iprot.readFieldEnd()
21215 
    iprot.readStructEnd()
21216 
 
21217 
  def write(self, oprot):
21218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21220 
      return
21221 
    oprot.writeStructBegin('getOrdersForItemIds_args')
21222 
    if self.itemIds is not None:
21223 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
21224 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 21225 
      for iter493 in self.itemIds:
21226 
        oprot.writeI64(iter493)
4295 varun.gupt 21227 
      oprot.writeListEnd()
21228 
      oprot.writeFieldEnd()
21229 
    oprot.writeFieldStop()
21230 
    oprot.writeStructEnd()
21231 
 
21232 
  def validate(self):
21233 
    return
21234 
 
21235 
 
21236 
  def __repr__(self):
21237 
    L = ['%s=%r' % (key, value)
21238 
      for key, value in self.__dict__.iteritems()]
21239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21240 
 
21241 
  def __eq__(self, other):
21242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21243 
 
21244 
  def __ne__(self, other):
21245 
    return not (self == other)
21246 
 
21247 
class getOrdersForItemIds_result:
21248 
  """
21249 
  Attributes:
21250 
   - success
21251 
  """
21252 
 
21253 
  thrift_spec = (
21254 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
21255 
  )
21256 
 
21257 
  def __init__(self, success=None,):
21258 
    self.success = success
21259 
 
21260 
  def read(self, iprot):
21261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21263 
      return
21264 
    iprot.readStructBegin()
21265 
    while True:
21266 
      (fname, ftype, fid) = iprot.readFieldBegin()
21267 
      if ftype == TType.STOP:
21268 
        break
21269 
      if fid == 0:
21270 
        if ftype == TType.LIST:
21271 
          self.success = []
6188 rajveer 21272 
          (_etype497, _size494) = iprot.readListBegin()
21273 
          for _i498 in xrange(_size494):
21274 
            _elem499 = Order()
21275 
            _elem499.read(iprot)
21276 
            self.success.append(_elem499)
4295 varun.gupt 21277 
          iprot.readListEnd()
21278 
        else:
21279 
          iprot.skip(ftype)
21280 
      else:
21281 
        iprot.skip(ftype)
21282 
      iprot.readFieldEnd()
21283 
    iprot.readStructEnd()
21284 
 
21285 
  def write(self, oprot):
21286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21288 
      return
21289 
    oprot.writeStructBegin('getOrdersForItemIds_result')
21290 
    if self.success is not None:
21291 
      oprot.writeFieldBegin('success', TType.LIST, 0)
21292 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 21293 
      for iter500 in self.success:
21294 
        iter500.write(oprot)
4295 varun.gupt 21295 
      oprot.writeListEnd()
21296 
      oprot.writeFieldEnd()
21297 
    oprot.writeFieldStop()
21298 
    oprot.writeStructEnd()
21299 
 
21300 
  def validate(self):
21301 
    return
21302 
 
21303 
 
21304 
  def __repr__(self):
21305 
    L = ['%s=%r' % (key, value)
21306 
      for key, value in self.__dict__.iteritems()]
21307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21308 
 
21309 
  def __eq__(self, other):
21310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21311 
 
21312 
  def __ne__(self, other):
21313 
    return not (self == other)
21314 
 
4247 rajveer 21315 
class markOrderCancellationRequestReceived_args:
21316 
  """
21317 
  Attributes:
21318 
   - orderId
21319 
  """
21320 
 
21321 
  thrift_spec = (
21322 
    None, # 0
21323 
    (1, TType.I64, 'orderId', None, None, ), # 1
21324 
  )
21325 
 
21326 
  def __init__(self, orderId=None,):
21327 
    self.orderId = orderId
21328 
 
21329 
  def read(self, iprot):
21330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21332 
      return
21333 
    iprot.readStructBegin()
21334 
    while True:
21335 
      (fname, ftype, fid) = iprot.readFieldBegin()
21336 
      if ftype == TType.STOP:
21337 
        break
21338 
      if fid == 1:
21339 
        if ftype == TType.I64:
21340 
          self.orderId = iprot.readI64();
21341 
        else:
21342 
          iprot.skip(ftype)
21343 
      else:
21344 
        iprot.skip(ftype)
21345 
      iprot.readFieldEnd()
21346 
    iprot.readStructEnd()
21347 
 
21348 
  def write(self, oprot):
21349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21351 
      return
21352 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
21353 
    if self.orderId is not None:
21354 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21355 
      oprot.writeI64(self.orderId)
21356 
      oprot.writeFieldEnd()
21357 
    oprot.writeFieldStop()
21358 
    oprot.writeStructEnd()
21359 
 
21360 
  def validate(self):
21361 
    return
21362 
 
21363 
 
21364 
  def __repr__(self):
21365 
    L = ['%s=%r' % (key, value)
21366 
      for key, value in self.__dict__.iteritems()]
21367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21368 
 
21369 
  def __eq__(self, other):
21370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21371 
 
21372 
  def __ne__(self, other):
21373 
    return not (self == other)
21374 
 
21375 
class markOrderCancellationRequestReceived_result:
21376 
  """
21377 
  Attributes:
21378 
   - ex
21379 
  """
21380 
 
21381 
  thrift_spec = (
21382 
    None, # 0
21383 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21384 
  )
21385 
 
21386 
  def __init__(self, ex=None,):
21387 
    self.ex = ex
21388 
 
21389 
  def read(self, iprot):
21390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21392 
      return
21393 
    iprot.readStructBegin()
21394 
    while True:
21395 
      (fname, ftype, fid) = iprot.readFieldBegin()
21396 
      if ftype == TType.STOP:
21397 
        break
21398 
      if fid == 1:
21399 
        if ftype == TType.STRUCT:
21400 
          self.ex = TransactionServiceException()
21401 
          self.ex.read(iprot)
21402 
        else:
21403 
          iprot.skip(ftype)
21404 
      else:
21405 
        iprot.skip(ftype)
21406 
      iprot.readFieldEnd()
21407 
    iprot.readStructEnd()
21408 
 
21409 
  def write(self, oprot):
21410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21412 
      return
21413 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
21414 
    if self.ex is not None:
21415 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21416 
      self.ex.write(oprot)
21417 
      oprot.writeFieldEnd()
21418 
    oprot.writeFieldStop()
21419 
    oprot.writeStructEnd()
21420 
 
21421 
  def validate(self):
21422 
    return
21423 
 
21424 
 
21425 
  def __repr__(self):
21426 
    L = ['%s=%r' % (key, value)
21427 
      for key, value in self.__dict__.iteritems()]
21428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21429 
 
21430 
  def __eq__(self, other):
21431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21432 
 
21433 
  def __ne__(self, other):
21434 
    return not (self == other)
21435 
 
21436 
class markOrderCancellationRequestConfirmed_args:
21437 
  """
21438 
  Attributes:
21439 
   - orderId
21440 
  """
21441 
 
21442 
  thrift_spec = (
21443 
    None, # 0
21444 
    (1, TType.I64, 'orderId', None, None, ), # 1
21445 
  )
21446 
 
21447 
  def __init__(self, orderId=None,):
21448 
    self.orderId = orderId
21449 
 
21450 
  def read(self, iprot):
21451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21453 
      return
21454 
    iprot.readStructBegin()
21455 
    while True:
21456 
      (fname, ftype, fid) = iprot.readFieldBegin()
21457 
      if ftype == TType.STOP:
21458 
        break
21459 
      if fid == 1:
21460 
        if ftype == TType.I64:
21461 
          self.orderId = iprot.readI64();
21462 
        else:
21463 
          iprot.skip(ftype)
21464 
      else:
21465 
        iprot.skip(ftype)
21466 
      iprot.readFieldEnd()
21467 
    iprot.readStructEnd()
21468 
 
21469 
  def write(self, oprot):
21470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21472 
      return
21473 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
21474 
    if self.orderId is not None:
21475 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21476 
      oprot.writeI64(self.orderId)
21477 
      oprot.writeFieldEnd()
21478 
    oprot.writeFieldStop()
21479 
    oprot.writeStructEnd()
21480 
 
21481 
  def validate(self):
21482 
    return
21483 
 
21484 
 
21485 
  def __repr__(self):
21486 
    L = ['%s=%r' % (key, value)
21487 
      for key, value in self.__dict__.iteritems()]
21488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21489 
 
21490 
  def __eq__(self, other):
21491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21492 
 
21493 
  def __ne__(self, other):
21494 
    return not (self == other)
21495 
 
21496 
class markOrderCancellationRequestConfirmed_result:
21497 
  """
21498 
  Attributes:
21499 
   - ex
21500 
  """
21501 
 
21502 
  thrift_spec = (
21503 
    None, # 0
21504 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21505 
  )
21506 
 
21507 
  def __init__(self, ex=None,):
21508 
    self.ex = ex
21509 
 
21510 
  def read(self, iprot):
21511 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21512 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21513 
      return
21514 
    iprot.readStructBegin()
21515 
    while True:
21516 
      (fname, ftype, fid) = iprot.readFieldBegin()
21517 
      if ftype == TType.STOP:
21518 
        break
21519 
      if fid == 1:
21520 
        if ftype == TType.STRUCT:
21521 
          self.ex = TransactionServiceException()
21522 
          self.ex.read(iprot)
21523 
        else:
21524 
          iprot.skip(ftype)
21525 
      else:
21526 
        iprot.skip(ftype)
21527 
      iprot.readFieldEnd()
21528 
    iprot.readStructEnd()
21529 
 
21530 
  def write(self, oprot):
21531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21533 
      return
21534 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
21535 
    if self.ex is not None:
21536 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21537 
      self.ex.write(oprot)
21538 
      oprot.writeFieldEnd()
21539 
    oprot.writeFieldStop()
21540 
    oprot.writeStructEnd()
21541 
 
21542 
  def validate(self):
21543 
    return
21544 
 
21545 
 
21546 
  def __repr__(self):
21547 
    L = ['%s=%r' % (key, value)
21548 
      for key, value in self.__dict__.iteritems()]
21549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21550 
 
21551 
  def __eq__(self, other):
21552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21553 
 
21554 
  def __ne__(self, other):
21555 
    return not (self == other)
21556 
 
21557 
class markOrderCancellationRequestDenied_args:
21558 
  """
21559 
  Attributes:
21560 
   - orderId
21561 
  """
21562 
 
21563 
  thrift_spec = (
21564 
    None, # 0
21565 
    (1, TType.I64, 'orderId', None, None, ), # 1
21566 
  )
21567 
 
21568 
  def __init__(self, orderId=None,):
21569 
    self.orderId = orderId
21570 
 
21571 
  def read(self, iprot):
21572 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21573 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21574 
      return
21575 
    iprot.readStructBegin()
21576 
    while True:
21577 
      (fname, ftype, fid) = iprot.readFieldBegin()
21578 
      if ftype == TType.STOP:
21579 
        break
21580 
      if fid == 1:
21581 
        if ftype == TType.I64:
21582 
          self.orderId = iprot.readI64();
21583 
        else:
21584 
          iprot.skip(ftype)
21585 
      else:
21586 
        iprot.skip(ftype)
21587 
      iprot.readFieldEnd()
21588 
    iprot.readStructEnd()
21589 
 
21590 
  def write(self, oprot):
21591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21593 
      return
21594 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
21595 
    if self.orderId is not None:
21596 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21597 
      oprot.writeI64(self.orderId)
21598 
      oprot.writeFieldEnd()
21599 
    oprot.writeFieldStop()
21600 
    oprot.writeStructEnd()
21601 
 
21602 
  def validate(self):
21603 
    return
21604 
 
21605 
 
21606 
  def __repr__(self):
21607 
    L = ['%s=%r' % (key, value)
21608 
      for key, value in self.__dict__.iteritems()]
21609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21610 
 
21611 
  def __eq__(self, other):
21612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21613 
 
21614 
  def __ne__(self, other):
21615 
    return not (self == other)
21616 
 
21617 
class markOrderCancellationRequestDenied_result:
21618 
  """
21619 
  Attributes:
21620 
   - ex
21621 
  """
21622 
 
21623 
  thrift_spec = (
21624 
    None, # 0
21625 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21626 
  )
21627 
 
21628 
  def __init__(self, ex=None,):
21629 
    self.ex = ex
21630 
 
21631 
  def read(self, iprot):
21632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21634 
      return
21635 
    iprot.readStructBegin()
21636 
    while True:
21637 
      (fname, ftype, fid) = iprot.readFieldBegin()
21638 
      if ftype == TType.STOP:
21639 
        break
21640 
      if fid == 1:
21641 
        if ftype == TType.STRUCT:
21642 
          self.ex = TransactionServiceException()
21643 
          self.ex.read(iprot)
21644 
        else:
21645 
          iprot.skip(ftype)
21646 
      else:
21647 
        iprot.skip(ftype)
21648 
      iprot.readFieldEnd()
21649 
    iprot.readStructEnd()
21650 
 
21651 
  def write(self, oprot):
21652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21654 
      return
21655 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
21656 
    if self.ex is not None:
21657 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21658 
      self.ex.write(oprot)
21659 
      oprot.writeFieldEnd()
21660 
    oprot.writeFieldStop()
21661 
    oprot.writeStructEnd()
21662 
 
21663 
  def validate(self):
21664 
    return
21665 
 
21666 
 
21667 
  def __repr__(self):
21668 
    L = ['%s=%r' % (key, value)
21669 
      for key, value in self.__dict__.iteritems()]
21670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21671 
 
21672 
  def __eq__(self, other):
21673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21674 
 
21675 
  def __ne__(self, other):
21676 
    return not (self == other)
21677 
 
4258 rajveer 21678 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 21679 
  """
21680 
  Attributes:
4258 rajveer 21681 
   - transactionId
4247 rajveer 21682 
  """
21683 
 
21684 
  thrift_spec = (
21685 
    None, # 0
4258 rajveer 21686 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 21687 
  )
21688 
 
4258 rajveer 21689 
  def __init__(self, transactionId=None,):
21690 
    self.transactionId = transactionId
4247 rajveer 21691 
 
21692 
  def read(self, iprot):
21693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21695 
      return
21696 
    iprot.readStructBegin()
21697 
    while True:
21698 
      (fname, ftype, fid) = iprot.readFieldBegin()
21699 
      if ftype == TType.STOP:
21700 
        break
21701 
      if fid == 1:
21702 
        if ftype == TType.I64:
4258 rajveer 21703 
          self.transactionId = iprot.readI64();
4247 rajveer 21704 
        else:
21705 
          iprot.skip(ftype)
21706 
      else:
21707 
        iprot.skip(ftype)
21708 
      iprot.readFieldEnd()
21709 
    iprot.readStructEnd()
21710 
 
21711 
  def write(self, oprot):
21712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21714 
      return
4258 rajveer 21715 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
21716 
    if self.transactionId is not None:
21717 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21718 
      oprot.writeI64(self.transactionId)
4247 rajveer 21719 
      oprot.writeFieldEnd()
21720 
    oprot.writeFieldStop()
21721 
    oprot.writeStructEnd()
21722 
 
21723 
  def validate(self):
21724 
    return
21725 
 
21726 
 
21727 
  def __repr__(self):
21728 
    L = ['%s=%r' % (key, value)
21729 
      for key, value in self.__dict__.iteritems()]
21730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21731 
 
21732 
  def __eq__(self, other):
21733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21734 
 
21735 
  def __ne__(self, other):
21736 
    return not (self == other)
21737 
 
4258 rajveer 21738 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 21739 
  """
21740 
  Attributes:
21741 
   - ex
21742 
  """
21743 
 
21744 
  thrift_spec = (
21745 
    None, # 0
21746 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21747 
  )
21748 
 
21749 
  def __init__(self, ex=None,):
21750 
    self.ex = ex
21751 
 
21752 
  def read(self, iprot):
21753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21755 
      return
21756 
    iprot.readStructBegin()
21757 
    while True:
21758 
      (fname, ftype, fid) = iprot.readFieldBegin()
21759 
      if ftype == TType.STOP:
21760 
        break
21761 
      if fid == 1:
21762 
        if ftype == TType.STRUCT:
21763 
          self.ex = TransactionServiceException()
21764 
          self.ex.read(iprot)
21765 
        else:
21766 
          iprot.skip(ftype)
21767 
      else:
21768 
        iprot.skip(ftype)
21769 
      iprot.readFieldEnd()
21770 
    iprot.readStructEnd()
21771 
 
21772 
  def write(self, oprot):
21773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21775 
      return
4258 rajveer 21776 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 21777 
    if self.ex is not None:
21778 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21779 
      self.ex.write(oprot)
21780 
      oprot.writeFieldEnd()
21781 
    oprot.writeFieldStop()
21782 
    oprot.writeStructEnd()
21783 
 
21784 
  def validate(self):
21785 
    return
21786 
 
21787 
 
21788 
  def __repr__(self):
21789 
    L = ['%s=%r' % (key, value)
21790 
      for key, value in self.__dict__.iteritems()]
21791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21792 
 
21793 
  def __eq__(self, other):
21794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21795 
 
21796 
  def __ne__(self, other):
21797 
    return not (self == other)
4259 anupam.sin 21798 
 
21799 
class refundTransaction_args:
21800 
  """
21801 
  Attributes:
21802 
   - transactionId
21803 
   - refundedBy
21804 
   - reason
21805 
  """
21806 
 
21807 
  thrift_spec = (
21808 
    None, # 0
21809 
    (1, TType.I64, 'transactionId', None, None, ), # 1
21810 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
21811 
    (3, TType.STRING, 'reason', None, None, ), # 3
21812 
  )
21813 
 
21814 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
21815 
    self.transactionId = transactionId
21816 
    self.refundedBy = refundedBy
21817 
    self.reason = reason
21818 
 
21819 
  def read(self, iprot):
21820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21822 
      return
21823 
    iprot.readStructBegin()
21824 
    while True:
21825 
      (fname, ftype, fid) = iprot.readFieldBegin()
21826 
      if ftype == TType.STOP:
21827 
        break
21828 
      if fid == 1:
21829 
        if ftype == TType.I64:
21830 
          self.transactionId = iprot.readI64();
21831 
        else:
21832 
          iprot.skip(ftype)
21833 
      elif fid == 2:
21834 
        if ftype == TType.STRING:
21835 
          self.refundedBy = iprot.readString();
21836 
        else:
21837 
          iprot.skip(ftype)
21838 
      elif fid == 3:
21839 
        if ftype == TType.STRING:
21840 
          self.reason = iprot.readString();
21841 
        else:
21842 
          iprot.skip(ftype)
21843 
      else:
21844 
        iprot.skip(ftype)
21845 
      iprot.readFieldEnd()
21846 
    iprot.readStructEnd()
21847 
 
21848 
  def write(self, oprot):
21849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21851 
      return
21852 
    oprot.writeStructBegin('refundTransaction_args')
21853 
    if self.transactionId is not None:
21854 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21855 
      oprot.writeI64(self.transactionId)
21856 
      oprot.writeFieldEnd()
21857 
    if self.refundedBy is not None:
21858 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
21859 
      oprot.writeString(self.refundedBy)
21860 
      oprot.writeFieldEnd()
21861 
    if self.reason is not None:
21862 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
21863 
      oprot.writeString(self.reason)
21864 
      oprot.writeFieldEnd()
21865 
    oprot.writeFieldStop()
21866 
    oprot.writeStructEnd()
21867 
 
21868 
  def validate(self):
21869 
    return
21870 
 
21871 
 
21872 
  def __repr__(self):
21873 
    L = ['%s=%r' % (key, value)
21874 
      for key, value in self.__dict__.iteritems()]
21875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21876 
 
21877 
  def __eq__(self, other):
21878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21879 
 
21880 
  def __ne__(self, other):
21881 
    return not (self == other)
21882 
 
21883 
class refundTransaction_result:
21884 
  """
21885 
  Attributes:
21886 
   - ex
21887 
  """
21888 
 
21889 
  thrift_spec = (
21890 
    None, # 0
21891 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21892 
  )
21893 
 
21894 
  def __init__(self, ex=None,):
21895 
    self.ex = ex
21896 
 
21897 
  def read(self, iprot):
21898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21900 
      return
21901 
    iprot.readStructBegin()
21902 
    while True:
21903 
      (fname, ftype, fid) = iprot.readFieldBegin()
21904 
      if ftype == TType.STOP:
21905 
        break
21906 
      if fid == 1:
21907 
        if ftype == TType.STRUCT:
21908 
          self.ex = TransactionServiceException()
21909 
          self.ex.read(iprot)
21910 
        else:
21911 
          iprot.skip(ftype)
21912 
      else:
21913 
        iprot.skip(ftype)
21914 
      iprot.readFieldEnd()
21915 
    iprot.readStructEnd()
21916 
 
21917 
  def write(self, oprot):
21918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21920 
      return
21921 
    oprot.writeStructBegin('refundTransaction_result')
21922 
    if self.ex is not None:
21923 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21924 
      self.ex.write(oprot)
21925 
      oprot.writeFieldEnd()
21926 
    oprot.writeFieldStop()
21927 
    oprot.writeStructEnd()
21928 
 
21929 
  def validate(self):
21930 
    return
21931 
 
21932 
 
21933 
  def __repr__(self):
21934 
    L = ['%s=%r' % (key, value)
21935 
      for key, value in self.__dict__.iteritems()]
21936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21937 
 
21938 
  def __eq__(self, other):
21939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21940 
 
21941 
  def __ne__(self, other):
21942 
    return not (self == other)
4285 rajveer 21943 
 
4324 mandeep.dh 21944 
class updateShipmentAddress_args:
21945 
  """
21946 
  Attributes:
21947 
   - orderId
21948 
   - addressId
21949 
  """
21950 
 
21951 
  thrift_spec = (
21952 
    None, # 0
21953 
    (1, TType.I64, 'orderId', None, None, ), # 1
21954 
    (2, TType.I64, 'addressId', None, None, ), # 2
21955 
  )
21956 
 
21957 
  def __init__(self, orderId=None, addressId=None,):
21958 
    self.orderId = orderId
21959 
    self.addressId = addressId
21960 
 
21961 
  def read(self, iprot):
21962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21964 
      return
21965 
    iprot.readStructBegin()
21966 
    while True:
21967 
      (fname, ftype, fid) = iprot.readFieldBegin()
21968 
      if ftype == TType.STOP:
21969 
        break
21970 
      if fid == 1:
21971 
        if ftype == TType.I64:
21972 
          self.orderId = iprot.readI64();
21973 
        else:
21974 
          iprot.skip(ftype)
21975 
      elif fid == 2:
21976 
        if ftype == TType.I64:
21977 
          self.addressId = iprot.readI64();
21978 
        else:
21979 
          iprot.skip(ftype)
21980 
      else:
21981 
        iprot.skip(ftype)
21982 
      iprot.readFieldEnd()
21983 
    iprot.readStructEnd()
21984 
 
21985 
  def write(self, oprot):
21986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21988 
      return
21989 
    oprot.writeStructBegin('updateShipmentAddress_args')
21990 
    if self.orderId is not None:
21991 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21992 
      oprot.writeI64(self.orderId)
21993 
      oprot.writeFieldEnd()
21994 
    if self.addressId is not None:
21995 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
21996 
      oprot.writeI64(self.addressId)
21997 
      oprot.writeFieldEnd()
21998 
    oprot.writeFieldStop()
21999 
    oprot.writeStructEnd()
22000 
 
22001 
  def validate(self):
22002 
    return
22003 
 
22004 
 
22005 
  def __repr__(self):
22006 
    L = ['%s=%r' % (key, value)
22007 
      for key, value in self.__dict__.iteritems()]
22008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22009 
 
22010 
  def __eq__(self, other):
22011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22012 
 
22013 
  def __ne__(self, other):
22014 
    return not (self == other)
22015 
 
22016 
class updateShipmentAddress_result:
22017 
  """
22018 
  Attributes:
22019 
   - ex
22020 
  """
22021 
 
22022 
  thrift_spec = (
22023 
    None, # 0
22024 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22025 
  )
22026 
 
22027 
  def __init__(self, ex=None,):
22028 
    self.ex = ex
22029 
 
22030 
  def read(self, iprot):
22031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22033 
      return
22034 
    iprot.readStructBegin()
22035 
    while True:
22036 
      (fname, ftype, fid) = iprot.readFieldBegin()
22037 
      if ftype == TType.STOP:
22038 
        break
22039 
      if fid == 1:
22040 
        if ftype == TType.STRUCT:
22041 
          self.ex = TransactionServiceException()
22042 
          self.ex.read(iprot)
22043 
        else:
22044 
          iprot.skip(ftype)
22045 
      else:
22046 
        iprot.skip(ftype)
22047 
      iprot.readFieldEnd()
22048 
    iprot.readStructEnd()
22049 
 
22050 
  def write(self, oprot):
22051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22053 
      return
22054 
    oprot.writeStructBegin('updateShipmentAddress_result')
22055 
    if self.ex is not None:
22056 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22057 
      self.ex.write(oprot)
22058 
      oprot.writeFieldEnd()
22059 
    oprot.writeFieldStop()
22060 
    oprot.writeStructEnd()
22061 
 
22062 
  def validate(self):
22063 
    return
22064 
 
22065 
 
22066 
  def __repr__(self):
22067 
    L = ['%s=%r' % (key, value)
22068 
      for key, value in self.__dict__.iteritems()]
22069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22070 
 
22071 
  def __eq__(self, other):
22072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22073 
 
22074 
  def __ne__(self, other):
22075 
    return not (self == other)
22076 
 
4285 rajveer 22077 
class acceptOrdersForItemId_args:
22078 
  """
22079 
  Attributes:
22080 
   - itemId
22081 
   - inventory
22082 
  """
22083 
 
22084 
  thrift_spec = (
22085 
    None, # 0
22086 
    (1, TType.I64, 'itemId', None, None, ), # 1
22087 
    (2, TType.I64, 'inventory', None, None, ), # 2
22088 
  )
22089 
 
22090 
  def __init__(self, itemId=None, inventory=None,):
22091 
    self.itemId = itemId
22092 
    self.inventory = inventory
22093 
 
22094 
  def read(self, iprot):
22095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22097 
      return
22098 
    iprot.readStructBegin()
22099 
    while True:
22100 
      (fname, ftype, fid) = iprot.readFieldBegin()
22101 
      if ftype == TType.STOP:
22102 
        break
22103 
      if fid == 1:
22104 
        if ftype == TType.I64:
22105 
          self.itemId = iprot.readI64();
22106 
        else:
22107 
          iprot.skip(ftype)
22108 
      elif fid == 2:
22109 
        if ftype == TType.I64:
22110 
          self.inventory = iprot.readI64();
22111 
        else:
22112 
          iprot.skip(ftype)
22113 
      else:
22114 
        iprot.skip(ftype)
22115 
      iprot.readFieldEnd()
22116 
    iprot.readStructEnd()
22117 
 
22118 
  def write(self, oprot):
22119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22121 
      return
22122 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
22123 
    if self.itemId is not None:
22124 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
22125 
      oprot.writeI64(self.itemId)
22126 
      oprot.writeFieldEnd()
22127 
    if self.inventory is not None:
22128 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
22129 
      oprot.writeI64(self.inventory)
22130 
      oprot.writeFieldEnd()
22131 
    oprot.writeFieldStop()
22132 
    oprot.writeStructEnd()
22133 
 
22134 
  def validate(self):
22135 
    return
22136 
 
22137 
 
22138 
  def __repr__(self):
22139 
    L = ['%s=%r' % (key, value)
22140 
      for key, value in self.__dict__.iteritems()]
22141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22142 
 
22143 
  def __eq__(self, other):
22144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22145 
 
22146 
  def __ne__(self, other):
22147 
    return not (self == other)
22148 
 
22149 
class acceptOrdersForItemId_result:
22150 
  """
22151 
  Attributes:
22152 
   - success
22153 
   - ex
22154 
  """
22155 
 
22156 
  thrift_spec = (
22157 
    (0, TType.BOOL, 'success', None, None, ), # 0
22158 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22159 
  )
22160 
 
22161 
  def __init__(self, success=None, ex=None,):
22162 
    self.success = success
22163 
    self.ex = ex
22164 
 
22165 
  def read(self, iprot):
22166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22168 
      return
22169 
    iprot.readStructBegin()
22170 
    while True:
22171 
      (fname, ftype, fid) = iprot.readFieldBegin()
22172 
      if ftype == TType.STOP:
22173 
        break
22174 
      if fid == 0:
22175 
        if ftype == TType.BOOL:
22176 
          self.success = iprot.readBool();
22177 
        else:
22178 
          iprot.skip(ftype)
22179 
      elif fid == 1:
22180 
        if ftype == TType.STRUCT:
22181 
          self.ex = TransactionServiceException()
22182 
          self.ex.read(iprot)
22183 
        else:
22184 
          iprot.skip(ftype)
22185 
      else:
22186 
        iprot.skip(ftype)
22187 
      iprot.readFieldEnd()
22188 
    iprot.readStructEnd()
22189 
 
22190 
  def write(self, oprot):
22191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22193 
      return
22194 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
22195 
    if self.success is not None:
22196 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22197 
      oprot.writeBool(self.success)
22198 
      oprot.writeFieldEnd()
22199 
    if self.ex is not None:
22200 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22201 
      self.ex.write(oprot)
22202 
      oprot.writeFieldEnd()
22203 
    oprot.writeFieldStop()
22204 
    oprot.writeStructEnd()
22205 
 
22206 
  def validate(self):
22207 
    return
22208 
 
22209 
 
22210 
  def __repr__(self):
22211 
    L = ['%s=%r' % (key, value)
22212 
      for key, value in self.__dict__.iteritems()]
22213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22214 
 
22215 
  def __eq__(self, other):
22216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22217 
 
22218 
  def __ne__(self, other):
22219 
    return not (self == other)
4303 rajveer 22220 
 
22221 
class markOrdersAsPORaised_args:
22222 
  """
22223 
  Attributes:
22224 
   - vendorId
22225 
   - itemId
22226 
   - quantity
22227 
   - estimate
4369 rajveer 22228 
   - isReminder
4303 rajveer 22229 
  """
22230 
 
22231 
  thrift_spec = (
22232 
    None, # 0
22233 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22234 
    (2, TType.I64, 'itemId', None, None, ), # 2
22235 
    (3, TType.I64, 'quantity', None, None, ), # 3
22236 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22237 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22238 
  )
22239 
 
4369 rajveer 22240 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22241 
    self.vendorId = vendorId
22242 
    self.itemId = itemId
22243 
    self.quantity = quantity
22244 
    self.estimate = estimate
4369 rajveer 22245 
    self.isReminder = isReminder
4303 rajveer 22246 
 
22247 
  def read(self, iprot):
22248 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22249 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22250 
      return
22251 
    iprot.readStructBegin()
22252 
    while True:
22253 
      (fname, ftype, fid) = iprot.readFieldBegin()
22254 
      if ftype == TType.STOP:
22255 
        break
22256 
      if fid == 1:
22257 
        if ftype == TType.I64:
22258 
          self.vendorId = iprot.readI64();
22259 
        else:
22260 
          iprot.skip(ftype)
22261 
      elif fid == 2:
22262 
        if ftype == TType.I64:
22263 
          self.itemId = iprot.readI64();
22264 
        else:
22265 
          iprot.skip(ftype)
22266 
      elif fid == 3:
22267 
        if ftype == TType.I64:
22268 
          self.quantity = iprot.readI64();
22269 
        else:
22270 
          iprot.skip(ftype)
22271 
      elif fid == 4:
22272 
        if ftype == TType.I64:
22273 
          self.estimate = iprot.readI64();
22274 
        else:
22275 
          iprot.skip(ftype)
4369 rajveer 22276 
      elif fid == 5:
22277 
        if ftype == TType.BOOL:
22278 
          self.isReminder = iprot.readBool();
22279 
        else:
22280 
          iprot.skip(ftype)
4303 rajveer 22281 
      else:
22282 
        iprot.skip(ftype)
22283 
      iprot.readFieldEnd()
22284 
    iprot.readStructEnd()
22285 
 
22286 
  def write(self, oprot):
22287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22289 
      return
22290 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
22291 
    if self.vendorId is not None:
22292 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22293 
      oprot.writeI64(self.vendorId)
22294 
      oprot.writeFieldEnd()
22295 
    if self.itemId is not None:
22296 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22297 
      oprot.writeI64(self.itemId)
22298 
      oprot.writeFieldEnd()
22299 
    if self.quantity is not None:
22300 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22301 
      oprot.writeI64(self.quantity)
22302 
      oprot.writeFieldEnd()
22303 
    if self.estimate is not None:
22304 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22305 
      oprot.writeI64(self.estimate)
22306 
      oprot.writeFieldEnd()
4369 rajveer 22307 
    if self.isReminder is not None:
22308 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22309 
      oprot.writeBool(self.isReminder)
22310 
      oprot.writeFieldEnd()
4303 rajveer 22311 
    oprot.writeFieldStop()
22312 
    oprot.writeStructEnd()
22313 
 
22314 
  def validate(self):
22315 
    return
22316 
 
22317 
 
22318 
  def __repr__(self):
22319 
    L = ['%s=%r' % (key, value)
22320 
      for key, value in self.__dict__.iteritems()]
22321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22322 
 
22323 
  def __eq__(self, other):
22324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22325 
 
22326 
  def __ne__(self, other):
22327 
    return not (self == other)
22328 
 
22329 
class markOrdersAsPORaised_result:
22330 
  """
22331 
  Attributes:
22332 
   - ex
22333 
  """
22334 
 
22335 
  thrift_spec = (
22336 
    None, # 0
22337 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22338 
  )
22339 
 
22340 
  def __init__(self, ex=None,):
22341 
    self.ex = ex
22342 
 
22343 
  def read(self, iprot):
22344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22346 
      return
22347 
    iprot.readStructBegin()
22348 
    while True:
22349 
      (fname, ftype, fid) = iprot.readFieldBegin()
22350 
      if ftype == TType.STOP:
22351 
        break
22352 
      if fid == 1:
22353 
        if ftype == TType.STRUCT:
22354 
          self.ex = TransactionServiceException()
22355 
          self.ex.read(iprot)
22356 
        else:
22357 
          iprot.skip(ftype)
22358 
      else:
22359 
        iprot.skip(ftype)
22360 
      iprot.readFieldEnd()
22361 
    iprot.readStructEnd()
22362 
 
22363 
  def write(self, oprot):
22364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22366 
      return
22367 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
22368 
    if self.ex is not None:
22369 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22370 
      self.ex.write(oprot)
22371 
      oprot.writeFieldEnd()
22372 
    oprot.writeFieldStop()
22373 
    oprot.writeStructEnd()
22374 
 
22375 
  def validate(self):
22376 
    return
22377 
 
22378 
 
22379 
  def __repr__(self):
22380 
    L = ['%s=%r' % (key, value)
22381 
      for key, value in self.__dict__.iteritems()]
22382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22383 
 
22384 
  def __eq__(self, other):
22385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22386 
 
22387 
  def __ne__(self, other):
22388 
    return not (self == other)
22389 
 
22390 
class markOrdersAsReversalInitiated_args:
22391 
  """
22392 
  Attributes:
22393 
   - vendorId
22394 
   - itemId
22395 
   - quantity
22396 
   - estimate
4369 rajveer 22397 
   - isReminder
4303 rajveer 22398 
  """
22399 
 
22400 
  thrift_spec = (
22401 
    None, # 0
22402 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22403 
    (2, TType.I64, 'itemId', None, None, ), # 2
22404 
    (3, TType.I64, 'quantity', None, None, ), # 3
22405 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22406 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22407 
  )
22408 
 
4369 rajveer 22409 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22410 
    self.vendorId = vendorId
22411 
    self.itemId = itemId
22412 
    self.quantity = quantity
22413 
    self.estimate = estimate
4369 rajveer 22414 
    self.isReminder = isReminder
4303 rajveer 22415 
 
22416 
  def read(self, iprot):
22417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22419 
      return
22420 
    iprot.readStructBegin()
22421 
    while True:
22422 
      (fname, ftype, fid) = iprot.readFieldBegin()
22423 
      if ftype == TType.STOP:
22424 
        break
22425 
      if fid == 1:
22426 
        if ftype == TType.I64:
22427 
          self.vendorId = iprot.readI64();
22428 
        else:
22429 
          iprot.skip(ftype)
22430 
      elif fid == 2:
22431 
        if ftype == TType.I64:
22432 
          self.itemId = iprot.readI64();
22433 
        else:
22434 
          iprot.skip(ftype)
22435 
      elif fid == 3:
22436 
        if ftype == TType.I64:
22437 
          self.quantity = iprot.readI64();
22438 
        else:
22439 
          iprot.skip(ftype)
22440 
      elif fid == 4:
22441 
        if ftype == TType.I64:
22442 
          self.estimate = iprot.readI64();
22443 
        else:
22444 
          iprot.skip(ftype)
4369 rajveer 22445 
      elif fid == 5:
22446 
        if ftype == TType.BOOL:
22447 
          self.isReminder = iprot.readBool();
22448 
        else:
22449 
          iprot.skip(ftype)
4303 rajveer 22450 
      else:
22451 
        iprot.skip(ftype)
22452 
      iprot.readFieldEnd()
22453 
    iprot.readStructEnd()
22454 
 
22455 
  def write(self, oprot):
22456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22458 
      return
22459 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
22460 
    if self.vendorId is not None:
22461 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22462 
      oprot.writeI64(self.vendorId)
22463 
      oprot.writeFieldEnd()
22464 
    if self.itemId is not None:
22465 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22466 
      oprot.writeI64(self.itemId)
22467 
      oprot.writeFieldEnd()
22468 
    if self.quantity is not None:
22469 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22470 
      oprot.writeI64(self.quantity)
22471 
      oprot.writeFieldEnd()
22472 
    if self.estimate is not None:
22473 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22474 
      oprot.writeI64(self.estimate)
22475 
      oprot.writeFieldEnd()
4369 rajveer 22476 
    if self.isReminder is not None:
22477 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22478 
      oprot.writeBool(self.isReminder)
22479 
      oprot.writeFieldEnd()
4303 rajveer 22480 
    oprot.writeFieldStop()
22481 
    oprot.writeStructEnd()
22482 
 
22483 
  def validate(self):
22484 
    return
22485 
 
22486 
 
22487 
  def __repr__(self):
22488 
    L = ['%s=%r' % (key, value)
22489 
      for key, value in self.__dict__.iteritems()]
22490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22491 
 
22492 
  def __eq__(self, other):
22493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22494 
 
22495 
  def __ne__(self, other):
22496 
    return not (self == other)
22497 
 
22498 
class markOrdersAsReversalInitiated_result:
22499 
  """
22500 
  Attributes:
22501 
   - ex
22502 
  """
22503 
 
22504 
  thrift_spec = (
22505 
    None, # 0
22506 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22507 
  )
22508 
 
22509 
  def __init__(self, ex=None,):
22510 
    self.ex = ex
22511 
 
22512 
  def read(self, iprot):
22513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22515 
      return
22516 
    iprot.readStructBegin()
22517 
    while True:
22518 
      (fname, ftype, fid) = iprot.readFieldBegin()
22519 
      if ftype == TType.STOP:
22520 
        break
22521 
      if fid == 1:
22522 
        if ftype == TType.STRUCT:
22523 
          self.ex = TransactionServiceException()
22524 
          self.ex.read(iprot)
22525 
        else:
22526 
          iprot.skip(ftype)
22527 
      else:
22528 
        iprot.skip(ftype)
22529 
      iprot.readFieldEnd()
22530 
    iprot.readStructEnd()
22531 
 
22532 
  def write(self, oprot):
22533 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22534 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22535 
      return
22536 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
22537 
    if self.ex is not None:
22538 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22539 
      self.ex.write(oprot)
22540 
      oprot.writeFieldEnd()
22541 
    oprot.writeFieldStop()
22542 
    oprot.writeStructEnd()
22543 
 
22544 
  def validate(self):
22545 
    return
22546 
 
22547 
 
22548 
  def __repr__(self):
22549 
    L = ['%s=%r' % (key, value)
22550 
      for key, value in self.__dict__.iteritems()]
22551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22552 
 
22553 
  def __eq__(self, other):
22554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22555 
 
22556 
  def __ne__(self, other):
22557 
    return not (self == other)
22558 
 
22559 
class markOrdersAsNotAvailabke_args:
22560 
  """
22561 
  Attributes:
22562 
   - vendorId
22563 
   - itemId
22564 
   - quantity
22565 
   - estimate
4369 rajveer 22566 
   - isReminder
4303 rajveer 22567 
  """
22568 
 
22569 
  thrift_spec = (
22570 
    None, # 0
22571 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22572 
    (2, TType.I64, 'itemId', None, None, ), # 2
22573 
    (3, TType.I64, 'quantity', None, None, ), # 3
22574 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 22575 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 22576 
  )
22577 
 
4369 rajveer 22578 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 22579 
    self.vendorId = vendorId
22580 
    self.itemId = itemId
22581 
    self.quantity = quantity
22582 
    self.estimate = estimate
4369 rajveer 22583 
    self.isReminder = isReminder
4303 rajveer 22584 
 
22585 
  def read(self, iprot):
22586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22588 
      return
22589 
    iprot.readStructBegin()
22590 
    while True:
22591 
      (fname, ftype, fid) = iprot.readFieldBegin()
22592 
      if ftype == TType.STOP:
22593 
        break
22594 
      if fid == 1:
22595 
        if ftype == TType.I64:
22596 
          self.vendorId = iprot.readI64();
22597 
        else:
22598 
          iprot.skip(ftype)
22599 
      elif fid == 2:
22600 
        if ftype == TType.I64:
22601 
          self.itemId = iprot.readI64();
22602 
        else:
22603 
          iprot.skip(ftype)
22604 
      elif fid == 3:
22605 
        if ftype == TType.I64:
22606 
          self.quantity = iprot.readI64();
22607 
        else:
22608 
          iprot.skip(ftype)
22609 
      elif fid == 4:
22610 
        if ftype == TType.I64:
22611 
          self.estimate = iprot.readI64();
22612 
        else:
22613 
          iprot.skip(ftype)
4369 rajveer 22614 
      elif fid == 5:
22615 
        if ftype == TType.BOOL:
22616 
          self.isReminder = iprot.readBool();
22617 
        else:
22618 
          iprot.skip(ftype)
4303 rajveer 22619 
      else:
22620 
        iprot.skip(ftype)
22621 
      iprot.readFieldEnd()
22622 
    iprot.readStructEnd()
22623 
 
22624 
  def write(self, oprot):
22625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22627 
      return
22628 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
22629 
    if self.vendorId is not None:
22630 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22631 
      oprot.writeI64(self.vendorId)
22632 
      oprot.writeFieldEnd()
22633 
    if self.itemId is not None:
22634 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
22635 
      oprot.writeI64(self.itemId)
22636 
      oprot.writeFieldEnd()
22637 
    if self.quantity is not None:
22638 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22639 
      oprot.writeI64(self.quantity)
22640 
      oprot.writeFieldEnd()
22641 
    if self.estimate is not None:
22642 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22643 
      oprot.writeI64(self.estimate)
22644 
      oprot.writeFieldEnd()
4369 rajveer 22645 
    if self.isReminder is not None:
22646 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22647 
      oprot.writeBool(self.isReminder)
22648 
      oprot.writeFieldEnd()
4303 rajveer 22649 
    oprot.writeFieldStop()
22650 
    oprot.writeStructEnd()
22651 
 
22652 
  def validate(self):
22653 
    return
22654 
 
22655 
 
22656 
  def __repr__(self):
22657 
    L = ['%s=%r' % (key, value)
22658 
      for key, value in self.__dict__.iteritems()]
22659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22660 
 
22661 
  def __eq__(self, other):
22662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22663 
 
22664 
  def __ne__(self, other):
22665 
    return not (self == other)
22666 
 
22667 
class markOrdersAsNotAvailabke_result:
22668 
  """
22669 
  Attributes:
22670 
   - ex
22671 
  """
22672 
 
22673 
  thrift_spec = (
22674 
    None, # 0
22675 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22676 
  )
22677 
 
22678 
  def __init__(self, ex=None,):
22679 
    self.ex = ex
22680 
 
22681 
  def read(self, iprot):
22682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22684 
      return
22685 
    iprot.readStructBegin()
22686 
    while True:
22687 
      (fname, ftype, fid) = iprot.readFieldBegin()
22688 
      if ftype == TType.STOP:
22689 
        break
22690 
      if fid == 1:
22691 
        if ftype == TType.STRUCT:
22692 
          self.ex = TransactionServiceException()
22693 
          self.ex.read(iprot)
22694 
        else:
22695 
          iprot.skip(ftype)
22696 
      else:
22697 
        iprot.skip(ftype)
22698 
      iprot.readFieldEnd()
22699 
    iprot.readStructEnd()
22700 
 
22701 
  def write(self, oprot):
22702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22704 
      return
22705 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
22706 
    if self.ex is not None:
22707 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22708 
      self.ex.write(oprot)
22709 
      oprot.writeFieldEnd()
22710 
    oprot.writeFieldStop()
22711 
    oprot.writeStructEnd()
22712 
 
22713 
  def validate(self):
22714 
    return
22715 
 
22716 
 
22717 
  def __repr__(self):
22718 
    L = ['%s=%r' % (key, value)
22719 
      for key, value in self.__dict__.iteritems()]
22720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22721 
 
22722 
  def __eq__(self, other):
22723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22724 
 
22725 
  def __ne__(self, other):
22726 
    return not (self == other)
4369 rajveer 22727 
 
22728 
class markOrdersAsTimeout_args:
22729 
  """
22730 
  Attributes:
22731 
   - vendorId
22732 
  """
22733 
 
22734 
  thrift_spec = (
22735 
    None, # 0
22736 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22737 
  )
22738 
 
22739 
  def __init__(self, vendorId=None,):
22740 
    self.vendorId = vendorId
22741 
 
22742 
  def read(self, iprot):
22743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22745 
      return
22746 
    iprot.readStructBegin()
22747 
    while True:
22748 
      (fname, ftype, fid) = iprot.readFieldBegin()
22749 
      if ftype == TType.STOP:
22750 
        break
22751 
      if fid == 1:
22752 
        if ftype == TType.I64:
22753 
          self.vendorId = iprot.readI64();
22754 
        else:
22755 
          iprot.skip(ftype)
22756 
      else:
22757 
        iprot.skip(ftype)
22758 
      iprot.readFieldEnd()
22759 
    iprot.readStructEnd()
22760 
 
22761 
  def write(self, oprot):
22762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22764 
      return
22765 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
22766 
    if self.vendorId is not None:
22767 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22768 
      oprot.writeI64(self.vendorId)
22769 
      oprot.writeFieldEnd()
22770 
    oprot.writeFieldStop()
22771 
    oprot.writeStructEnd()
22772 
 
22773 
  def validate(self):
22774 
    return
22775 
 
22776 
 
22777 
  def __repr__(self):
22778 
    L = ['%s=%r' % (key, value)
22779 
      for key, value in self.__dict__.iteritems()]
22780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22781 
 
22782 
  def __eq__(self, other):
22783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22784 
 
22785 
  def __ne__(self, other):
22786 
    return not (self == other)
22787 
 
22788 
class markOrdersAsTimeout_result:
22789 
  """
22790 
  Attributes:
22791 
   - success
22792 
   - ex
22793 
  """
22794 
 
22795 
  thrift_spec = (
22796 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
22797 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22798 
  )
22799 
 
22800 
  def __init__(self, success=None, ex=None,):
22801 
    self.success = success
22802 
    self.ex = ex
22803 
 
22804 
  def read(self, iprot):
22805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22807 
      return
22808 
    iprot.readStructBegin()
22809 
    while True:
22810 
      (fname, ftype, fid) = iprot.readFieldBegin()
22811 
      if ftype == TType.STOP:
22812 
        break
22813 
      if fid == 0:
22814 
        if ftype == TType.MAP:
22815 
          self.success = {}
6188 rajveer 22816 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
22817 
          for _i505 in xrange(_size501):
22818 
            _key506 = iprot.readI32();
22819 
            _val507 = TimeoutSummary()
22820 
            _val507.read(iprot)
22821 
            self.success[_key506] = _val507
4369 rajveer 22822 
          iprot.readMapEnd()
22823 
        else:
22824 
          iprot.skip(ftype)
22825 
      elif fid == 1:
22826 
        if ftype == TType.STRUCT:
22827 
          self.ex = TransactionServiceException()
22828 
          self.ex.read(iprot)
22829 
        else:
22830 
          iprot.skip(ftype)
22831 
      else:
22832 
        iprot.skip(ftype)
22833 
      iprot.readFieldEnd()
22834 
    iprot.readStructEnd()
22835 
 
22836 
  def write(self, oprot):
22837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22839 
      return
22840 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
22841 
    if self.success is not None:
22842 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22843 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 22844 
      for kiter508,viter509 in self.success.items():
22845 
        oprot.writeI32(kiter508)
22846 
        viter509.write(oprot)
4369 rajveer 22847 
      oprot.writeMapEnd()
22848 
      oprot.writeFieldEnd()
22849 
    if self.ex is not None:
22850 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22851 
      self.ex.write(oprot)
22852 
      oprot.writeFieldEnd()
22853 
    oprot.writeFieldStop()
22854 
    oprot.writeStructEnd()
22855 
 
22856 
  def validate(self):
22857 
    return
22858 
 
22859 
 
22860 
  def __repr__(self):
22861 
    L = ['%s=%r' % (key, value)
22862 
      for key, value in self.__dict__.iteritems()]
22863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22864 
 
22865 
  def __eq__(self, other):
22866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22867 
 
22868 
  def __ne__(self, other):
22869 
    return not (self == other)
4386 anupam.sin 22870 
 
4662 rajveer 22871 
class markOrderAsLostInTransit_args:
22872 
  """
22873 
  Attributes:
22874 
   - orderId
22875 
  """
22876 
 
22877 
  thrift_spec = (
22878 
    None, # 0
22879 
    (1, TType.I64, 'orderId', None, None, ), # 1
22880 
  )
22881 
 
22882 
  def __init__(self, orderId=None,):
22883 
    self.orderId = orderId
22884 
 
22885 
  def read(self, iprot):
22886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22888 
      return
22889 
    iprot.readStructBegin()
22890 
    while True:
22891 
      (fname, ftype, fid) = iprot.readFieldBegin()
22892 
      if ftype == TType.STOP:
22893 
        break
22894 
      if fid == 1:
22895 
        if ftype == TType.I64:
22896 
          self.orderId = iprot.readI64();
22897 
        else:
22898 
          iprot.skip(ftype)
22899 
      else:
22900 
        iprot.skip(ftype)
22901 
      iprot.readFieldEnd()
22902 
    iprot.readStructEnd()
22903 
 
22904 
  def write(self, oprot):
22905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22907 
      return
22908 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
22909 
    if self.orderId is not None:
22910 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22911 
      oprot.writeI64(self.orderId)
22912 
      oprot.writeFieldEnd()
22913 
    oprot.writeFieldStop()
22914 
    oprot.writeStructEnd()
22915 
 
22916 
  def validate(self):
22917 
    return
22918 
 
22919 
 
22920 
  def __repr__(self):
22921 
    L = ['%s=%r' % (key, value)
22922 
      for key, value in self.__dict__.iteritems()]
22923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22924 
 
22925 
  def __eq__(self, other):
22926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22927 
 
22928 
  def __ne__(self, other):
22929 
    return not (self == other)
22930 
 
22931 
class markOrderAsLostInTransit_result:
22932 
  """
22933 
  Attributes:
22934 
   - success
22935 
   - ex
22936 
  """
22937 
 
22938 
  thrift_spec = (
22939 
    (0, TType.BOOL, 'success', None, None, ), # 0
22940 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22941 
  )
22942 
 
22943 
  def __init__(self, success=None, ex=None,):
22944 
    self.success = success
22945 
    self.ex = ex
22946 
 
22947 
  def read(self, iprot):
22948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22950 
      return
22951 
    iprot.readStructBegin()
22952 
    while True:
22953 
      (fname, ftype, fid) = iprot.readFieldBegin()
22954 
      if ftype == TType.STOP:
22955 
        break
22956 
      if fid == 0:
22957 
        if ftype == TType.BOOL:
22958 
          self.success = iprot.readBool();
22959 
        else:
22960 
          iprot.skip(ftype)
22961 
      elif fid == 1:
22962 
        if ftype == TType.STRUCT:
22963 
          self.ex = TransactionServiceException()
22964 
          self.ex.read(iprot)
22965 
        else:
22966 
          iprot.skip(ftype)
22967 
      else:
22968 
        iprot.skip(ftype)
22969 
      iprot.readFieldEnd()
22970 
    iprot.readStructEnd()
22971 
 
22972 
  def write(self, oprot):
22973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22975 
      return
22976 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
22977 
    if self.success is not None:
22978 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22979 
      oprot.writeBool(self.success)
22980 
      oprot.writeFieldEnd()
22981 
    if self.ex is not None:
22982 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22983 
      self.ex.write(oprot)
22984 
      oprot.writeFieldEnd()
22985 
    oprot.writeFieldStop()
22986 
    oprot.writeStructEnd()
22987 
 
22988 
  def validate(self):
22989 
    return
22990 
 
22991 
 
22992 
  def __repr__(self):
22993 
    L = ['%s=%r' % (key, value)
22994 
      for key, value in self.__dict__.iteritems()]
22995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22996 
 
22997 
  def __eq__(self, other):
22998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22999 
 
23000 
  def __ne__(self, other):
23001 
    return not (self == other)
23002 
 
4386 anupam.sin 23003 
class getOrderForAwb_args:
23004 
  """
23005 
  Attributes:
23006 
   - awb
23007 
  """
23008 
 
23009 
  thrift_spec = (
23010 
    None, # 0
23011 
    (1, TType.STRING, 'awb', None, None, ), # 1
23012 
  )
23013 
 
23014 
  def __init__(self, awb=None,):
23015 
    self.awb = awb
23016 
 
23017 
  def read(self, iprot):
23018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23020 
      return
23021 
    iprot.readStructBegin()
23022 
    while True:
23023 
      (fname, ftype, fid) = iprot.readFieldBegin()
23024 
      if ftype == TType.STOP:
23025 
        break
23026 
      if fid == 1:
23027 
        if ftype == TType.STRING:
23028 
          self.awb = iprot.readString();
23029 
        else:
23030 
          iprot.skip(ftype)
23031 
      else:
23032 
        iprot.skip(ftype)
23033 
      iprot.readFieldEnd()
23034 
    iprot.readStructEnd()
23035 
 
23036 
  def write(self, oprot):
23037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23039 
      return
23040 
    oprot.writeStructBegin('getOrderForAwb_args')
23041 
    if self.awb is not None:
23042 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
23043 
      oprot.writeString(self.awb)
23044 
      oprot.writeFieldEnd()
23045 
    oprot.writeFieldStop()
23046 
    oprot.writeStructEnd()
23047 
 
23048 
  def validate(self):
23049 
    return
23050 
 
23051 
 
23052 
  def __repr__(self):
23053 
    L = ['%s=%r' % (key, value)
23054 
      for key, value in self.__dict__.iteritems()]
23055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23056 
 
23057 
  def __eq__(self, other):
23058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23059 
 
23060 
  def __ne__(self, other):
23061 
    return not (self == other)
23062 
 
23063 
class getOrderForAwb_result:
23064 
  """
23065 
  Attributes:
23066 
   - success
23067 
   - ex
23068 
  """
23069 
 
23070 
  thrift_spec = (
23071 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
23072 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23073 
  )
23074 
 
23075 
  def __init__(self, success=None, ex=None,):
23076 
    self.success = success
23077 
    self.ex = ex
23078 
 
23079 
  def read(self, iprot):
23080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23082 
      return
23083 
    iprot.readStructBegin()
23084 
    while True:
23085 
      (fname, ftype, fid) = iprot.readFieldBegin()
23086 
      if ftype == TType.STOP:
23087 
        break
23088 
      if fid == 0:
23089 
        if ftype == TType.STRUCT:
23090 
          self.success = Order()
23091 
          self.success.read(iprot)
23092 
        else:
23093 
          iprot.skip(ftype)
23094 
      elif fid == 1:
23095 
        if ftype == TType.STRUCT:
23096 
          self.ex = TransactionServiceException()
23097 
          self.ex.read(iprot)
23098 
        else:
23099 
          iprot.skip(ftype)
23100 
      else:
23101 
        iprot.skip(ftype)
23102 
      iprot.readFieldEnd()
23103 
    iprot.readStructEnd()
23104 
 
23105 
  def write(self, oprot):
23106 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23107 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23108 
      return
23109 
    oprot.writeStructBegin('getOrderForAwb_result')
23110 
    if self.success is not None:
23111 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23112 
      self.success.write(oprot)
23113 
      oprot.writeFieldEnd()
23114 
    if self.ex is not None:
23115 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23116 
      self.ex.write(oprot)
23117 
      oprot.writeFieldEnd()
23118 
    oprot.writeFieldStop()
23119 
    oprot.writeStructEnd()
23120 
 
23121 
  def validate(self):
23122 
    return
23123 
 
23124 
 
23125 
  def __repr__(self):
23126 
    L = ['%s=%r' % (key, value)
23127 
      for key, value in self.__dict__.iteritems()]
23128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23129 
 
23130 
  def __eq__(self, other):
23131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23132 
 
23133 
  def __ne__(self, other):
23134 
    return not (self == other)
4506 phani.kuma 23135 
 
23136 
class getOrdersForProviderForStatus_args:
23137 
  """
23138 
  Attributes:
23139 
   - logistics_provider_id
4910 phani.kuma 23140 
   - order_status_list
4506 phani.kuma 23141 
  """
23142 
 
23143 
  thrift_spec = (
23144 
    None, # 0
23145 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 23146 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 23147 
  )
23148 
 
4910 phani.kuma 23149 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 23150 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 23151 
    self.order_status_list = order_status_list
4506 phani.kuma 23152 
 
23153 
  def read(self, iprot):
23154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23156 
      return
23157 
    iprot.readStructBegin()
23158 
    while True:
23159 
      (fname, ftype, fid) = iprot.readFieldBegin()
23160 
      if ftype == TType.STOP:
23161 
        break
23162 
      if fid == 1:
23163 
        if ftype == TType.I64:
23164 
          self.logistics_provider_id = iprot.readI64();
23165 
        else:
23166 
          iprot.skip(ftype)
23167 
      elif fid == 2:
4910 phani.kuma 23168 
        if ftype == TType.LIST:
23169 
          self.order_status_list = []
6188 rajveer 23170 
          (_etype513, _size510) = iprot.readListBegin()
23171 
          for _i514 in xrange(_size510):
23172 
            _elem515 = iprot.readI32();
23173 
            self.order_status_list.append(_elem515)
4910 phani.kuma 23174 
          iprot.readListEnd()
4506 phani.kuma 23175 
        else:
23176 
          iprot.skip(ftype)
23177 
      else:
23178 
        iprot.skip(ftype)
23179 
      iprot.readFieldEnd()
23180 
    iprot.readStructEnd()
23181 
 
23182 
  def write(self, oprot):
23183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23185 
      return
23186 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
23187 
    if self.logistics_provider_id is not None:
23188 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
23189 
      oprot.writeI64(self.logistics_provider_id)
23190 
      oprot.writeFieldEnd()
4910 phani.kuma 23191 
    if self.order_status_list is not None:
23192 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
23193 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 23194 
      for iter516 in self.order_status_list:
23195 
        oprot.writeI32(iter516)
4910 phani.kuma 23196 
      oprot.writeListEnd()
4506 phani.kuma 23197 
      oprot.writeFieldEnd()
23198 
    oprot.writeFieldStop()
23199 
    oprot.writeStructEnd()
23200 
 
23201 
  def validate(self):
23202 
    return
23203 
 
23204 
 
23205 
  def __repr__(self):
23206 
    L = ['%s=%r' % (key, value)
23207 
      for key, value in self.__dict__.iteritems()]
23208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23209 
 
23210 
  def __eq__(self, other):
23211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23212 
 
23213 
  def __ne__(self, other):
23214 
    return not (self == other)
23215 
 
23216 
class getOrdersForProviderForStatus_result:
23217 
  """
23218 
  Attributes:
23219 
   - success
23220 
   - ex
23221 
  """
23222 
 
23223 
  thrift_spec = (
23224 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23225 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23226 
  )
23227 
 
23228 
  def __init__(self, success=None, ex=None,):
23229 
    self.success = success
23230 
    self.ex = ex
23231 
 
23232 
  def read(self, iprot):
23233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23235 
      return
23236 
    iprot.readStructBegin()
23237 
    while True:
23238 
      (fname, ftype, fid) = iprot.readFieldBegin()
23239 
      if ftype == TType.STOP:
23240 
        break
23241 
      if fid == 0:
23242 
        if ftype == TType.LIST:
23243 
          self.success = []
6188 rajveer 23244 
          (_etype520, _size517) = iprot.readListBegin()
23245 
          for _i521 in xrange(_size517):
23246 
            _elem522 = Order()
23247 
            _elem522.read(iprot)
23248 
            self.success.append(_elem522)
4506 phani.kuma 23249 
          iprot.readListEnd()
23250 
        else:
23251 
          iprot.skip(ftype)
23252 
      elif fid == 1:
23253 
        if ftype == TType.STRUCT:
23254 
          self.ex = TransactionServiceException()
23255 
          self.ex.read(iprot)
23256 
        else:
23257 
          iprot.skip(ftype)
23258 
      else:
23259 
        iprot.skip(ftype)
23260 
      iprot.readFieldEnd()
23261 
    iprot.readStructEnd()
23262 
 
23263 
  def write(self, oprot):
23264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23266 
      return
23267 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
23268 
    if self.success is not None:
23269 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23270 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23271 
      for iter523 in self.success:
23272 
        iter523.write(oprot)
4506 phani.kuma 23273 
      oprot.writeListEnd()
23274 
      oprot.writeFieldEnd()
23275 
    if self.ex is not None:
23276 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23277 
      self.ex.write(oprot)
23278 
      oprot.writeFieldEnd()
23279 
    oprot.writeFieldStop()
23280 
    oprot.writeStructEnd()
23281 
 
23282 
  def validate(self):
23283 
    return
23284 
 
23285 
 
23286 
  def __repr__(self):
23287 
    L = ['%s=%r' % (key, value)
23288 
      for key, value in self.__dict__.iteritems()]
23289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23290 
 
23291 
  def __eq__(self, other):
23292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23293 
 
23294 
  def __ne__(self, other):
23295 
    return not (self == other)
4600 varun.gupt 23296 
 
23297 
class getBilledOrdersForVendor_args:
23298 
  """
23299 
  Attributes:
23300 
   - vendorId
23301 
   - billingDateFrom
23302 
   - billingDateTo
23303 
  """
23304 
 
23305 
  thrift_spec = (
23306 
    None, # 0
23307 
    (1, TType.I64, 'vendorId', None, None, ), # 1
23308 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
23309 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
23310 
  )
23311 
 
23312 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
23313 
    self.vendorId = vendorId
23314 
    self.billingDateFrom = billingDateFrom
23315 
    self.billingDateTo = billingDateTo
23316 
 
23317 
  def read(self, iprot):
23318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23320 
      return
23321 
    iprot.readStructBegin()
23322 
    while True:
23323 
      (fname, ftype, fid) = iprot.readFieldBegin()
23324 
      if ftype == TType.STOP:
23325 
        break
23326 
      if fid == 1:
23327 
        if ftype == TType.I64:
23328 
          self.vendorId = iprot.readI64();
23329 
        else:
23330 
          iprot.skip(ftype)
23331 
      elif fid == 2:
23332 
        if ftype == TType.I64:
23333 
          self.billingDateFrom = iprot.readI64();
23334 
        else:
23335 
          iprot.skip(ftype)
23336 
      elif fid == 3:
23337 
        if ftype == TType.I64:
23338 
          self.billingDateTo = iprot.readI64();
23339 
        else:
23340 
          iprot.skip(ftype)
23341 
      else:
23342 
        iprot.skip(ftype)
23343 
      iprot.readFieldEnd()
23344 
    iprot.readStructEnd()
23345 
 
23346 
  def write(self, oprot):
23347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23349 
      return
23350 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
23351 
    if self.vendorId is not None:
23352 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
23353 
      oprot.writeI64(self.vendorId)
23354 
      oprot.writeFieldEnd()
23355 
    if self.billingDateFrom is not None:
23356 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
23357 
      oprot.writeI64(self.billingDateFrom)
23358 
      oprot.writeFieldEnd()
23359 
    if self.billingDateTo is not None:
23360 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
23361 
      oprot.writeI64(self.billingDateTo)
23362 
      oprot.writeFieldEnd()
23363 
    oprot.writeFieldStop()
23364 
    oprot.writeStructEnd()
23365 
 
23366 
  def validate(self):
23367 
    return
23368 
 
23369 
 
23370 
  def __repr__(self):
23371 
    L = ['%s=%r' % (key, value)
23372 
      for key, value in self.__dict__.iteritems()]
23373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23374 
 
23375 
  def __eq__(self, other):
23376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23377 
 
23378 
  def __ne__(self, other):
23379 
    return not (self == other)
23380 
 
23381 
class getBilledOrdersForVendor_result:
23382 
  """
23383 
  Attributes:
23384 
   - success
23385 
   - ex
23386 
  """
23387 
 
23388 
  thrift_spec = (
23389 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23390 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23391 
  )
23392 
 
23393 
  def __init__(self, success=None, ex=None,):
23394 
    self.success = success
23395 
    self.ex = ex
23396 
 
23397 
  def read(self, iprot):
23398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23400 
      return
23401 
    iprot.readStructBegin()
23402 
    while True:
23403 
      (fname, ftype, fid) = iprot.readFieldBegin()
23404 
      if ftype == TType.STOP:
23405 
        break
23406 
      if fid == 0:
23407 
        if ftype == TType.LIST:
23408 
          self.success = []
6188 rajveer 23409 
          (_etype527, _size524) = iprot.readListBegin()
23410 
          for _i528 in xrange(_size524):
23411 
            _elem529 = Order()
23412 
            _elem529.read(iprot)
23413 
            self.success.append(_elem529)
4600 varun.gupt 23414 
          iprot.readListEnd()
23415 
        else:
23416 
          iprot.skip(ftype)
23417 
      elif fid == 1:
23418 
        if ftype == TType.STRUCT:
23419 
          self.ex = TransactionServiceException()
23420 
          self.ex.read(iprot)
23421 
        else:
23422 
          iprot.skip(ftype)
23423 
      else:
23424 
        iprot.skip(ftype)
23425 
      iprot.readFieldEnd()
23426 
    iprot.readStructEnd()
23427 
 
23428 
  def write(self, oprot):
23429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23431 
      return
23432 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
23433 
    if self.success is not None:
23434 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23435 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23436 
      for iter530 in self.success:
23437 
        iter530.write(oprot)
4600 varun.gupt 23438 
      oprot.writeListEnd()
23439 
      oprot.writeFieldEnd()
23440 
    if self.ex is not None:
23441 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23442 
      self.ex.write(oprot)
23443 
      oprot.writeFieldEnd()
23444 
    oprot.writeFieldStop()
23445 
    oprot.writeStructEnd()
23446 
 
23447 
  def validate(self):
23448 
    return
23449 
 
23450 
 
23451 
  def __repr__(self):
23452 
    L = ['%s=%r' % (key, value)
23453 
      for key, value in self.__dict__.iteritems()]
23454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23455 
 
23456 
  def __eq__(self, other):
23457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23458 
 
23459 
  def __ne__(self, other):
23460 
    return not (self == other)
23461 
 
4607 rajveer 23462 
class getSlippedSippingDateOrders_args:
23463 
 
23464 
  thrift_spec = (
23465 
  )
23466 
 
23467 
  def read(self, iprot):
23468 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23469 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23470 
      return
23471 
    iprot.readStructBegin()
23472 
    while True:
23473 
      (fname, ftype, fid) = iprot.readFieldBegin()
23474 
      if ftype == TType.STOP:
23475 
        break
23476 
      else:
23477 
        iprot.skip(ftype)
23478 
      iprot.readFieldEnd()
23479 
    iprot.readStructEnd()
23480 
 
23481 
  def write(self, oprot):
23482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23484 
      return
23485 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
23486 
    oprot.writeFieldStop()
23487 
    oprot.writeStructEnd()
23488 
 
23489 
  def validate(self):
23490 
    return
23491 
 
23492 
 
23493 
  def __repr__(self):
23494 
    L = ['%s=%r' % (key, value)
23495 
      for key, value in self.__dict__.iteritems()]
23496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23497 
 
23498 
  def __eq__(self, other):
23499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23500 
 
23501 
  def __ne__(self, other):
23502 
    return not (self == other)
23503 
 
23504 
class getSlippedSippingDateOrders_result:
23505 
  """
23506 
  Attributes:
23507 
   - success
23508 
   - ex
23509 
  """
23510 
 
23511 
  thrift_spec = (
23512 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23513 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23514 
  )
23515 
 
23516 
  def __init__(self, success=None, ex=None,):
23517 
    self.success = success
23518 
    self.ex = ex
23519 
 
23520 
  def read(self, iprot):
23521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23523 
      return
23524 
    iprot.readStructBegin()
23525 
    while True:
23526 
      (fname, ftype, fid) = iprot.readFieldBegin()
23527 
      if ftype == TType.STOP:
23528 
        break
23529 
      if fid == 0:
23530 
        if ftype == TType.LIST:
23531 
          self.success = []
6188 rajveer 23532 
          (_etype534, _size531) = iprot.readListBegin()
23533 
          for _i535 in xrange(_size531):
23534 
            _elem536 = Order()
23535 
            _elem536.read(iprot)
23536 
            self.success.append(_elem536)
4607 rajveer 23537 
          iprot.readListEnd()
23538 
        else:
23539 
          iprot.skip(ftype)
23540 
      elif fid == 1:
23541 
        if ftype == TType.STRUCT:
23542 
          self.ex = TransactionServiceException()
23543 
          self.ex.read(iprot)
23544 
        else:
23545 
          iprot.skip(ftype)
23546 
      else:
23547 
        iprot.skip(ftype)
23548 
      iprot.readFieldEnd()
23549 
    iprot.readStructEnd()
23550 
 
23551 
  def write(self, oprot):
23552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23554 
      return
23555 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
23556 
    if self.success is not None:
23557 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23558 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23559 
      for iter537 in self.success:
23560 
        iter537.write(oprot)
4607 rajveer 23561 
      oprot.writeListEnd()
23562 
      oprot.writeFieldEnd()
23563 
    if self.ex is not None:
23564 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23565 
      self.ex.write(oprot)
23566 
      oprot.writeFieldEnd()
23567 
    oprot.writeFieldStop()
23568 
    oprot.writeStructEnd()
23569 
 
23570 
  def validate(self):
23571 
    return
23572 
 
23573 
 
23574 
  def __repr__(self):
23575 
    L = ['%s=%r' % (key, value)
23576 
      for key, value in self.__dict__.iteritems()]
23577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23578 
 
23579 
  def __eq__(self, other):
23580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23581 
 
23582 
  def __ne__(self, other):
23583 
    return not (self == other)
23584 
 
4709 rajveer 23585 
class getCancelledOrders_args:
23586 
  """
23587 
  Attributes:
23588 
   - cancelDateFrom
23589 
   - cancelDateTo
23590 
  """
23591 
 
23592 
  thrift_spec = (
23593 
    None, # 0
23594 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
23595 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
23596 
  )
23597 
 
23598 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
23599 
    self.cancelDateFrom = cancelDateFrom
23600 
    self.cancelDateTo = cancelDateTo
23601 
 
23602 
  def read(self, iprot):
23603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23605 
      return
23606 
    iprot.readStructBegin()
23607 
    while True:
23608 
      (fname, ftype, fid) = iprot.readFieldBegin()
23609 
      if ftype == TType.STOP:
23610 
        break
23611 
      if fid == 1:
23612 
        if ftype == TType.I64:
23613 
          self.cancelDateFrom = iprot.readI64();
23614 
        else:
23615 
          iprot.skip(ftype)
23616 
      elif fid == 2:
23617 
        if ftype == TType.I64:
23618 
          self.cancelDateTo = iprot.readI64();
23619 
        else:
23620 
          iprot.skip(ftype)
23621 
      else:
23622 
        iprot.skip(ftype)
23623 
      iprot.readFieldEnd()
23624 
    iprot.readStructEnd()
23625 
 
23626 
  def write(self, oprot):
23627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23629 
      return
23630 
    oprot.writeStructBegin('getCancelledOrders_args')
23631 
    if self.cancelDateFrom is not None:
23632 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
23633 
      oprot.writeI64(self.cancelDateFrom)
23634 
      oprot.writeFieldEnd()
23635 
    if self.cancelDateTo is not None:
23636 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
23637 
      oprot.writeI64(self.cancelDateTo)
23638 
      oprot.writeFieldEnd()
23639 
    oprot.writeFieldStop()
23640 
    oprot.writeStructEnd()
23641 
 
23642 
  def validate(self):
23643 
    return
23644 
 
23645 
 
23646 
  def __repr__(self):
23647 
    L = ['%s=%r' % (key, value)
23648 
      for key, value in self.__dict__.iteritems()]
23649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23650 
 
23651 
  def __eq__(self, other):
23652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23653 
 
23654 
  def __ne__(self, other):
23655 
    return not (self == other)
23656 
 
23657 
class getCancelledOrders_result:
23658 
  """
23659 
  Attributes:
23660 
   - success
23661 
   - ex
23662 
  """
23663 
 
23664 
  thrift_spec = (
23665 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23666 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23667 
  )
23668 
 
23669 
  def __init__(self, success=None, ex=None,):
23670 
    self.success = success
23671 
    self.ex = ex
23672 
 
23673 
  def read(self, iprot):
23674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23676 
      return
23677 
    iprot.readStructBegin()
23678 
    while True:
23679 
      (fname, ftype, fid) = iprot.readFieldBegin()
23680 
      if ftype == TType.STOP:
23681 
        break
23682 
      if fid == 0:
23683 
        if ftype == TType.LIST:
23684 
          self.success = []
6188 rajveer 23685 
          (_etype541, _size538) = iprot.readListBegin()
23686 
          for _i542 in xrange(_size538):
23687 
            _elem543 = Order()
23688 
            _elem543.read(iprot)
23689 
            self.success.append(_elem543)
4709 rajveer 23690 
          iprot.readListEnd()
23691 
        else:
23692 
          iprot.skip(ftype)
23693 
      elif fid == 1:
23694 
        if ftype == TType.STRUCT:
23695 
          self.ex = TransactionServiceException()
23696 
          self.ex.read(iprot)
23697 
        else:
23698 
          iprot.skip(ftype)
23699 
      else:
23700 
        iprot.skip(ftype)
23701 
      iprot.readFieldEnd()
23702 
    iprot.readStructEnd()
23703 
 
23704 
  def write(self, oprot):
23705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23707 
      return
23708 
    oprot.writeStructBegin('getCancelledOrders_result')
23709 
    if self.success is not None:
23710 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23711 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23712 
      for iter544 in self.success:
23713 
        iter544.write(oprot)
4709 rajveer 23714 
      oprot.writeListEnd()
23715 
      oprot.writeFieldEnd()
23716 
    if self.ex is not None:
23717 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23718 
      self.ex.write(oprot)
23719 
      oprot.writeFieldEnd()
23720 
    oprot.writeFieldStop()
23721 
    oprot.writeStructEnd()
23722 
 
23723 
  def validate(self):
23724 
    return
23725 
 
23726 
 
23727 
  def __repr__(self):
23728 
    L = ['%s=%r' % (key, value)
23729 
      for key, value in self.__dict__.iteritems()]
23730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23731 
 
23732 
  def __eq__(self, other):
23733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23734 
 
23735 
  def __ne__(self, other):
23736 
    return not (self == other)
23737 
 
4600 varun.gupt 23738 
class saveBluedartSettlements_args:
23739 
  """
23740 
  Attributes:
23741 
   - mapAWBAndAmount
23742 
  """
23743 
 
23744 
  thrift_spec = (
23745 
    None, # 0
23746 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
23747 
  )
23748 
 
23749 
  def __init__(self, mapAWBAndAmount=None,):
23750 
    self.mapAWBAndAmount = mapAWBAndAmount
23751 
 
23752 
  def read(self, iprot):
23753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23755 
      return
23756 
    iprot.readStructBegin()
23757 
    while True:
23758 
      (fname, ftype, fid) = iprot.readFieldBegin()
23759 
      if ftype == TType.STOP:
23760 
        break
23761 
      if fid == 1:
23762 
        if ftype == TType.MAP:
23763 
          self.mapAWBAndAmount = {}
6188 rajveer 23764 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
23765 
          for _i549 in xrange(_size545):
23766 
            _key550 = iprot.readI64();
23767 
            _val551 = iprot.readDouble();
23768 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 23769 
          iprot.readMapEnd()
23770 
        else:
23771 
          iprot.skip(ftype)
23772 
      else:
23773 
        iprot.skip(ftype)
23774 
      iprot.readFieldEnd()
23775 
    iprot.readStructEnd()
23776 
 
23777 
  def write(self, oprot):
23778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23780 
      return
23781 
    oprot.writeStructBegin('saveBluedartSettlements_args')
23782 
    if self.mapAWBAndAmount is not None:
23783 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
23784 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 23785 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
23786 
        oprot.writeI64(kiter552)
23787 
        oprot.writeDouble(viter553)
4600 varun.gupt 23788 
      oprot.writeMapEnd()
23789 
      oprot.writeFieldEnd()
23790 
    oprot.writeFieldStop()
23791 
    oprot.writeStructEnd()
23792 
 
23793 
  def validate(self):
23794 
    return
23795 
 
23796 
 
23797 
  def __repr__(self):
23798 
    L = ['%s=%r' % (key, value)
23799 
      for key, value in self.__dict__.iteritems()]
23800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23801 
 
23802 
  def __eq__(self, other):
23803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23804 
 
23805 
  def __ne__(self, other):
23806 
    return not (self == other)
23807 
 
23808 
class saveBluedartSettlements_result:
23809 
  """
23810 
  Attributes:
23811 
   - ex
23812 
  """
23813 
 
23814 
  thrift_spec = (
23815 
    None, # 0
23816 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23817 
  )
23818 
 
23819 
  def __init__(self, ex=None,):
23820 
    self.ex = ex
23821 
 
23822 
  def read(self, iprot):
23823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23825 
      return
23826 
    iprot.readStructBegin()
23827 
    while True:
23828 
      (fname, ftype, fid) = iprot.readFieldBegin()
23829 
      if ftype == TType.STOP:
23830 
        break
23831 
      if fid == 1:
23832 
        if ftype == TType.STRUCT:
23833 
          self.ex = TransactionServiceException()
23834 
          self.ex.read(iprot)
23835 
        else:
23836 
          iprot.skip(ftype)
23837 
      else:
23838 
        iprot.skip(ftype)
23839 
      iprot.readFieldEnd()
23840 
    iprot.readStructEnd()
23841 
 
23842 
  def write(self, oprot):
23843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23845 
      return
23846 
    oprot.writeStructBegin('saveBluedartSettlements_result')
23847 
    if self.ex is not None:
23848 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23849 
      self.ex.write(oprot)
23850 
      oprot.writeFieldEnd()
23851 
    oprot.writeFieldStop()
23852 
    oprot.writeStructEnd()
23853 
 
23854 
  def validate(self):
23855 
    return
23856 
 
23857 
 
23858 
  def __repr__(self):
23859 
    L = ['%s=%r' % (key, value)
23860 
      for key, value in self.__dict__.iteritems()]
23861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23862 
 
23863 
  def __eq__(self, other):
23864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23865 
 
23866 
  def __ne__(self, other):
23867 
    return not (self == other)
23868 
 
23869 
class savePaymentSettlements_args:
23870 
  """
23871 
  Attributes:
23872 
   - settlementDate
23873 
   - paymentGatewayId
4905 varun.gupt 23874 
   - referenceId
4600 varun.gupt 23875 
   - serviceTax
23876 
   - otherCharges
23877 
   - netCollection
23878 
  """
23879 
 
23880 
  thrift_spec = (
23881 
    None, # 0
23882 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
23883 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 23884 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 23885 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
23886 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
23887 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
23888 
  )
23889 
 
4905 varun.gupt 23890 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 23891 
    self.settlementDate = settlementDate
23892 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 23893 
    self.referenceId = referenceId
4600 varun.gupt 23894 
    self.serviceTax = serviceTax
23895 
    self.otherCharges = otherCharges
23896 
    self.netCollection = netCollection
23897 
 
23898 
  def read(self, iprot):
23899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23901 
      return
23902 
    iprot.readStructBegin()
23903 
    while True:
23904 
      (fname, ftype, fid) = iprot.readFieldBegin()
23905 
      if ftype == TType.STOP:
23906 
        break
23907 
      if fid == 1:
23908 
        if ftype == TType.I64:
23909 
          self.settlementDate = iprot.readI64();
23910 
        else:
23911 
          iprot.skip(ftype)
23912 
      elif fid == 2:
23913 
        if ftype == TType.I64:
23914 
          self.paymentGatewayId = iprot.readI64();
23915 
        else:
23916 
          iprot.skip(ftype)
23917 
      elif fid == 3:
23918 
        if ftype == TType.I64:
4905 varun.gupt 23919 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23920 
        else:
23921 
          iprot.skip(ftype)
23922 
      elif fid == 4:
23923 
        if ftype == TType.DOUBLE:
23924 
          self.serviceTax = iprot.readDouble();
23925 
        else:
23926 
          iprot.skip(ftype)
23927 
      elif fid == 5:
23928 
        if ftype == TType.DOUBLE:
23929 
          self.otherCharges = iprot.readDouble();
23930 
        else:
23931 
          iprot.skip(ftype)
23932 
      elif fid == 6:
23933 
        if ftype == TType.DOUBLE:
23934 
          self.netCollection = iprot.readDouble();
23935 
        else:
23936 
          iprot.skip(ftype)
23937 
      else:
23938 
        iprot.skip(ftype)
23939 
      iprot.readFieldEnd()
23940 
    iprot.readStructEnd()
23941 
 
23942 
  def write(self, oprot):
23943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23945 
      return
23946 
    oprot.writeStructBegin('savePaymentSettlements_args')
23947 
    if self.settlementDate is not None:
23948 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
23949 
      oprot.writeI64(self.settlementDate)
23950 
      oprot.writeFieldEnd()
23951 
    if self.paymentGatewayId is not None:
23952 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
23953 
      oprot.writeI64(self.paymentGatewayId)
23954 
      oprot.writeFieldEnd()
4905 varun.gupt 23955 
    if self.referenceId is not None:
23956 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
23957 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23958 
      oprot.writeFieldEnd()
23959 
    if self.serviceTax is not None:
23960 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
23961 
      oprot.writeDouble(self.serviceTax)
23962 
      oprot.writeFieldEnd()
23963 
    if self.otherCharges is not None:
23964 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
23965 
      oprot.writeDouble(self.otherCharges)
23966 
      oprot.writeFieldEnd()
23967 
    if self.netCollection is not None:
23968 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
23969 
      oprot.writeDouble(self.netCollection)
23970 
      oprot.writeFieldEnd()
23971 
    oprot.writeFieldStop()
23972 
    oprot.writeStructEnd()
23973 
 
23974 
  def validate(self):
23975 
    return
23976 
 
23977 
 
23978 
  def __repr__(self):
23979 
    L = ['%s=%r' % (key, value)
23980 
      for key, value in self.__dict__.iteritems()]
23981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23982 
 
23983 
  def __eq__(self, other):
23984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23985 
 
23986 
  def __ne__(self, other):
23987 
    return not (self == other)
23988 
 
23989 
class savePaymentSettlements_result:
23990 
  """
23991 
  Attributes:
23992 
   - ex
23993 
  """
23994 
 
23995 
  thrift_spec = (
23996 
    None, # 0
23997 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23998 
  )
23999 
 
24000 
  def __init__(self, ex=None,):
24001 
    self.ex = ex
24002 
 
24003 
  def read(self, iprot):
24004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24006 
      return
24007 
    iprot.readStructBegin()
24008 
    while True:
24009 
      (fname, ftype, fid) = iprot.readFieldBegin()
24010 
      if ftype == TType.STOP:
24011 
        break
24012 
      if fid == 1:
24013 
        if ftype == TType.STRUCT:
24014 
          self.ex = TransactionServiceException()
24015 
          self.ex.read(iprot)
24016 
        else:
24017 
          iprot.skip(ftype)
24018 
      else:
24019 
        iprot.skip(ftype)
24020 
      iprot.readFieldEnd()
24021 
    iprot.readStructEnd()
24022 
 
24023 
  def write(self, oprot):
24024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24026 
      return
24027 
    oprot.writeStructBegin('savePaymentSettlements_result')
24028 
    if self.ex is not None:
24029 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24030 
      self.ex.write(oprot)
24031 
      oprot.writeFieldEnd()
24032 
    oprot.writeFieldStop()
24033 
    oprot.writeStructEnd()
24034 
 
24035 
  def validate(self):
24036 
    return
24037 
 
24038 
 
24039 
  def __repr__(self):
24040 
    L = ['%s=%r' % (key, value)
24041 
      for key, value in self.__dict__.iteritems()]
24042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24043 
 
24044 
  def __eq__(self, other):
24045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24046 
 
24047 
  def __ne__(self, other):
24048 
    return not (self == other)
24049 
 
24050 
class saveEBSSettlementSummary_args:
24051 
  """
24052 
  Attributes:
24053 
   - settlementId
24054 
   - settlementDate
24055 
   - transactionDateFrom
24056 
   - transactionDateTo
24057 
   - amount
24058 
  """
24059 
 
24060 
  thrift_spec = (
24061 
    None, # 0
24062 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24063 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
24064 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
24065 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
24066 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
24067 
  )
24068 
 
24069 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
24070 
    self.settlementId = settlementId
24071 
    self.settlementDate = settlementDate
24072 
    self.transactionDateFrom = transactionDateFrom
24073 
    self.transactionDateTo = transactionDateTo
24074 
    self.amount = amount
24075 
 
24076 
  def read(self, iprot):
24077 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24078 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24079 
      return
24080 
    iprot.readStructBegin()
24081 
    while True:
24082 
      (fname, ftype, fid) = iprot.readFieldBegin()
24083 
      if ftype == TType.STOP:
24084 
        break
24085 
      if fid == 1:
24086 
        if ftype == TType.I64:
24087 
          self.settlementId = iprot.readI64();
24088 
        else:
24089 
          iprot.skip(ftype)
24090 
      elif fid == 2:
24091 
        if ftype == TType.I64:
24092 
          self.settlementDate = iprot.readI64();
24093 
        else:
24094 
          iprot.skip(ftype)
24095 
      elif fid == 3:
24096 
        if ftype == TType.I64:
24097 
          self.transactionDateFrom = iprot.readI64();
24098 
        else:
24099 
          iprot.skip(ftype)
24100 
      elif fid == 4:
24101 
        if ftype == TType.I64:
24102 
          self.transactionDateTo = iprot.readI64();
24103 
        else:
24104 
          iprot.skip(ftype)
24105 
      elif fid == 5:
24106 
        if ftype == TType.DOUBLE:
24107 
          self.amount = iprot.readDouble();
24108 
        else:
24109 
          iprot.skip(ftype)
24110 
      else:
24111 
        iprot.skip(ftype)
24112 
      iprot.readFieldEnd()
24113 
    iprot.readStructEnd()
24114 
 
24115 
  def write(self, oprot):
24116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24118 
      return
24119 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
24120 
    if self.settlementId is not None:
24121 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24122 
      oprot.writeI64(self.settlementId)
24123 
      oprot.writeFieldEnd()
24124 
    if self.settlementDate is not None:
24125 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
24126 
      oprot.writeI64(self.settlementDate)
24127 
      oprot.writeFieldEnd()
24128 
    if self.transactionDateFrom is not None:
24129 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
24130 
      oprot.writeI64(self.transactionDateFrom)
24131 
      oprot.writeFieldEnd()
24132 
    if self.transactionDateTo is not None:
24133 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
24134 
      oprot.writeI64(self.transactionDateTo)
24135 
      oprot.writeFieldEnd()
24136 
    if self.amount is not None:
24137 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
24138 
      oprot.writeDouble(self.amount)
24139 
      oprot.writeFieldEnd()
24140 
    oprot.writeFieldStop()
24141 
    oprot.writeStructEnd()
24142 
 
24143 
  def validate(self):
24144 
    return
24145 
 
24146 
 
24147 
  def __repr__(self):
24148 
    L = ['%s=%r' % (key, value)
24149 
      for key, value in self.__dict__.iteritems()]
24150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24151 
 
24152 
  def __eq__(self, other):
24153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24154 
 
24155 
  def __ne__(self, other):
24156 
    return not (self == other)
24157 
 
24158 
class saveEBSSettlementSummary_result:
24159 
  """
24160 
  Attributes:
24161 
   - ex
24162 
  """
24163 
 
24164 
  thrift_spec = (
24165 
    None, # 0
24166 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24167 
  )
24168 
 
24169 
  def __init__(self, ex=None,):
24170 
    self.ex = ex
24171 
 
24172 
  def read(self, iprot):
24173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24175 
      return
24176 
    iprot.readStructBegin()
24177 
    while True:
24178 
      (fname, ftype, fid) = iprot.readFieldBegin()
24179 
      if ftype == TType.STOP:
24180 
        break
24181 
      if fid == 1:
24182 
        if ftype == TType.STRUCT:
24183 
          self.ex = TransactionServiceException()
24184 
          self.ex.read(iprot)
24185 
        else:
24186 
          iprot.skip(ftype)
24187 
      else:
24188 
        iprot.skip(ftype)
24189 
      iprot.readFieldEnd()
24190 
    iprot.readStructEnd()
24191 
 
24192 
  def write(self, oprot):
24193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24195 
      return
24196 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
24197 
    if self.ex is not None:
24198 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24199 
      self.ex.write(oprot)
24200 
      oprot.writeFieldEnd()
24201 
    oprot.writeFieldStop()
24202 
    oprot.writeStructEnd()
24203 
 
24204 
  def validate(self):
24205 
    return
24206 
 
24207 
 
24208 
  def __repr__(self):
24209 
    L = ['%s=%r' % (key, value)
24210 
      for key, value in self.__dict__.iteritems()]
24211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24212 
 
24213 
  def __eq__(self, other):
24214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24215 
 
24216 
  def __ne__(self, other):
24217 
    return not (self == other)
24218 
 
5386 phani.kuma 24219 
class getSettlementForPrepaid_args:
4600 varun.gupt 24220 
  """
24221 
  Attributes:
5189 varun.gupt 24222 
   - referenceId
24223 
   - isRefund
4600 varun.gupt 24224 
  """
24225 
 
24226 
  thrift_spec = (
24227 
    None, # 0
5189 varun.gupt 24228 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 24229 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 24230 
  )
24231 
 
5386 phani.kuma 24232 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 24233 
    self.referenceId = referenceId
24234 
    self.isRefund = isRefund
4600 varun.gupt 24235 
 
24236 
  def read(self, iprot):
24237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24239 
      return
24240 
    iprot.readStructBegin()
24241 
    while True:
24242 
      (fname, ftype, fid) = iprot.readFieldBegin()
24243 
      if ftype == TType.STOP:
24244 
        break
24245 
      if fid == 1:
24246 
        if ftype == TType.I64:
5189 varun.gupt 24247 
          self.referenceId = iprot.readI64();
4600 varun.gupt 24248 
        else:
24249 
          iprot.skip(ftype)
5189 varun.gupt 24250 
      elif fid == 2:
24251 
        if ftype == TType.BOOL:
24252 
          self.isRefund = iprot.readBool();
24253 
        else:
24254 
          iprot.skip(ftype)
4600 varun.gupt 24255 
      else:
24256 
        iprot.skip(ftype)
24257 
      iprot.readFieldEnd()
24258 
    iprot.readStructEnd()
24259 
 
24260 
  def write(self, oprot):
24261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24263 
      return
5386 phani.kuma 24264 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 24265 
    if self.referenceId is not None:
24266 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
24267 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 24268 
      oprot.writeFieldEnd()
5386 phani.kuma 24269 
    if self.isRefund is not None:
24270 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
24271 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 24272 
      oprot.writeFieldEnd()
5386 phani.kuma 24273 
    oprot.writeFieldStop()
24274 
    oprot.writeStructEnd()
24275 
 
24276 
  def validate(self):
24277 
    return
24278 
 
24279 
 
24280 
  def __repr__(self):
24281 
    L = ['%s=%r' % (key, value)
24282 
      for key, value in self.__dict__.iteritems()]
24283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24284 
 
24285 
  def __eq__(self, other):
24286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24287 
 
24288 
  def __ne__(self, other):
24289 
    return not (self == other)
24290 
 
24291 
class getSettlementForPrepaid_result:
24292 
  """
24293 
  Attributes:
24294 
   - success
24295 
   - ex
24296 
  """
24297 
 
24298 
  thrift_spec = (
24299 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
24300 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24301 
  )
24302 
 
24303 
  def __init__(self, success=None, ex=None,):
24304 
    self.success = success
24305 
    self.ex = ex
24306 
 
24307 
  def read(self, iprot):
24308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24310 
      return
24311 
    iprot.readStructBegin()
24312 
    while True:
24313 
      (fname, ftype, fid) = iprot.readFieldBegin()
24314 
      if ftype == TType.STOP:
24315 
        break
24316 
      if fid == 0:
24317 
        if ftype == TType.STRUCT:
24318 
          self.success = PaymentSettlement()
24319 
          self.success.read(iprot)
24320 
        else:
24321 
          iprot.skip(ftype)
24322 
      elif fid == 1:
24323 
        if ftype == TType.STRUCT:
24324 
          self.ex = TransactionServiceException()
24325 
          self.ex.read(iprot)
24326 
        else:
24327 
          iprot.skip(ftype)
24328 
      else:
24329 
        iprot.skip(ftype)
24330 
      iprot.readFieldEnd()
24331 
    iprot.readStructEnd()
24332 
 
24333 
  def write(self, oprot):
24334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24336 
      return
24337 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
24338 
    if self.success is not None:
24339 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24340 
      self.success.write(oprot)
24341 
      oprot.writeFieldEnd()
24342 
    if self.ex is not None:
24343 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24344 
      self.ex.write(oprot)
24345 
      oprot.writeFieldEnd()
24346 
    oprot.writeFieldStop()
24347 
    oprot.writeStructEnd()
24348 
 
24349 
  def validate(self):
24350 
    return
24351 
 
24352 
 
24353 
  def __repr__(self):
24354 
    L = ['%s=%r' % (key, value)
24355 
      for key, value in self.__dict__.iteritems()]
24356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24357 
 
24358 
  def __eq__(self, other):
24359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24360 
 
24361 
  def __ne__(self, other):
24362 
    return not (self == other)
24363 
 
24364 
class getSettlementForCod_args:
24365 
  """
24366 
  Attributes:
24367 
   - orderId
24368 
   - isRefund
24369 
  """
24370 
 
24371 
  thrift_spec = (
24372 
    None, # 0
24373 
    (1, TType.I64, 'orderId', None, None, ), # 1
24374 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
24375 
  )
24376 
 
24377 
  def __init__(self, orderId=None, isRefund=None,):
24378 
    self.orderId = orderId
24379 
    self.isRefund = isRefund
24380 
 
24381 
  def read(self, iprot):
24382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24384 
      return
24385 
    iprot.readStructBegin()
24386 
    while True:
24387 
      (fname, ftype, fid) = iprot.readFieldBegin()
24388 
      if ftype == TType.STOP:
24389 
        break
24390 
      if fid == 1:
24391 
        if ftype == TType.I64:
24392 
          self.orderId = iprot.readI64();
24393 
        else:
24394 
          iprot.skip(ftype)
24395 
      elif fid == 2:
24396 
        if ftype == TType.BOOL:
24397 
          self.isRefund = iprot.readBool();
24398 
        else:
24399 
          iprot.skip(ftype)
24400 
      else:
24401 
        iprot.skip(ftype)
24402 
      iprot.readFieldEnd()
24403 
    iprot.readStructEnd()
24404 
 
24405 
  def write(self, oprot):
24406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24408 
      return
24409 
    oprot.writeStructBegin('getSettlementForCod_args')
24410 
    if self.orderId is not None:
24411 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24412 
      oprot.writeI64(self.orderId)
24413 
      oprot.writeFieldEnd()
5189 varun.gupt 24414 
    if self.isRefund is not None:
5386 phani.kuma 24415 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 24416 
      oprot.writeBool(self.isRefund)
24417 
      oprot.writeFieldEnd()
4600 varun.gupt 24418 
    oprot.writeFieldStop()
24419 
    oprot.writeStructEnd()
24420 
 
24421 
  def validate(self):
24422 
    return
24423 
 
24424 
 
24425 
  def __repr__(self):
24426 
    L = ['%s=%r' % (key, value)
24427 
      for key, value in self.__dict__.iteritems()]
24428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24429 
 
24430 
  def __eq__(self, other):
24431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24432 
 
24433 
  def __ne__(self, other):
24434 
    return not (self == other)
24435 
 
5386 phani.kuma 24436 
class getSettlementForCod_result:
4600 varun.gupt 24437 
  """
24438 
  Attributes:
24439 
   - success
24440 
   - ex
24441 
  """
24442 
 
24443 
  thrift_spec = (
24444 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
24445 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24446 
  )
24447 
 
24448 
  def __init__(self, success=None, ex=None,):
24449 
    self.success = success
24450 
    self.ex = ex
24451 
 
24452 
  def read(self, iprot):
24453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24455 
      return
24456 
    iprot.readStructBegin()
24457 
    while True:
24458 
      (fname, ftype, fid) = iprot.readFieldBegin()
24459 
      if ftype == TType.STOP:
24460 
        break
24461 
      if fid == 0:
24462 
        if ftype == TType.STRUCT:
24463 
          self.success = PaymentSettlement()
24464 
          self.success.read(iprot)
24465 
        else:
24466 
          iprot.skip(ftype)
24467 
      elif fid == 1:
24468 
        if ftype == TType.STRUCT:
24469 
          self.ex = TransactionServiceException()
24470 
          self.ex.read(iprot)
24471 
        else:
24472 
          iprot.skip(ftype)
24473 
      else:
24474 
        iprot.skip(ftype)
24475 
      iprot.readFieldEnd()
24476 
    iprot.readStructEnd()
24477 
 
24478 
  def write(self, oprot):
24479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24481 
      return
5386 phani.kuma 24482 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 24483 
    if self.success is not None:
24484 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
24485 
      self.success.write(oprot)
24486 
      oprot.writeFieldEnd()
24487 
    if self.ex is not None:
24488 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24489 
      self.ex.write(oprot)
24490 
      oprot.writeFieldEnd()
24491 
    oprot.writeFieldStop()
24492 
    oprot.writeStructEnd()
24493 
 
24494 
  def validate(self):
24495 
    return
24496 
 
24497 
 
24498 
  def __repr__(self):
24499 
    L = ['%s=%r' % (key, value)
24500 
      for key, value in self.__dict__.iteritems()]
24501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24502 
 
24503 
  def __eq__(self, other):
24504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24505 
 
24506 
  def __ne__(self, other):
24507 
    return not (self == other)
24508 
 
24509 
class getEBSSettlementSummaries_args:
24510 
 
24511 
  thrift_spec = (
24512 
  )
24513 
 
24514 
  def read(self, iprot):
24515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24517 
      return
24518 
    iprot.readStructBegin()
24519 
    while True:
24520 
      (fname, ftype, fid) = iprot.readFieldBegin()
24521 
      if ftype == TType.STOP:
24522 
        break
24523 
      else:
24524 
        iprot.skip(ftype)
24525 
      iprot.readFieldEnd()
24526 
    iprot.readStructEnd()
24527 
 
24528 
  def write(self, oprot):
24529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24531 
      return
24532 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
24533 
    oprot.writeFieldStop()
24534 
    oprot.writeStructEnd()
24535 
 
24536 
  def validate(self):
24537 
    return
24538 
 
24539 
 
24540 
  def __repr__(self):
24541 
    L = ['%s=%r' % (key, value)
24542 
      for key, value in self.__dict__.iteritems()]
24543 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24544 
 
24545 
  def __eq__(self, other):
24546 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24547 
 
24548 
  def __ne__(self, other):
24549 
    return not (self == other)
24550 
 
24551 
class getEBSSettlementSummaries_result:
24552 
  """
24553 
  Attributes:
24554 
   - success
24555 
   - ex
24556 
  """
24557 
 
24558 
  thrift_spec = (
24559 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
24560 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24561 
  )
24562 
 
24563 
  def __init__(self, success=None, ex=None,):
24564 
    self.success = success
24565 
    self.ex = ex
24566 
 
24567 
  def read(self, iprot):
24568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24570 
      return
24571 
    iprot.readStructBegin()
24572 
    while True:
24573 
      (fname, ftype, fid) = iprot.readFieldBegin()
24574 
      if ftype == TType.STOP:
24575 
        break
24576 
      if fid == 0:
24577 
        if ftype == TType.MAP:
24578 
          self.success = {}
6188 rajveer 24579 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
24580 
          for _i558 in xrange(_size554):
24581 
            _key559 = iprot.readI64();
24582 
            _val560 = iprot.readString();
24583 
            self.success[_key559] = _val560
4600 varun.gupt 24584 
          iprot.readMapEnd()
24585 
        else:
24586 
          iprot.skip(ftype)
24587 
      elif fid == 1:
24588 
        if ftype == TType.STRUCT:
24589 
          self.ex = TransactionServiceException()
24590 
          self.ex.read(iprot)
24591 
        else:
24592 
          iprot.skip(ftype)
24593 
      else:
24594 
        iprot.skip(ftype)
24595 
      iprot.readFieldEnd()
24596 
    iprot.readStructEnd()
24597 
 
24598 
  def write(self, oprot):
24599 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24600 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24601 
      return
24602 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
24603 
    if self.success is not None:
24604 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24605 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 24606 
      for kiter561,viter562 in self.success.items():
24607 
        oprot.writeI64(kiter561)
24608 
        oprot.writeString(viter562)
4600 varun.gupt 24609 
      oprot.writeMapEnd()
24610 
      oprot.writeFieldEnd()
24611 
    if self.ex is not None:
24612 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24613 
      self.ex.write(oprot)
24614 
      oprot.writeFieldEnd()
24615 
    oprot.writeFieldStop()
24616 
    oprot.writeStructEnd()
24617 
 
24618 
  def validate(self):
24619 
    return
24620 
 
24621 
 
24622 
  def __repr__(self):
24623 
    L = ['%s=%r' % (key, value)
24624 
      for key, value in self.__dict__.iteritems()]
24625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24626 
 
24627 
  def __eq__(self, other):
24628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24629 
 
24630 
  def __ne__(self, other):
24631 
    return not (self == other)
24632 
 
24633 
class markEBSSettlementUploaded_args:
24634 
  """
24635 
  Attributes:
24636 
   - settlementId
24637 
  """
24638 
 
24639 
  thrift_spec = (
24640 
    None, # 0
24641 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24642 
  )
24643 
 
24644 
  def __init__(self, settlementId=None,):
24645 
    self.settlementId = settlementId
24646 
 
24647 
  def read(self, iprot):
24648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24650 
      return
24651 
    iprot.readStructBegin()
24652 
    while True:
24653 
      (fname, ftype, fid) = iprot.readFieldBegin()
24654 
      if ftype == TType.STOP:
24655 
        break
24656 
      if fid == 1:
24657 
        if ftype == TType.I64:
24658 
          self.settlementId = iprot.readI64();
24659 
        else:
24660 
          iprot.skip(ftype)
24661 
      else:
24662 
        iprot.skip(ftype)
24663 
      iprot.readFieldEnd()
24664 
    iprot.readStructEnd()
24665 
 
24666 
  def write(self, oprot):
24667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24669 
      return
24670 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
24671 
    if self.settlementId is not None:
24672 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24673 
      oprot.writeI64(self.settlementId)
24674 
      oprot.writeFieldEnd()
24675 
    oprot.writeFieldStop()
24676 
    oprot.writeStructEnd()
24677 
 
24678 
  def validate(self):
24679 
    return
24680 
 
24681 
 
24682 
  def __repr__(self):
24683 
    L = ['%s=%r' % (key, value)
24684 
      for key, value in self.__dict__.iteritems()]
24685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24686 
 
24687 
  def __eq__(self, other):
24688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24689 
 
24690 
  def __ne__(self, other):
24691 
    return not (self == other)
24692 
 
24693 
class markEBSSettlementUploaded_result:
24694 
  """
24695 
  Attributes:
24696 
   - ex
24697 
  """
24698 
 
24699 
  thrift_spec = (
24700 
    None, # 0
24701 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24702 
  )
24703 
 
24704 
  def __init__(self, ex=None,):
24705 
    self.ex = ex
24706 
 
24707 
  def read(self, iprot):
24708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24710 
      return
24711 
    iprot.readStructBegin()
24712 
    while True:
24713 
      (fname, ftype, fid) = iprot.readFieldBegin()
24714 
      if ftype == TType.STOP:
24715 
        break
24716 
      if fid == 1:
24717 
        if ftype == TType.STRUCT:
24718 
          self.ex = TransactionServiceException()
24719 
          self.ex.read(iprot)
24720 
        else:
24721 
          iprot.skip(ftype)
24722 
      else:
24723 
        iprot.skip(ftype)
24724 
      iprot.readFieldEnd()
24725 
    iprot.readStructEnd()
24726 
 
24727 
  def write(self, oprot):
24728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24730 
      return
24731 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
24732 
    if self.ex is not None:
24733 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24734 
      self.ex.write(oprot)
24735 
      oprot.writeFieldEnd()
24736 
    oprot.writeFieldStop()
24737 
    oprot.writeStructEnd()
24738 
 
24739 
  def validate(self):
24740 
    return
24741 
 
24742 
 
24743 
  def __repr__(self):
24744 
    L = ['%s=%r' % (key, value)
24745 
      for key, value in self.__dict__.iteritems()]
24746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24747 
 
24748 
  def __eq__(self, other):
24749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24750 
 
24751 
  def __ne__(self, other):
24752 
    return not (self == other)
24753 
 
24754 
class getEBSSettlementDate_args:
24755 
  """
24756 
  Attributes:
24757 
   - settlementId
24758 
  """
24759 
 
24760 
  thrift_spec = (
24761 
    None, # 0
24762 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24763 
  )
24764 
 
24765 
  def __init__(self, settlementId=None,):
24766 
    self.settlementId = settlementId
24767 
 
24768 
  def read(self, iprot):
24769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24771 
      return
24772 
    iprot.readStructBegin()
24773 
    while True:
24774 
      (fname, ftype, fid) = iprot.readFieldBegin()
24775 
      if ftype == TType.STOP:
24776 
        break
24777 
      if fid == 1:
24778 
        if ftype == TType.I64:
24779 
          self.settlementId = iprot.readI64();
24780 
        else:
24781 
          iprot.skip(ftype)
24782 
      else:
24783 
        iprot.skip(ftype)
24784 
      iprot.readFieldEnd()
24785 
    iprot.readStructEnd()
24786 
 
24787 
  def write(self, oprot):
24788 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24789 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24790 
      return
24791 
    oprot.writeStructBegin('getEBSSettlementDate_args')
24792 
    if self.settlementId is not None:
24793 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24794 
      oprot.writeI64(self.settlementId)
24795 
      oprot.writeFieldEnd()
24796 
    oprot.writeFieldStop()
24797 
    oprot.writeStructEnd()
24798 
 
24799 
  def validate(self):
24800 
    return
24801 
 
24802 
 
24803 
  def __repr__(self):
24804 
    L = ['%s=%r' % (key, value)
24805 
      for key, value in self.__dict__.iteritems()]
24806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24807 
 
24808 
  def __eq__(self, other):
24809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24810 
 
24811 
  def __ne__(self, other):
24812 
    return not (self == other)
24813 
 
24814 
class getEBSSettlementDate_result:
24815 
  """
24816 
  Attributes:
24817 
   - success
24818 
   - ex
24819 
  """
24820 
 
24821 
  thrift_spec = (
24822 
    (0, TType.I64, 'success', None, None, ), # 0
24823 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24824 
  )
24825 
 
24826 
  def __init__(self, success=None, ex=None,):
24827 
    self.success = success
24828 
    self.ex = ex
24829 
 
24830 
  def read(self, iprot):
24831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24833 
      return
24834 
    iprot.readStructBegin()
24835 
    while True:
24836 
      (fname, ftype, fid) = iprot.readFieldBegin()
24837 
      if ftype == TType.STOP:
24838 
        break
24839 
      if fid == 0:
24840 
        if ftype == TType.I64:
24841 
          self.success = iprot.readI64();
24842 
        else:
24843 
          iprot.skip(ftype)
24844 
      elif fid == 1:
24845 
        if ftype == TType.STRUCT:
24846 
          self.ex = TransactionServiceException()
24847 
          self.ex.read(iprot)
24848 
        else:
24849 
          iprot.skip(ftype)
24850 
      else:
24851 
        iprot.skip(ftype)
24852 
      iprot.readFieldEnd()
24853 
    iprot.readStructEnd()
24854 
 
24855 
  def write(self, oprot):
24856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24858 
      return
24859 
    oprot.writeStructBegin('getEBSSettlementDate_result')
24860 
    if self.success is not None:
24861 
      oprot.writeFieldBegin('success', TType.I64, 0)
24862 
      oprot.writeI64(self.success)
24863 
      oprot.writeFieldEnd()
24864 
    if self.ex is not None:
24865 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24866 
      self.ex.write(oprot)
24867 
      oprot.writeFieldEnd()
24868 
    oprot.writeFieldStop()
24869 
    oprot.writeStructEnd()
24870 
 
24871 
  def validate(self):
24872 
    return
24873 
 
24874 
 
24875 
  def __repr__(self):
24876 
    L = ['%s=%r' % (key, value)
24877 
      for key, value in self.__dict__.iteritems()]
24878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24879 
 
24880 
  def __eq__(self, other):
24881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24882 
 
24883 
  def __ne__(self, other):
24884 
    return not (self == other)
4715 varun.gupt 24885 
 
24886 
class getSettlementsByDate_args:
24887 
  """
24888 
  Attributes:
24889 
   - settlementDateFrom
24890 
   - settlementDateTo
24891 
   - isRefund
24892 
  """
24893 
 
24894 
  thrift_spec = (
24895 
    None, # 0
24896 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
24897 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
24898 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
24899 
  )
24900 
 
24901 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
24902 
    self.settlementDateFrom = settlementDateFrom
24903 
    self.settlementDateTo = settlementDateTo
24904 
    self.isRefund = isRefund
24905 
 
24906 
  def read(self, iprot):
24907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24909 
      return
24910 
    iprot.readStructBegin()
24911 
    while True:
24912 
      (fname, ftype, fid) = iprot.readFieldBegin()
24913 
      if ftype == TType.STOP:
24914 
        break
24915 
      if fid == 1:
24916 
        if ftype == TType.I64:
24917 
          self.settlementDateFrom = iprot.readI64();
24918 
        else:
24919 
          iprot.skip(ftype)
24920 
      elif fid == 2:
24921 
        if ftype == TType.I64:
24922 
          self.settlementDateTo = iprot.readI64();
24923 
        else:
24924 
          iprot.skip(ftype)
24925 
      elif fid == 3:
24926 
        if ftype == TType.BOOL:
24927 
          self.isRefund = iprot.readBool();
24928 
        else:
24929 
          iprot.skip(ftype)
24930 
      else:
24931 
        iprot.skip(ftype)
24932 
      iprot.readFieldEnd()
24933 
    iprot.readStructEnd()
24934 
 
24935 
  def write(self, oprot):
24936 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24937 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24938 
      return
24939 
    oprot.writeStructBegin('getSettlementsByDate_args')
24940 
    if self.settlementDateFrom is not None:
24941 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
24942 
      oprot.writeI64(self.settlementDateFrom)
24943 
      oprot.writeFieldEnd()
24944 
    if self.settlementDateTo is not None:
24945 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
24946 
      oprot.writeI64(self.settlementDateTo)
24947 
      oprot.writeFieldEnd()
24948 
    if self.isRefund is not None:
24949 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
24950 
      oprot.writeBool(self.isRefund)
24951 
      oprot.writeFieldEnd()
24952 
    oprot.writeFieldStop()
24953 
    oprot.writeStructEnd()
24954 
 
24955 
  def validate(self):
24956 
    return
24957 
 
24958 
 
24959 
  def __repr__(self):
24960 
    L = ['%s=%r' % (key, value)
24961 
      for key, value in self.__dict__.iteritems()]
24962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24963 
 
24964 
  def __eq__(self, other):
24965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24966 
 
24967 
  def __ne__(self, other):
24968 
    return not (self == other)
24969 
 
24970 
class getSettlementsByDate_result:
24971 
  """
24972 
  Attributes:
24973 
   - success
24974 
   - ex
24975 
  """
24976 
 
24977 
  thrift_spec = (
24978 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
24979 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24980 
  )
24981 
 
24982 
  def __init__(self, success=None, ex=None,):
24983 
    self.success = success
24984 
    self.ex = ex
24985 
 
24986 
  def read(self, iprot):
24987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24989 
      return
24990 
    iprot.readStructBegin()
24991 
    while True:
24992 
      (fname, ftype, fid) = iprot.readFieldBegin()
24993 
      if ftype == TType.STOP:
24994 
        break
24995 
      if fid == 0:
24996 
        if ftype == TType.LIST:
24997 
          self.success = []
6188 rajveer 24998 
          (_etype566, _size563) = iprot.readListBegin()
24999 
          for _i567 in xrange(_size563):
25000 
            _elem568 = PaymentSettlement()
25001 
            _elem568.read(iprot)
25002 
            self.success.append(_elem568)
4715 varun.gupt 25003 
          iprot.readListEnd()
25004 
        else:
25005 
          iprot.skip(ftype)
25006 
      elif fid == 1:
25007 
        if ftype == TType.STRUCT:
25008 
          self.ex = TransactionServiceException()
25009 
          self.ex.read(iprot)
25010 
        else:
25011 
          iprot.skip(ftype)
25012 
      else:
25013 
        iprot.skip(ftype)
25014 
      iprot.readFieldEnd()
25015 
    iprot.readStructEnd()
25016 
 
25017 
  def write(self, oprot):
25018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25020 
      return
25021 
    oprot.writeStructBegin('getSettlementsByDate_result')
25022 
    if self.success is not None:
25023 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25024 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25025 
      for iter569 in self.success:
25026 
        iter569.write(oprot)
4715 varun.gupt 25027 
      oprot.writeListEnd()
25028 
      oprot.writeFieldEnd()
25029 
    if self.ex is not None:
25030 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25031 
      self.ex.write(oprot)
25032 
      oprot.writeFieldEnd()
25033 
    oprot.writeFieldStop()
25034 
    oprot.writeStructEnd()
25035 
 
25036 
  def validate(self):
25037 
    return
25038 
 
25039 
 
25040 
  def __repr__(self):
25041 
    L = ['%s=%r' % (key, value)
25042 
      for key, value in self.__dict__.iteritems()]
25043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25044 
 
25045 
  def __eq__(self, other):
25046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25047 
 
25048 
  def __ne__(self, other):
25049 
    return not (self == other)
25050 
 
25051 
class getReshippedOrderIds_args:
25052 
  """
25053 
  Attributes:
25054 
   - orderIds
25055 
  """
25056 
 
25057 
  thrift_spec = (
25058 
    None, # 0
25059 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
25060 
  )
25061 
 
25062 
  def __init__(self, orderIds=None,):
25063 
    self.orderIds = orderIds
25064 
 
25065 
  def read(self, iprot):
25066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25068 
      return
25069 
    iprot.readStructBegin()
25070 
    while True:
25071 
      (fname, ftype, fid) = iprot.readFieldBegin()
25072 
      if ftype == TType.STOP:
25073 
        break
25074 
      if fid == 1:
25075 
        if ftype == TType.LIST:
25076 
          self.orderIds = []
6188 rajveer 25077 
          (_etype573, _size570) = iprot.readListBegin()
25078 
          for _i574 in xrange(_size570):
25079 
            _elem575 = iprot.readI64();
25080 
            self.orderIds.append(_elem575)
4715 varun.gupt 25081 
          iprot.readListEnd()
25082 
        else:
25083 
          iprot.skip(ftype)
25084 
      else:
25085 
        iprot.skip(ftype)
25086 
      iprot.readFieldEnd()
25087 
    iprot.readStructEnd()
25088 
 
25089 
  def write(self, oprot):
25090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25092 
      return
25093 
    oprot.writeStructBegin('getReshippedOrderIds_args')
25094 
    if self.orderIds is not None:
25095 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
25096 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 25097 
      for iter576 in self.orderIds:
25098 
        oprot.writeI64(iter576)
4715 varun.gupt 25099 
      oprot.writeListEnd()
25100 
      oprot.writeFieldEnd()
25101 
    oprot.writeFieldStop()
25102 
    oprot.writeStructEnd()
25103 
 
25104 
  def validate(self):
25105 
    return
25106 
 
25107 
 
25108 
  def __repr__(self):
25109 
    L = ['%s=%r' % (key, value)
25110 
      for key, value in self.__dict__.iteritems()]
25111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25112 
 
25113 
  def __eq__(self, other):
25114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25115 
 
25116 
  def __ne__(self, other):
25117 
    return not (self == other)
25118 
 
25119 
class getReshippedOrderIds_result:
25120 
  """
25121 
  Attributes:
25122 
   - success
25123 
   - ex
25124 
  """
25125 
 
25126 
  thrift_spec = (
25127 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
25128 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25129 
  )
25130 
 
25131 
  def __init__(self, success=None, ex=None,):
25132 
    self.success = success
25133 
    self.ex = ex
25134 
 
25135 
  def read(self, iprot):
25136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25138 
      return
25139 
    iprot.readStructBegin()
25140 
    while True:
25141 
      (fname, ftype, fid) = iprot.readFieldBegin()
25142 
      if ftype == TType.STOP:
25143 
        break
25144 
      if fid == 0:
25145 
        if ftype == TType.LIST:
25146 
          self.success = []
6188 rajveer 25147 
          (_etype580, _size577) = iprot.readListBegin()
25148 
          for _i581 in xrange(_size577):
25149 
            _elem582 = iprot.readI64();
25150 
            self.success.append(_elem582)
4715 varun.gupt 25151 
          iprot.readListEnd()
25152 
        else:
25153 
          iprot.skip(ftype)
25154 
      elif fid == 1:
25155 
        if ftype == TType.STRUCT:
25156 
          self.ex = TransactionServiceException()
25157 
          self.ex.read(iprot)
25158 
        else:
25159 
          iprot.skip(ftype)
25160 
      else:
25161 
        iprot.skip(ftype)
25162 
      iprot.readFieldEnd()
25163 
    iprot.readStructEnd()
25164 
 
25165 
  def write(self, oprot):
25166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25168 
      return
25169 
    oprot.writeStructBegin('getReshippedOrderIds_result')
25170 
    if self.success is not None:
25171 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25172 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25173 
      for iter583 in self.success:
25174 
        oprot.writeI64(iter583)
4715 varun.gupt 25175 
      oprot.writeListEnd()
25176 
      oprot.writeFieldEnd()
25177 
    if self.ex is not None:
25178 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25179 
      self.ex.write(oprot)
25180 
      oprot.writeFieldEnd()
25181 
    oprot.writeFieldStop()
25182 
    oprot.writeStructEnd()
25183 
 
25184 
  def validate(self):
25185 
    return
25186 
 
25187 
 
25188 
  def __repr__(self):
25189 
    L = ['%s=%r' % (key, value)
25190 
      for key, value in self.__dict__.iteritems()]
25191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25192 
 
25193 
  def __eq__(self, other):
25194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25195 
 
25196 
  def __ne__(self, other):
25197 
    return not (self == other)
4757 mandeep.dh 25198 
 
5481 phani.kuma 25199 
class getBilledOrders_args:
4875 varun.gupt 25200 
  """
25201 
  Attributes:
25202 
   - vendorId
5481 phani.kuma 25203 
   - onlyVendorNotPaid
25204 
   - billingDateFrom
25205 
   - billingDateTo
4875 varun.gupt 25206 
  """
25207 
 
25208 
  thrift_spec = (
25209 
    None, # 0
25210 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 25211 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
25212 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
25213 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 25214 
  )
25215 
 
5481 phani.kuma 25216 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 25217 
    self.vendorId = vendorId
5481 phani.kuma 25218 
    self.onlyVendorNotPaid = onlyVendorNotPaid
25219 
    self.billingDateFrom = billingDateFrom
25220 
    self.billingDateTo = billingDateTo
4875 varun.gupt 25221 
 
25222 
  def read(self, iprot):
25223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25225 
      return
25226 
    iprot.readStructBegin()
25227 
    while True:
25228 
      (fname, ftype, fid) = iprot.readFieldBegin()
25229 
      if ftype == TType.STOP:
25230 
        break
25231 
      if fid == 1:
25232 
        if ftype == TType.I64:
25233 
          self.vendorId = iprot.readI64();
25234 
        else:
25235 
          iprot.skip(ftype)
5481 phani.kuma 25236 
      elif fid == 2:
25237 
        if ftype == TType.BOOL:
25238 
          self.onlyVendorNotPaid = iprot.readBool();
25239 
        else:
25240 
          iprot.skip(ftype)
25241 
      elif fid == 3:
25242 
        if ftype == TType.I64:
25243 
          self.billingDateFrom = iprot.readI64();
25244 
        else:
25245 
          iprot.skip(ftype)
25246 
      elif fid == 4:
25247 
        if ftype == TType.I64:
25248 
          self.billingDateTo = iprot.readI64();
25249 
        else:
25250 
          iprot.skip(ftype)
4875 varun.gupt 25251 
      else:
25252 
        iprot.skip(ftype)
25253 
      iprot.readFieldEnd()
25254 
    iprot.readStructEnd()
25255 
 
25256 
  def write(self, oprot):
25257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25259 
      return
5481 phani.kuma 25260 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 25261 
    if self.vendorId is not None:
25262 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
25263 
      oprot.writeI64(self.vendorId)
25264 
      oprot.writeFieldEnd()
5481 phani.kuma 25265 
    if self.onlyVendorNotPaid is not None:
25266 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
25267 
      oprot.writeBool(self.onlyVendorNotPaid)
25268 
      oprot.writeFieldEnd()
25269 
    if self.billingDateFrom is not None:
25270 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
25271 
      oprot.writeI64(self.billingDateFrom)
25272 
      oprot.writeFieldEnd()
25273 
    if self.billingDateTo is not None:
25274 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
25275 
      oprot.writeI64(self.billingDateTo)
25276 
      oprot.writeFieldEnd()
4875 varun.gupt 25277 
    oprot.writeFieldStop()
25278 
    oprot.writeStructEnd()
25279 
 
25280 
  def validate(self):
25281 
    return
25282 
 
25283 
 
25284 
  def __repr__(self):
25285 
    L = ['%s=%r' % (key, value)
25286 
      for key, value in self.__dict__.iteritems()]
25287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25288 
 
25289 
  def __eq__(self, other):
25290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25291 
 
25292 
  def __ne__(self, other):
25293 
    return not (self == other)
25294 
 
5481 phani.kuma 25295 
class getBilledOrders_result:
4875 varun.gupt 25296 
  """
25297 
  Attributes:
25298 
   - success
25299 
   - ex
25300 
  """
25301 
 
25302 
  thrift_spec = (
25303 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25304 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25305 
  )
25306 
 
25307 
  def __init__(self, success=None, ex=None,):
25308 
    self.success = success
25309 
    self.ex = ex
25310 
 
25311 
  def read(self, iprot):
25312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25314 
      return
25315 
    iprot.readStructBegin()
25316 
    while True:
25317 
      (fname, ftype, fid) = iprot.readFieldBegin()
25318 
      if ftype == TType.STOP:
25319 
        break
25320 
      if fid == 0:
25321 
        if ftype == TType.LIST:
25322 
          self.success = []
6188 rajveer 25323 
          (_etype587, _size584) = iprot.readListBegin()
25324 
          for _i588 in xrange(_size584):
25325 
            _elem589 = Order()
25326 
            _elem589.read(iprot)
25327 
            self.success.append(_elem589)
4875 varun.gupt 25328 
          iprot.readListEnd()
25329 
        else:
25330 
          iprot.skip(ftype)
25331 
      elif fid == 1:
25332 
        if ftype == TType.STRUCT:
25333 
          self.ex = TransactionServiceException()
25334 
          self.ex.read(iprot)
25335 
        else:
25336 
          iprot.skip(ftype)
25337 
      else:
25338 
        iprot.skip(ftype)
25339 
      iprot.readFieldEnd()
25340 
    iprot.readStructEnd()
25341 
 
25342 
  def write(self, oprot):
25343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25345 
      return
5481 phani.kuma 25346 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 25347 
    if self.success is not None:
25348 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25349 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25350 
      for iter590 in self.success:
25351 
        iter590.write(oprot)
4875 varun.gupt 25352 
      oprot.writeListEnd()
25353 
      oprot.writeFieldEnd()
25354 
    if self.ex is not None:
25355 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25356 
      self.ex.write(oprot)
25357 
      oprot.writeFieldEnd()
25358 
    oprot.writeFieldStop()
25359 
    oprot.writeStructEnd()
25360 
 
25361 
  def validate(self):
25362 
    return
25363 
 
25364 
 
25365 
  def __repr__(self):
25366 
    L = ['%s=%r' % (key, value)
25367 
      for key, value in self.__dict__.iteritems()]
25368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25369 
 
25370 
  def __eq__(self, other):
25371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25372 
 
25373 
  def __ne__(self, other):
25374 
    return not (self == other)
5031 varun.gupt 25375 
 
25376 
class getStatusDistributionOfOrders_args:
25377 
  """
25378 
  Attributes:
25379 
   - startDate
25380 
   - endDate
25381 
  """
25382 
 
25383 
  thrift_spec = (
25384 
    None, # 0
25385 
    (1, TType.I64, 'startDate', None, None, ), # 1
25386 
    (2, TType.I64, 'endDate', None, None, ), # 2
25387 
  )
25388 
 
25389 
  def __init__(self, startDate=None, endDate=None,):
25390 
    self.startDate = startDate
25391 
    self.endDate = endDate
25392 
 
25393 
  def read(self, iprot):
25394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25396 
      return
25397 
    iprot.readStructBegin()
25398 
    while True:
25399 
      (fname, ftype, fid) = iprot.readFieldBegin()
25400 
      if ftype == TType.STOP:
25401 
        break
25402 
      if fid == 1:
25403 
        if ftype == TType.I64:
25404 
          self.startDate = iprot.readI64();
25405 
        else:
25406 
          iprot.skip(ftype)
25407 
      elif fid == 2:
25408 
        if ftype == TType.I64:
25409 
          self.endDate = iprot.readI64();
25410 
        else:
25411 
          iprot.skip(ftype)
25412 
      else:
25413 
        iprot.skip(ftype)
25414 
      iprot.readFieldEnd()
25415 
    iprot.readStructEnd()
25416 
 
25417 
  def write(self, oprot):
25418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25420 
      return
25421 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
25422 
    if self.startDate is not None:
25423 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
25424 
      oprot.writeI64(self.startDate)
25425 
      oprot.writeFieldEnd()
25426 
    if self.endDate is not None:
25427 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
25428 
      oprot.writeI64(self.endDate)
25429 
      oprot.writeFieldEnd()
25430 
    oprot.writeFieldStop()
25431 
    oprot.writeStructEnd()
25432 
 
25433 
  def validate(self):
25434 
    return
25435 
 
25436 
 
25437 
  def __repr__(self):
25438 
    L = ['%s=%r' % (key, value)
25439 
      for key, value in self.__dict__.iteritems()]
25440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25441 
 
25442 
  def __eq__(self, other):
25443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25444 
 
25445 
  def __ne__(self, other):
25446 
    return not (self == other)
25447 
 
25448 
class getStatusDistributionOfOrders_result:
25449 
  """
25450 
  Attributes:
25451 
   - success
25452 
   - ex
25453 
  """
25454 
 
25455 
  thrift_spec = (
25456 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
25457 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25458 
  )
25459 
 
25460 
  def __init__(self, success=None, ex=None,):
25461 
    self.success = success
25462 
    self.ex = ex
25463 
 
25464 
  def read(self, iprot):
25465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25467 
      return
25468 
    iprot.readStructBegin()
25469 
    while True:
25470 
      (fname, ftype, fid) = iprot.readFieldBegin()
25471 
      if ftype == TType.STOP:
25472 
        break
25473 
      if fid == 0:
25474 
        if ftype == TType.MAP:
25475 
          self.success = {}
6188 rajveer 25476 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
25477 
          for _i595 in xrange(_size591):
25478 
            _key596 = iprot.readI64();
25479 
            _val597 = iprot.readI64();
25480 
            self.success[_key596] = _val597
5031 varun.gupt 25481 
          iprot.readMapEnd()
25482 
        else:
25483 
          iprot.skip(ftype)
25484 
      elif fid == 1:
25485 
        if ftype == TType.STRUCT:
25486 
          self.ex = TransactionServiceException()
25487 
          self.ex.read(iprot)
25488 
        else:
25489 
          iprot.skip(ftype)
25490 
      else:
25491 
        iprot.skip(ftype)
25492 
      iprot.readFieldEnd()
25493 
    iprot.readStructEnd()
25494 
 
25495 
  def write(self, oprot):
25496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25498 
      return
25499 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
25500 
    if self.success is not None:
25501 
      oprot.writeFieldBegin('success', TType.MAP, 0)
25502 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 25503 
      for kiter598,viter599 in self.success.items():
25504 
        oprot.writeI64(kiter598)
25505 
        oprot.writeI64(viter599)
5031 varun.gupt 25506 
      oprot.writeMapEnd()
25507 
      oprot.writeFieldEnd()
25508 
    if self.ex is not None:
25509 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25510 
      self.ex.write(oprot)
25511 
      oprot.writeFieldEnd()
25512 
    oprot.writeFieldStop()
25513 
    oprot.writeStructEnd()
25514 
 
25515 
  def validate(self):
25516 
    return
25517 
 
25518 
 
25519 
  def __repr__(self):
25520 
    L = ['%s=%r' % (key, value)
25521 
      for key, value in self.__dict__.iteritems()]
25522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25523 
 
25524 
  def __eq__(self, other):
25525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25526 
 
25527 
  def __ne__(self, other):
25528 
    return not (self == other)
5067 varun.gupt 25529 
 
25530 
class getOrderIdsForStatus_args:
25531 
  """
25532 
  Attributes:
25533 
   - status
25534 
   - startDatetime
25535 
   - endDatetime
25536 
  """
25537 
 
25538 
  thrift_spec = (
25539 
    None, # 0
25540 
    (1, TType.I64, 'status', None, None, ), # 1
25541 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
25542 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
25543 
  )
25544 
 
25545 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
25546 
    self.status = status
25547 
    self.startDatetime = startDatetime
25548 
    self.endDatetime = endDatetime
25549 
 
25550 
  def read(self, iprot):
25551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25553 
      return
25554 
    iprot.readStructBegin()
25555 
    while True:
25556 
      (fname, ftype, fid) = iprot.readFieldBegin()
25557 
      if ftype == TType.STOP:
25558 
        break
25559 
      if fid == 1:
25560 
        if ftype == TType.I64:
25561 
          self.status = iprot.readI64();
25562 
        else:
25563 
          iprot.skip(ftype)
25564 
      elif fid == 2:
25565 
        if ftype == TType.I64:
25566 
          self.startDatetime = iprot.readI64();
25567 
        else:
25568 
          iprot.skip(ftype)
25569 
      elif fid == 3:
25570 
        if ftype == TType.I64:
25571 
          self.endDatetime = iprot.readI64();
25572 
        else:
25573 
          iprot.skip(ftype)
25574 
      else:
25575 
        iprot.skip(ftype)
25576 
      iprot.readFieldEnd()
25577 
    iprot.readStructEnd()
25578 
 
25579 
  def write(self, oprot):
25580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25582 
      return
25583 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
25584 
    if self.status is not None:
25585 
      oprot.writeFieldBegin('status', TType.I64, 1)
25586 
      oprot.writeI64(self.status)
25587 
      oprot.writeFieldEnd()
25588 
    if self.startDatetime is not None:
25589 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
25590 
      oprot.writeI64(self.startDatetime)
25591 
      oprot.writeFieldEnd()
25592 
    if self.endDatetime is not None:
25593 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
25594 
      oprot.writeI64(self.endDatetime)
25595 
      oprot.writeFieldEnd()
25596 
    oprot.writeFieldStop()
25597 
    oprot.writeStructEnd()
25598 
 
25599 
  def validate(self):
25600 
    return
25601 
 
25602 
 
25603 
  def __repr__(self):
25604 
    L = ['%s=%r' % (key, value)
25605 
      for key, value in self.__dict__.iteritems()]
25606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25607 
 
25608 
  def __eq__(self, other):
25609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25610 
 
25611 
  def __ne__(self, other):
25612 
    return not (self == other)
25613 
 
25614 
class getOrderIdsForStatus_result:
25615 
  """
25616 
  Attributes:
25617 
   - success
25618 
   - ex
25619 
  """
25620 
 
25621 
  thrift_spec = (
25622 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
25623 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25624 
  )
25625 
 
25626 
  def __init__(self, success=None, ex=None,):
25627 
    self.success = success
25628 
    self.ex = ex
25629 
 
25630 
  def read(self, iprot):
25631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25633 
      return
25634 
    iprot.readStructBegin()
25635 
    while True:
25636 
      (fname, ftype, fid) = iprot.readFieldBegin()
25637 
      if ftype == TType.STOP:
25638 
        break
25639 
      if fid == 0:
25640 
        if ftype == TType.LIST:
25641 
          self.success = []
6188 rajveer 25642 
          (_etype603, _size600) = iprot.readListBegin()
25643 
          for _i604 in xrange(_size600):
25644 
            _elem605 = iprot.readI64();
25645 
            self.success.append(_elem605)
5067 varun.gupt 25646 
          iprot.readListEnd()
25647 
        else:
25648 
          iprot.skip(ftype)
25649 
      elif fid == 1:
25650 
        if ftype == TType.STRUCT:
25651 
          self.ex = TransactionServiceException()
25652 
          self.ex.read(iprot)
25653 
        else:
25654 
          iprot.skip(ftype)
25655 
      else:
25656 
        iprot.skip(ftype)
25657 
      iprot.readFieldEnd()
25658 
    iprot.readStructEnd()
25659 
 
25660 
  def write(self, oprot):
25661 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25662 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25663 
      return
25664 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
25665 
    if self.success is not None:
25666 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25667 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25668 
      for iter606 in self.success:
25669 
        oprot.writeI64(iter606)
5067 varun.gupt 25670 
      oprot.writeListEnd()
25671 
      oprot.writeFieldEnd()
25672 
    if self.ex is not None:
25673 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25674 
      self.ex.write(oprot)
25675 
      oprot.writeFieldEnd()
25676 
    oprot.writeFieldStop()
25677 
    oprot.writeStructEnd()
25678 
 
25679 
  def validate(self):
25680 
    return
25681 
 
25682 
 
25683 
  def __repr__(self):
25684 
    L = ['%s=%r' % (key, value)
25685 
      for key, value in self.__dict__.iteritems()]
25686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25687 
 
25688 
  def __eq__(self, other):
25689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25690 
 
25691 
  def __ne__(self, other):
25692 
    return not (self == other)
5099 varun.gupt 25693 
 
5348 anupam.sin 25694 
class updateCODAgent_args:
25695 
  """
25696 
  Attributes:
25697 
   - agent
25698 
   - orderId
25699 
  """
25700 
 
25701 
  thrift_spec = (
25702 
    None, # 0
25703 
    (1, TType.STRING, 'agent', None, None, ), # 1
25704 
    (2, TType.I64, 'orderId', None, None, ), # 2
25705 
  )
25706 
 
25707 
  def __init__(self, agent=None, orderId=None,):
25708 
    self.agent = agent
25709 
    self.orderId = orderId
25710 
 
25711 
  def read(self, iprot):
25712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25714 
      return
25715 
    iprot.readStructBegin()
25716 
    while True:
25717 
      (fname, ftype, fid) = iprot.readFieldBegin()
25718 
      if ftype == TType.STOP:
25719 
        break
25720 
      if fid == 1:
25721 
        if ftype == TType.STRING:
25722 
          self.agent = iprot.readString();
25723 
        else:
25724 
          iprot.skip(ftype)
25725 
      elif fid == 2:
25726 
        if ftype == TType.I64:
25727 
          self.orderId = iprot.readI64();
25728 
        else:
25729 
          iprot.skip(ftype)
25730 
      else:
25731 
        iprot.skip(ftype)
25732 
      iprot.readFieldEnd()
25733 
    iprot.readStructEnd()
25734 
 
25735 
  def write(self, oprot):
25736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25738 
      return
25739 
    oprot.writeStructBegin('updateCODAgent_args')
25740 
    if self.agent is not None:
25741 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
25742 
      oprot.writeString(self.agent)
25743 
      oprot.writeFieldEnd()
25744 
    if self.orderId is not None:
25745 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
25746 
      oprot.writeI64(self.orderId)
25747 
      oprot.writeFieldEnd()
25748 
    oprot.writeFieldStop()
25749 
    oprot.writeStructEnd()
25750 
 
25751 
  def validate(self):
25752 
    return
25753 
 
25754 
 
25755 
  def __repr__(self):
25756 
    L = ['%s=%r' % (key, value)
25757 
      for key, value in self.__dict__.iteritems()]
25758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25759 
 
25760 
  def __eq__(self, other):
25761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25762 
 
25763 
  def __ne__(self, other):
25764 
    return not (self == other)
25765 
 
25766 
class updateCODAgent_result:
25767 
  """
25768 
  Attributes:
25769 
   - ex
25770 
  """
25771 
 
25772 
  thrift_spec = (
25773 
    None, # 0
25774 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25775 
  )
25776 
 
25777 
  def __init__(self, ex=None,):
25778 
    self.ex = ex
25779 
 
25780 
  def read(self, iprot):
25781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25783 
      return
25784 
    iprot.readStructBegin()
25785 
    while True:
25786 
      (fname, ftype, fid) = iprot.readFieldBegin()
25787 
      if ftype == TType.STOP:
25788 
        break
25789 
      if fid == 1:
25790 
        if ftype == TType.STRUCT:
25791 
          self.ex = TransactionServiceException()
25792 
          self.ex.read(iprot)
25793 
        else:
25794 
          iprot.skip(ftype)
25795 
      else:
25796 
        iprot.skip(ftype)
25797 
      iprot.readFieldEnd()
25798 
    iprot.readStructEnd()
25799 
 
25800 
  def write(self, oprot):
25801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25803 
      return
25804 
    oprot.writeStructBegin('updateCODAgent_result')
25805 
    if self.ex is not None:
25806 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25807 
      self.ex.write(oprot)
25808 
      oprot.writeFieldEnd()
25809 
    oprot.writeFieldStop()
25810 
    oprot.writeStructEnd()
25811 
 
25812 
  def validate(self):
25813 
    return
25814 
 
25815 
 
25816 
  def __repr__(self):
25817 
    L = ['%s=%r' % (key, value)
25818 
      for key, value in self.__dict__.iteritems()]
25819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25820 
 
25821 
  def __eq__(self, other):
25822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25823 
 
25824 
  def __ne__(self, other):
25825 
    return not (self == other)
25826 
 
5099 varun.gupt 25827 
class updateOrderAsPaidToVendor_args:
25828 
  """
25829 
  Attributes:
25830 
   - orderId
25831 
  """
25832 
 
25833 
  thrift_spec = (
25834 
    None, # 0
25835 
    (1, TType.I64, 'orderId', None, None, ), # 1
25836 
  )
25837 
 
25838 
  def __init__(self, orderId=None,):
25839 
    self.orderId = orderId
25840 
 
25841 
  def read(self, iprot):
25842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25844 
      return
25845 
    iprot.readStructBegin()
25846 
    while True:
25847 
      (fname, ftype, fid) = iprot.readFieldBegin()
25848 
      if ftype == TType.STOP:
25849 
        break
25850 
      if fid == 1:
25851 
        if ftype == TType.I64:
25852 
          self.orderId = iprot.readI64();
25853 
        else:
25854 
          iprot.skip(ftype)
25855 
      else:
25856 
        iprot.skip(ftype)
25857 
      iprot.readFieldEnd()
25858 
    iprot.readStructEnd()
25859 
 
25860 
  def write(self, oprot):
25861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25863 
      return
25864 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
25865 
    if self.orderId is not None:
25866 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25867 
      oprot.writeI64(self.orderId)
25868 
      oprot.writeFieldEnd()
25869 
    oprot.writeFieldStop()
25870 
    oprot.writeStructEnd()
25871 
 
25872 
  def validate(self):
25873 
    return
25874 
 
25875 
 
25876 
  def __repr__(self):
25877 
    L = ['%s=%r' % (key, value)
25878 
      for key, value in self.__dict__.iteritems()]
25879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25880 
 
25881 
  def __eq__(self, other):
25882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25883 
 
25884 
  def __ne__(self, other):
25885 
    return not (self == other)
25886 
 
25887 
class updateOrderAsPaidToVendor_result:
25888 
  """
25889 
  Attributes:
25890 
   - ex
25891 
  """
25892 
 
25893 
  thrift_spec = (
25894 
    None, # 0
25895 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25896 
  )
25897 
 
25898 
  def __init__(self, ex=None,):
25899 
    self.ex = ex
25900 
 
25901 
  def read(self, iprot):
25902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25904 
      return
25905 
    iprot.readStructBegin()
25906 
    while True:
25907 
      (fname, ftype, fid) = iprot.readFieldBegin()
25908 
      if ftype == TType.STOP:
25909 
        break
25910 
      if fid == 1:
25911 
        if ftype == TType.STRUCT:
25912 
          self.ex = TransactionServiceException()
25913 
          self.ex.read(iprot)
25914 
        else:
25915 
          iprot.skip(ftype)
25916 
      else:
25917 
        iprot.skip(ftype)
25918 
      iprot.readFieldEnd()
25919 
    iprot.readStructEnd()
25920 
 
25921 
  def write(self, oprot):
25922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25924 
      return
25925 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
25926 
    if self.ex is not None:
25927 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25928 
      self.ex.write(oprot)
25929 
      oprot.writeFieldEnd()
25930 
    oprot.writeFieldStop()
25931 
    oprot.writeStructEnd()
25932 
 
25933 
  def validate(self):
25934 
    return
25935 
 
25936 
 
25937 
  def __repr__(self):
25938 
    L = ['%s=%r' % (key, value)
25939 
      for key, value in self.__dict__.iteritems()]
25940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25941 
 
25942 
  def __eq__(self, other):
25943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25944 
 
25945 
  def __ne__(self, other):
25946 
    return not (self == other)
5208 varun.gupt 25947 
 
5386 phani.kuma 25948 
class updateOrderOnlyAsPaidToVendor_args:
25949 
  """
25950 
  Attributes:
25951 
   - orderId
25952 
  """
25953 
 
25954 
  thrift_spec = (
25955 
    None, # 0
25956 
    (1, TType.I64, 'orderId', None, None, ), # 1
25957 
  )
25958 
 
25959 
  def __init__(self, orderId=None,):
25960 
    self.orderId = orderId
25961 
 
25962 
  def read(self, iprot):
25963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25965 
      return
25966 
    iprot.readStructBegin()
25967 
    while True:
25968 
      (fname, ftype, fid) = iprot.readFieldBegin()
25969 
      if ftype == TType.STOP:
25970 
        break
25971 
      if fid == 1:
25972 
        if ftype == TType.I64:
25973 
          self.orderId = iprot.readI64();
25974 
        else:
25975 
          iprot.skip(ftype)
25976 
      else:
25977 
        iprot.skip(ftype)
25978 
      iprot.readFieldEnd()
25979 
    iprot.readStructEnd()
25980 
 
25981 
  def write(self, oprot):
25982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25984 
      return
25985 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
25986 
    if self.orderId is not None:
25987 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25988 
      oprot.writeI64(self.orderId)
25989 
      oprot.writeFieldEnd()
25990 
    oprot.writeFieldStop()
25991 
    oprot.writeStructEnd()
25992 
 
25993 
  def validate(self):
25994 
    return
25995 
 
25996 
 
25997 
  def __repr__(self):
25998 
    L = ['%s=%r' % (key, value)
25999 
      for key, value in self.__dict__.iteritems()]
26000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26001 
 
26002 
  def __eq__(self, other):
26003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26004 
 
26005 
  def __ne__(self, other):
26006 
    return not (self == other)
26007 
 
26008 
class updateOrderOnlyAsPaidToVendor_result:
26009 
  """
26010 
  Attributes:
26011 
   - ex
26012 
  """
26013 
 
26014 
  thrift_spec = (
26015 
    None, # 0
26016 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26017 
  )
26018 
 
26019 
  def __init__(self, ex=None,):
26020 
    self.ex = ex
26021 
 
26022 
  def read(self, iprot):
26023 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26024 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26025 
      return
26026 
    iprot.readStructBegin()
26027 
    while True:
26028 
      (fname, ftype, fid) = iprot.readFieldBegin()
26029 
      if ftype == TType.STOP:
26030 
        break
26031 
      if fid == 1:
26032 
        if ftype == TType.STRUCT:
26033 
          self.ex = TransactionServiceException()
26034 
          self.ex.read(iprot)
26035 
        else:
26036 
          iprot.skip(ftype)
26037 
      else:
26038 
        iprot.skip(ftype)
26039 
      iprot.readFieldEnd()
26040 
    iprot.readStructEnd()
26041 
 
26042 
  def write(self, oprot):
26043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26045 
      return
26046 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
26047 
    if self.ex is not None:
26048 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26049 
      self.ex.write(oprot)
26050 
      oprot.writeFieldEnd()
26051 
    oprot.writeFieldStop()
26052 
    oprot.writeStructEnd()
26053 
 
26054 
  def validate(self):
26055 
    return
26056 
 
26057 
 
26058 
  def __repr__(self):
26059 
    L = ['%s=%r' % (key, value)
26060 
      for key, value in self.__dict__.iteritems()]
26061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26062 
 
26063 
  def __eq__(self, other):
26064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26065 
 
26066 
  def __ne__(self, other):
26067 
    return not (self == other)
26068 
 
5208 varun.gupt 26069 
class getRefundedOrdersMarkedPaid_args:
26070 
 
26071 
  thrift_spec = (
26072 
  )
26073 
 
26074 
  def read(self, iprot):
26075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26077 
      return
26078 
    iprot.readStructBegin()
26079 
    while True:
26080 
      (fname, ftype, fid) = iprot.readFieldBegin()
26081 
      if ftype == TType.STOP:
26082 
        break
26083 
      else:
26084 
        iprot.skip(ftype)
26085 
      iprot.readFieldEnd()
26086 
    iprot.readStructEnd()
26087 
 
26088 
  def write(self, oprot):
26089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26091 
      return
26092 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
26093 
    oprot.writeFieldStop()
26094 
    oprot.writeStructEnd()
26095 
 
26096 
  def validate(self):
26097 
    return
26098 
 
26099 
 
26100 
  def __repr__(self):
26101 
    L = ['%s=%r' % (key, value)
26102 
      for key, value in self.__dict__.iteritems()]
26103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26104 
 
26105 
  def __eq__(self, other):
26106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26107 
 
26108 
  def __ne__(self, other):
26109 
    return not (self == other)
26110 
 
26111 
class getRefundedOrdersMarkedPaid_result:
26112 
  """
26113 
  Attributes:
26114 
   - success
26115 
   - ex
26116 
  """
26117 
 
26118 
  thrift_spec = (
26119 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26120 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26121 
  )
26122 
 
26123 
  def __init__(self, success=None, ex=None,):
26124 
    self.success = success
26125 
    self.ex = ex
26126 
 
26127 
  def read(self, iprot):
26128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26130 
      return
26131 
    iprot.readStructBegin()
26132 
    while True:
26133 
      (fname, ftype, fid) = iprot.readFieldBegin()
26134 
      if ftype == TType.STOP:
26135 
        break
26136 
      if fid == 0:
26137 
        if ftype == TType.LIST:
26138 
          self.success = []
6188 rajveer 26139 
          (_etype610, _size607) = iprot.readListBegin()
26140 
          for _i611 in xrange(_size607):
26141 
            _elem612 = Order()
26142 
            _elem612.read(iprot)
26143 
            self.success.append(_elem612)
5208 varun.gupt 26144 
          iprot.readListEnd()
26145 
        else:
26146 
          iprot.skip(ftype)
26147 
      elif fid == 1:
26148 
        if ftype == TType.STRUCT:
26149 
          self.ex = TransactionServiceException()
26150 
          self.ex.read(iprot)
26151 
        else:
26152 
          iprot.skip(ftype)
26153 
      else:
26154 
        iprot.skip(ftype)
26155 
      iprot.readFieldEnd()
26156 
    iprot.readStructEnd()
26157 
 
26158 
  def write(self, oprot):
26159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26161 
      return
26162 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
26163 
    if self.success is not None:
26164 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26165 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26166 
      for iter613 in self.success:
26167 
        iter613.write(oprot)
5208 varun.gupt 26168 
      oprot.writeListEnd()
26169 
      oprot.writeFieldEnd()
26170 
    if self.ex is not None:
26171 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26172 
      self.ex.write(oprot)
26173 
      oprot.writeFieldEnd()
26174 
    oprot.writeFieldStop()
26175 
    oprot.writeStructEnd()
26176 
 
26177 
  def validate(self):
26178 
    return
26179 
 
26180 
 
26181 
  def __repr__(self):
26182 
    L = ['%s=%r' % (key, value)
26183 
      for key, value in self.__dict__.iteritems()]
26184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26185 
 
26186 
  def __eq__(self, other):
26187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26188 
 
26189 
  def __ne__(self, other):
26190 
    return not (self == other)
5447 anupam.sin 26191 
 
26192 
class getAllVerificationAgents_args:
26193 
  """
26194 
  Attributes:
26195 
   - minOrderId
26196 
   - maxOrderId
26197 
  """
26198 
 
26199 
  thrift_spec = (
26200 
    None, # 0
26201 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
26202 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
26203 
  )
26204 
 
26205 
  def __init__(self, minOrderId=None, maxOrderId=None,):
26206 
    self.minOrderId = minOrderId
26207 
    self.maxOrderId = maxOrderId
26208 
 
26209 
  def read(self, iprot):
26210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26212 
      return
26213 
    iprot.readStructBegin()
26214 
    while True:
26215 
      (fname, ftype, fid) = iprot.readFieldBegin()
26216 
      if ftype == TType.STOP:
26217 
        break
26218 
      if fid == 1:
26219 
        if ftype == TType.I64:
26220 
          self.minOrderId = iprot.readI64();
26221 
        else:
26222 
          iprot.skip(ftype)
26223 
      elif fid == 2:
26224 
        if ftype == TType.I64:
26225 
          self.maxOrderId = iprot.readI64();
26226 
        else:
26227 
          iprot.skip(ftype)
26228 
      else:
26229 
        iprot.skip(ftype)
26230 
      iprot.readFieldEnd()
26231 
    iprot.readStructEnd()
26232 
 
26233 
  def write(self, oprot):
26234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26236 
      return
26237 
    oprot.writeStructBegin('getAllVerificationAgents_args')
26238 
    if self.minOrderId is not None:
26239 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
26240 
      oprot.writeI64(self.minOrderId)
26241 
      oprot.writeFieldEnd()
26242 
    if self.maxOrderId is not None:
26243 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
26244 
      oprot.writeI64(self.maxOrderId)
26245 
      oprot.writeFieldEnd()
26246 
    oprot.writeFieldStop()
26247 
    oprot.writeStructEnd()
26248 
 
26249 
  def validate(self):
26250 
    return
26251 
 
26252 
 
26253 
  def __repr__(self):
26254 
    L = ['%s=%r' % (key, value)
26255 
      for key, value in self.__dict__.iteritems()]
26256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26257 
 
26258 
  def __eq__(self, other):
26259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26260 
 
26261 
  def __ne__(self, other):
26262 
    return not (self == other)
26263 
 
26264 
class getAllVerificationAgents_result:
26265 
  """
26266 
  Attributes:
26267 
   - success
26268 
  """
26269 
 
26270 
  thrift_spec = (
26271 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
26272 
  )
26273 
 
26274 
  def __init__(self, success=None,):
26275 
    self.success = success
26276 
 
26277 
  def read(self, iprot):
26278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26280 
      return
26281 
    iprot.readStructBegin()
26282 
    while True:
26283 
      (fname, ftype, fid) = iprot.readFieldBegin()
26284 
      if ftype == TType.STOP:
26285 
        break
26286 
      if fid == 0:
26287 
        if ftype == TType.LIST:
26288 
          self.success = []
6188 rajveer 26289 
          (_etype617, _size614) = iprot.readListBegin()
26290 
          for _i618 in xrange(_size614):
26291 
            _elem619 = CODVerificationAgent()
26292 
            _elem619.read(iprot)
26293 
            self.success.append(_elem619)
5447 anupam.sin 26294 
          iprot.readListEnd()
26295 
        else:
26296 
          iprot.skip(ftype)
26297 
      else:
26298 
        iprot.skip(ftype)
26299 
      iprot.readFieldEnd()
26300 
    iprot.readStructEnd()
26301 
 
26302 
  def write(self, oprot):
26303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26305 
      return
26306 
    oprot.writeStructBegin('getAllVerificationAgents_result')
26307 
    if self.success is not None:
26308 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26309 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26310 
      for iter620 in self.success:
26311 
        iter620.write(oprot)
5447 anupam.sin 26312 
      oprot.writeListEnd()
26313 
      oprot.writeFieldEnd()
26314 
    oprot.writeFieldStop()
26315 
    oprot.writeStructEnd()
26316 
 
26317 
  def validate(self):
26318 
    return
26319 
 
26320 
 
26321 
  def __repr__(self):
26322 
    L = ['%s=%r' % (key, value)
26323 
      for key, value in self.__dict__.iteritems()]
26324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26325 
 
26326 
  def __eq__(self, other):
26327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26328 
 
26329 
  def __ne__(self, other):
26330 
    return not (self == other)
5527 anupam.sin 26331 
 
26332 
class getAllAttributesForOrderId_args:
26333 
  """
26334 
  Attributes:
26335 
   - orderId
26336 
  """
26337 
 
26338 
  thrift_spec = (
26339 
    None, # 0
26340 
    (1, TType.I64, 'orderId', None, None, ), # 1
26341 
  )
26342 
 
26343 
  def __init__(self, orderId=None,):
26344 
    self.orderId = orderId
26345 
 
26346 
  def read(self, iprot):
26347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26349 
      return
26350 
    iprot.readStructBegin()
26351 
    while True:
26352 
      (fname, ftype, fid) = iprot.readFieldBegin()
26353 
      if ftype == TType.STOP:
26354 
        break
26355 
      if fid == 1:
26356 
        if ftype == TType.I64:
26357 
          self.orderId = iprot.readI64();
26358 
        else:
26359 
          iprot.skip(ftype)
26360 
      else:
26361 
        iprot.skip(ftype)
26362 
      iprot.readFieldEnd()
26363 
    iprot.readStructEnd()
26364 
 
26365 
  def write(self, oprot):
26366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26368 
      return
26369 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
26370 
    if self.orderId is not None:
26371 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26372 
      oprot.writeI64(self.orderId)
26373 
      oprot.writeFieldEnd()
26374 
    oprot.writeFieldStop()
26375 
    oprot.writeStructEnd()
26376 
 
26377 
  def validate(self):
26378 
    return
26379 
 
26380 
 
26381 
  def __repr__(self):
26382 
    L = ['%s=%r' % (key, value)
26383 
      for key, value in self.__dict__.iteritems()]
26384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26385 
 
26386 
  def __eq__(self, other):
26387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26388 
 
26389 
  def __ne__(self, other):
26390 
    return not (self == other)
26391 
 
26392 
class getAllAttributesForOrderId_result:
26393 
  """
26394 
  Attributes:
26395 
   - success
26396 
  """
26397 
 
26398 
  thrift_spec = (
26399 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
26400 
  )
26401 
 
26402 
  def __init__(self, success=None,):
26403 
    self.success = success
26404 
 
26405 
  def read(self, iprot):
26406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26408 
      return
26409 
    iprot.readStructBegin()
26410 
    while True:
26411 
      (fname, ftype, fid) = iprot.readFieldBegin()
26412 
      if ftype == TType.STOP:
26413 
        break
26414 
      if fid == 0:
26415 
        if ftype == TType.LIST:
26416 
          self.success = []
6188 rajveer 26417 
          (_etype624, _size621) = iprot.readListBegin()
26418 
          for _i625 in xrange(_size621):
26419 
            _elem626 = Attribute()
26420 
            _elem626.read(iprot)
26421 
            self.success.append(_elem626)
5527 anupam.sin 26422 
          iprot.readListEnd()
26423 
        else:
26424 
          iprot.skip(ftype)
26425 
      else:
26426 
        iprot.skip(ftype)
26427 
      iprot.readFieldEnd()
26428 
    iprot.readStructEnd()
26429 
 
26430 
  def write(self, oprot):
26431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26433 
      return
26434 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
26435 
    if self.success is not None:
26436 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26437 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26438 
      for iter627 in self.success:
26439 
        iter627.write(oprot)
5527 anupam.sin 26440 
      oprot.writeListEnd()
26441 
      oprot.writeFieldEnd()
26442 
    oprot.writeFieldStop()
26443 
    oprot.writeStructEnd()
26444 
 
26445 
  def validate(self):
26446 
    return
26447 
 
26448 
 
26449 
  def __repr__(self):
26450 
    L = ['%s=%r' % (key, value)
26451 
      for key, value in self.__dict__.iteritems()]
26452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26453 
 
26454 
  def __eq__(self, other):
26455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26456 
 
26457 
  def __ne__(self, other):
26458 
    return not (self == other)
26459 
 
5676 rajveer 26460 
class setOrderAttributes_args:
26461 
  """
26462 
  Attributes:
26463 
   - orderId
26464 
   - attributes
26465 
  """
26466 
 
26467 
  thrift_spec = None
26468 
  def __init__(self, orderId=None, attributes=None,):
26469 
    self.orderId = orderId
26470 
    self.attributes = attributes
26471 
 
26472 
  def read(self, iprot):
26473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26475 
      return
26476 
    iprot.readStructBegin()
26477 
    while True:
26478 
      (fname, ftype, fid) = iprot.readFieldBegin()
26479 
      if ftype == TType.STOP:
26480 
        break
26481 
      if fid == 1:
26482 
        if ftype == TType.I64:
26483 
          self.orderId = iprot.readI64();
26484 
        else:
26485 
          iprot.skip(ftype)
26486 
      elif fid == -1:
26487 
        if ftype == TType.LIST:
26488 
          self.attributes = []
6188 rajveer 26489 
          (_etype631, _size628) = iprot.readListBegin()
26490 
          for _i632 in xrange(_size628):
26491 
            _elem633 = Attribute()
26492 
            _elem633.read(iprot)
26493 
            self.attributes.append(_elem633)
5676 rajveer 26494 
          iprot.readListEnd()
26495 
        else:
26496 
          iprot.skip(ftype)
26497 
      else:
26498 
        iprot.skip(ftype)
26499 
      iprot.readFieldEnd()
26500 
    iprot.readStructEnd()
26501 
 
26502 
  def write(self, oprot):
26503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26505 
      return
26506 
    oprot.writeStructBegin('setOrderAttributes_args')
26507 
    if self.attributes is not None:
26508 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
26509 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 26510 
      for iter634 in self.attributes:
26511 
        iter634.write(oprot)
5676 rajveer 26512 
      oprot.writeListEnd()
26513 
      oprot.writeFieldEnd()
26514 
    if self.orderId is not None:
26515 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26516 
      oprot.writeI64(self.orderId)
26517 
      oprot.writeFieldEnd()
26518 
    oprot.writeFieldStop()
26519 
    oprot.writeStructEnd()
26520 
 
26521 
  def validate(self):
26522 
    return
26523 
 
26524 
 
26525 
  def __repr__(self):
26526 
    L = ['%s=%r' % (key, value)
26527 
      for key, value in self.__dict__.iteritems()]
26528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26529 
 
26530 
  def __eq__(self, other):
26531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26532 
 
26533 
  def __ne__(self, other):
26534 
    return not (self == other)
26535 
 
26536 
class setOrderAttributes_result:
26537 
 
26538 
  thrift_spec = (
26539 
  )
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 
      else:
26551 
        iprot.skip(ftype)
26552 
      iprot.readFieldEnd()
26553 
    iprot.readStructEnd()
26554 
 
26555 
  def write(self, oprot):
26556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26558 
      return
26559 
    oprot.writeStructBegin('setOrderAttributes_result')
26560 
    oprot.writeFieldStop()
26561 
    oprot.writeStructEnd()
26562 
 
26563 
  def validate(self):
26564 
    return
26565 
 
26566 
 
26567 
  def __repr__(self):
26568 
    L = ['%s=%r' % (key, value)
26569 
      for key, value in self.__dict__.iteritems()]
26570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26571 
 
26572 
  def __eq__(self, other):
26573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26574 
 
26575 
  def __ne__(self, other):
26576 
    return not (self == other)
26577 
 
5527 anupam.sin 26578 
class setOrderAttributeForTransaction_args:
26579 
  """
26580 
  Attributes:
26581 
   - transactionId
26582 
   - attribute
26583 
  """
26584 
 
26585 
  thrift_spec = None
26586 
  def __init__(self, transactionId=None, attribute=None,):
26587 
    self.transactionId = transactionId
26588 
    self.attribute = attribute
26589 
 
26590 
  def read(self, iprot):
26591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26593 
      return
26594 
    iprot.readStructBegin()
26595 
    while True:
26596 
      (fname, ftype, fid) = iprot.readFieldBegin()
26597 
      if ftype == TType.STOP:
26598 
        break
26599 
      if fid == 1:
26600 
        if ftype == TType.I64:
26601 
          self.transactionId = iprot.readI64();
26602 
        else:
26603 
          iprot.skip(ftype)
26604 
      elif fid == -1:
26605 
        if ftype == TType.STRUCT:
26606 
          self.attribute = Attribute()
26607 
          self.attribute.read(iprot)
26608 
        else:
26609 
          iprot.skip(ftype)
26610 
      else:
26611 
        iprot.skip(ftype)
26612 
      iprot.readFieldEnd()
26613 
    iprot.readStructEnd()
26614 
 
26615 
  def write(self, oprot):
26616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26618 
      return
26619 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
26620 
    if self.attribute is not None:
26621 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
26622 
      self.attribute.write(oprot)
26623 
      oprot.writeFieldEnd()
26624 
    if self.transactionId is not None:
26625 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
26626 
      oprot.writeI64(self.transactionId)
26627 
      oprot.writeFieldEnd()
26628 
    oprot.writeFieldStop()
26629 
    oprot.writeStructEnd()
26630 
 
26631 
  def validate(self):
26632 
    return
26633 
 
26634 
 
26635 
  def __repr__(self):
26636 
    L = ['%s=%r' % (key, value)
26637 
      for key, value in self.__dict__.iteritems()]
26638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26639 
 
26640 
  def __eq__(self, other):
26641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26642 
 
26643 
  def __ne__(self, other):
26644 
    return not (self == other)
26645 
 
26646 
class setOrderAttributeForTransaction_result:
26647 
 
26648 
  thrift_spec = (
26649 
  )
26650 
 
26651 
  def read(self, iprot):
26652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26654 
      return
26655 
    iprot.readStructBegin()
26656 
    while True:
26657 
      (fname, ftype, fid) = iprot.readFieldBegin()
26658 
      if ftype == TType.STOP:
26659 
        break
26660 
      else:
26661 
        iprot.skip(ftype)
26662 
      iprot.readFieldEnd()
26663 
    iprot.readStructEnd()
26664 
 
26665 
  def write(self, oprot):
26666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26668 
      return
26669 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
26670 
    oprot.writeFieldStop()
26671 
    oprot.writeStructEnd()
26672 
 
26673 
  def validate(self):
26674 
    return
26675 
 
26676 
 
26677 
  def __repr__(self):
26678 
    L = ['%s=%r' % (key, value)
26679 
      for key, value in self.__dict__.iteritems()]
26680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26681 
 
26682 
  def __eq__(self, other):
26683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26684 
 
26685 
  def __ne__(self, other):
26686 
    return not (self == other)
5553 rajveer 26687 
 
26688 
class getReceivePendingOrders_args:
26689 
  """
26690 
  Attributes:
26691 
   - storeId
26692 
  """
26693 
 
26694 
  thrift_spec = (
26695 
    None, # 0
26696 
    (1, TType.I64, 'storeId', None, None, ), # 1
26697 
  )
26698 
 
26699 
  def __init__(self, storeId=None,):
26700 
    self.storeId = storeId
26701 
 
26702 
  def read(self, iprot):
26703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26705 
      return
26706 
    iprot.readStructBegin()
26707 
    while True:
26708 
      (fname, ftype, fid) = iprot.readFieldBegin()
26709 
      if ftype == TType.STOP:
26710 
        break
26711 
      if fid == 1:
26712 
        if ftype == TType.I64:
26713 
          self.storeId = iprot.readI64();
26714 
        else:
26715 
          iprot.skip(ftype)
26716 
      else:
26717 
        iprot.skip(ftype)
26718 
      iprot.readFieldEnd()
26719 
    iprot.readStructEnd()
26720 
 
26721 
  def write(self, oprot):
26722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26724 
      return
26725 
    oprot.writeStructBegin('getReceivePendingOrders_args')
26726 
    if self.storeId is not None:
26727 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26728 
      oprot.writeI64(self.storeId)
26729 
      oprot.writeFieldEnd()
26730 
    oprot.writeFieldStop()
26731 
    oprot.writeStructEnd()
26732 
 
26733 
  def validate(self):
26734 
    return
26735 
 
26736 
 
26737 
  def __repr__(self):
26738 
    L = ['%s=%r' % (key, value)
26739 
      for key, value in self.__dict__.iteritems()]
26740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26741 
 
26742 
  def __eq__(self, other):
26743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26744 
 
26745 
  def __ne__(self, other):
26746 
    return not (self == other)
26747 
 
26748 
class getReceivePendingOrders_result:
26749 
  """
26750 
  Attributes:
26751 
   - success
26752 
  """
26753 
 
26754 
  thrift_spec = (
26755 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26756 
  )
26757 
 
26758 
  def __init__(self, success=None,):
26759 
    self.success = success
26760 
 
26761 
  def read(self, iprot):
26762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26764 
      return
26765 
    iprot.readStructBegin()
26766 
    while True:
26767 
      (fname, ftype, fid) = iprot.readFieldBegin()
26768 
      if ftype == TType.STOP:
26769 
        break
26770 
      if fid == 0:
26771 
        if ftype == TType.LIST:
26772 
          self.success = []
6188 rajveer 26773 
          (_etype638, _size635) = iprot.readListBegin()
26774 
          for _i639 in xrange(_size635):
26775 
            _elem640 = Order()
26776 
            _elem640.read(iprot)
26777 
            self.success.append(_elem640)
5553 rajveer 26778 
          iprot.readListEnd()
26779 
        else:
26780 
          iprot.skip(ftype)
26781 
      else:
26782 
        iprot.skip(ftype)
26783 
      iprot.readFieldEnd()
26784 
    iprot.readStructEnd()
26785 
 
26786 
  def write(self, oprot):
26787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26789 
      return
26790 
    oprot.writeStructBegin('getReceivePendingOrders_result')
26791 
    if self.success is not None:
26792 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26793 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26794 
      for iter641 in self.success:
26795 
        iter641.write(oprot)
5553 rajveer 26796 
      oprot.writeListEnd()
26797 
      oprot.writeFieldEnd()
26798 
    oprot.writeFieldStop()
26799 
    oprot.writeStructEnd()
26800 
 
26801 
  def validate(self):
26802 
    return
26803 
 
26804 
 
26805 
  def __repr__(self):
26806 
    L = ['%s=%r' % (key, value)
26807 
      for key, value in self.__dict__.iteritems()]
26808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26809 
 
26810 
  def __eq__(self, other):
26811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26812 
 
26813 
  def __ne__(self, other):
26814 
    return not (self == other)
26815 
 
26816 
class getReceivedAtStoreOrders_args:
26817 
  """
26818 
  Attributes:
26819 
   - storeId
26820 
  """
26821 
 
26822 
  thrift_spec = (
26823 
    None, # 0
26824 
    (1, TType.I64, 'storeId', None, None, ), # 1
26825 
  )
26826 
 
26827 
  def __init__(self, storeId=None,):
26828 
    self.storeId = storeId
26829 
 
26830 
  def read(self, iprot):
26831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26833 
      return
26834 
    iprot.readStructBegin()
26835 
    while True:
26836 
      (fname, ftype, fid) = iprot.readFieldBegin()
26837 
      if ftype == TType.STOP:
26838 
        break
26839 
      if fid == 1:
26840 
        if ftype == TType.I64:
26841 
          self.storeId = iprot.readI64();
26842 
        else:
26843 
          iprot.skip(ftype)
26844 
      else:
26845 
        iprot.skip(ftype)
26846 
      iprot.readFieldEnd()
26847 
    iprot.readStructEnd()
26848 
 
26849 
  def write(self, oprot):
26850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26852 
      return
26853 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
26854 
    if self.storeId is not None:
26855 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26856 
      oprot.writeI64(self.storeId)
26857 
      oprot.writeFieldEnd()
26858 
    oprot.writeFieldStop()
26859 
    oprot.writeStructEnd()
26860 
 
26861 
  def validate(self):
26862 
    return
26863 
 
26864 
 
26865 
  def __repr__(self):
26866 
    L = ['%s=%r' % (key, value)
26867 
      for key, value in self.__dict__.iteritems()]
26868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26869 
 
26870 
  def __eq__(self, other):
26871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26872 
 
26873 
  def __ne__(self, other):
26874 
    return not (self == other)
26875 
 
26876 
class getReceivedAtStoreOrders_result:
26877 
  """
26878 
  Attributes:
26879 
   - success
26880 
  """
26881 
 
26882 
  thrift_spec = (
26883 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26884 
  )
26885 
 
26886 
  def __init__(self, success=None,):
26887 
    self.success = success
26888 
 
26889 
  def read(self, iprot):
26890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26892 
      return
26893 
    iprot.readStructBegin()
26894 
    while True:
26895 
      (fname, ftype, fid) = iprot.readFieldBegin()
26896 
      if ftype == TType.STOP:
26897 
        break
26898 
      if fid == 0:
26899 
        if ftype == TType.LIST:
26900 
          self.success = []
6188 rajveer 26901 
          (_etype645, _size642) = iprot.readListBegin()
26902 
          for _i646 in xrange(_size642):
26903 
            _elem647 = Order()
26904 
            _elem647.read(iprot)
26905 
            self.success.append(_elem647)
5553 rajveer 26906 
          iprot.readListEnd()
26907 
        else:
26908 
          iprot.skip(ftype)
26909 
      else:
26910 
        iprot.skip(ftype)
26911 
      iprot.readFieldEnd()
26912 
    iprot.readStructEnd()
26913 
 
26914 
  def write(self, oprot):
26915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26917 
      return
26918 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
26919 
    if self.success is not None:
26920 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26921 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26922 
      for iter648 in self.success:
26923 
        iter648.write(oprot)
5553 rajveer 26924 
      oprot.writeListEnd()
26925 
      oprot.writeFieldEnd()
26926 
    oprot.writeFieldStop()
26927 
    oprot.writeStructEnd()
26928 
 
26929 
  def validate(self):
26930 
    return
26931 
 
26932 
 
26933 
  def __repr__(self):
26934 
    L = ['%s=%r' % (key, value)
26935 
      for key, value in self.__dict__.iteritems()]
26936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26937 
 
26938 
  def __eq__(self, other):
26939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26940 
 
26941 
  def __ne__(self, other):
26942 
    return not (self == other)
5593 mandeep.dh 26943 
 
5713 rajveer 26944 
class getOrdersCollectionAtStore_args:
26945 
  """
26946 
  Attributes:
26947 
   - storeId
26948 
   - fromDate
26949 
   - toDate
26950 
   - onlyCod
26951 
  """
26952 
 
26953 
  thrift_spec = (
26954 
    None, # 0
26955 
    (1, TType.I64, 'storeId', None, None, ), # 1
26956 
    (2, TType.I64, 'fromDate', None, None, ), # 2
26957 
    (3, TType.I64, 'toDate', None, None, ), # 3
26958 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
26959 
  )
26960 
 
26961 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
26962 
    self.storeId = storeId
26963 
    self.fromDate = fromDate
26964 
    self.toDate = toDate
26965 
    self.onlyCod = onlyCod
26966 
 
26967 
  def read(self, iprot):
26968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26970 
      return
26971 
    iprot.readStructBegin()
26972 
    while True:
26973 
      (fname, ftype, fid) = iprot.readFieldBegin()
26974 
      if ftype == TType.STOP:
26975 
        break
26976 
      if fid == 1:
26977 
        if ftype == TType.I64:
26978 
          self.storeId = iprot.readI64();
26979 
        else:
26980 
          iprot.skip(ftype)
26981 
      elif fid == 2:
26982 
        if ftype == TType.I64:
26983 
          self.fromDate = iprot.readI64();
26984 
        else:
26985 
          iprot.skip(ftype)
26986 
      elif fid == 3:
26987 
        if ftype == TType.I64:
26988 
          self.toDate = iprot.readI64();
26989 
        else:
26990 
          iprot.skip(ftype)
26991 
      elif fid == 4:
26992 
        if ftype == TType.BOOL:
26993 
          self.onlyCod = iprot.readBool();
26994 
        else:
26995 
          iprot.skip(ftype)
26996 
      else:
26997 
        iprot.skip(ftype)
26998 
      iprot.readFieldEnd()
26999 
    iprot.readStructEnd()
27000 
 
27001 
  def write(self, oprot):
27002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27004 
      return
27005 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
27006 
    if self.storeId is not None:
27007 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
27008 
      oprot.writeI64(self.storeId)
27009 
      oprot.writeFieldEnd()
27010 
    if self.fromDate is not None:
27011 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
27012 
      oprot.writeI64(self.fromDate)
27013 
      oprot.writeFieldEnd()
27014 
    if self.toDate is not None:
27015 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
27016 
      oprot.writeI64(self.toDate)
27017 
      oprot.writeFieldEnd()
27018 
    if self.onlyCod is not None:
27019 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
27020 
      oprot.writeBool(self.onlyCod)
27021 
      oprot.writeFieldEnd()
27022 
    oprot.writeFieldStop()
27023 
    oprot.writeStructEnd()
27024 
 
27025 
  def validate(self):
27026 
    return
27027 
 
27028 
 
27029 
  def __repr__(self):
27030 
    L = ['%s=%r' % (key, value)
27031 
      for key, value in self.__dict__.iteritems()]
27032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27033 
 
27034 
  def __eq__(self, other):
27035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27036 
 
27037 
  def __ne__(self, other):
27038 
    return not (self == other)
27039 
 
27040 
class getOrdersCollectionAtStore_result:
27041 
  """
27042 
  Attributes:
27043 
   - success
27044 
  """
27045 
 
27046 
  thrift_spec = (
27047 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
27048 
  )
27049 
 
27050 
  def __init__(self, success=None,):
27051 
    self.success = success
27052 
 
27053 
  def read(self, iprot):
27054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27056 
      return
27057 
    iprot.readStructBegin()
27058 
    while True:
27059 
      (fname, ftype, fid) = iprot.readFieldBegin()
27060 
      if ftype == TType.STOP:
27061 
        break
27062 
      if fid == 0:
27063 
        if ftype == TType.LIST:
27064 
          self.success = []
6188 rajveer 27065 
          (_etype652, _size649) = iprot.readListBegin()
27066 
          for _i653 in xrange(_size649):
27067 
            _elem654 = Order()
27068 
            _elem654.read(iprot)
27069 
            self.success.append(_elem654)
5713 rajveer 27070 
          iprot.readListEnd()
27071 
        else:
27072 
          iprot.skip(ftype)
27073 
      else:
27074 
        iprot.skip(ftype)
27075 
      iprot.readFieldEnd()
27076 
    iprot.readStructEnd()
27077 
 
27078 
  def write(self, oprot):
27079 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27080 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27081 
      return
27082 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
27083 
    if self.success is not None:
27084 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27085 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27086 
      for iter655 in self.success:
27087 
        iter655.write(oprot)
5713 rajveer 27088 
      oprot.writeListEnd()
27089 
      oprot.writeFieldEnd()
27090 
    oprot.writeFieldStop()
27091 
    oprot.writeStructEnd()
27092 
 
27093 
  def validate(self):
27094 
    return
27095 
 
27096 
 
27097 
  def __repr__(self):
27098 
    L = ['%s=%r' % (key, value)
27099 
      for key, value in self.__dict__.iteritems()]
27100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27101 
 
27102 
  def __eq__(self, other):
27103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27104 
 
27105 
  def __ne__(self, other):
27106 
    return not (self == other)
27107 
 
5833 rajveer 27108 
class getOrderAttributeValue_args:
27109 
  """
27110 
  Attributes:
27111 
   - orderId
27112 
   - attributeName
27113 
  """
27114 
 
27115 
  thrift_spec = None
27116 
  def __init__(self, orderId=None, attributeName=None,):
27117 
    self.orderId = orderId
27118 
    self.attributeName = attributeName
27119 
 
27120 
  def read(self, iprot):
27121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27123 
      return
27124 
    iprot.readStructBegin()
27125 
    while True:
27126 
      (fname, ftype, fid) = iprot.readFieldBegin()
27127 
      if ftype == TType.STOP:
27128 
        break
27129 
      if fid == 1:
27130 
        if ftype == TType.I64:
27131 
          self.orderId = iprot.readI64();
27132 
        else:
27133 
          iprot.skip(ftype)
27134 
      elif fid == -1:
27135 
        if ftype == TType.STRING:
27136 
          self.attributeName = iprot.readString();
27137 
        else:
27138 
          iprot.skip(ftype)
27139 
      else:
27140 
        iprot.skip(ftype)
27141 
      iprot.readFieldEnd()
27142 
    iprot.readStructEnd()
27143 
 
27144 
  def write(self, oprot):
27145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27147 
      return
27148 
    oprot.writeStructBegin('getOrderAttributeValue_args')
27149 
    if self.attributeName is not None:
27150 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
27151 
      oprot.writeString(self.attributeName)
27152 
      oprot.writeFieldEnd()
27153 
    if self.orderId is not None:
27154 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27155 
      oprot.writeI64(self.orderId)
27156 
      oprot.writeFieldEnd()
27157 
    oprot.writeFieldStop()
27158 
    oprot.writeStructEnd()
27159 
 
27160 
  def validate(self):
27161 
    return
27162 
 
27163 
 
27164 
  def __repr__(self):
27165 
    L = ['%s=%r' % (key, value)
27166 
      for key, value in self.__dict__.iteritems()]
27167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27168 
 
27169 
  def __eq__(self, other):
27170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27171 
 
27172 
  def __ne__(self, other):
27173 
    return not (self == other)
27174 
 
27175 
class getOrderAttributeValue_result:
27176 
  """
27177 
  Attributes:
27178 
   - success
27179 
  """
27180 
 
27181 
  thrift_spec = (
27182 
    (0, TType.STRING, 'success', None, None, ), # 0
27183 
  )
27184 
 
27185 
  def __init__(self, success=None,):
27186 
    self.success = success
27187 
 
27188 
  def read(self, iprot):
27189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27191 
      return
27192 
    iprot.readStructBegin()
27193 
    while True:
27194 
      (fname, ftype, fid) = iprot.readFieldBegin()
27195 
      if ftype == TType.STOP:
27196 
        break
27197 
      if fid == 0:
27198 
        if ftype == TType.STRING:
27199 
          self.success = iprot.readString();
27200 
        else:
27201 
          iprot.skip(ftype)
27202 
      else:
27203 
        iprot.skip(ftype)
27204 
      iprot.readFieldEnd()
27205 
    iprot.readStructEnd()
27206 
 
27207 
  def write(self, oprot):
27208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27210 
      return
27211 
    oprot.writeStructBegin('getOrderAttributeValue_result')
27212 
    if self.success is not None:
27213 
      oprot.writeFieldBegin('success', TType.STRING, 0)
27214 
      oprot.writeString(self.success)
27215 
      oprot.writeFieldEnd()
27216 
    oprot.writeFieldStop()
27217 
    oprot.writeStructEnd()
27218 
 
27219 
  def validate(self):
27220 
    return
27221 
 
27222 
 
27223 
  def __repr__(self):
27224 
    L = ['%s=%r' % (key, value)
27225 
      for key, value in self.__dict__.iteritems()]
27226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27227 
 
27228 
  def __eq__(self, other):
27229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27230 
 
27231 
  def __ne__(self, other):
27232 
    return not (self == other)
27233 
 
6019 rajveer 27234 
class changeJacketNumber_args:
27235 
  """
27236 
  Attributes:
27237 
   - orderId
27238 
   - jacketNumber
27239 
  """
27240 
 
27241 
  thrift_spec = (
27242 
    None, # 0
27243 
    (1, TType.I64, 'orderId', None, None, ), # 1
27244 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
27245 
  )
27246 
 
27247 
  def __init__(self, orderId=None, jacketNumber=None,):
27248 
    self.orderId = orderId
27249 
    self.jacketNumber = jacketNumber
27250 
 
27251 
  def read(self, iprot):
27252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27254 
      return
27255 
    iprot.readStructBegin()
27256 
    while True:
27257 
      (fname, ftype, fid) = iprot.readFieldBegin()
27258 
      if ftype == TType.STOP:
27259 
        break
27260 
      if fid == 1:
27261 
        if ftype == TType.I64:
27262 
          self.orderId = iprot.readI64();
27263 
        else:
27264 
          iprot.skip(ftype)
27265 
      elif fid == 2:
27266 
        if ftype == TType.I64:
27267 
          self.jacketNumber = iprot.readI64();
27268 
        else:
27269 
          iprot.skip(ftype)
27270 
      else:
27271 
        iprot.skip(ftype)
27272 
      iprot.readFieldEnd()
27273 
    iprot.readStructEnd()
27274 
 
27275 
  def write(self, oprot):
27276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27278 
      return
27279 
    oprot.writeStructBegin('changeJacketNumber_args')
27280 
    if self.orderId is not None:
27281 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27282 
      oprot.writeI64(self.orderId)
27283 
      oprot.writeFieldEnd()
27284 
    if self.jacketNumber is not None:
27285 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
27286 
      oprot.writeI64(self.jacketNumber)
27287 
      oprot.writeFieldEnd()
27288 
    oprot.writeFieldStop()
27289 
    oprot.writeStructEnd()
27290 
 
27291 
  def validate(self):
27292 
    return
27293 
 
27294 
 
27295 
  def __repr__(self):
27296 
    L = ['%s=%r' % (key, value)
27297 
      for key, value in self.__dict__.iteritems()]
27298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27299 
 
27300 
  def __eq__(self, other):
27301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27302 
 
27303 
  def __ne__(self, other):
27304 
    return not (self == other)
27305 
 
27306 
class changeJacketNumber_result:
27307 
  """
27308 
  Attributes:
27309 
   - success
27310 
  """
27311 
 
27312 
  thrift_spec = (
27313 
    (0, TType.BOOL, 'success', None, None, ), # 0
27314 
  )
27315 
 
27316 
  def __init__(self, success=None,):
27317 
    self.success = success
27318 
 
27319 
  def read(self, iprot):
27320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27322 
      return
27323 
    iprot.readStructBegin()
27324 
    while True:
27325 
      (fname, ftype, fid) = iprot.readFieldBegin()
27326 
      if ftype == TType.STOP:
27327 
        break
27328 
      if fid == 0:
27329 
        if ftype == TType.BOOL:
27330 
          self.success = iprot.readBool();
27331 
        else:
27332 
          iprot.skip(ftype)
27333 
      else:
27334 
        iprot.skip(ftype)
27335 
      iprot.readFieldEnd()
27336 
    iprot.readStructEnd()
27337 
 
27338 
  def write(self, oprot):
27339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27341 
      return
27342 
    oprot.writeStructBegin('changeJacketNumber_result')
27343 
    if self.success is not None:
27344 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27345 
      oprot.writeBool(self.success)
27346 
      oprot.writeFieldEnd()
27347 
    oprot.writeFieldStop()
27348 
    oprot.writeStructEnd()
27349 
 
27350 
  def validate(self):
27351 
    return
27352 
 
27353 
 
27354 
  def __repr__(self):
27355 
    L = ['%s=%r' % (key, value)
27356 
      for key, value in self.__dict__.iteritems()]
27357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27358 
 
27359 
  def __eq__(self, other):
27360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27361 
 
27362 
  def __ne__(self, other):
27363 
    return not (self == other)
27364 
 
27365 
class markOrderAsRtoInTransit_args:
27366 
  """
27367 
  Attributes:
27368 
   - orderId
27369 
  """
27370 
 
27371 
  thrift_spec = (
27372 
    None, # 0
27373 
    (1, TType.I64, 'orderId', None, None, ), # 1
27374 
  )
27375 
 
27376 
  def __init__(self, orderId=None,):
27377 
    self.orderId = orderId
27378 
 
27379 
  def read(self, iprot):
27380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27382 
      return
27383 
    iprot.readStructBegin()
27384 
    while True:
27385 
      (fname, ftype, fid) = iprot.readFieldBegin()
27386 
      if ftype == TType.STOP:
27387 
        break
27388 
      if fid == 1:
27389 
        if ftype == TType.I64:
27390 
          self.orderId = iprot.readI64();
27391 
        else:
27392 
          iprot.skip(ftype)
27393 
      else:
27394 
        iprot.skip(ftype)
27395 
      iprot.readFieldEnd()
27396 
    iprot.readStructEnd()
27397 
 
27398 
  def write(self, oprot):
27399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27401 
      return
27402 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
27403 
    if self.orderId is not None:
27404 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
27405 
      oprot.writeI64(self.orderId)
27406 
      oprot.writeFieldEnd()
27407 
    oprot.writeFieldStop()
27408 
    oprot.writeStructEnd()
27409 
 
27410 
  def validate(self):
27411 
    return
27412 
 
27413 
 
27414 
  def __repr__(self):
27415 
    L = ['%s=%r' % (key, value)
27416 
      for key, value in self.__dict__.iteritems()]
27417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27418 
 
27419 
  def __eq__(self, other):
27420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27421 
 
27422 
  def __ne__(self, other):
27423 
    return not (self == other)
27424 
 
27425 
class markOrderAsRtoInTransit_result:
27426 
  """
27427 
  Attributes:
27428 
   - success
27429 
  """
27430 
 
27431 
  thrift_spec = (
27432 
    (0, TType.BOOL, 'success', None, None, ), # 0
27433 
  )
27434 
 
27435 
  def __init__(self, success=None,):
27436 
    self.success = success
27437 
 
27438 
  def read(self, iprot):
27439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27441 
      return
27442 
    iprot.readStructBegin()
27443 
    while True:
27444 
      (fname, ftype, fid) = iprot.readFieldBegin()
27445 
      if ftype == TType.STOP:
27446 
        break
27447 
      if fid == 0:
27448 
        if ftype == TType.BOOL:
27449 
          self.success = iprot.readBool();
27450 
        else:
27451 
          iprot.skip(ftype)
27452 
      else:
27453 
        iprot.skip(ftype)
27454 
      iprot.readFieldEnd()
27455 
    iprot.readStructEnd()
27456 
 
27457 
  def write(self, oprot):
27458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27460 
      return
27461 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
27462 
    if self.success is not None:
27463 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27464 
      oprot.writeBool(self.success)
27465 
      oprot.writeFieldEnd()
27466 
    oprot.writeFieldStop()
27467 
    oprot.writeStructEnd()
27468 
 
27469 
  def validate(self):
27470 
    return
27471 
 
27472 
 
27473 
  def __repr__(self):
27474 
    L = ['%s=%r' % (key, value)
27475 
      for key, value in self.__dict__.iteritems()]
27476 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27477 
 
27478 
  def __eq__(self, other):
27479 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27480 
 
27481 
  def __ne__(self, other):
27482 
    return not (self == other)
27483 
 
5593 mandeep.dh 27484 
class acceptOrderForItem_args:
27485 
  """
27486 
  Attributes:
27487 
   - itemId
27488 
   - quantity
27489 
   - fulfilmentWarehouseId
27490 
   - billingWarehouseId
27491 
  """
27492 
 
27493 
  thrift_spec = (
27494 
    None, # 0
27495 
    (1, TType.I64, 'itemId', None, None, ), # 1
27496 
    (2, TType.I64, 'quantity', None, None, ), # 2
27497 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
27498 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
27499 
  )
27500 
 
27501 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
27502 
    self.itemId = itemId
27503 
    self.quantity = quantity
27504 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
27505 
    self.billingWarehouseId = billingWarehouseId
27506 
 
27507 
  def read(self, iprot):
27508 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27509 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27510 
      return
27511 
    iprot.readStructBegin()
27512 
    while True:
27513 
      (fname, ftype, fid) = iprot.readFieldBegin()
27514 
      if ftype == TType.STOP:
27515 
        break
27516 
      if fid == 1:
27517 
        if ftype == TType.I64:
27518 
          self.itemId = iprot.readI64();
27519 
        else:
27520 
          iprot.skip(ftype)
27521 
      elif fid == 2:
27522 
        if ftype == TType.I64:
27523 
          self.quantity = iprot.readI64();
27524 
        else:
27525 
          iprot.skip(ftype)
27526 
      elif fid == 3:
27527 
        if ftype == TType.I64:
27528 
          self.fulfilmentWarehouseId = iprot.readI64();
27529 
        else:
27530 
          iprot.skip(ftype)
27531 
      elif fid == 4:
27532 
        if ftype == TType.I64:
27533 
          self.billingWarehouseId = iprot.readI64();
27534 
        else:
27535 
          iprot.skip(ftype)
27536 
      else:
27537 
        iprot.skip(ftype)
27538 
      iprot.readFieldEnd()
27539 
    iprot.readStructEnd()
27540 
 
27541 
  def write(self, oprot):
27542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27544 
      return
27545 
    oprot.writeStructBegin('acceptOrderForItem_args')
27546 
    if self.itemId is not None:
27547 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
27548 
      oprot.writeI64(self.itemId)
27549 
      oprot.writeFieldEnd()
27550 
    if self.quantity is not None:
27551 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
27552 
      oprot.writeI64(self.quantity)
27553 
      oprot.writeFieldEnd()
27554 
    if self.fulfilmentWarehouseId is not None:
27555 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
27556 
      oprot.writeI64(self.fulfilmentWarehouseId)
27557 
      oprot.writeFieldEnd()
27558 
    if self.billingWarehouseId is not None:
27559 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
27560 
      oprot.writeI64(self.billingWarehouseId)
27561 
      oprot.writeFieldEnd()
27562 
    oprot.writeFieldStop()
27563 
    oprot.writeStructEnd()
27564 
 
27565 
  def validate(self):
27566 
    return
27567 
 
27568 
 
27569 
  def __repr__(self):
27570 
    L = ['%s=%r' % (key, value)
27571 
      for key, value in self.__dict__.iteritems()]
27572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27573 
 
27574 
  def __eq__(self, other):
27575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27576 
 
27577 
  def __ne__(self, other):
27578 
    return not (self == other)
27579 
 
27580 
class acceptOrderForItem_result:
27581 
 
27582 
  thrift_spec = (
27583 
  )
27584 
 
27585 
  def read(self, iprot):
27586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27588 
      return
27589 
    iprot.readStructBegin()
27590 
    while True:
27591 
      (fname, ftype, fid) = iprot.readFieldBegin()
27592 
      if ftype == TType.STOP:
27593 
        break
27594 
      else:
27595 
        iprot.skip(ftype)
27596 
      iprot.readFieldEnd()
27597 
    iprot.readStructEnd()
27598 
 
27599 
  def write(self, oprot):
27600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27602 
      return
27603 
    oprot.writeStructBegin('acceptOrderForItem_result')
27604 
    oprot.writeFieldStop()
27605 
    oprot.writeStructEnd()
27606 
 
27607 
  def validate(self):
27608 
    return
27609 
 
27610 
 
27611 
  def __repr__(self):
27612 
    L = ['%s=%r' % (key, value)
27613 
      for key, value in self.__dict__.iteritems()]
27614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27615 
 
27616 
  def __eq__(self, other):
27617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27618 
 
27619 
  def __ne__(self, other):
27620 
    return not (self == other)
6000 mandeep.dh 27621 
 
27622 
class createRechargeOrder_args:
27623 
  """
27624 
  Attributes:
27625 
   - rechargeOrder
27626 
  """
27627 
 
27628 
  thrift_spec = (
27629 
    None, # 0
27630 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
27631 
  )
27632 
 
27633 
  def __init__(self, rechargeOrder=None,):
27634 
    self.rechargeOrder = rechargeOrder
27635 
 
27636 
  def read(self, iprot):
27637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27639 
      return
27640 
    iprot.readStructBegin()
27641 
    while True:
27642 
      (fname, ftype, fid) = iprot.readFieldBegin()
27643 
      if ftype == TType.STOP:
27644 
        break
27645 
      if fid == 1:
27646 
        if ftype == TType.STRUCT:
27647 
          self.rechargeOrder = RechargeOrder()
27648 
          self.rechargeOrder.read(iprot)
27649 
        else:
27650 
          iprot.skip(ftype)
27651 
      else:
27652 
        iprot.skip(ftype)
27653 
      iprot.readFieldEnd()
27654 
    iprot.readStructEnd()
27655 
 
27656 
  def write(self, oprot):
27657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27659 
      return
27660 
    oprot.writeStructBegin('createRechargeOrder_args')
27661 
    if self.rechargeOrder is not None:
27662 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
27663 
      self.rechargeOrder.write(oprot)
27664 
      oprot.writeFieldEnd()
27665 
    oprot.writeFieldStop()
27666 
    oprot.writeStructEnd()
27667 
 
27668 
  def validate(self):
27669 
    return
27670 
 
27671 
 
27672 
  def __repr__(self):
27673 
    L = ['%s=%r' % (key, value)
27674 
      for key, value in self.__dict__.iteritems()]
27675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27676 
 
27677 
  def __eq__(self, other):
27678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27679 
 
27680 
  def __ne__(self, other):
27681 
    return not (self == other)
27682 
 
27683 
class createRechargeOrder_result:
27684 
  """
27685 
  Attributes:
27686 
   - success
27687 
   - ex
27688 
  """
27689 
 
27690 
  thrift_spec = (
27691 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27692 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27693 
  )
27694 
 
27695 
  def __init__(self, success=None, ex=None,):
27696 
    self.success = success
27697 
    self.ex = ex
27698 
 
27699 
  def read(self, iprot):
27700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27702 
      return
27703 
    iprot.readStructBegin()
27704 
    while True:
27705 
      (fname, ftype, fid) = iprot.readFieldBegin()
27706 
      if ftype == TType.STOP:
27707 
        break
27708 
      if fid == 0:
27709 
        if ftype == TType.STRUCT:
27710 
          self.success = RechargeOrder()
27711 
          self.success.read(iprot)
27712 
        else:
27713 
          iprot.skip(ftype)
27714 
      elif fid == 1:
27715 
        if ftype == TType.STRUCT:
27716 
          self.ex = TransactionServiceException()
27717 
          self.ex.read(iprot)
27718 
        else:
27719 
          iprot.skip(ftype)
27720 
      else:
27721 
        iprot.skip(ftype)
27722 
      iprot.readFieldEnd()
27723 
    iprot.readStructEnd()
27724 
 
27725 
  def write(self, oprot):
27726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27728 
      return
27729 
    oprot.writeStructBegin('createRechargeOrder_result')
27730 
    if self.success is not None:
27731 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27732 
      self.success.write(oprot)
27733 
      oprot.writeFieldEnd()
27734 
    if self.ex is not None:
27735 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27736 
      self.ex.write(oprot)
27737 
      oprot.writeFieldEnd()
27738 
    oprot.writeFieldStop()
27739 
    oprot.writeStructEnd()
27740 
 
27741 
  def validate(self):
27742 
    return
27743 
 
27744 
 
27745 
  def __repr__(self):
27746 
    L = ['%s=%r' % (key, value)
27747 
      for key, value in self.__dict__.iteritems()]
27748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27749 
 
27750 
  def __eq__(self, other):
27751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27752 
 
27753 
  def __ne__(self, other):
27754 
    return not (self == other)
27755 
 
6031 rajveer 27756 
class getRechargeOrder_args:
27757 
  """
27758 
  Attributes:
27759 
   - rechargeRrderId
27760 
  """
27761 
 
27762 
  thrift_spec = (
27763 
    None, # 0
27764 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
27765 
  )
27766 
 
27767 
  def __init__(self, rechargeRrderId=None,):
27768 
    self.rechargeRrderId = rechargeRrderId
27769 
 
27770 
  def read(self, iprot):
27771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27773 
      return
27774 
    iprot.readStructBegin()
27775 
    while True:
27776 
      (fname, ftype, fid) = iprot.readFieldBegin()
27777 
      if ftype == TType.STOP:
27778 
        break
27779 
      if fid == 1:
27780 
        if ftype == TType.I64:
27781 
          self.rechargeRrderId = iprot.readI64();
27782 
        else:
27783 
          iprot.skip(ftype)
27784 
      else:
27785 
        iprot.skip(ftype)
27786 
      iprot.readFieldEnd()
27787 
    iprot.readStructEnd()
27788 
 
27789 
  def write(self, oprot):
27790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27792 
      return
27793 
    oprot.writeStructBegin('getRechargeOrder_args')
27794 
    if self.rechargeRrderId is not None:
27795 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
27796 
      oprot.writeI64(self.rechargeRrderId)
27797 
      oprot.writeFieldEnd()
27798 
    oprot.writeFieldStop()
27799 
    oprot.writeStructEnd()
27800 
 
27801 
  def validate(self):
27802 
    return
27803 
 
27804 
 
27805 
  def __repr__(self):
27806 
    L = ['%s=%r' % (key, value)
27807 
      for key, value in self.__dict__.iteritems()]
27808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27809 
 
27810 
  def __eq__(self, other):
27811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27812 
 
27813 
  def __ne__(self, other):
27814 
    return not (self == other)
27815 
 
27816 
class getRechargeOrder_result:
27817 
  """
27818 
  Attributes:
27819 
   - success
27820 
   - ex
27821 
  """
27822 
 
27823 
  thrift_spec = (
27824 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27825 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27826 
  )
27827 
 
27828 
  def __init__(self, success=None, ex=None,):
27829 
    self.success = success
27830 
    self.ex = ex
27831 
 
27832 
  def read(self, iprot):
27833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27835 
      return
27836 
    iprot.readStructBegin()
27837 
    while True:
27838 
      (fname, ftype, fid) = iprot.readFieldBegin()
27839 
      if ftype == TType.STOP:
27840 
        break
27841 
      if fid == 0:
27842 
        if ftype == TType.STRUCT:
27843 
          self.success = RechargeOrder()
27844 
          self.success.read(iprot)
27845 
        else:
27846 
          iprot.skip(ftype)
27847 
      elif fid == 1:
27848 
        if ftype == TType.STRUCT:
27849 
          self.ex = TransactionServiceException()
27850 
          self.ex.read(iprot)
27851 
        else:
27852 
          iprot.skip(ftype)
27853 
      else:
27854 
        iprot.skip(ftype)
27855 
      iprot.readFieldEnd()
27856 
    iprot.readStructEnd()
27857 
 
27858 
  def write(self, oprot):
27859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27861 
      return
27862 
    oprot.writeStructBegin('getRechargeOrder_result')
27863 
    if self.success is not None:
27864 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27865 
      self.success.write(oprot)
27866 
      oprot.writeFieldEnd()
27867 
    if self.ex is not None:
27868 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27869 
      self.ex.write(oprot)
27870 
      oprot.writeFieldEnd()
27871 
    oprot.writeFieldStop()
27872 
    oprot.writeStructEnd()
27873 
 
27874 
  def validate(self):
27875 
    return
27876 
 
27877 
 
27878 
  def __repr__(self):
27879 
    L = ['%s=%r' % (key, value)
27880 
      for key, value in self.__dict__.iteritems()]
27881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27882 
 
27883 
  def __eq__(self, other):
27884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27885 
 
27886 
  def __ne__(self, other):
27887 
    return not (self == other)
27888 
 
27889 
class getRechargeOrders_args:
27890 
  """
27891 
  Attributes:
27892 
   - userId
27893 
  """
27894 
 
27895 
  thrift_spec = (
27896 
    None, # 0
27897 
    (1, TType.I64, 'userId', None, None, ), # 1
27898 
  )
27899 
 
27900 
  def __init__(self, userId=None,):
27901 
    self.userId = userId
27902 
 
27903 
  def read(self, iprot):
27904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27906 
      return
27907 
    iprot.readStructBegin()
27908 
    while True:
27909 
      (fname, ftype, fid) = iprot.readFieldBegin()
27910 
      if ftype == TType.STOP:
27911 
        break
27912 
      if fid == 1:
27913 
        if ftype == TType.I64:
27914 
          self.userId = iprot.readI64();
27915 
        else:
27916 
          iprot.skip(ftype)
27917 
      else:
27918 
        iprot.skip(ftype)
27919 
      iprot.readFieldEnd()
27920 
    iprot.readStructEnd()
27921 
 
27922 
  def write(self, oprot):
27923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27925 
      return
27926 
    oprot.writeStructBegin('getRechargeOrders_args')
27927 
    if self.userId is not None:
27928 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27929 
      oprot.writeI64(self.userId)
27930 
      oprot.writeFieldEnd()
27931 
    oprot.writeFieldStop()
27932 
    oprot.writeStructEnd()
27933 
 
27934 
  def validate(self):
27935 
    return
27936 
 
27937 
 
27938 
  def __repr__(self):
27939 
    L = ['%s=%r' % (key, value)
27940 
      for key, value in self.__dict__.iteritems()]
27941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27942 
 
27943 
  def __eq__(self, other):
27944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27945 
 
27946 
  def __ne__(self, other):
27947 
    return not (self == other)
27948 
 
27949 
class getRechargeOrders_result:
27950 
  """
27951 
  Attributes:
27952 
   - success
27953 
  """
27954 
 
27955 
  thrift_spec = (
27956 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27957 
  )
27958 
 
27959 
  def __init__(self, success=None,):
27960 
    self.success = success
27961 
 
27962 
  def read(self, iprot):
27963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27965 
      return
27966 
    iprot.readStructBegin()
27967 
    while True:
27968 
      (fname, ftype, fid) = iprot.readFieldBegin()
27969 
      if ftype == TType.STOP:
27970 
        break
27971 
      if fid == 0:
27972 
        if ftype == TType.LIST:
27973 
          self.success = []
6188 rajveer 27974 
          (_etype659, _size656) = iprot.readListBegin()
27975 
          for _i660 in xrange(_size656):
27976 
            _elem661 = RechargeOrder()
27977 
            _elem661.read(iprot)
27978 
            self.success.append(_elem661)
6031 rajveer 27979 
          iprot.readListEnd()
27980 
        else:
27981 
          iprot.skip(ftype)
27982 
      else:
27983 
        iprot.skip(ftype)
27984 
      iprot.readFieldEnd()
27985 
    iprot.readStructEnd()
27986 
 
27987 
  def write(self, oprot):
27988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27990 
      return
27991 
    oprot.writeStructBegin('getRechargeOrders_result')
27992 
    if self.success is not None:
27993 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27994 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27995 
      for iter662 in self.success:
27996 
        iter662.write(oprot)
6031 rajveer 27997 
      oprot.writeListEnd()
27998 
      oprot.writeFieldEnd()
27999 
    oprot.writeFieldStop()
28000 
    oprot.writeStructEnd()
28001 
 
28002 
  def validate(self):
28003 
    return
28004 
 
28005 
 
28006 
  def __repr__(self):
28007 
    L = ['%s=%r' % (key, value)
28008 
      for key, value in self.__dict__.iteritems()]
28009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28010 
 
28011 
  def __eq__(self, other):
28012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28013 
 
28014 
  def __ne__(self, other):
28015 
    return not (self == other)
28016 
 
6000 mandeep.dh 28017 
class updateRechargeOrderStatus_args:
28018 
  """
28019 
  Attributes:
28020 
   - rechargeOrderId
28021 
   - rechargeOrderStatus
28022 
  """
28023 
 
28024 
  thrift_spec = (
28025 
    None, # 0
28026 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
28027 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
28028 
  )
28029 
 
28030 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
28031 
    self.rechargeOrderId = rechargeOrderId
28032 
    self.rechargeOrderStatus = rechargeOrderStatus
28033 
 
28034 
  def read(self, iprot):
28035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28037 
      return
28038 
    iprot.readStructBegin()
28039 
    while True:
28040 
      (fname, ftype, fid) = iprot.readFieldBegin()
28041 
      if ftype == TType.STOP:
28042 
        break
28043 
      if fid == 1:
28044 
        if ftype == TType.I64:
28045 
          self.rechargeOrderId = iprot.readI64();
28046 
        else:
28047 
          iprot.skip(ftype)
28048 
      elif fid == 2:
28049 
        if ftype == TType.I32:
28050 
          self.rechargeOrderStatus = iprot.readI32();
28051 
        else:
28052 
          iprot.skip(ftype)
28053 
      else:
28054 
        iprot.skip(ftype)
28055 
      iprot.readFieldEnd()
28056 
    iprot.readStructEnd()
28057 
 
28058 
  def write(self, oprot):
28059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28061 
      return
28062 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
28063 
    if self.rechargeOrderId is not None:
28064 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
28065 
      oprot.writeI64(self.rechargeOrderId)
28066 
      oprot.writeFieldEnd()
28067 
    if self.rechargeOrderStatus is not None:
28068 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
28069 
      oprot.writeI32(self.rechargeOrderStatus)
28070 
      oprot.writeFieldEnd()
28071 
    oprot.writeFieldStop()
28072 
    oprot.writeStructEnd()
28073 
 
28074 
  def validate(self):
28075 
    return
28076 
 
28077 
 
28078 
  def __repr__(self):
28079 
    L = ['%s=%r' % (key, value)
28080 
      for key, value in self.__dict__.iteritems()]
28081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28082 
 
28083 
  def __eq__(self, other):
28084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28085 
 
28086 
  def __ne__(self, other):
28087 
    return not (self == other)
28088 
 
28089 
class updateRechargeOrderStatus_result:
28090 
  """
28091 
  Attributes:
6031 rajveer 28092 
   - success
6000 mandeep.dh 28093 
   - ex
28094 
  """
28095 
 
28096 
  thrift_spec = (
6031 rajveer 28097 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 28098 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28099 
  )
28100 
 
6031 rajveer 28101 
  def __init__(self, success=None, ex=None,):
28102 
    self.success = success
6000 mandeep.dh 28103 
    self.ex = ex
28104 
 
28105 
  def read(self, iprot):
28106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28108 
      return
28109 
    iprot.readStructBegin()
28110 
    while True:
28111 
      (fname, ftype, fid) = iprot.readFieldBegin()
28112 
      if ftype == TType.STOP:
28113 
        break
6031 rajveer 28114 
      if fid == 0:
28115 
        if ftype == TType.BOOL:
28116 
          self.success = iprot.readBool();
28117 
        else:
28118 
          iprot.skip(ftype)
28119 
      elif fid == 1:
6000 mandeep.dh 28120 
        if ftype == TType.STRUCT:
28121 
          self.ex = TransactionServiceException()
28122 
          self.ex.read(iprot)
28123 
        else:
28124 
          iprot.skip(ftype)
28125 
      else:
28126 
        iprot.skip(ftype)
28127 
      iprot.readFieldEnd()
28128 
    iprot.readStructEnd()
28129 
 
28130 
  def write(self, oprot):
28131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28133 
      return
28134 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 28135 
    if self.success is not None:
28136 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28137 
      oprot.writeBool(self.success)
28138 
      oprot.writeFieldEnd()
6000 mandeep.dh 28139 
    if self.ex is not None:
28140 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28141 
      self.ex.write(oprot)
28142 
      oprot.writeFieldEnd()
28143 
    oprot.writeFieldStop()
28144 
    oprot.writeStructEnd()
28145 
 
28146 
  def validate(self):
28147 
    return
28148 
 
28149 
 
28150 
  def __repr__(self):
28151 
    L = ['%s=%r' % (key, value)
28152 
      for key, value in self.__dict__.iteritems()]
28153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28154 
 
28155 
  def __eq__(self, other):
28156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28157 
 
28158 
  def __ne__(self, other):
28159 
    return not (self == other)
28160 
 
28161 
class activateRechargeTxn_args:
28162 
  """
28163 
  Attributes:
6031 rajveer 28164 
   - rechargeOrderId
6000 mandeep.dh 28165 
  """
28166 
 
28167 
  thrift_spec = (
28168 
    None, # 0
6031 rajveer 28169 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 28170 
  )
28171 
 
6031 rajveer 28172 
  def __init__(self, rechargeOrderId=None,):
28173 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 28174 
 
28175 
  def read(self, iprot):
28176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28178 
      return
28179 
    iprot.readStructBegin()
28180 
    while True:
28181 
      (fname, ftype, fid) = iprot.readFieldBegin()
28182 
      if ftype == TType.STOP:
28183 
        break
28184 
      if fid == 1:
6031 rajveer 28185 
        if ftype == TType.I64:
28186 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 28187 
        else:
28188 
          iprot.skip(ftype)
28189 
      else:
28190 
        iprot.skip(ftype)
28191 
      iprot.readFieldEnd()
28192 
    iprot.readStructEnd()
28193 
 
28194 
  def write(self, oprot):
28195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28197 
      return
28198 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 28199 
    if self.rechargeOrderId is not None:
28200 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
28201 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 28202 
      oprot.writeFieldEnd()
28203 
    oprot.writeFieldStop()
28204 
    oprot.writeStructEnd()
28205 
 
28206 
  def validate(self):
28207 
    return
28208 
 
28209 
 
28210 
  def __repr__(self):
28211 
    L = ['%s=%r' % (key, value)
28212 
      for key, value in self.__dict__.iteritems()]
28213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28214 
 
28215 
  def __eq__(self, other):
28216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28217 
 
28218 
  def __ne__(self, other):
28219 
    return not (self == other)
28220 
 
28221 
class activateRechargeTxn_result:
28222 
  """
28223 
  Attributes:
28224 
   - success
28225 
   - ex
28226 
  """
28227 
 
28228 
  thrift_spec = (
6031 rajveer 28229 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 28230 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28231 
  )
28232 
 
28233 
  def __init__(self, success=None, ex=None,):
28234 
    self.success = success
28235 
    self.ex = ex
28236 
 
28237 
  def read(self, iprot):
28238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28240 
      return
28241 
    iprot.readStructBegin()
28242 
    while True:
28243 
      (fname, ftype, fid) = iprot.readFieldBegin()
28244 
      if ftype == TType.STOP:
28245 
        break
28246 
      if fid == 0:
6031 rajveer 28247 
        if ftype == TType.BOOL:
28248 
          self.success = iprot.readBool();
6000 mandeep.dh 28249 
        else:
28250 
          iprot.skip(ftype)
28251 
      elif fid == 1:
28252 
        if ftype == TType.STRUCT:
28253 
          self.ex = TransactionServiceException()
28254 
          self.ex.read(iprot)
28255 
        else:
28256 
          iprot.skip(ftype)
28257 
      else:
28258 
        iprot.skip(ftype)
28259 
      iprot.readFieldEnd()
28260 
    iprot.readStructEnd()
28261 
 
28262 
  def write(self, oprot):
28263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28265 
      return
28266 
    oprot.writeStructBegin('activateRechargeTxn_result')
28267 
    if self.success is not None:
6031 rajveer 28268 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
28269 
      oprot.writeBool(self.success)
6000 mandeep.dh 28270 
      oprot.writeFieldEnd()
28271 
    if self.ex is not None:
28272 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28273 
      self.ex.write(oprot)
28274 
      oprot.writeFieldEnd()
28275 
    oprot.writeFieldStop()
28276 
    oprot.writeStructEnd()
28277 
 
28278 
  def validate(self):
28279 
    return
28280 
 
28281 
 
28282 
  def __repr__(self):
28283 
    L = ['%s=%r' % (key, value)
28284 
      for key, value in self.__dict__.iteritems()]
28285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28286 
 
28287 
  def __eq__(self, other):
28288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28289 
 
28290 
  def __ne__(self, other):
28291 
    return not (self == other)
28292 
 
6031 rajveer 28293 
class getUserWallet_args:
6000 mandeep.dh 28294 
  """
28295 
  Attributes:
6031 rajveer 28296 
   - userId
6000 mandeep.dh 28297 
  """
28298 
 
28299 
  thrift_spec = (
28300 
    None, # 0
6031 rajveer 28301 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 28302 
  )
28303 
 
6031 rajveer 28304 
  def __init__(self, userId=None,):
28305 
    self.userId = userId
6000 mandeep.dh 28306 
 
28307 
  def read(self, iprot):
28308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28310 
      return
28311 
    iprot.readStructBegin()
28312 
    while True:
28313 
      (fname, ftype, fid) = iprot.readFieldBegin()
28314 
      if ftype == TType.STOP:
28315 
        break
28316 
      if fid == 1:
28317 
        if ftype == TType.I64:
6031 rajveer 28318 
          self.userId = iprot.readI64();
6000 mandeep.dh 28319 
        else:
28320 
          iprot.skip(ftype)
28321 
      else:
28322 
        iprot.skip(ftype)
28323 
      iprot.readFieldEnd()
28324 
    iprot.readStructEnd()
28325 
 
28326 
  def write(self, oprot):
28327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28329 
      return
6031 rajveer 28330 
    oprot.writeStructBegin('getUserWallet_args')
28331 
    if self.userId is not None:
28332 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28333 
      oprot.writeI64(self.userId)
6000 mandeep.dh 28334 
      oprot.writeFieldEnd()
28335 
    oprot.writeFieldStop()
28336 
    oprot.writeStructEnd()
28337 
 
28338 
  def validate(self):
28339 
    return
28340 
 
28341 
 
28342 
  def __repr__(self):
28343 
    L = ['%s=%r' % (key, value)
28344 
      for key, value in self.__dict__.iteritems()]
28345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28346 
 
28347 
  def __eq__(self, other):
28348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28349 
 
28350 
  def __ne__(self, other):
28351 
    return not (self == other)
28352 
 
6031 rajveer 28353 
class getUserWallet_result:
6000 mandeep.dh 28354 
  """
28355 
  Attributes:
28356 
   - success
28357 
  """
28358 
 
28359 
  thrift_spec = (
6031 rajveer 28360 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 28361 
  )
28362 
 
28363 
  def __init__(self, success=None,):
28364 
    self.success = success
28365 
 
28366 
  def read(self, iprot):
28367 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28368 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28369 
      return
28370 
    iprot.readStructBegin()
28371 
    while True:
28372 
      (fname, ftype, fid) = iprot.readFieldBegin()
28373 
      if ftype == TType.STOP:
28374 
        break
28375 
      if fid == 0:
6031 rajveer 28376 
        if ftype == TType.STRUCT:
28377 
          self.success = UserWallet()
28378 
          self.success.read(iprot)
6000 mandeep.dh 28379 
        else:
28380 
          iprot.skip(ftype)
28381 
      else:
28382 
        iprot.skip(ftype)
28383 
      iprot.readFieldEnd()
28384 
    iprot.readStructEnd()
28385 
 
28386 
  def write(self, oprot):
28387 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28388 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28389 
      return
6031 rajveer 28390 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 28391 
    if self.success is not None:
6031 rajveer 28392 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28393 
      self.success.write(oprot)
6000 mandeep.dh 28394 
      oprot.writeFieldEnd()
28395 
    oprot.writeFieldStop()
28396 
    oprot.writeStructEnd()
28397 
 
28398 
  def validate(self):
28399 
    return
28400 
 
28401 
 
28402 
  def __repr__(self):
28403 
    L = ['%s=%r' % (key, value)
28404 
      for key, value in self.__dict__.iteritems()]
28405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28406 
 
28407 
  def __eq__(self, other):
28408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28409 
 
28410 
  def __ne__(self, other):
28411 
    return not (self == other)
28412 
 
6031 rajveer 28413 
class getUserWalletHistory_args:
6000 mandeep.dh 28414 
  """
28415 
  Attributes:
6031 rajveer 28416 
   - userId
6000 mandeep.dh 28417 
  """
28418 
 
28419 
  thrift_spec = (
28420 
    None, # 0
6031 rajveer 28421 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 28422 
  )
28423 
 
6031 rajveer 28424 
  def __init__(self, userId=None,):
28425 
    self.userId = userId
6000 mandeep.dh 28426 
 
28427 
  def read(self, iprot):
28428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28430 
      return
28431 
    iprot.readStructBegin()
28432 
    while True:
28433 
      (fname, ftype, fid) = iprot.readFieldBegin()
28434 
      if ftype == TType.STOP:
28435 
        break
28436 
      if fid == 1:
28437 
        if ftype == TType.I64:
6031 rajveer 28438 
          self.userId = iprot.readI64();
6000 mandeep.dh 28439 
        else:
28440 
          iprot.skip(ftype)
28441 
      else:
28442 
        iprot.skip(ftype)
28443 
      iprot.readFieldEnd()
28444 
    iprot.readStructEnd()
28445 
 
28446 
  def write(self, oprot):
28447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28449 
      return
6031 rajveer 28450 
    oprot.writeStructBegin('getUserWalletHistory_args')
28451 
    if self.userId is not None:
28452 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28453 
      oprot.writeI64(self.userId)
6000 mandeep.dh 28454 
      oprot.writeFieldEnd()
28455 
    oprot.writeFieldStop()
28456 
    oprot.writeStructEnd()
28457 
 
28458 
  def validate(self):
28459 
    return
28460 
 
28461 
 
28462 
  def __repr__(self):
28463 
    L = ['%s=%r' % (key, value)
28464 
      for key, value in self.__dict__.iteritems()]
28465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28466 
 
28467 
  def __eq__(self, other):
28468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28469 
 
28470 
  def __ne__(self, other):
28471 
    return not (self == other)
28472 
 
6031 rajveer 28473 
class getUserWalletHistory_result:
6000 mandeep.dh 28474 
  """
28475 
  Attributes:
28476 
   - success
28477 
  """
28478 
 
28479 
  thrift_spec = (
6031 rajveer 28480 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 28481 
  )
28482 
 
28483 
  def __init__(self, success=None,):
28484 
    self.success = success
28485 
 
28486 
  def read(self, iprot):
28487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28489 
      return
28490 
    iprot.readStructBegin()
28491 
    while True:
28492 
      (fname, ftype, fid) = iprot.readFieldBegin()
28493 
      if ftype == TType.STOP:
28494 
        break
28495 
      if fid == 0:
28496 
        if ftype == TType.LIST:
28497 
          self.success = []
6188 rajveer 28498 
          (_etype666, _size663) = iprot.readListBegin()
28499 
          for _i667 in xrange(_size663):
28500 
            _elem668 = UserWalletHistory()
28501 
            _elem668.read(iprot)
28502 
            self.success.append(_elem668)
6000 mandeep.dh 28503 
          iprot.readListEnd()
28504 
        else:
28505 
          iprot.skip(ftype)
28506 
      else:
28507 
        iprot.skip(ftype)
28508 
      iprot.readFieldEnd()
28509 
    iprot.readStructEnd()
28510 
 
28511 
  def write(self, oprot):
28512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28514 
      return
6031 rajveer 28515 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 28516 
    if self.success is not None:
28517 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28518 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28519 
      for iter669 in self.success:
28520 
        iter669.write(oprot)
6000 mandeep.dh 28521 
      oprot.writeListEnd()
28522 
      oprot.writeFieldEnd()
28523 
    oprot.writeFieldStop()
28524 
    oprot.writeStructEnd()
28525 
 
28526 
  def validate(self):
28527 
    return
28528 
 
28529 
 
28530 
  def __repr__(self):
28531 
    L = ['%s=%r' % (key, value)
28532 
      for key, value in self.__dict__.iteritems()]
28533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28534 
 
28535 
  def __eq__(self, other):
28536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28537 
 
28538 
  def __ne__(self, other):
28539 
    return not (self == other)
6048 rajveer 28540 
 
6050 anupam.sin 28541 
class getRechargeOrdersForTransaction_args:
28542 
  """
28543 
  Attributes:
28544 
   - txnId
28545 
  """
28546 
 
28547 
  thrift_spec = (
28548 
    None, # 0
28549 
    (1, TType.I64, 'txnId', None, None, ), # 1
28550 
  )
28551 
 
28552 
  def __init__(self, txnId=None,):
28553 
    self.txnId = txnId
28554 
 
28555 
  def read(self, iprot):
28556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28558 
      return
28559 
    iprot.readStructBegin()
28560 
    while True:
28561 
      (fname, ftype, fid) = iprot.readFieldBegin()
28562 
      if ftype == TType.STOP:
28563 
        break
28564 
      if fid == 1:
28565 
        if ftype == TType.I64:
28566 
          self.txnId = iprot.readI64();
28567 
        else:
28568 
          iprot.skip(ftype)
28569 
      else:
28570 
        iprot.skip(ftype)
28571 
      iprot.readFieldEnd()
28572 
    iprot.readStructEnd()
28573 
 
28574 
  def write(self, oprot):
28575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28577 
      return
28578 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
28579 
    if self.txnId is not None:
28580 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
28581 
      oprot.writeI64(self.txnId)
28582 
      oprot.writeFieldEnd()
28583 
    oprot.writeFieldStop()
28584 
    oprot.writeStructEnd()
28585 
 
28586 
  def validate(self):
28587 
    return
28588 
 
28589 
 
28590 
  def __repr__(self):
28591 
    L = ['%s=%r' % (key, value)
28592 
      for key, value in self.__dict__.iteritems()]
28593 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28594 
 
28595 
  def __eq__(self, other):
28596 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28597 
 
28598 
  def __ne__(self, other):
28599 
    return not (self == other)
28600 
 
28601 
class getRechargeOrdersForTransaction_result:
28602 
  """
28603 
  Attributes:
28604 
   - success
28605 
   - ex
28606 
  """
28607 
 
28608 
  thrift_spec = (
28609 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
28610 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28611 
  )
28612 
 
28613 
  def __init__(self, success=None, ex=None,):
28614 
    self.success = success
28615 
    self.ex = ex
28616 
 
28617 
  def read(self, iprot):
28618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28620 
      return
28621 
    iprot.readStructBegin()
28622 
    while True:
28623 
      (fname, ftype, fid) = iprot.readFieldBegin()
28624 
      if ftype == TType.STOP:
28625 
        break
28626 
      if fid == 0:
28627 
        if ftype == TType.STRUCT:
28628 
          self.success = RechargeOrder()
28629 
          self.success.read(iprot)
28630 
        else:
28631 
          iprot.skip(ftype)
28632 
      elif fid == 1:
28633 
        if ftype == TType.STRUCT:
28634 
          self.ex = TransactionServiceException()
28635 
          self.ex.read(iprot)
28636 
        else:
28637 
          iprot.skip(ftype)
28638 
      else:
28639 
        iprot.skip(ftype)
28640 
      iprot.readFieldEnd()
28641 
    iprot.readStructEnd()
28642 
 
28643 
  def write(self, oprot):
28644 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28645 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28646 
      return
28647 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
28648 
    if self.success is not None:
28649 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28650 
      self.success.write(oprot)
28651 
      oprot.writeFieldEnd()
28652 
    if self.ex is not None:
28653 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28654 
      self.ex.write(oprot)
28655 
      oprot.writeFieldEnd()
28656 
    oprot.writeFieldStop()
28657 
    oprot.writeStructEnd()
28658 
 
28659 
  def validate(self):
28660 
    return
28661 
 
28662 
 
28663 
  def __repr__(self):
28664 
    L = ['%s=%r' % (key, value)
28665 
      for key, value in self.__dict__.iteritems()]
28666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28667 
 
28668 
  def __eq__(self, other):
28669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28670 
 
28671 
  def __ne__(self, other):
28672 
    return not (self == other)
28673 
 
6048 rajveer 28674 
class getServiceProviders_args:
28675 
  """
28676 
  Attributes:
28677 
   - rechargeType
6206 rajveer 28678 
   - onlyActive
6048 rajveer 28679 
  """
28680 
 
28681 
  thrift_spec = (
28682 
    None, # 0
28683 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 28684 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 28685 
  )
28686 
 
6206 rajveer 28687 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 28688 
    self.rechargeType = rechargeType
6206 rajveer 28689 
    self.onlyActive = onlyActive
6048 rajveer 28690 
 
28691 
  def read(self, iprot):
28692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28694 
      return
28695 
    iprot.readStructBegin()
28696 
    while True:
28697 
      (fname, ftype, fid) = iprot.readFieldBegin()
28698 
      if ftype == TType.STOP:
28699 
        break
28700 
      if fid == 1:
28701 
        if ftype == TType.I32:
28702 
          self.rechargeType = iprot.readI32();
28703 
        else:
28704 
          iprot.skip(ftype)
6206 rajveer 28705 
      elif fid == 2:
28706 
        if ftype == TType.BOOL:
28707 
          self.onlyActive = iprot.readBool();
28708 
        else:
28709 
          iprot.skip(ftype)
6048 rajveer 28710 
      else:
28711 
        iprot.skip(ftype)
28712 
      iprot.readFieldEnd()
28713 
    iprot.readStructEnd()
28714 
 
28715 
  def write(self, oprot):
28716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28718 
      return
28719 
    oprot.writeStructBegin('getServiceProviders_args')
28720 
    if self.rechargeType is not None:
28721 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28722 
      oprot.writeI32(self.rechargeType)
28723 
      oprot.writeFieldEnd()
6206 rajveer 28724 
    if self.onlyActive is not None:
28725 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
28726 
      oprot.writeBool(self.onlyActive)
28727 
      oprot.writeFieldEnd()
6048 rajveer 28728 
    oprot.writeFieldStop()
28729 
    oprot.writeStructEnd()
28730 
 
28731 
  def validate(self):
28732 
    return
28733 
 
28734 
 
28735 
  def __repr__(self):
28736 
    L = ['%s=%r' % (key, value)
28737 
      for key, value in self.__dict__.iteritems()]
28738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28739 
 
28740 
  def __eq__(self, other):
28741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28742 
 
28743 
  def __ne__(self, other):
28744 
    return not (self == other)
28745 
 
28746 
class getServiceProviders_result:
28747 
  """
28748 
  Attributes:
28749 
   - success
28750 
  """
28751 
 
28752 
  thrift_spec = (
28753 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
28754 
  )
28755 
 
28756 
  def __init__(self, success=None,):
28757 
    self.success = success
28758 
 
28759 
  def read(self, iprot):
28760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28762 
      return
28763 
    iprot.readStructBegin()
28764 
    while True:
28765 
      (fname, ftype, fid) = iprot.readFieldBegin()
28766 
      if ftype == TType.STOP:
28767 
        break
28768 
      if fid == 0:
28769 
        if ftype == TType.MAP:
28770 
          self.success = {}
6188 rajveer 28771 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
28772 
          for _i674 in xrange(_size670):
28773 
            _key675 = iprot.readI64();
28774 
            _val676 = iprot.readString();
28775 
            self.success[_key675] = _val676
6048 rajveer 28776 
          iprot.readMapEnd()
28777 
        else:
28778 
          iprot.skip(ftype)
28779 
      else:
28780 
        iprot.skip(ftype)
28781 
      iprot.readFieldEnd()
28782 
    iprot.readStructEnd()
28783 
 
28784 
  def write(self, oprot):
28785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28787 
      return
28788 
    oprot.writeStructBegin('getServiceProviders_result')
28789 
    if self.success is not None:
28790 
      oprot.writeFieldBegin('success', TType.MAP, 0)
28791 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 28792 
      for kiter677,viter678 in self.success.items():
28793 
        oprot.writeI64(kiter677)
28794 
        oprot.writeString(viter678)
6048 rajveer 28795 
      oprot.writeMapEnd()
28796 
      oprot.writeFieldEnd()
28797 
    oprot.writeFieldStop()
28798 
    oprot.writeStructEnd()
28799 
 
28800 
  def validate(self):
28801 
    return
28802 
 
28803 
 
28804 
  def __repr__(self):
28805 
    L = ['%s=%r' % (key, value)
28806 
      for key, value in self.__dict__.iteritems()]
28807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28808 
 
28809 
  def __eq__(self, other):
28810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28811 
 
28812 
  def __ne__(self, other):
28813 
    return not (self == other)
28814 
 
28815 
class getServiceProviderForDevice_args:
28816 
  """
28817 
  Attributes:
6049 rajveer 28818 
   - rechargeType
6048 rajveer 28819 
   - deviceNumber
28820 
  """
28821 
 
28822 
  thrift_spec = (
28823 
    None, # 0
6049 rajveer 28824 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28825 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 28826 
  )
28827 
 
6049 rajveer 28828 
  def __init__(self, rechargeType=None, deviceNumber=None,):
28829 
    self.rechargeType = rechargeType
6048 rajveer 28830 
    self.deviceNumber = deviceNumber
28831 
 
28832 
  def read(self, iprot):
28833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28835 
      return
28836 
    iprot.readStructBegin()
28837 
    while True:
28838 
      (fname, ftype, fid) = iprot.readFieldBegin()
28839 
      if ftype == TType.STOP:
28840 
        break
28841 
      if fid == 1:
6049 rajveer 28842 
        if ftype == TType.I32:
28843 
          self.rechargeType = iprot.readI32();
28844 
        else:
28845 
          iprot.skip(ftype)
28846 
      elif fid == 2:
6048 rajveer 28847 
        if ftype == TType.STRING:
28848 
          self.deviceNumber = iprot.readString();
28849 
        else:
28850 
          iprot.skip(ftype)
28851 
      else:
28852 
        iprot.skip(ftype)
28853 
      iprot.readFieldEnd()
28854 
    iprot.readStructEnd()
28855 
 
28856 
  def write(self, oprot):
28857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28859 
      return
28860 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 28861 
    if self.rechargeType is not None:
28862 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28863 
      oprot.writeI32(self.rechargeType)
28864 
      oprot.writeFieldEnd()
6048 rajveer 28865 
    if self.deviceNumber is not None:
6049 rajveer 28866 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 28867 
      oprot.writeString(self.deviceNumber)
28868 
      oprot.writeFieldEnd()
28869 
    oprot.writeFieldStop()
28870 
    oprot.writeStructEnd()
28871 
 
28872 
  def validate(self):
28873 
    return
28874 
 
28875 
 
28876 
  def __repr__(self):
28877 
    L = ['%s=%r' % (key, value)
28878 
      for key, value in self.__dict__.iteritems()]
28879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28880 
 
28881 
  def __eq__(self, other):
28882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28883 
 
28884 
  def __ne__(self, other):
28885 
    return not (self == other)
28886 
 
28887 
class getServiceProviderForDevice_result:
28888 
  """
28889 
  Attributes:
28890 
   - success
28891 
  """
28892 
 
28893 
  thrift_spec = (
6289 anupam.sin 28894 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 28895 
  )
28896 
 
28897 
  def __init__(self, success=None,):
28898 
    self.success = success
28899 
 
28900 
  def read(self, iprot):
28901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28903 
      return
28904 
    iprot.readStructBegin()
28905 
    while True:
28906 
      (fname, ftype, fid) = iprot.readFieldBegin()
28907 
      if ftype == TType.STOP:
28908 
        break
28909 
      if fid == 0:
6289 anupam.sin 28910 
        if ftype == TType.STRUCT:
28911 
          self.success = DeviceNumberInfo()
28912 
          self.success.read(iprot)
6048 rajveer 28913 
        else:
28914 
          iprot.skip(ftype)
28915 
      else:
28916 
        iprot.skip(ftype)
28917 
      iprot.readFieldEnd()
28918 
    iprot.readStructEnd()
28919 
 
28920 
  def write(self, oprot):
28921 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28922 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28923 
      return
28924 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
28925 
    if self.success is not None:
6289 anupam.sin 28926 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28927 
      self.success.write(oprot)
6048 rajveer 28928 
      oprot.writeFieldEnd()
28929 
    oprot.writeFieldStop()
28930 
    oprot.writeStructEnd()
28931 
 
28932 
  def validate(self):
28933 
    return
28934 
 
28935 
 
28936 
  def __repr__(self):
28937 
    L = ['%s=%r' % (key, value)
28938 
      for key, value in self.__dict__.iteritems()]
28939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28940 
 
28941 
  def __eq__(self, other):
28942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28943 
 
28944 
  def __ne__(self, other):
28945 
    return not (self == other)
6094 rajveer 28946 
 
6269 rajveer 28947 
class validateRecharge_args:
28948 
  """
28949 
  Attributes:
28950 
   - rechargeType
28951 
   - deviceNumber
6307 anupam.sin 28952 
   - userSelectedProviderId
6591 anupam.sin 28953 
   - clientAddress
6269 rajveer 28954 
  """
28955 
 
28956 
  thrift_spec = (
28957 
    None, # 0
28958 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28959 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 28960 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6591 anupam.sin 28961 
    (4, TType.STRING, 'clientAddress', None, None, ), # 4
6269 rajveer 28962 
  )
28963 
 
6591 anupam.sin 28964 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None, clientAddress=None,):
6269 rajveer 28965 
    self.rechargeType = rechargeType
28966 
    self.deviceNumber = deviceNumber
6307 anupam.sin 28967 
    self.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 28968 
    self.clientAddress = clientAddress
6269 rajveer 28969 
 
28970 
  def read(self, iprot):
28971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28973 
      return
28974 
    iprot.readStructBegin()
28975 
    while True:
28976 
      (fname, ftype, fid) = iprot.readFieldBegin()
28977 
      if ftype == TType.STOP:
28978 
        break
28979 
      if fid == 1:
28980 
        if ftype == TType.I32:
28981 
          self.rechargeType = iprot.readI32();
28982 
        else:
28983 
          iprot.skip(ftype)
28984 
      elif fid == 2:
28985 
        if ftype == TType.STRING:
28986 
          self.deviceNumber = iprot.readString();
28987 
        else:
28988 
          iprot.skip(ftype)
6307 anupam.sin 28989 
      elif fid == 3:
28990 
        if ftype == TType.I64:
28991 
          self.userSelectedProviderId = iprot.readI64();
28992 
        else:
28993 
          iprot.skip(ftype)
6591 anupam.sin 28994 
      elif fid == 4:
28995 
        if ftype == TType.STRING:
28996 
          self.clientAddress = iprot.readString();
28997 
        else:
28998 
          iprot.skip(ftype)
6269 rajveer 28999 
      else:
29000 
        iprot.skip(ftype)
29001 
      iprot.readFieldEnd()
29002 
    iprot.readStructEnd()
29003 
 
29004 
  def write(self, oprot):
29005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29007 
      return
29008 
    oprot.writeStructBegin('validateRecharge_args')
29009 
    if self.rechargeType is not None:
29010 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
29011 
      oprot.writeI32(self.rechargeType)
29012 
      oprot.writeFieldEnd()
29013 
    if self.deviceNumber is not None:
29014 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
29015 
      oprot.writeString(self.deviceNumber)
29016 
      oprot.writeFieldEnd()
6307 anupam.sin 29017 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 29018 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 29019 
      oprot.writeI64(self.userSelectedProviderId)
29020 
      oprot.writeFieldEnd()
6591 anupam.sin 29021 
    if self.clientAddress is not None:
29022 
      oprot.writeFieldBegin('clientAddress', TType.STRING, 4)
29023 
      oprot.writeString(self.clientAddress)
29024 
      oprot.writeFieldEnd()
6269 rajveer 29025 
    oprot.writeFieldStop()
29026 
    oprot.writeStructEnd()
29027 
 
29028 
  def validate(self):
29029 
    return
29030 
 
29031 
 
29032 
  def __repr__(self):
29033 
    L = ['%s=%r' % (key, value)
29034 
      for key, value in self.__dict__.iteritems()]
29035 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29036 
 
29037 
  def __eq__(self, other):
29038 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29039 
 
29040 
  def __ne__(self, other):
29041 
    return not (self == other)
29042 
 
29043 
class validateRecharge_result:
29044 
  """
29045 
  Attributes:
29046 
   - success
29047 
  """
29048 
 
29049 
  thrift_spec = (
29050 
    (0, TType.STRING, 'success', None, None, ), # 0
29051 
  )
29052 
 
29053 
  def __init__(self, success=None,):
29054 
    self.success = success
29055 
 
29056 
  def read(self, iprot):
29057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29059 
      return
29060 
    iprot.readStructBegin()
29061 
    while True:
29062 
      (fname, ftype, fid) = iprot.readFieldBegin()
29063 
      if ftype == TType.STOP:
29064 
        break
29065 
      if fid == 0:
29066 
        if ftype == TType.STRING:
29067 
          self.success = iprot.readString();
29068 
        else:
29069 
          iprot.skip(ftype)
29070 
      else:
29071 
        iprot.skip(ftype)
29072 
      iprot.readFieldEnd()
29073 
    iprot.readStructEnd()
29074 
 
29075 
  def write(self, oprot):
29076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29078 
      return
29079 
    oprot.writeStructBegin('validateRecharge_result')
29080 
    if self.success is not None:
29081 
      oprot.writeFieldBegin('success', TType.STRING, 0)
29082 
      oprot.writeString(self.success)
29083 
      oprot.writeFieldEnd()
29084 
    oprot.writeFieldStop()
29085 
    oprot.writeStructEnd()
29086 
 
29087 
  def validate(self):
29088 
    return
29089 
 
29090 
 
29091 
  def __repr__(self):
29092 
    L = ['%s=%r' % (key, value)
29093 
      for key, value in self.__dict__.iteritems()]
29094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29095 
 
29096 
  def __eq__(self, other):
29097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29098 
 
29099 
  def __ne__(self, other):
29100 
    return not (self == other)
29101 
 
6094 rajveer 29102 
class getRechargeOrdersForDevice_args:
29103 
  """
29104 
  Attributes:
29105 
   - deviceNumber
29106 
  """
29107 
 
29108 
  thrift_spec = (
29109 
    None, # 0
29110 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
29111 
  )
29112 
 
29113 
  def __init__(self, deviceNumber=None,):
29114 
    self.deviceNumber = deviceNumber
29115 
 
29116 
  def read(self, iprot):
29117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29119 
      return
29120 
    iprot.readStructBegin()
29121 
    while True:
29122 
      (fname, ftype, fid) = iprot.readFieldBegin()
29123 
      if ftype == TType.STOP:
29124 
        break
29125 
      if fid == 1:
29126 
        if ftype == TType.STRING:
29127 
          self.deviceNumber = iprot.readString();
29128 
        else:
29129 
          iprot.skip(ftype)
29130 
      else:
29131 
        iprot.skip(ftype)
29132 
      iprot.readFieldEnd()
29133 
    iprot.readStructEnd()
29134 
 
29135 
  def write(self, oprot):
29136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29138 
      return
29139 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
29140 
    if self.deviceNumber is not None:
29141 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
29142 
      oprot.writeString(self.deviceNumber)
29143 
      oprot.writeFieldEnd()
29144 
    oprot.writeFieldStop()
29145 
    oprot.writeStructEnd()
29146 
 
29147 
  def validate(self):
29148 
    return
29149 
 
29150 
 
29151 
  def __repr__(self):
29152 
    L = ['%s=%r' % (key, value)
29153 
      for key, value in self.__dict__.iteritems()]
29154 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29155 
 
29156 
  def __eq__(self, other):
29157 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29158 
 
29159 
  def __ne__(self, other):
29160 
    return not (self == other)
29161 
 
29162 
class getRechargeOrdersForDevice_result:
29163 
  """
29164 
  Attributes:
29165 
   - success
29166 
  """
29167 
 
29168 
  thrift_spec = (
29169 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
29170 
  )
29171 
 
29172 
  def __init__(self, success=None,):
29173 
    self.success = success
29174 
 
29175 
  def read(self, iprot):
29176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29178 
      return
29179 
    iprot.readStructBegin()
29180 
    while True:
29181 
      (fname, ftype, fid) = iprot.readFieldBegin()
29182 
      if ftype == TType.STOP:
29183 
        break
29184 
      if fid == 0:
29185 
        if ftype == TType.LIST:
29186 
          self.success = []
6188 rajveer 29187 
          (_etype682, _size679) = iprot.readListBegin()
29188 
          for _i683 in xrange(_size679):
29189 
            _elem684 = RechargeOrder()
29190 
            _elem684.read(iprot)
29191 
            self.success.append(_elem684)
6094 rajveer 29192 
          iprot.readListEnd()
29193 
        else:
29194 
          iprot.skip(ftype)
29195 
      else:
29196 
        iprot.skip(ftype)
29197 
      iprot.readFieldEnd()
29198 
    iprot.readStructEnd()
29199 
 
29200 
  def write(self, oprot):
29201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29203 
      return
29204 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
29205 
    if self.success is not None:
29206 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29207 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29208 
      for iter685 in self.success:
29209 
        iter685.write(oprot)
6094 rajveer 29210 
      oprot.writeListEnd()
29211 
      oprot.writeFieldEnd()
29212 
    oprot.writeFieldStop()
29213 
    oprot.writeStructEnd()
29214 
 
29215 
  def validate(self):
29216 
    return
29217 
 
29218 
 
29219 
  def __repr__(self):
29220 
    L = ['%s=%r' % (key, value)
29221 
      for key, value in self.__dict__.iteritems()]
29222 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29223 
 
29224 
  def __eq__(self, other):
29225 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29226 
 
29227 
  def __ne__(self, other):
29228 
    return not (self == other)
29229 
 
29230 
class addAmountToWallet_args:
29231 
  """
29232 
  Attributes:
29233 
   - userId
29234 
   - orderId
29235 
   - amount
29236 
  """
29237 
 
29238 
  thrift_spec = (
29239 
    None, # 0
29240 
    (1, TType.I64, 'userId', None, None, ), # 1
29241 
    (2, TType.I64, 'orderId', None, None, ), # 2
29242 
    (3, TType.I64, 'amount', None, None, ), # 3
29243 
  )
29244 
 
29245 
  def __init__(self, userId=None, orderId=None, amount=None,):
29246 
    self.userId = userId
29247 
    self.orderId = orderId
29248 
    self.amount = amount
29249 
 
29250 
  def read(self, iprot):
29251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29253 
      return
29254 
    iprot.readStructBegin()
29255 
    while True:
29256 
      (fname, ftype, fid) = iprot.readFieldBegin()
29257 
      if ftype == TType.STOP:
29258 
        break
29259 
      if fid == 1:
29260 
        if ftype == TType.I64:
29261 
          self.userId = iprot.readI64();
29262 
        else:
29263 
          iprot.skip(ftype)
29264 
      elif fid == 2:
29265 
        if ftype == TType.I64:
29266 
          self.orderId = iprot.readI64();
29267 
        else:
29268 
          iprot.skip(ftype)
29269 
      elif fid == 3:
29270 
        if ftype == TType.I64:
29271 
          self.amount = iprot.readI64();
29272 
        else:
29273 
          iprot.skip(ftype)
29274 
      else:
29275 
        iprot.skip(ftype)
29276 
      iprot.readFieldEnd()
29277 
    iprot.readStructEnd()
29278 
 
29279 
  def write(self, oprot):
29280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29282 
      return
29283 
    oprot.writeStructBegin('addAmountToWallet_args')
29284 
    if self.userId is not None:
29285 
      oprot.writeFieldBegin('userId', TType.I64, 1)
29286 
      oprot.writeI64(self.userId)
29287 
      oprot.writeFieldEnd()
29288 
    if self.orderId is not None:
29289 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
29290 
      oprot.writeI64(self.orderId)
29291 
      oprot.writeFieldEnd()
29292 
    if self.amount is not None:
29293 
      oprot.writeFieldBegin('amount', TType.I64, 3)
29294 
      oprot.writeI64(self.amount)
29295 
      oprot.writeFieldEnd()
29296 
    oprot.writeFieldStop()
29297 
    oprot.writeStructEnd()
29298 
 
29299 
  def validate(self):
29300 
    return
29301 
 
29302 
 
29303 
  def __repr__(self):
29304 
    L = ['%s=%r' % (key, value)
29305 
      for key, value in self.__dict__.iteritems()]
29306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29307 
 
29308 
  def __eq__(self, other):
29309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29310 
 
29311 
  def __ne__(self, other):
29312 
    return not (self == other)
29313 
 
29314 
class addAmountToWallet_result:
29315 
 
29316 
  thrift_spec = (
29317 
  )
29318 
 
29319 
  def read(self, iprot):
29320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29322 
      return
29323 
    iprot.readStructBegin()
29324 
    while True:
29325 
      (fname, ftype, fid) = iprot.readFieldBegin()
29326 
      if ftype == TType.STOP:
29327 
        break
29328 
      else:
29329 
        iprot.skip(ftype)
29330 
      iprot.readFieldEnd()
29331 
    iprot.readStructEnd()
29332 
 
29333 
  def write(self, oprot):
29334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29336 
      return
29337 
    oprot.writeStructBegin('addAmountToWallet_result')
29338 
    oprot.writeFieldStop()
29339 
    oprot.writeStructEnd()
29340 
 
29341 
  def validate(self):
29342 
    return
29343 
 
29344 
 
29345 
  def __repr__(self):
29346 
    L = ['%s=%r' % (key, value)
29347 
      for key, value in self.__dict__.iteritems()]
29348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29349 
 
29350 
  def __eq__(self, other):
29351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29352 
 
29353 
  def __ne__(self, other):
29354 
    return not (self == other)
6154 rajveer 29355 
 
6188 rajveer 29356 
class getRechargeStatistics_args:
29357 
 
29358 
  thrift_spec = (
29359 
  )
29360 
 
29361 
  def read(self, iprot):
29362 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29363 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29364 
      return
29365 
    iprot.readStructBegin()
29366 
    while True:
29367 
      (fname, ftype, fid) = iprot.readFieldBegin()
29368 
      if ftype == TType.STOP:
29369 
        break
29370 
      else:
29371 
        iprot.skip(ftype)
29372 
      iprot.readFieldEnd()
29373 
    iprot.readStructEnd()
29374 
 
29375 
  def write(self, oprot):
29376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29378 
      return
29379 
    oprot.writeStructBegin('getRechargeStatistics_args')
29380 
    oprot.writeFieldStop()
29381 
    oprot.writeStructEnd()
29382 
 
29383 
  def validate(self):
29384 
    return
29385 
 
29386 
 
29387 
  def __repr__(self):
29388 
    L = ['%s=%r' % (key, value)
29389 
      for key, value in self.__dict__.iteritems()]
29390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29391 
 
29392 
  def __eq__(self, other):
29393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29394 
 
29395 
  def __ne__(self, other):
29396 
    return not (self == other)
29397 
 
29398 
class getRechargeStatistics_result:
29399 
  """
29400 
  Attributes:
29401 
   - success
29402 
  """
29403 
 
29404 
  thrift_spec = (
29405 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
29406 
  )
29407 
 
29408 
  def __init__(self, success=None,):
29409 
    self.success = success
29410 
 
29411 
  def read(self, iprot):
29412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29414 
      return
29415 
    iprot.readStructBegin()
29416 
    while True:
29417 
      (fname, ftype, fid) = iprot.readFieldBegin()
29418 
      if ftype == TType.STOP:
29419 
        break
29420 
      if fid == 0:
29421 
        if ftype == TType.STRUCT:
29422 
          self.success = RechargeStatistics()
29423 
          self.success.read(iprot)
29424 
        else:
29425 
          iprot.skip(ftype)
29426 
      else:
29427 
        iprot.skip(ftype)
29428 
      iprot.readFieldEnd()
29429 
    iprot.readStructEnd()
29430 
 
29431 
  def write(self, oprot):
29432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29434 
      return
29435 
    oprot.writeStructBegin('getRechargeStatistics_result')
29436 
    if self.success is not None:
29437 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
29438 
      self.success.write(oprot)
29439 
      oprot.writeFieldEnd()
29440 
    oprot.writeFieldStop()
29441 
    oprot.writeStructEnd()
29442 
 
29443 
  def validate(self):
29444 
    return
29445 
 
29446 
 
29447 
  def __repr__(self):
29448 
    L = ['%s=%r' % (key, value)
29449 
      for key, value in self.__dict__.iteritems()]
29450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29451 
 
29452 
  def __eq__(self, other):
29453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29454 
 
29455 
  def __ne__(self, other):
29456 
    return not (self == other)
29457 
 
6154 rajveer 29458 
class getRechargeOrdersForStatus_args:
29459 
  """
29460 
  Attributes:
29461 
   - status
29462 
  """
29463 
 
29464 
  thrift_spec = (
29465 
    None, # 0
29466 
    (1, TType.I64, 'status', None, None, ), # 1
29467 
  )
29468 
 
29469 
  def __init__(self, status=None,):
29470 
    self.status = status
29471 
 
29472 
  def read(self, iprot):
29473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29475 
      return
29476 
    iprot.readStructBegin()
29477 
    while True:
29478 
      (fname, ftype, fid) = iprot.readFieldBegin()
29479 
      if ftype == TType.STOP:
29480 
        break
29481 
      if fid == 1:
29482 
        if ftype == TType.I64:
29483 
          self.status = iprot.readI64();
29484 
        else:
29485 
          iprot.skip(ftype)
29486 
      else:
29487 
        iprot.skip(ftype)
29488 
      iprot.readFieldEnd()
29489 
    iprot.readStructEnd()
29490 
 
29491 
  def write(self, oprot):
29492 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29493 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29494 
      return
29495 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
29496 
    if self.status is not None:
29497 
      oprot.writeFieldBegin('status', TType.I64, 1)
29498 
      oprot.writeI64(self.status)
29499 
      oprot.writeFieldEnd()
29500 
    oprot.writeFieldStop()
29501 
    oprot.writeStructEnd()
29502 
 
29503 
  def validate(self):
29504 
    return
29505 
 
29506 
 
29507 
  def __repr__(self):
29508 
    L = ['%s=%r' % (key, value)
29509 
      for key, value in self.__dict__.iteritems()]
29510 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29511 
 
29512 
  def __eq__(self, other):
29513 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29514 
 
29515 
  def __ne__(self, other):
29516 
    return not (self == other)
29517 
 
29518 
class getRechargeOrdersForStatus_result:
29519 
  """
29520 
  Attributes:
29521 
   - success
29522 
  """
29523 
 
29524 
  thrift_spec = (
29525 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
29526 
  )
29527 
 
29528 
  def __init__(self, success=None,):
29529 
    self.success = success
29530 
 
29531 
  def read(self, iprot):
29532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29534 
      return
29535 
    iprot.readStructBegin()
29536 
    while True:
29537 
      (fname, ftype, fid) = iprot.readFieldBegin()
29538 
      if ftype == TType.STOP:
29539 
        break
29540 
      if fid == 0:
29541 
        if ftype == TType.LIST:
29542 
          self.success = []
6188 rajveer 29543 
          (_etype689, _size686) = iprot.readListBegin()
29544 
          for _i690 in xrange(_size686):
29545 
            _elem691 = RechargeOrder()
29546 
            _elem691.read(iprot)
29547 
            self.success.append(_elem691)
6154 rajveer 29548 
          iprot.readListEnd()
29549 
        else:
29550 
          iprot.skip(ftype)
29551 
      else:
29552 
        iprot.skip(ftype)
29553 
      iprot.readFieldEnd()
29554 
    iprot.readStructEnd()
29555 
 
29556 
  def write(self, oprot):
29557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29559 
      return
29560 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
29561 
    if self.success is not None:
29562 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29563 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29564 
      for iter692 in self.success:
29565 
        iter692.write(oprot)
6154 rajveer 29566 
      oprot.writeListEnd()
29567 
      oprot.writeFieldEnd()
29568 
    oprot.writeFieldStop()
29569 
    oprot.writeStructEnd()
29570 
 
29571 
  def validate(self):
29572 
    return
29573 
 
29574 
 
29575 
  def __repr__(self):
29576 
    L = ['%s=%r' % (key, value)
29577 
      for key, value in self.__dict__.iteritems()]
29578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29579 
 
29580 
  def __eq__(self, other):
29581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29582 
 
29583 
  def __ne__(self, other):
29584 
    return not (self == other)
6159 rajveer 29585 
 
29586 
class getPlansForOperator_args:
29587 
  """
29588 
  Attributes:
29589 
   - operatorId
29590 
  """
29591 
 
29592 
  thrift_spec = (
29593 
    None, # 0
29594 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29595 
  )
29596 
 
29597 
  def __init__(self, operatorId=None,):
29598 
    self.operatorId = operatorId
29599 
 
29600 
  def read(self, iprot):
29601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29603 
      return
29604 
    iprot.readStructBegin()
29605 
    while True:
29606 
      (fname, ftype, fid) = iprot.readFieldBegin()
29607 
      if ftype == TType.STOP:
29608 
        break
29609 
      if fid == 1:
29610 
        if ftype == TType.I64:
29611 
          self.operatorId = iprot.readI64();
29612 
        else:
29613 
          iprot.skip(ftype)
29614 
      else:
29615 
        iprot.skip(ftype)
29616 
      iprot.readFieldEnd()
29617 
    iprot.readStructEnd()
29618 
 
29619 
  def write(self, oprot):
29620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29622 
      return
29623 
    oprot.writeStructBegin('getPlansForOperator_args')
29624 
    if self.operatorId is not None:
29625 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29626 
      oprot.writeI64(self.operatorId)
29627 
      oprot.writeFieldEnd()
29628 
    oprot.writeFieldStop()
29629 
    oprot.writeStructEnd()
29630 
 
29631 
  def validate(self):
29632 
    return
29633 
 
29634 
 
29635 
  def __repr__(self):
29636 
    L = ['%s=%r' % (key, value)
29637 
      for key, value in self.__dict__.iteritems()]
29638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29639 
 
29640 
  def __eq__(self, other):
29641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29642 
 
29643 
  def __ne__(self, other):
29644 
    return not (self == other)
29645 
 
29646 
class getPlansForOperator_result:
29647 
  """
29648 
  Attributes:
29649 
   - success
29650 
  """
29651 
 
29652 
  thrift_spec = (
29653 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
29654 
  )
29655 
 
29656 
  def __init__(self, success=None,):
29657 
    self.success = success
29658 
 
29659 
  def read(self, iprot):
29660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29662 
      return
29663 
    iprot.readStructBegin()
29664 
    while True:
29665 
      (fname, ftype, fid) = iprot.readFieldBegin()
29666 
      if ftype == TType.STOP:
29667 
        break
29668 
      if fid == 0:
29669 
        if ftype == TType.LIST:
29670 
          self.success = []
6188 rajveer 29671 
          (_etype696, _size693) = iprot.readListBegin()
29672 
          for _i697 in xrange(_size693):
29673 
            _elem698 = RechargePlan()
29674 
            _elem698.read(iprot)
29675 
            self.success.append(_elem698)
6159 rajveer 29676 
          iprot.readListEnd()
29677 
        else:
29678 
          iprot.skip(ftype)
29679 
      else:
29680 
        iprot.skip(ftype)
29681 
      iprot.readFieldEnd()
29682 
    iprot.readStructEnd()
29683 
 
29684 
  def write(self, oprot):
29685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29687 
      return
29688 
    oprot.writeStructBegin('getPlansForOperator_result')
29689 
    if self.success is not None:
29690 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29691 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29692 
      for iter699 in self.success:
29693 
        iter699.write(oprot)
6159 rajveer 29694 
      oprot.writeListEnd()
29695 
      oprot.writeFieldEnd()
29696 
    oprot.writeFieldStop()
29697 
    oprot.writeStructEnd()
29698 
 
29699 
  def validate(self):
29700 
    return
29701 
 
29702 
 
29703 
  def __repr__(self):
29704 
    L = ['%s=%r' % (key, value)
29705 
      for key, value in self.__dict__.iteritems()]
29706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29707 
 
29708 
  def __eq__(self, other):
29709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29710 
 
29711 
  def __ne__(self, other):
29712 
    return not (self == other)
6289 anupam.sin 29713 
 
29714 
class getRechargeDenominations_args:
29715 
  """
29716 
  Attributes:
29717 
   - operatorId
6307 anupam.sin 29718 
   - circleCode
6289 anupam.sin 29719 
   - denominationType
29720 
  """
29721 
 
29722 
  thrift_spec = (
29723 
    None, # 0
29724 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 29725 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 29726 
    (3, TType.I32, 'denominationType', None, None, ), # 3
29727 
  )
29728 
 
6307 anupam.sin 29729 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 29730 
    self.operatorId = operatorId
6307 anupam.sin 29731 
    self.circleCode = circleCode
6289 anupam.sin 29732 
    self.denominationType = denominationType
29733 
 
29734 
  def read(self, iprot):
29735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29737 
      return
29738 
    iprot.readStructBegin()
29739 
    while True:
29740 
      (fname, ftype, fid) = iprot.readFieldBegin()
29741 
      if ftype == TType.STOP:
29742 
        break
29743 
      if fid == 1:
29744 
        if ftype == TType.I64:
29745 
          self.operatorId = iprot.readI64();
29746 
        else:
29747 
          iprot.skip(ftype)
29748 
      elif fid == 2:
29749 
        if ftype == TType.STRING:
6307 anupam.sin 29750 
          self.circleCode = iprot.readString();
6289 anupam.sin 29751 
        else:
29752 
          iprot.skip(ftype)
29753 
      elif fid == 3:
29754 
        if ftype == TType.I32:
29755 
          self.denominationType = iprot.readI32();
29756 
        else:
29757 
          iprot.skip(ftype)
29758 
      else:
29759 
        iprot.skip(ftype)
29760 
      iprot.readFieldEnd()
29761 
    iprot.readStructEnd()
29762 
 
29763 
  def write(self, oprot):
29764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29766 
      return
29767 
    oprot.writeStructBegin('getRechargeDenominations_args')
29768 
    if self.operatorId is not None:
29769 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29770 
      oprot.writeI64(self.operatorId)
29771 
      oprot.writeFieldEnd()
6307 anupam.sin 29772 
    if self.circleCode is not None:
29773 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
29774 
      oprot.writeString(self.circleCode)
6289 anupam.sin 29775 
      oprot.writeFieldEnd()
29776 
    if self.denominationType is not None:
29777 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
29778 
      oprot.writeI32(self.denominationType)
29779 
      oprot.writeFieldEnd()
29780 
    oprot.writeFieldStop()
29781 
    oprot.writeStructEnd()
29782 
 
29783 
  def validate(self):
29784 
    return
29785 
 
29786 
 
29787 
  def __repr__(self):
29788 
    L = ['%s=%r' % (key, value)
29789 
      for key, value in self.__dict__.iteritems()]
29790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29791 
 
29792 
  def __eq__(self, other):
29793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29794 
 
29795 
  def __ne__(self, other):
29796 
    return not (self == other)
29797 
 
29798 
class getRechargeDenominations_result:
29799 
  """
29800 
  Attributes:
29801 
   - success
29802 
   - ex
29803 
  """
29804 
 
29805 
  thrift_spec = (
29806 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
29807 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29808 
  )
29809 
 
29810 
  def __init__(self, success=None, ex=None,):
29811 
    self.success = success
29812 
    self.ex = ex
29813 
 
29814 
  def read(self, iprot):
29815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29817 
      return
29818 
    iprot.readStructBegin()
29819 
    while True:
29820 
      (fname, ftype, fid) = iprot.readFieldBegin()
29821 
      if ftype == TType.STOP:
29822 
        break
29823 
      if fid == 0:
29824 
        if ftype == TType.LIST:
29825 
          self.success = []
29826 
          (_etype703, _size700) = iprot.readListBegin()
29827 
          for _i704 in xrange(_size700):
29828 
            _elem705 = RechargeDenomination()
29829 
            _elem705.read(iprot)
29830 
            self.success.append(_elem705)
29831 
          iprot.readListEnd()
29832 
        else:
29833 
          iprot.skip(ftype)
29834 
      elif fid == 1:
29835 
        if ftype == TType.STRUCT:
29836 
          self.ex = TransactionServiceException()
29837 
          self.ex.read(iprot)
29838 
        else:
29839 
          iprot.skip(ftype)
29840 
      else:
29841 
        iprot.skip(ftype)
29842 
      iprot.readFieldEnd()
29843 
    iprot.readStructEnd()
29844 
 
29845 
  def write(self, oprot):
29846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29848 
      return
29849 
    oprot.writeStructBegin('getRechargeDenominations_result')
29850 
    if self.success is not None:
29851 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29852 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29853 
      for iter706 in self.success:
29854 
        iter706.write(oprot)
29855 
      oprot.writeListEnd()
29856 
      oprot.writeFieldEnd()
29857 
    if self.ex is not None:
29858 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29859 
      self.ex.write(oprot)
29860 
      oprot.writeFieldEnd()
29861 
    oprot.writeFieldStop()
29862 
    oprot.writeStructEnd()
29863 
 
29864 
  def validate(self):
29865 
    return
29866 
 
29867 
 
29868 
  def __repr__(self):
29869 
    L = ['%s=%r' % (key, value)
29870 
      for key, value in self.__dict__.iteritems()]
29871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29872 
 
29873 
  def __eq__(self, other):
29874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29875 
 
29876 
  def __ne__(self, other):
29877 
    return not (self == other)
6371 rajveer 29878 
 
29879 
class updateAvailabilityStatus_args:
29880 
  """
29881 
  Attributes:
29882 
   - operatorId
29883 
   - circleId
29884 
   - isAvailable
29885 
  """
29886 
 
29887 
  thrift_spec = (
29888 
    None, # 0
29889 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29890 
    (2, TType.I64, 'circleId', None, None, ), # 2
29891 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
29892 
  )
29893 
 
29894 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
29895 
    self.operatorId = operatorId
29896 
    self.circleId = circleId
29897 
    self.isAvailable = isAvailable
29898 
 
29899 
  def read(self, iprot):
29900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29902 
      return
29903 
    iprot.readStructBegin()
29904 
    while True:
29905 
      (fname, ftype, fid) = iprot.readFieldBegin()
29906 
      if ftype == TType.STOP:
29907 
        break
29908 
      if fid == 1:
29909 
        if ftype == TType.I64:
29910 
          self.operatorId = iprot.readI64();
29911 
        else:
29912 
          iprot.skip(ftype)
29913 
      elif fid == 2:
29914 
        if ftype == TType.I64:
29915 
          self.circleId = iprot.readI64();
29916 
        else:
29917 
          iprot.skip(ftype)
29918 
      elif fid == 3:
29919 
        if ftype == TType.BOOL:
29920 
          self.isAvailable = iprot.readBool();
29921 
        else:
29922 
          iprot.skip(ftype)
29923 
      else:
29924 
        iprot.skip(ftype)
29925 
      iprot.readFieldEnd()
29926 
    iprot.readStructEnd()
29927 
 
29928 
  def write(self, oprot):
29929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29931 
      return
29932 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
29933 
    if self.operatorId is not None:
29934 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29935 
      oprot.writeI64(self.operatorId)
29936 
      oprot.writeFieldEnd()
29937 
    if self.circleId is not None:
29938 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
29939 
      oprot.writeI64(self.circleId)
29940 
      oprot.writeFieldEnd()
29941 
    if self.isAvailable is not None:
29942 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
29943 
      oprot.writeBool(self.isAvailable)
29944 
      oprot.writeFieldEnd()
29945 
    oprot.writeFieldStop()
29946 
    oprot.writeStructEnd()
29947 
 
29948 
  def validate(self):
29949 
    return
29950 
 
29951 
 
29952 
  def __repr__(self):
29953 
    L = ['%s=%r' % (key, value)
29954 
      for key, value in self.__dict__.iteritems()]
29955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29956 
 
29957 
  def __eq__(self, other):
29958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29959 
 
29960 
  def __ne__(self, other):
29961 
    return not (self == other)
29962 
 
29963 
class updateAvailabilityStatus_result:
29964 
 
29965 
  thrift_spec = (
29966 
  )
29967 
 
29968 
  def read(self, iprot):
29969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29971 
      return
29972 
    iprot.readStructBegin()
29973 
    while True:
29974 
      (fname, ftype, fid) = iprot.readFieldBegin()
29975 
      if ftype == TType.STOP:
29976 
        break
29977 
      else:
29978 
        iprot.skip(ftype)
29979 
      iprot.readFieldEnd()
29980 
    iprot.readStructEnd()
29981 
 
29982 
  def write(self, oprot):
29983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29985 
      return
29986 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
29987 
    oprot.writeFieldStop()
29988 
    oprot.writeStructEnd()
29989 
 
29990 
  def validate(self):
29991 
    return
29992 
 
29993 
 
29994 
  def __repr__(self):
29995 
    L = ['%s=%r' % (key, value)
29996 
      for key, value in self.__dict__.iteritems()]
29997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29998 
 
29999 
  def __eq__(self, other):
30000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30001 
 
30002 
  def __ne__(self, other):
30003 
    return not (self == other)
6389 rajveer 30004 
 
30005 
class getAvailableEmiSchemes_args:
30006 
 
30007 
  thrift_spec = (
30008 
  )
30009 
 
30010 
  def read(self, iprot):
30011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30013 
      return
30014 
    iprot.readStructBegin()
30015 
    while True:
30016 
      (fname, ftype, fid) = iprot.readFieldBegin()
30017 
      if ftype == TType.STOP:
30018 
        break
30019 
      else:
30020 
        iprot.skip(ftype)
30021 
      iprot.readFieldEnd()
30022 
    iprot.readStructEnd()
30023 
 
30024 
  def write(self, oprot):
30025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30027 
      return
30028 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
30029 
    oprot.writeFieldStop()
30030 
    oprot.writeStructEnd()
30031 
 
30032 
  def validate(self):
30033 
    return
30034 
 
30035 
 
30036 
  def __repr__(self):
30037 
    L = ['%s=%r' % (key, value)
30038 
      for key, value in self.__dict__.iteritems()]
30039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30040 
 
30041 
  def __eq__(self, other):
30042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30043 
 
30044 
  def __ne__(self, other):
30045 
    return not (self == other)
30046 
 
30047 
class getAvailableEmiSchemes_result:
30048 
  """
30049 
  Attributes:
30050 
   - success
30051 
  """
30052 
 
30053 
  thrift_spec = (
30054 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
30055 
  )
30056 
 
30057 
  def __init__(self, success=None,):
30058 
    self.success = success
30059 
 
30060 
  def read(self, iprot):
30061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30063 
      return
30064 
    iprot.readStructBegin()
30065 
    while True:
30066 
      (fname, ftype, fid) = iprot.readFieldBegin()
30067 
      if ftype == TType.STOP:
30068 
        break
30069 
      if fid == 0:
30070 
        if ftype == TType.LIST:
30071 
          self.success = []
30072 
          (_etype710, _size707) = iprot.readListBegin()
30073 
          for _i711 in xrange(_size707):
30074 
            _elem712 = EmiScheme()
30075 
            _elem712.read(iprot)
30076 
            self.success.append(_elem712)
30077 
          iprot.readListEnd()
30078 
        else:
30079 
          iprot.skip(ftype)
30080 
      else:
30081 
        iprot.skip(ftype)
30082 
      iprot.readFieldEnd()
30083 
    iprot.readStructEnd()
30084 
 
30085 
  def write(self, oprot):
30086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30088 
      return
30089 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
30090 
    if self.success is not None:
30091 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30092 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30093 
      for iter713 in self.success:
30094 
        iter713.write(oprot)
30095 
      oprot.writeListEnd()
30096 
      oprot.writeFieldEnd()
30097 
    oprot.writeFieldStop()
30098 
    oprot.writeStructEnd()
30099 
 
30100 
  def validate(self):
30101 
    return
30102 
 
30103 
 
30104 
  def __repr__(self):
30105 
    L = ['%s=%r' % (key, value)
30106 
      for key, value in self.__dict__.iteritems()]
30107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30108 
 
30109 
  def __eq__(self, other):
30110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30111 
 
30112 
  def __ne__(self, other):
30113 
    return not (self == other)
30114 
 
30115 
class getMiscCharges_args:
30116 
  """
30117 
  Attributes:
30118 
   - transactionId
30119 
  """
30120 
 
30121 
  thrift_spec = (
30122 
    None, # 0
30123 
    (1, TType.I64, 'transactionId', None, None, ), # 1
30124 
  )
30125 
 
30126 
  def __init__(self, transactionId=None,):
30127 
    self.transactionId = transactionId
30128 
 
30129 
  def read(self, iprot):
30130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30132 
      return
30133 
    iprot.readStructBegin()
30134 
    while True:
30135 
      (fname, ftype, fid) = iprot.readFieldBegin()
30136 
      if ftype == TType.STOP:
30137 
        break
30138 
      if fid == 1:
30139 
        if ftype == TType.I64:
30140 
          self.transactionId = iprot.readI64();
30141 
        else:
30142 
          iprot.skip(ftype)
30143 
      else:
30144 
        iprot.skip(ftype)
30145 
      iprot.readFieldEnd()
30146 
    iprot.readStructEnd()
30147 
 
30148 
  def write(self, oprot):
30149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30151 
      return
30152 
    oprot.writeStructBegin('getMiscCharges_args')
30153 
    if self.transactionId is not None:
30154 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
30155 
      oprot.writeI64(self.transactionId)
30156 
      oprot.writeFieldEnd()
30157 
    oprot.writeFieldStop()
30158 
    oprot.writeStructEnd()
30159 
 
30160 
  def validate(self):
30161 
    return
30162 
 
30163 
 
30164 
  def __repr__(self):
30165 
    L = ['%s=%r' % (key, value)
30166 
      for key, value in self.__dict__.iteritems()]
30167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30168 
 
30169 
  def __eq__(self, other):
30170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30171 
 
30172 
  def __ne__(self, other):
30173 
    return not (self == other)
30174 
 
30175 
class getMiscCharges_result:
30176 
  """
30177 
  Attributes:
30178 
   - success
30179 
  """
30180 
 
30181 
  thrift_spec = (
6412 rajveer 30182 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 30183 
  )
30184 
 
30185 
  def __init__(self, success=None,):
30186 
    self.success = success
30187 
 
30188 
  def read(self, iprot):
30189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30191 
      return
30192 
    iprot.readStructBegin()
30193 
    while True:
30194 
      (fname, ftype, fid) = iprot.readFieldBegin()
30195 
      if ftype == TType.STOP:
30196 
        break
30197 
      if fid == 0:
30198 
        if ftype == TType.MAP:
30199 
          self.success = {}
30200 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
30201 
          for _i718 in xrange(_size714):
30202 
            _key719 = iprot.readI64();
6412 rajveer 30203 
            _val720 = iprot.readDouble();
6389 rajveer 30204 
            self.success[_key719] = _val720
30205 
          iprot.readMapEnd()
30206 
        else:
30207 
          iprot.skip(ftype)
30208 
      else:
30209 
        iprot.skip(ftype)
30210 
      iprot.readFieldEnd()
30211 
    iprot.readStructEnd()
30212 
 
30213 
  def write(self, oprot):
30214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30216 
      return
30217 
    oprot.writeStructBegin('getMiscCharges_result')
30218 
    if self.success is not None:
30219 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 30220 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 30221 
      for kiter721,viter722 in self.success.items():
30222 
        oprot.writeI64(kiter721)
6412 rajveer 30223 
        oprot.writeDouble(viter722)
6389 rajveer 30224 
      oprot.writeMapEnd()
30225 
      oprot.writeFieldEnd()
30226 
    oprot.writeFieldStop()
30227 
    oprot.writeStructEnd()
30228 
 
30229 
  def validate(self):
30230 
    return
30231 
 
30232 
 
30233 
  def __repr__(self):
30234 
    L = ['%s=%r' % (key, value)
30235 
      for key, value in self.__dict__.iteritems()]
30236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30237 
 
30238 
  def __eq__(self, other):
30239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30240 
 
30241 
  def __ne__(self, other):
30242 
    return not (self == other)
6507 anupam.sin 30243 
 
30244 
class refundRechargeOrder_args:
30245 
  """
30246 
  Attributes:
30247 
   - rechargeOrderId
30248 
  """
30249 
 
30250 
  thrift_spec = (
30251 
    None, # 0
30252 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
30253 
  )
30254 
 
30255 
  def __init__(self, rechargeOrderId=None,):
30256 
    self.rechargeOrderId = rechargeOrderId
30257 
 
30258 
  def read(self, iprot):
30259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30261 
      return
30262 
    iprot.readStructBegin()
30263 
    while True:
30264 
      (fname, ftype, fid) = iprot.readFieldBegin()
30265 
      if ftype == TType.STOP:
30266 
        break
30267 
      if fid == 1:
30268 
        if ftype == TType.I64:
30269 
          self.rechargeOrderId = iprot.readI64();
30270 
        else:
30271 
          iprot.skip(ftype)
30272 
      else:
30273 
        iprot.skip(ftype)
30274 
      iprot.readFieldEnd()
30275 
    iprot.readStructEnd()
30276 
 
30277 
  def write(self, oprot):
30278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30280 
      return
30281 
    oprot.writeStructBegin('refundRechargeOrder_args')
30282 
    if self.rechargeOrderId is not None:
30283 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
30284 
      oprot.writeI64(self.rechargeOrderId)
30285 
      oprot.writeFieldEnd()
30286 
    oprot.writeFieldStop()
30287 
    oprot.writeStructEnd()
30288 
 
30289 
  def validate(self):
30290 
    return
30291 
 
30292 
 
30293 
  def __repr__(self):
30294 
    L = ['%s=%r' % (key, value)
30295 
      for key, value in self.__dict__.iteritems()]
30296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30297 
 
30298 
  def __eq__(self, other):
30299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30300 
 
30301 
  def __ne__(self, other):
30302 
    return not (self == other)
30303 
 
30304 
class refundRechargeOrder_result:
30305 
  """
30306 
  Attributes:
30307 
   - success
30308 
   - ex
30309 
  """
30310 
 
30311 
  thrift_spec = (
30312 
    (0, TType.BOOL, 'success', None, None, ), # 0
30313 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
30314 
  )
30315 
 
30316 
  def __init__(self, success=None, ex=None,):
30317 
    self.success = success
30318 
    self.ex = ex
30319 
 
30320 
  def read(self, iprot):
30321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30323 
      return
30324 
    iprot.readStructBegin()
30325 
    while True:
30326 
      (fname, ftype, fid) = iprot.readFieldBegin()
30327 
      if ftype == TType.STOP:
30328 
        break
30329 
      if fid == 0:
30330 
        if ftype == TType.BOOL:
30331 
          self.success = iprot.readBool();
30332 
        else:
30333 
          iprot.skip(ftype)
30334 
      elif fid == 1:
30335 
        if ftype == TType.STRUCT:
30336 
          self.ex = TransactionServiceException()
30337 
          self.ex.read(iprot)
30338 
        else:
30339 
          iprot.skip(ftype)
30340 
      else:
30341 
        iprot.skip(ftype)
30342 
      iprot.readFieldEnd()
30343 
    iprot.readStructEnd()
30344 
 
30345 
  def write(self, oprot):
30346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30348 
      return
30349 
    oprot.writeStructBegin('refundRechargeOrder_result')
30350 
    if self.success is not None:
30351 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30352 
      oprot.writeBool(self.success)
30353 
      oprot.writeFieldEnd()
30354 
    if self.ex is not None:
30355 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
30356 
      self.ex.write(oprot)
30357 
      oprot.writeFieldEnd()
30358 
    oprot.writeFieldStop()
30359 
    oprot.writeStructEnd()
30360 
 
30361 
  def validate(self):
30362 
    return
30363 
 
30364 
 
30365 
  def __repr__(self):
30366 
    L = ['%s=%r' % (key, value)
30367 
      for key, value in self.__dict__.iteritems()]
30368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30369 
 
30370 
  def __eq__(self, other):
30371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30372 
 
30373 
  def __ne__(self, other):
30374 
    return not (self == other)
6821 amar.kumar 30375 
 
30376 
class getPhysicalOrders_args:
30377 
  """
30378 
  Attributes:
30379 
   - fromDate
30380 
   - toDate
30381 
  """
30382 
 
30383 
  thrift_spec = (
30384 
    None, # 0
30385 
    (1, TType.I64, 'fromDate', None, None, ), # 1
30386 
    (2, TType.I64, 'toDate', None, None, ), # 2
30387 
  )
30388 
 
30389 
  def __init__(self, fromDate=None, toDate=None,):
30390 
    self.fromDate = fromDate
30391 
    self.toDate = toDate
30392 
 
30393 
  def read(self, iprot):
30394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30396 
      return
30397 
    iprot.readStructBegin()
30398 
    while True:
30399 
      (fname, ftype, fid) = iprot.readFieldBegin()
30400 
      if ftype == TType.STOP:
30401 
        break
30402 
      if fid == 1:
30403 
        if ftype == TType.I64:
30404 
          self.fromDate = iprot.readI64();
30405 
        else:
30406 
          iprot.skip(ftype)
30407 
      elif fid == 2:
30408 
        if ftype == TType.I64:
30409 
          self.toDate = iprot.readI64();
30410 
        else:
30411 
          iprot.skip(ftype)
30412 
      else:
30413 
        iprot.skip(ftype)
30414 
      iprot.readFieldEnd()
30415 
    iprot.readStructEnd()
30416 
 
30417 
  def write(self, oprot):
30418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30420 
      return
30421 
    oprot.writeStructBegin('getPhysicalOrders_args')
30422 
    if self.fromDate is not None:
30423 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
30424 
      oprot.writeI64(self.fromDate)
30425 
      oprot.writeFieldEnd()
30426 
    if self.toDate is not None:
30427 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
30428 
      oprot.writeI64(self.toDate)
30429 
      oprot.writeFieldEnd()
30430 
    oprot.writeFieldStop()
30431 
    oprot.writeStructEnd()
30432 
 
30433 
  def validate(self):
30434 
    return
30435 
 
30436 
 
30437 
  def __repr__(self):
30438 
    L = ['%s=%r' % (key, value)
30439 
      for key, value in self.__dict__.iteritems()]
30440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30441 
 
30442 
  def __eq__(self, other):
30443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30444 
 
30445 
  def __ne__(self, other):
30446 
    return not (self == other)
30447 
 
30448 
class getPhysicalOrders_result:
30449 
  """
30450 
  Attributes:
30451 
   - success
30452 
  """
30453 
 
30454 
  thrift_spec = (
30455 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
30456 
  )
30457 
 
30458 
  def __init__(self, success=None,):
30459 
    self.success = success
30460 
 
30461 
  def read(self, iprot):
30462 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30463 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30464 
      return
30465 
    iprot.readStructBegin()
30466 
    while True:
30467 
      (fname, ftype, fid) = iprot.readFieldBegin()
30468 
      if ftype == TType.STOP:
30469 
        break
30470 
      if fid == 0:
30471 
        if ftype == TType.LIST:
30472 
          self.success = []
30473 
          (_etype726, _size723) = iprot.readListBegin()
30474 
          for _i727 in xrange(_size723):
30475 
            _elem728 = Order()
30476 
            _elem728.read(iprot)
30477 
            self.success.append(_elem728)
30478 
          iprot.readListEnd()
30479 
        else:
30480 
          iprot.skip(ftype)
30481 
      else:
30482 
        iprot.skip(ftype)
30483 
      iprot.readFieldEnd()
30484 
    iprot.readStructEnd()
30485 
 
30486 
  def write(self, oprot):
30487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30489 
      return
30490 
    oprot.writeStructBegin('getPhysicalOrders_result')
30491 
    if self.success is not None:
30492 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30493 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
30494 
      for iter729 in self.success:
30495 
        iter729.write(oprot)
30496 
      oprot.writeListEnd()
30497 
      oprot.writeFieldEnd()
30498 
    oprot.writeFieldStop()
30499 
    oprot.writeStructEnd()
30500 
 
30501 
  def validate(self):
30502 
    return
30503 
 
30504 
 
30505 
  def __repr__(self):
30506 
    L = ['%s=%r' % (key, value)
30507 
      for key, value in self.__dict__.iteritems()]
30508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30509 
 
30510 
  def __eq__(self, other):
30511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30512 
 
30513 
  def __ne__(self, other):
30514 
    return not (self == other)
6906 rajveer 30515 
 
30516 
class getDocument_args:
30517 
  """
30518 
  Attributes:
30519 
   - docType
30520 
   - docSource
30521 
  """
30522 
 
30523 
  thrift_spec = (
30524 
    None, # 0
30525 
    (1, TType.I64, 'docType', None, None, ), # 1
30526 
    (2, TType.I64, 'docSource', None, None, ), # 2
30527 
  )
30528 
 
30529 
  def __init__(self, docType=None, docSource=None,):
30530 
    self.docType = docType
30531 
    self.docSource = docSource
30532 
 
30533 
  def read(self, iprot):
30534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30536 
      return
30537 
    iprot.readStructBegin()
30538 
    while True:
30539 
      (fname, ftype, fid) = iprot.readFieldBegin()
30540 
      if ftype == TType.STOP:
30541 
        break
30542 
      if fid == 1:
30543 
        if ftype == TType.I64:
30544 
          self.docType = iprot.readI64();
30545 
        else:
30546 
          iprot.skip(ftype)
30547 
      elif fid == 2:
30548 
        if ftype == TType.I64:
30549 
          self.docSource = iprot.readI64();
30550 
        else:
30551 
          iprot.skip(ftype)
30552 
      else:
30553 
        iprot.skip(ftype)
30554 
      iprot.readFieldEnd()
30555 
    iprot.readStructEnd()
30556 
 
30557 
  def write(self, oprot):
30558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30560 
      return
30561 
    oprot.writeStructBegin('getDocument_args')
30562 
    if self.docType is not None:
30563 
      oprot.writeFieldBegin('docType', TType.I64, 1)
30564 
      oprot.writeI64(self.docType)
30565 
      oprot.writeFieldEnd()
30566 
    if self.docSource is not None:
30567 
      oprot.writeFieldBegin('docSource', TType.I64, 2)
30568 
      oprot.writeI64(self.docSource)
30569 
      oprot.writeFieldEnd()
30570 
    oprot.writeFieldStop()
30571 
    oprot.writeStructEnd()
30572 
 
30573 
  def validate(self):
30574 
    return
30575 
 
30576 
 
30577 
  def __repr__(self):
30578 
    L = ['%s=%r' % (key, value)
30579 
      for key, value in self.__dict__.iteritems()]
30580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30581 
 
30582 
  def __eq__(self, other):
30583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30584 
 
30585 
  def __ne__(self, other):
30586 
    return not (self == other)
30587 
 
30588 
class getDocument_result:
30589 
  """
30590 
  Attributes:
30591 
   - success
30592 
  """
30593 
 
30594 
  thrift_spec = (
30595 
    (0, TType.STRING, 'success', None, None, ), # 0
30596 
  )
30597 
 
30598 
  def __init__(self, success=None,):
30599 
    self.success = success
30600 
 
30601 
  def read(self, iprot):
30602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30604 
      return
30605 
    iprot.readStructBegin()
30606 
    while True:
30607 
      (fname, ftype, fid) = iprot.readFieldBegin()
30608 
      if ftype == TType.STOP:
30609 
        break
30610 
      if fid == 0:
30611 
        if ftype == TType.STRING:
30612 
          self.success = iprot.readString();
30613 
        else:
30614 
          iprot.skip(ftype)
30615 
      else:
30616 
        iprot.skip(ftype)
30617 
      iprot.readFieldEnd()
30618 
    iprot.readStructEnd()
30619 
 
30620 
  def write(self, oprot):
30621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30623 
      return
30624 
    oprot.writeStructBegin('getDocument_result')
30625 
    if self.success is not None:
30626 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30627 
      oprot.writeString(self.success)
30628 
      oprot.writeFieldEnd()
30629 
    oprot.writeFieldStop()
30630 
    oprot.writeStructEnd()
30631 
 
30632 
  def validate(self):
30633 
    return
30634 
 
30635 
 
30636 
  def __repr__(self):
30637 
    L = ['%s=%r' % (key, value)
30638 
      for key, value in self.__dict__.iteritems()]
30639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30640 
 
30641 
  def __eq__(self, other):
30642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30643 
 
30644 
  def __ne__(self, other):
30645 
    return not (self == other)
6985 anupam.sin 30646 
 
30647 
class changeShippingAddress_args:
30648 
  """
30649 
  Attributes:
30650 
   - orderId
30651 
   - line1
30652 
   - line2
30653 
   - city
30654 
   - state
30655 
   - pin
30656 
  """
30657 
 
30658 
  thrift_spec = (
30659 
    None, # 0
30660 
    (1, TType.I64, 'orderId', None, None, ), # 1
30661 
    (2, TType.STRING, 'line1', None, None, ), # 2
30662 
    (3, TType.STRING, 'line2', None, None, ), # 3
30663 
    (4, TType.STRING, 'city', None, None, ), # 4
30664 
    (5, TType.STRING, 'state', None, None, ), # 5
30665 
    (6, TType.STRING, 'pin', None, None, ), # 6
30666 
  )
30667 
 
30668 
  def __init__(self, orderId=None, line1=None, line2=None, city=None, state=None, pin=None,):
30669 
    self.orderId = orderId
30670 
    self.line1 = line1
30671 
    self.line2 = line2
30672 
    self.city = city
30673 
    self.state = state
30674 
    self.pin = pin
30675 
 
30676 
  def read(self, iprot):
30677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30679 
      return
30680 
    iprot.readStructBegin()
30681 
    while True:
30682 
      (fname, ftype, fid) = iprot.readFieldBegin()
30683 
      if ftype == TType.STOP:
30684 
        break
30685 
      if fid == 1:
30686 
        if ftype == TType.I64:
30687 
          self.orderId = iprot.readI64();
30688 
        else:
30689 
          iprot.skip(ftype)
30690 
      elif fid == 2:
30691 
        if ftype == TType.STRING:
30692 
          self.line1 = iprot.readString();
30693 
        else:
30694 
          iprot.skip(ftype)
30695 
      elif fid == 3:
30696 
        if ftype == TType.STRING:
30697 
          self.line2 = iprot.readString();
30698 
        else:
30699 
          iprot.skip(ftype)
30700 
      elif fid == 4:
30701 
        if ftype == TType.STRING:
30702 
          self.city = iprot.readString();
30703 
        else:
30704 
          iprot.skip(ftype)
30705 
      elif fid == 5:
30706 
        if ftype == TType.STRING:
30707 
          self.state = iprot.readString();
30708 
        else:
30709 
          iprot.skip(ftype)
30710 
      elif fid == 6:
30711 
        if ftype == TType.STRING:
30712 
          self.pin = iprot.readString();
30713 
        else:
30714 
          iprot.skip(ftype)
30715 
      else:
30716 
        iprot.skip(ftype)
30717 
      iprot.readFieldEnd()
30718 
    iprot.readStructEnd()
30719 
 
30720 
  def write(self, oprot):
30721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30723 
      return
30724 
    oprot.writeStructBegin('changeShippingAddress_args')
30725 
    if self.orderId is not None:
30726 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30727 
      oprot.writeI64(self.orderId)
30728 
      oprot.writeFieldEnd()
30729 
    if self.line1 is not None:
30730 
      oprot.writeFieldBegin('line1', TType.STRING, 2)
30731 
      oprot.writeString(self.line1)
30732 
      oprot.writeFieldEnd()
30733 
    if self.line2 is not None:
30734 
      oprot.writeFieldBegin('line2', TType.STRING, 3)
30735 
      oprot.writeString(self.line2)
30736 
      oprot.writeFieldEnd()
30737 
    if self.city is not None:
30738 
      oprot.writeFieldBegin('city', TType.STRING, 4)
30739 
      oprot.writeString(self.city)
30740 
      oprot.writeFieldEnd()
30741 
    if self.state is not None:
30742 
      oprot.writeFieldBegin('state', TType.STRING, 5)
30743 
      oprot.writeString(self.state)
30744 
      oprot.writeFieldEnd()
30745 
    if self.pin is not None:
30746 
      oprot.writeFieldBegin('pin', TType.STRING, 6)
30747 
      oprot.writeString(self.pin)
30748 
      oprot.writeFieldEnd()
30749 
    oprot.writeFieldStop()
30750 
    oprot.writeStructEnd()
30751 
 
30752 
  def validate(self):
30753 
    return
30754 
 
30755 
 
30756 
  def __repr__(self):
30757 
    L = ['%s=%r' % (key, value)
30758 
      for key, value in self.__dict__.iteritems()]
30759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30760 
 
30761 
  def __eq__(self, other):
30762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30763 
 
30764 
  def __ne__(self, other):
30765 
    return not (self == other)
30766 
 
30767 
class changeShippingAddress_result:
30768 
  """
30769 
  Attributes:
30770 
   - success
30771 
  """
30772 
 
30773 
  thrift_spec = (
30774 
    (0, TType.BOOL, 'success', None, None, ), # 0
30775 
  )
30776 
 
30777 
  def __init__(self, success=None,):
30778 
    self.success = success
30779 
 
30780 
  def read(self, iprot):
30781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30783 
      return
30784 
    iprot.readStructBegin()
30785 
    while True:
30786 
      (fname, ftype, fid) = iprot.readFieldBegin()
30787 
      if ftype == TType.STOP:
30788 
        break
30789 
      if fid == 0:
30790 
        if ftype == TType.BOOL:
30791 
          self.success = iprot.readBool();
30792 
        else:
30793 
          iprot.skip(ftype)
30794 
      else:
30795 
        iprot.skip(ftype)
30796 
      iprot.readFieldEnd()
30797 
    iprot.readStructEnd()
30798 
 
30799 
  def write(self, oprot):
30800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30802 
      return
30803 
    oprot.writeStructBegin('changeShippingAddress_result')
30804 
    if self.success is not None:
30805 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30806 
      oprot.writeBool(self.success)
30807 
      oprot.writeFieldEnd()
30808 
    oprot.writeFieldStop()
30809 
    oprot.writeStructEnd()
30810 
 
30811 
  def validate(self):
30812 
    return
30813 
 
30814 
 
30815 
  def __repr__(self):
30816 
    L = ['%s=%r' % (key, value)
30817 
      for key, value in self.__dict__.iteritems()]
30818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30819 
 
30820 
  def __eq__(self, other):
30821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30822 
 
30823 
  def __ne__(self, other):
30824 
    return not (self == other)
6988 rajveer 30825 
 
30826 
class retrieveInvoice_args:
30827 
  """
30828 
  Attributes:
30829 
   - orderId
7075 rajveer 30830 
   - userId
6988 rajveer 30831 
  """
30832 
 
30833 
  thrift_spec = (
30834 
    None, # 0
30835 
    (1, TType.I64, 'orderId', None, None, ), # 1
7075 rajveer 30836 
    (2, TType.I64, 'userId', None, None, ), # 2
6988 rajveer 30837 
  )
30838 
 
7075 rajveer 30839 
  def __init__(self, orderId=None, userId=None,):
6988 rajveer 30840 
    self.orderId = orderId
7075 rajveer 30841 
    self.userId = userId
6988 rajveer 30842 
 
30843 
  def read(self, iprot):
30844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30846 
      return
30847 
    iprot.readStructBegin()
30848 
    while True:
30849 
      (fname, ftype, fid) = iprot.readFieldBegin()
30850 
      if ftype == TType.STOP:
30851 
        break
30852 
      if fid == 1:
30853 
        if ftype == TType.I64:
30854 
          self.orderId = iprot.readI64();
30855 
        else:
30856 
          iprot.skip(ftype)
7075 rajveer 30857 
      elif fid == 2:
30858 
        if ftype == TType.I64:
30859 
          self.userId = iprot.readI64();
30860 
        else:
30861 
          iprot.skip(ftype)
6988 rajveer 30862 
      else:
30863 
        iprot.skip(ftype)
30864 
      iprot.readFieldEnd()
30865 
    iprot.readStructEnd()
30866 
 
30867 
  def write(self, oprot):
30868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30870 
      return
30871 
    oprot.writeStructBegin('retrieveInvoice_args')
30872 
    if self.orderId is not None:
30873 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30874 
      oprot.writeI64(self.orderId)
30875 
      oprot.writeFieldEnd()
7075 rajveer 30876 
    if self.userId is not None:
30877 
      oprot.writeFieldBegin('userId', TType.I64, 2)
30878 
      oprot.writeI64(self.userId)
30879 
      oprot.writeFieldEnd()
6988 rajveer 30880 
    oprot.writeFieldStop()
30881 
    oprot.writeStructEnd()
30882 
 
30883 
  def validate(self):
30884 
    return
30885 
 
30886 
 
30887 
  def __repr__(self):
30888 
    L = ['%s=%r' % (key, value)
30889 
      for key, value in self.__dict__.iteritems()]
30890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30891 
 
30892 
  def __eq__(self, other):
30893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30894 
 
30895 
  def __ne__(self, other):
30896 
    return not (self == other)
30897 
 
30898 
class retrieveInvoice_result:
30899 
  """
30900 
  Attributes:
30901 
   - success
30902 
  """
30903 
 
30904 
  thrift_spec = (
30905 
    (0, TType.STRING, 'success', None, None, ), # 0
30906 
  )
30907 
 
30908 
  def __init__(self, success=None,):
30909 
    self.success = success
30910 
 
30911 
  def read(self, iprot):
30912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30914 
      return
30915 
    iprot.readStructBegin()
30916 
    while True:
30917 
      (fname, ftype, fid) = iprot.readFieldBegin()
30918 
      if ftype == TType.STOP:
30919 
        break
30920 
      if fid == 0:
30921 
        if ftype == TType.STRING:
30922 
          self.success = iprot.readString();
30923 
        else:
30924 
          iprot.skip(ftype)
30925 
      else:
30926 
        iprot.skip(ftype)
30927 
      iprot.readFieldEnd()
30928 
    iprot.readStructEnd()
30929 
 
30930 
  def write(self, oprot):
30931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30933 
      return
30934 
    oprot.writeStructBegin('retrieveInvoice_result')
30935 
    if self.success is not None:
30936 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30937 
      oprot.writeString(self.success)
30938 
      oprot.writeFieldEnd()
30939 
    oprot.writeFieldStop()
30940 
    oprot.writeStructEnd()
30941 
 
30942 
  def validate(self):
30943 
    return
30944 
 
30945 
 
30946 
  def __repr__(self):
30947 
    L = ['%s=%r' % (key, value)
30948 
      for key, value in self.__dict__.iteritems()]
30949 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30950 
 
30951 
  def __eq__(self, other):
30952 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30953 
 
30954 
  def __ne__(self, other):
30955 
    return not (self == other)
7026 rajveer 30956 
 
30957 
class receiveUpdatesForRedExpress_args:
30958 
  """
30959 
  Attributes:
30960 
   - awbNumber
30961 
  """
30962 
 
30963 
  thrift_spec = (
30964 
    None, # 0
30965 
    (1, TType.STRING, 'awbNumber', None, None, ), # 1
30966 
  )
30967 
 
30968 
  def __init__(self, awbNumber=None,):
30969 
    self.awbNumber = awbNumber
30970 
 
30971 
  def read(self, iprot):
30972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30974 
      return
30975 
    iprot.readStructBegin()
30976 
    while True:
30977 
      (fname, ftype, fid) = iprot.readFieldBegin()
30978 
      if ftype == TType.STOP:
30979 
        break
30980 
      if fid == 1:
30981 
        if ftype == TType.STRING:
30982 
          self.awbNumber = iprot.readString();
30983 
        else:
30984 
          iprot.skip(ftype)
30985 
      else:
30986 
        iprot.skip(ftype)
30987 
      iprot.readFieldEnd()
30988 
    iprot.readStructEnd()
30989 
 
30990 
  def write(self, oprot):
30991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30993 
      return
30994 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_args')
30995 
    if self.awbNumber is not None:
30996 
      oprot.writeFieldBegin('awbNumber', TType.STRING, 1)
30997 
      oprot.writeString(self.awbNumber)
30998 
      oprot.writeFieldEnd()
30999 
    oprot.writeFieldStop()
31000 
    oprot.writeStructEnd()
31001 
 
31002 
  def validate(self):
31003 
    return
31004 
 
31005 
 
31006 
  def __repr__(self):
31007 
    L = ['%s=%r' % (key, value)
31008 
      for key, value in self.__dict__.iteritems()]
31009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31010 
 
31011 
  def __eq__(self, other):
31012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31013 
 
31014 
  def __ne__(self, other):
31015 
    return not (self == other)
31016 
 
31017 
class receiveUpdatesForRedExpress_result:
31018 
  """
31019 
  Attributes:
31020 
   - success
31021 
  """
31022 
 
31023 
  thrift_spec = (
31024 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
31025 
  )
31026 
 
31027 
  def __init__(self, success=None,):
31028 
    self.success = success
31029 
 
31030 
  def read(self, iprot):
31031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31033 
      return
31034 
    iprot.readStructBegin()
31035 
    while True:
31036 
      (fname, ftype, fid) = iprot.readFieldBegin()
31037 
      if ftype == TType.STOP:
31038 
        break
31039 
      if fid == 0:
31040 
        if ftype == TType.LIST:
31041 
          self.success = []
31042 
          (_etype733, _size730) = iprot.readListBegin()
31043 
          for _i734 in xrange(_size730):
31044 
            _elem735 = iprot.readString();
31045 
            self.success.append(_elem735)
31046 
          iprot.readListEnd()
31047 
        else:
31048 
          iprot.skip(ftype)
31049 
      else:
31050 
        iprot.skip(ftype)
31051 
      iprot.readFieldEnd()
31052 
    iprot.readStructEnd()
31053 
 
31054 
  def write(self, oprot):
31055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31057 
      return
31058 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_result')
31059 
    if self.success is not None:
31060 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31061 
      oprot.writeListBegin(TType.STRING, len(self.success))
31062 
      for iter736 in self.success:
31063 
        oprot.writeString(iter736)
31064 
      oprot.writeListEnd()
31065 
      oprot.writeFieldEnd()
31066 
    oprot.writeFieldStop()
31067 
    oprot.writeStructEnd()
31068 
 
31069 
  def validate(self):
31070 
    return
31071 
 
31072 
 
31073 
  def __repr__(self):
31074 
    L = ['%s=%r' % (key, value)
31075 
      for key, value in self.__dict__.iteritems()]
31076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31077 
 
31078 
  def __eq__(self, other):
31079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31080 
 
31081 
  def __ne__(self, other):
31082 
    return not (self == other)
7073 anupam.sin 31083 
 
31084 
class createRechargeTransaction_args:
31085 
  """
31086 
  Attributes:
31087 
   - thriftRechargeTransaction
31088 
  """
31089 
 
31090 
  thrift_spec = (
31091 
    None, # 0
31092 
    (1, TType.STRUCT, 'thriftRechargeTransaction', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 1
31093 
  )
31094 
 
31095 
  def __init__(self, thriftRechargeTransaction=None,):
31096 
    self.thriftRechargeTransaction = thriftRechargeTransaction
31097 
 
31098 
  def read(self, iprot):
31099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31101 
      return
31102 
    iprot.readStructBegin()
31103 
    while True:
31104 
      (fname, ftype, fid) = iprot.readFieldBegin()
31105 
      if ftype == TType.STOP:
31106 
        break
31107 
      if fid == 1:
31108 
        if ftype == TType.STRUCT:
31109 
          self.thriftRechargeTransaction = RechargeTransaction()
31110 
          self.thriftRechargeTransaction.read(iprot)
31111 
        else:
31112 
          iprot.skip(ftype)
31113 
      else:
31114 
        iprot.skip(ftype)
31115 
      iprot.readFieldEnd()
31116 
    iprot.readStructEnd()
31117 
 
31118 
  def write(self, oprot):
31119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31121 
      return
31122 
    oprot.writeStructBegin('createRechargeTransaction_args')
31123 
    if self.thriftRechargeTransaction is not None:
31124 
      oprot.writeFieldBegin('thriftRechargeTransaction', TType.STRUCT, 1)
31125 
      self.thriftRechargeTransaction.write(oprot)
31126 
      oprot.writeFieldEnd()
31127 
    oprot.writeFieldStop()
31128 
    oprot.writeStructEnd()
31129 
 
31130 
  def validate(self):
31131 
    return
31132 
 
31133 
 
31134 
  def __repr__(self):
31135 
    L = ['%s=%r' % (key, value)
31136 
      for key, value in self.__dict__.iteritems()]
31137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31138 
 
31139 
  def __eq__(self, other):
31140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31141 
 
31142 
  def __ne__(self, other):
31143 
    return not (self == other)
31144 
 
31145 
class createRechargeTransaction_result:
31146 
  """
31147 
  Attributes:
31148 
   - success
31149 
  """
31150 
 
31151 
  thrift_spec = (
31152 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
31153 
  )
31154 
 
31155 
  def __init__(self, success=None,):
31156 
    self.success = success
31157 
 
31158 
  def read(self, iprot):
31159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31161 
      return
31162 
    iprot.readStructBegin()
31163 
    while True:
31164 
      (fname, ftype, fid) = iprot.readFieldBegin()
31165 
      if ftype == TType.STOP:
31166 
        break
31167 
      if fid == 0:
31168 
        if ftype == TType.STRUCT:
31169 
          self.success = RechargeTransaction()
31170 
          self.success.read(iprot)
31171 
        else:
31172 
          iprot.skip(ftype)
31173 
      else:
31174 
        iprot.skip(ftype)
31175 
      iprot.readFieldEnd()
31176 
    iprot.readStructEnd()
31177 
 
31178 
  def write(self, oprot):
31179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31181 
      return
31182 
    oprot.writeStructBegin('createRechargeTransaction_result')
31183 
    if self.success is not None:
31184 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31185 
      self.success.write(oprot)
31186 
      oprot.writeFieldEnd()
31187 
    oprot.writeFieldStop()
31188 
    oprot.writeStructEnd()
31189 
 
31190 
  def validate(self):
31191 
    return
31192 
 
31193 
 
31194 
  def __repr__(self):
31195 
    L = ['%s=%r' % (key, value)
31196 
      for key, value in self.__dict__.iteritems()]
31197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31198 
 
31199 
  def __eq__(self, other):
31200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31201 
 
31202 
  def __ne__(self, other):
31203 
    return not (self == other)
7080 anupam.sin 31204 
 
7085 rajveer 31205 
class getRechargeTransactions_args:
31206 
  """
31207 
  Attributes:
31208 
   - storeId
31209 
  """
31210 
 
31211 
  thrift_spec = (
31212 
    None, # 0
31213 
    (1, TType.I64, 'storeId', None, None, ), # 1
31214 
  )
31215 
 
31216 
  def __init__(self, storeId=None,):
31217 
    self.storeId = storeId
31218 
 
31219 
  def read(self, iprot):
31220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31222 
      return
31223 
    iprot.readStructBegin()
31224 
    while True:
31225 
      (fname, ftype, fid) = iprot.readFieldBegin()
31226 
      if ftype == TType.STOP:
31227 
        break
31228 
      if fid == 1:
31229 
        if ftype == TType.I64:
31230 
          self.storeId = iprot.readI64();
31231 
        else:
31232 
          iprot.skip(ftype)
31233 
      else:
31234 
        iprot.skip(ftype)
31235 
      iprot.readFieldEnd()
31236 
    iprot.readStructEnd()
31237 
 
31238 
  def write(self, oprot):
31239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31241 
      return
31242 
    oprot.writeStructBegin('getRechargeTransactions_args')
31243 
    if self.storeId is not None:
31244 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
31245 
      oprot.writeI64(self.storeId)
31246 
      oprot.writeFieldEnd()
31247 
    oprot.writeFieldStop()
31248 
    oprot.writeStructEnd()
31249 
 
31250 
  def validate(self):
31251 
    return
31252 
 
31253 
 
31254 
  def __repr__(self):
31255 
    L = ['%s=%r' % (key, value)
31256 
      for key, value in self.__dict__.iteritems()]
31257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31258 
 
31259 
  def __eq__(self, other):
31260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31261 
 
31262 
  def __ne__(self, other):
31263 
    return not (self == other)
31264 
 
31265 
class getRechargeTransactions_result:
31266 
  """
31267 
  Attributes:
31268 
   - success
31269 
  """
31270 
 
31271 
  thrift_spec = (
31272 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
31273 
  )
31274 
 
31275 
  def __init__(self, success=None,):
31276 
    self.success = success
31277 
 
31278 
  def read(self, iprot):
31279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31281 
      return
31282 
    iprot.readStructBegin()
31283 
    while True:
31284 
      (fname, ftype, fid) = iprot.readFieldBegin()
31285 
      if ftype == TType.STOP:
31286 
        break
31287 
      if fid == 0:
31288 
        if ftype == TType.LIST:
31289 
          self.success = []
31290 
          (_etype740, _size737) = iprot.readListBegin()
31291 
          for _i741 in xrange(_size737):
31292 
            _elem742 = RechargeTransaction()
31293 
            _elem742.read(iprot)
31294 
            self.success.append(_elem742)
31295 
          iprot.readListEnd()
31296 
        else:
31297 
          iprot.skip(ftype)
31298 
      else:
31299 
        iprot.skip(ftype)
31300 
      iprot.readFieldEnd()
31301 
    iprot.readStructEnd()
31302 
 
31303 
  def write(self, oprot):
31304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31306 
      return
31307 
    oprot.writeStructBegin('getRechargeTransactions_result')
31308 
    if self.success is not None:
31309 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31310 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
31311 
      for iter743 in self.success:
31312 
        iter743.write(oprot)
31313 
      oprot.writeListEnd()
31314 
      oprot.writeFieldEnd()
31315 
    oprot.writeFieldStop()
31316 
    oprot.writeStructEnd()
31317 
 
31318 
  def validate(self):
31319 
    return
31320 
 
31321 
 
31322 
  def __repr__(self):
31323 
    L = ['%s=%r' % (key, value)
31324 
      for key, value in self.__dict__.iteritems()]
31325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31326 
 
31327 
  def __eq__(self, other):
31328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31329 
 
31330 
  def __ne__(self, other):
31331 
    return not (self == other)
31332 
 
7151 amit.gupta 31333 
class getRechargeTrans_args:
31334 
  """
31335 
  Attributes:
31336 
   - storeId
31337 
   - startDate
31338 
   - endDate
31339 
   - status
31340 
  """
31341 
 
31342 
  thrift_spec = (
31343 
    None, # 0
31344 
    (1, TType.I64, 'storeId', None, None, ), # 1
31345 
    (2, TType.I64, 'startDate', None, None, ), # 2
31346 
    (3, TType.I64, 'endDate', None, None, ), # 3
31347 
    (4, TType.I32, 'status', None, None, ), # 4
31348 
  )
31349 
 
31350 
  def __init__(self, storeId=None, startDate=None, endDate=None, status=None,):
31351 
    self.storeId = storeId
31352 
    self.startDate = startDate
31353 
    self.endDate = endDate
31354 
    self.status = status
31355 
 
31356 
  def read(self, iprot):
31357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31359 
      return
31360 
    iprot.readStructBegin()
31361 
    while True:
31362 
      (fname, ftype, fid) = iprot.readFieldBegin()
31363 
      if ftype == TType.STOP:
31364 
        break
31365 
      if fid == 1:
31366 
        if ftype == TType.I64:
31367 
          self.storeId = iprot.readI64();
31368 
        else:
31369 
          iprot.skip(ftype)
31370 
      elif fid == 2:
31371 
        if ftype == TType.I64:
31372 
          self.startDate = iprot.readI64();
31373 
        else:
31374 
          iprot.skip(ftype)
31375 
      elif fid == 3:
31376 
        if ftype == TType.I64:
31377 
          self.endDate = iprot.readI64();
31378 
        else:
31379 
          iprot.skip(ftype)
31380 
      elif fid == 4:
31381 
        if ftype == TType.I32:
31382 
          self.status = iprot.readI32();
31383 
        else:
31384 
          iprot.skip(ftype)
31385 
      else:
31386 
        iprot.skip(ftype)
31387 
      iprot.readFieldEnd()
31388 
    iprot.readStructEnd()
31389 
 
31390 
  def write(self, oprot):
31391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31393 
      return
31394 
    oprot.writeStructBegin('getRechargeTrans_args')
31395 
    if self.storeId is not None:
31396 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
31397 
      oprot.writeI64(self.storeId)
31398 
      oprot.writeFieldEnd()
31399 
    if self.startDate is not None:
31400 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
31401 
      oprot.writeI64(self.startDate)
31402 
      oprot.writeFieldEnd()
31403 
    if self.endDate is not None:
31404 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
31405 
      oprot.writeI64(self.endDate)
31406 
      oprot.writeFieldEnd()
31407 
    if self.status is not None:
31408 
      oprot.writeFieldBegin('status', TType.I32, 4)
31409 
      oprot.writeI32(self.status)
31410 
      oprot.writeFieldEnd()
31411 
    oprot.writeFieldStop()
31412 
    oprot.writeStructEnd()
31413 
 
31414 
  def validate(self):
31415 
    return
31416 
 
31417 
 
31418 
  def __repr__(self):
31419 
    L = ['%s=%r' % (key, value)
31420 
      for key, value in self.__dict__.iteritems()]
31421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31422 
 
31423 
  def __eq__(self, other):
31424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31425 
 
31426 
  def __ne__(self, other):
31427 
    return not (self == other)
31428 
 
31429 
class getRechargeTrans_result:
31430 
  """
31431 
  Attributes:
31432 
   - success
31433 
  """
31434 
 
31435 
  thrift_spec = (
31436 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
31437 
  )
31438 
 
31439 
  def __init__(self, success=None,):
31440 
    self.success = success
31441 
 
31442 
  def read(self, iprot):
31443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31445 
      return
31446 
    iprot.readStructBegin()
31447 
    while True:
31448 
      (fname, ftype, fid) = iprot.readFieldBegin()
31449 
      if ftype == TType.STOP:
31450 
        break
31451 
      if fid == 0:
31452 
        if ftype == TType.LIST:
31453 
          self.success = []
31454 
          (_etype747, _size744) = iprot.readListBegin()
31455 
          for _i748 in xrange(_size744):
31456 
            _elem749 = RechargeTransaction()
31457 
            _elem749.read(iprot)
31458 
            self.success.append(_elem749)
31459 
          iprot.readListEnd()
31460 
        else:
31461 
          iprot.skip(ftype)
31462 
      else:
31463 
        iprot.skip(ftype)
31464 
      iprot.readFieldEnd()
31465 
    iprot.readStructEnd()
31466 
 
31467 
  def write(self, oprot):
31468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31470 
      return
31471 
    oprot.writeStructBegin('getRechargeTrans_result')
31472 
    if self.success is not None:
31473 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31474 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
31475 
      for iter750 in self.success:
31476 
        iter750.write(oprot)
31477 
      oprot.writeListEnd()
31478 
      oprot.writeFieldEnd()
31479 
    oprot.writeFieldStop()
31480 
    oprot.writeStructEnd()
31481 
 
31482 
  def validate(self):
31483 
    return
31484 
 
31485 
 
31486 
  def __repr__(self):
31487 
    L = ['%s=%r' % (key, value)
31488 
      for key, value in self.__dict__.iteritems()]
31489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31490 
 
31491 
  def __eq__(self, other):
31492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31493 
 
31494 
  def __ne__(self, other):
31495 
    return not (self == other)
31496 
 
7080 anupam.sin 31497 
class getRechargeTransaction_args:
31498 
  """
31499 
  Attributes:
31500 
   - rechargeId
31501 
  """
31502 
 
31503 
  thrift_spec = (
31504 
    None, # 0
31505 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
31506 
  )
31507 
 
31508 
  def __init__(self, rechargeId=None,):
31509 
    self.rechargeId = rechargeId
31510 
 
31511 
  def read(self, iprot):
31512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31514 
      return
31515 
    iprot.readStructBegin()
31516 
    while True:
31517 
      (fname, ftype, fid) = iprot.readFieldBegin()
31518 
      if ftype == TType.STOP:
31519 
        break
31520 
      if fid == 1:
31521 
        if ftype == TType.I64:
31522 
          self.rechargeId = iprot.readI64();
31523 
        else:
31524 
          iprot.skip(ftype)
31525 
      else:
31526 
        iprot.skip(ftype)
31527 
      iprot.readFieldEnd()
31528 
    iprot.readStructEnd()
31529 
 
31530 
  def write(self, oprot):
31531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31533 
      return
31534 
    oprot.writeStructBegin('getRechargeTransaction_args')
31535 
    if self.rechargeId is not None:
31536 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
31537 
      oprot.writeI64(self.rechargeId)
31538 
      oprot.writeFieldEnd()
31539 
    oprot.writeFieldStop()
31540 
    oprot.writeStructEnd()
31541 
 
31542 
  def validate(self):
31543 
    return
31544 
 
31545 
 
31546 
  def __repr__(self):
31547 
    L = ['%s=%r' % (key, value)
31548 
      for key, value in self.__dict__.iteritems()]
31549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31550 
 
31551 
  def __eq__(self, other):
31552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31553 
 
31554 
  def __ne__(self, other):
31555 
    return not (self == other)
31556 
 
31557 
class getRechargeTransaction_result:
31558 
  """
31559 
  Attributes:
31560 
   - success
31561 
  """
31562 
 
31563 
  thrift_spec = (
31564 
    (0, TType.STRUCT, 'success', (RechargeTransaction, RechargeTransaction.thrift_spec), None, ), # 0
31565 
  )
31566 
 
31567 
  def __init__(self, success=None,):
31568 
    self.success = success
31569 
 
31570 
  def read(self, iprot):
31571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31573 
      return
31574 
    iprot.readStructBegin()
31575 
    while True:
31576 
      (fname, ftype, fid) = iprot.readFieldBegin()
31577 
      if ftype == TType.STOP:
31578 
        break
31579 
      if fid == 0:
31580 
        if ftype == TType.STRUCT:
31581 
          self.success = RechargeTransaction()
31582 
          self.success.read(iprot)
31583 
        else:
31584 
          iprot.skip(ftype)
31585 
      else:
31586 
        iprot.skip(ftype)
31587 
      iprot.readFieldEnd()
31588 
    iprot.readStructEnd()
31589 
 
31590 
  def write(self, oprot):
31591 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31592 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31593 
      return
31594 
    oprot.writeStructBegin('getRechargeTransaction_result')
31595 
    if self.success is not None:
31596 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31597 
      self.success.write(oprot)
31598 
      oprot.writeFieldEnd()
31599 
    oprot.writeFieldStop()
31600 
    oprot.writeStructEnd()
31601 
 
31602 
  def validate(self):
31603 
    return
31604 
 
31605 
 
31606 
  def __repr__(self):
31607 
    L = ['%s=%r' % (key, value)
31608 
      for key, value in self.__dict__.iteritems()]
31609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31610 
 
31611 
  def __eq__(self, other):
31612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31613 
 
31614 
  def __ne__(self, other):
31615 
    return not (self == other)
31616 
 
31617 
class getFRCs_args:
31618 
  """
31619 
  Attributes:
31620 
   - circleId
31621 
   - operatorId
31622 
  """
31623 
 
31624 
  thrift_spec = (
31625 
    None, # 0
31626 
    (1, TType.I64, 'circleId', None, None, ), # 1
31627 
    (2, TType.I64, 'operatorId', None, None, ), # 2
31628 
  )
31629 
 
31630 
  def __init__(self, circleId=None, operatorId=None,):
31631 
    self.circleId = circleId
31632 
    self.operatorId = operatorId
31633 
 
31634 
  def read(self, iprot):
31635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31637 
      return
31638 
    iprot.readStructBegin()
31639 
    while True:
31640 
      (fname, ftype, fid) = iprot.readFieldBegin()
31641 
      if ftype == TType.STOP:
31642 
        break
31643 
      if fid == 1:
31644 
        if ftype == TType.I64:
31645 
          self.circleId = iprot.readI64();
31646 
        else:
31647 
          iprot.skip(ftype)
31648 
      elif fid == 2:
31649 
        if ftype == TType.I64:
31650 
          self.operatorId = iprot.readI64();
31651 
        else:
31652 
          iprot.skip(ftype)
31653 
      else:
31654 
        iprot.skip(ftype)
31655 
      iprot.readFieldEnd()
31656 
    iprot.readStructEnd()
31657 
 
31658 
  def write(self, oprot):
31659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31661 
      return
31662 
    oprot.writeStructBegin('getFRCs_args')
31663 
    if self.circleId is not None:
31664 
      oprot.writeFieldBegin('circleId', TType.I64, 1)
31665 
      oprot.writeI64(self.circleId)
31666 
      oprot.writeFieldEnd()
31667 
    if self.operatorId is not None:
31668 
      oprot.writeFieldBegin('operatorId', TType.I64, 2)
31669 
      oprot.writeI64(self.operatorId)
31670 
      oprot.writeFieldEnd()
31671 
    oprot.writeFieldStop()
31672 
    oprot.writeStructEnd()
31673 
 
31674 
  def validate(self):
31675 
    return
31676 
 
31677 
 
31678 
  def __repr__(self):
31679 
    L = ['%s=%r' % (key, value)
31680 
      for key, value in self.__dict__.iteritems()]
31681 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31682 
 
31683 
  def __eq__(self, other):
31684 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31685 
 
31686 
  def __ne__(self, other):
31687 
    return not (self == other)
31688 
 
31689 
class getFRCs_result:
31690 
  """
31691 
  Attributes:
31692 
   - success
31693 
  """
31694 
 
31695 
  thrift_spec = (
31696 
    (0, TType.LIST, 'success', (TType.STRUCT,(FRC, FRC.thrift_spec)), None, ), # 0
31697 
  )
31698 
 
31699 
  def __init__(self, success=None,):
31700 
    self.success = success
31701 
 
31702 
  def read(self, iprot):
31703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31705 
      return
31706 
    iprot.readStructBegin()
31707 
    while True:
31708 
      (fname, ftype, fid) = iprot.readFieldBegin()
31709 
      if ftype == TType.STOP:
31710 
        break
31711 
      if fid == 0:
31712 
        if ftype == TType.LIST:
31713 
          self.success = []
7151 amit.gupta 31714 
          (_etype754, _size751) = iprot.readListBegin()
31715 
          for _i755 in xrange(_size751):
31716 
            _elem756 = FRC()
31717 
            _elem756.read(iprot)
31718 
            self.success.append(_elem756)
7080 anupam.sin 31719 
          iprot.readListEnd()
31720 
        else:
31721 
          iprot.skip(ftype)
31722 
      else:
31723 
        iprot.skip(ftype)
31724 
      iprot.readFieldEnd()
31725 
    iprot.readStructEnd()
31726 
 
31727 
  def write(self, oprot):
31728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31730 
      return
31731 
    oprot.writeStructBegin('getFRCs_result')
31732 
    if self.success is not None:
31733 
      oprot.writeFieldBegin('success', TType.LIST, 0)
31734 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7151 amit.gupta 31735 
      for iter757 in self.success:
31736 
        iter757.write(oprot)
7080 anupam.sin 31737 
      oprot.writeListEnd()
31738 
      oprot.writeFieldEnd()
31739 
    oprot.writeFieldStop()
31740 
    oprot.writeStructEnd()
31741 
 
31742 
  def validate(self):
31743 
    return
31744 
 
31745 
 
31746 
  def __repr__(self):
31747 
    L = ['%s=%r' % (key, value)
31748 
      for key, value in self.__dict__.iteritems()]
31749 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31750 
 
31751 
  def __eq__(self, other):
31752 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31753 
 
31754 
  def __ne__(self, other):
31755 
    return not (self == other)
7096 anupam.sin 31756 
 
31757 
class getHotspotStore_args:
31758 
  """
31759 
  Attributes:
31760 
   - id
31761 
   - hotspotid
31762 
  """
31763 
 
31764 
  thrift_spec = (
31765 
    None, # 0
31766 
    (1, TType.I64, 'id', None, None, ), # 1
31767 
    (2, TType.STRING, 'hotspotid', None, None, ), # 2
31768 
  )
31769 
 
31770 
  def __init__(self, id=None, hotspotid=None,):
31771 
    self.id = id
31772 
    self.hotspotid = hotspotid
31773 
 
31774 
  def read(self, iprot):
31775 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31776 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31777 
      return
31778 
    iprot.readStructBegin()
31779 
    while True:
31780 
      (fname, ftype, fid) = iprot.readFieldBegin()
31781 
      if ftype == TType.STOP:
31782 
        break
31783 
      if fid == 1:
31784 
        if ftype == TType.I64:
31785 
          self.id = iprot.readI64();
31786 
        else:
31787 
          iprot.skip(ftype)
31788 
      elif fid == 2:
31789 
        if ftype == TType.STRING:
31790 
          self.hotspotid = iprot.readString();
31791 
        else:
31792 
          iprot.skip(ftype)
31793 
      else:
31794 
        iprot.skip(ftype)
31795 
      iprot.readFieldEnd()
31796 
    iprot.readStructEnd()
31797 
 
31798 
  def write(self, oprot):
31799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31801 
      return
31802 
    oprot.writeStructBegin('getHotspotStore_args')
31803 
    if self.id is not None:
31804 
      oprot.writeFieldBegin('id', TType.I64, 1)
31805 
      oprot.writeI64(self.id)
31806 
      oprot.writeFieldEnd()
31807 
    if self.hotspotid is not None:
31808 
      oprot.writeFieldBegin('hotspotid', TType.STRING, 2)
31809 
      oprot.writeString(self.hotspotid)
31810 
      oprot.writeFieldEnd()
31811 
    oprot.writeFieldStop()
31812 
    oprot.writeStructEnd()
31813 
 
31814 
  def validate(self):
31815 
    return
31816 
 
31817 
 
31818 
  def __repr__(self):
31819 
    L = ['%s=%r' % (key, value)
31820 
      for key, value in self.__dict__.iteritems()]
31821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31822 
 
31823 
  def __eq__(self, other):
31824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31825 
 
31826 
  def __ne__(self, other):
31827 
    return not (self == other)
31828 
 
31829 
class getHotspotStore_result:
31830 
  """
31831 
  Attributes:
31832 
   - success
31833 
  """
31834 
 
31835 
  thrift_spec = (
31836 
    (0, TType.STRUCT, 'success', (HotspotStore, HotspotStore.thrift_spec), None, ), # 0
31837 
  )
31838 
 
31839 
  def __init__(self, success=None,):
31840 
    self.success = success
31841 
 
31842 
  def read(self, iprot):
31843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31845 
      return
31846 
    iprot.readStructBegin()
31847 
    while True:
31848 
      (fname, ftype, fid) = iprot.readFieldBegin()
31849 
      if ftype == TType.STOP:
31850 
        break
31851 
      if fid == 0:
31852 
        if ftype == TType.STRUCT:
31853 
          self.success = HotspotStore()
31854 
          self.success.read(iprot)
31855 
        else:
31856 
          iprot.skip(ftype)
31857 
      else:
31858 
        iprot.skip(ftype)
31859 
      iprot.readFieldEnd()
31860 
    iprot.readStructEnd()
31861 
 
31862 
  def write(self, oprot):
31863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31865 
      return
31866 
    oprot.writeStructBegin('getHotspotStore_result')
31867 
    if self.success is not None:
31868 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
31869 
      self.success.write(oprot)
31870 
      oprot.writeFieldEnd()
31871 
    oprot.writeFieldStop()
31872 
    oprot.writeStructEnd()
31873 
 
31874 
  def validate(self):
31875 
    return
31876 
 
31877 
 
31878 
  def __repr__(self):
31879 
    L = ['%s=%r' % (key, value)
31880 
      for key, value in self.__dict__.iteritems()]
31881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31882 
 
31883 
  def __eq__(self, other):
31884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31885 
 
31886 
  def __ne__(self, other):
31887 
    return not (self == other)
31888 
 
31889 
class getTelecomCircle_args:
31890 
  """
31891 
  Attributes:
31892 
   - id
31893 
   - code
31894 
  """
31895 
 
31896 
  thrift_spec = (
31897 
    None, # 0
31898 
    (1, TType.I64, 'id', None, None, ), # 1
31899 
    (2, TType.STRING, 'code', None, None, ), # 2
31900 
  )
31901 
 
31902 
  def __init__(self, id=None, code=None,):
31903 
    self.id = id
31904 
    self.code = code
31905 
 
31906 
  def read(self, iprot):
31907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31909 
      return
31910 
    iprot.readStructBegin()
31911 
    while True:
31912 
      (fname, ftype, fid) = iprot.readFieldBegin()
31913 
      if ftype == TType.STOP:
31914 
        break
31915 
      if fid == 1:
31916 
        if ftype == TType.I64:
31917 
          self.id = iprot.readI64();
31918 
        else:
31919 
          iprot.skip(ftype)
31920 
      elif fid == 2:
31921 
        if ftype == TType.STRING:
31922 
          self.code = iprot.readString();
31923 
        else:
31924 
          iprot.skip(ftype)
31925 
      else:
31926 
        iprot.skip(ftype)
31927 
      iprot.readFieldEnd()
31928 
    iprot.readStructEnd()
31929 
 
31930 
  def write(self, oprot):
31931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31933 
      return
31934 
    oprot.writeStructBegin('getTelecomCircle_args')
31935 
    if self.id is not None:
31936 
      oprot.writeFieldBegin('id', TType.I64, 1)
31937 
      oprot.writeI64(self.id)
31938 
      oprot.writeFieldEnd()
31939 
    if self.code is not None:
31940 
      oprot.writeFieldBegin('code', TType.STRING, 2)
31941 
      oprot.writeString(self.code)
31942 
      oprot.writeFieldEnd()
31943 
    oprot.writeFieldStop()
31944 
    oprot.writeStructEnd()
31945 
 
31946 
  def validate(self):
31947 
    return
31948 
 
31949 
 
31950 
  def __repr__(self):
31951 
    L = ['%s=%r' % (key, value)
31952 
      for key, value in self.__dict__.iteritems()]
31953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
31954 
 
31955 
  def __eq__(self, other):
31956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
31957 
 
31958 
  def __ne__(self, other):
31959 
    return not (self == other)
31960 
 
31961 
class getTelecomCircle_result:
31962 
  """
31963 
  Attributes:
31964 
   - success
31965 
  """
31966 
 
31967 
  thrift_spec = (
31968 
    (0, TType.STRUCT, 'success', (TelecomCircle, TelecomCircle.thrift_spec), None, ), # 0
31969 
  )
31970 
 
31971 
  def __init__(self, success=None,):
31972 
    self.success = success
31973 
 
31974 
  def read(self, iprot):
31975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
31976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
31977 
      return
31978 
    iprot.readStructBegin()
31979 
    while True:
31980 
      (fname, ftype, fid) = iprot.readFieldBegin()
31981 
      if ftype == TType.STOP:
31982 
        break
31983 
      if fid == 0:
31984 
        if ftype == TType.STRUCT:
31985 
          self.success = TelecomCircle()
31986 
          self.success.read(iprot)
31987 
        else:
31988 
          iprot.skip(ftype)
31989 
      else:
31990 
        iprot.skip(ftype)
31991 
      iprot.readFieldEnd()
31992 
    iprot.readStructEnd()
31993 
 
31994 
  def write(self, oprot):
31995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
31996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
31997 
      return
31998 
    oprot.writeStructBegin('getTelecomCircle_result')
31999 
    if self.success is not None:
32000 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
32001 
      self.success.write(oprot)
32002 
      oprot.writeFieldEnd()
32003 
    oprot.writeFieldStop()
32004 
    oprot.writeStructEnd()
32005 
 
32006 
  def validate(self):
32007 
    return
32008 
 
32009 
 
32010 
  def __repr__(self):
32011 
    L = ['%s=%r' % (key, value)
32012 
      for key, value in self.__dict__.iteritems()]
32013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32014 
 
32015 
  def __eq__(self, other):
32016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32017 
 
32018 
  def __ne__(self, other):
32019 
    return not (self == other)
7109 anupam.sin 32020 
 
32021 
class retrieveHotspotRechargeInvoice_args:
32022 
  """
32023 
  Attributes:
32024 
   - rechargeId
32025 
  """
32026 
 
32027 
  thrift_spec = (
32028 
    None, # 0
32029 
    (1, TType.I64, 'rechargeId', None, None, ), # 1
32030 
  )
32031 
 
32032 
  def __init__(self, rechargeId=None,):
32033 
    self.rechargeId = rechargeId
32034 
 
32035 
  def read(self, iprot):
32036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32038 
      return
32039 
    iprot.readStructBegin()
32040 
    while True:
32041 
      (fname, ftype, fid) = iprot.readFieldBegin()
32042 
      if ftype == TType.STOP:
32043 
        break
32044 
      if fid == 1:
32045 
        if ftype == TType.I64:
32046 
          self.rechargeId = iprot.readI64();
32047 
        else:
32048 
          iprot.skip(ftype)
32049 
      else:
32050 
        iprot.skip(ftype)
32051 
      iprot.readFieldEnd()
32052 
    iprot.readStructEnd()
32053 
 
32054 
  def write(self, oprot):
32055 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32056 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32057 
      return
32058 
    oprot.writeStructBegin('retrieveHotspotRechargeInvoice_args')
32059 
    if self.rechargeId is not None:
32060 
      oprot.writeFieldBegin('rechargeId', TType.I64, 1)
32061 
      oprot.writeI64(self.rechargeId)
32062 
      oprot.writeFieldEnd()
32063 
    oprot.writeFieldStop()
32064 
    oprot.writeStructEnd()
32065 
 
32066 
  def validate(self):
32067 
    return
32068 
 
32069 
 
32070 
  def __repr__(self):
32071 
    L = ['%s=%r' % (key, value)
32072 
      for key, value in self.__dict__.iteritems()]
32073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32074 
 
32075 
  def __eq__(self, other):
32076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32077 
 
32078 
  def __ne__(self, other):
32079 
    return not (self == other)
32080 
 
32081 
class retrieveHotspotRechargeInvoice_result:
32082 
  """
32083 
  Attributes:
32084 
   - success
32085 
  """
32086 
 
32087 
  thrift_spec = (
32088 
    (0, TType.STRING, 'success', None, None, ), # 0
32089 
  )
32090 
 
32091 
  def __init__(self, success=None,):
32092 
    self.success = success
32093 
 
32094 
  def read(self, iprot):
32095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32097 
      return
32098 
    iprot.readStructBegin()
32099 
    while True:
32100 
      (fname, ftype, fid) = iprot.readFieldBegin()
32101 
      if ftype == TType.STOP:
32102 
        break
32103 
      if fid == 0:
32104 
        if ftype == TType.STRING:
32105 
          self.success = iprot.readString();
32106 
        else:
32107 
          iprot.skip(ftype)
32108 
      else:
32109 
        iprot.skip(ftype)
32110 
      iprot.readFieldEnd()
32111 
    iprot.readStructEnd()
32112 
 
32113 
  def write(self, oprot):
32114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32116 
      return
32117 
    oprot.writeStructBegin('retrieveHotspotRechargeInvoice_result')
32118 
    if self.success is not None:
32119 
      oprot.writeFieldBegin('success', TType.STRING, 0)
32120 
      oprot.writeString(self.success)
32121 
      oprot.writeFieldEnd()
32122 
    oprot.writeFieldStop()
32123 
    oprot.writeStructEnd()
32124 
 
32125 
  def validate(self):
32126 
    return
32127 
 
32128 
 
32129 
  def __repr__(self):
32130 
    L = ['%s=%r' % (key, value)
32131 
      for key, value in self.__dict__.iteritems()]
32132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32133 
 
32134 
  def __eq__(self, other):
32135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32136 
 
32137 
  def __ne__(self, other):
32138 
    return not (self == other)
7169 anupam.sin 32139 
 
7190 amar.kumar 32140 
class splitFreebieOrder_args:
32141 
  """
32142 
  Attributes:
32143 
   - orderId
32144 
   - splitReason
32145 
   - shippingDate
32146 
  """
32147 
 
32148 
  thrift_spec = (
32149 
    None, # 0
32150 
    (1, TType.I64, 'orderId', None, None, ), # 1
32151 
    (2, TType.STRING, 'splitReason', None, None, ), # 2
32152 
    (3, TType.I64, 'shippingDate', None, None, ), # 3
32153 
  )
32154 
 
32155 
  def __init__(self, orderId=None, splitReason=None, shippingDate=None,):
32156 
    self.orderId = orderId
32157 
    self.splitReason = splitReason
32158 
    self.shippingDate = shippingDate
32159 
 
32160 
  def read(self, iprot):
32161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32163 
      return
32164 
    iprot.readStructBegin()
32165 
    while True:
32166 
      (fname, ftype, fid) = iprot.readFieldBegin()
32167 
      if ftype == TType.STOP:
32168 
        break
32169 
      if fid == 1:
32170 
        if ftype == TType.I64:
32171 
          self.orderId = iprot.readI64();
32172 
        else:
32173 
          iprot.skip(ftype)
32174 
      elif fid == 2:
32175 
        if ftype == TType.STRING:
32176 
          self.splitReason = iprot.readString();
32177 
        else:
32178 
          iprot.skip(ftype)
32179 
      elif fid == 3:
32180 
        if ftype == TType.I64:
32181 
          self.shippingDate = iprot.readI64();
32182 
        else:
32183 
          iprot.skip(ftype)
32184 
      else:
32185 
        iprot.skip(ftype)
32186 
      iprot.readFieldEnd()
32187 
    iprot.readStructEnd()
32188 
 
32189 
  def write(self, oprot):
32190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32192 
      return
32193 
    oprot.writeStructBegin('splitFreebieOrder_args')
32194 
    if self.orderId is not None:
32195 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
32196 
      oprot.writeI64(self.orderId)
32197 
      oprot.writeFieldEnd()
32198 
    if self.splitReason is not None:
32199 
      oprot.writeFieldBegin('splitReason', TType.STRING, 2)
32200 
      oprot.writeString(self.splitReason)
32201 
      oprot.writeFieldEnd()
32202 
    if self.shippingDate is not None:
32203 
      oprot.writeFieldBegin('shippingDate', TType.I64, 3)
32204 
      oprot.writeI64(self.shippingDate)
32205 
      oprot.writeFieldEnd()
32206 
    oprot.writeFieldStop()
32207 
    oprot.writeStructEnd()
32208 
 
32209 
  def validate(self):
32210 
    return
32211 
 
32212 
 
32213 
  def __repr__(self):
32214 
    L = ['%s=%r' % (key, value)
32215 
      for key, value in self.__dict__.iteritems()]
32216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32217 
 
32218 
  def __eq__(self, other):
32219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32220 
 
32221 
  def __ne__(self, other):
32222 
    return not (self == other)
32223 
 
32224 
class splitFreebieOrder_result:
32225 
  """
32226 
  Attributes:
32227 
   - success
32228 
  """
32229 
 
32230 
  thrift_spec = (
32231 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
32232 
  )
32233 
 
32234 
  def __init__(self, success=None,):
32235 
    self.success = success
32236 
 
32237 
  def read(self, iprot):
32238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32240 
      return
32241 
    iprot.readStructBegin()
32242 
    while True:
32243 
      (fname, ftype, fid) = iprot.readFieldBegin()
32244 
      if ftype == TType.STOP:
32245 
        break
32246 
      if fid == 0:
32247 
        if ftype == TType.STRUCT:
32248 
          self.success = Order()
32249 
          self.success.read(iprot)
32250 
        else:
32251 
          iprot.skip(ftype)
32252 
      else:
32253 
        iprot.skip(ftype)
32254 
      iprot.readFieldEnd()
32255 
    iprot.readStructEnd()
32256 
 
32257 
  def write(self, oprot):
32258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32260 
      return
32261 
    oprot.writeStructBegin('splitFreebieOrder_result')
32262 
    if self.success is not None:
32263 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
32264 
      self.success.write(oprot)
32265 
      oprot.writeFieldEnd()
32266 
    oprot.writeFieldStop()
32267 
    oprot.writeStructEnd()
32268 
 
32269 
  def validate(self):
32270 
    return
32271 
 
32272 
 
32273 
  def __repr__(self):
32274 
    L = ['%s=%r' % (key, value)
32275 
      for key, value in self.__dict__.iteritems()]
32276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32277 
 
32278 
  def __eq__(self, other):
32279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32280 
 
32281 
  def __ne__(self, other):
32282 
    return not (self == other)
32283 
 
7169 anupam.sin 32284 
class getRechargeTransactionsByNumber_args:
32285 
  """
32286 
  Attributes:
32287 
   - number
7172 anupam.sin 32288 
   - storeId
7169 anupam.sin 32289 
  """
32290 
 
32291 
  thrift_spec = (
32292 
    None, # 0
32293 
    (1, TType.STRING, 'number', None, None, ), # 1
7172 anupam.sin 32294 
    (2, TType.I64, 'storeId', None, None, ), # 2
7169 anupam.sin 32295 
  )
32296 
 
7172 anupam.sin 32297 
  def __init__(self, number=None, storeId=None,):
7169 anupam.sin 32298 
    self.number = number
7172 anupam.sin 32299 
    self.storeId = storeId
7169 anupam.sin 32300 
 
32301 
  def read(self, iprot):
32302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32304 
      return
32305 
    iprot.readStructBegin()
32306 
    while True:
32307 
      (fname, ftype, fid) = iprot.readFieldBegin()
32308 
      if ftype == TType.STOP:
32309 
        break
32310 
      if fid == 1:
32311 
        if ftype == TType.STRING:
32312 
          self.number = iprot.readString();
32313 
        else:
32314 
          iprot.skip(ftype)
7172 anupam.sin 32315 
      elif fid == 2:
32316 
        if ftype == TType.I64:
32317 
          self.storeId = iprot.readI64();
32318 
        else:
32319 
          iprot.skip(ftype)
7169 anupam.sin 32320 
      else:
32321 
        iprot.skip(ftype)
32322 
      iprot.readFieldEnd()
32323 
    iprot.readStructEnd()
32324 
 
32325 
  def write(self, oprot):
32326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32328 
      return
32329 
    oprot.writeStructBegin('getRechargeTransactionsByNumber_args')
32330 
    if self.number is not None:
32331 
      oprot.writeFieldBegin('number', TType.STRING, 1)
32332 
      oprot.writeString(self.number)
32333 
      oprot.writeFieldEnd()
7172 anupam.sin 32334 
    if self.storeId is not None:
32335 
      oprot.writeFieldBegin('storeId', TType.I64, 2)
32336 
      oprot.writeI64(self.storeId)
32337 
      oprot.writeFieldEnd()
7169 anupam.sin 32338 
    oprot.writeFieldStop()
32339 
    oprot.writeStructEnd()
32340 
 
32341 
  def validate(self):
32342 
    return
32343 
 
32344 
 
32345 
  def __repr__(self):
32346 
    L = ['%s=%r' % (key, value)
32347 
      for key, value in self.__dict__.iteritems()]
32348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32349 
 
32350 
  def __eq__(self, other):
32351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32352 
 
32353 
  def __ne__(self, other):
32354 
    return not (self == other)
32355 
 
32356 
class getRechargeTransactionsByNumber_result:
32357 
  """
32358 
  Attributes:
32359 
   - success
32360 
  """
32361 
 
32362 
  thrift_spec = (
32363 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeTransaction, RechargeTransaction.thrift_spec)), None, ), # 0
32364 
  )
32365 
 
32366 
  def __init__(self, success=None,):
32367 
    self.success = success
32368 
 
32369 
  def read(self, iprot):
32370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32372 
      return
32373 
    iprot.readStructBegin()
32374 
    while True:
32375 
      (fname, ftype, fid) = iprot.readFieldBegin()
32376 
      if ftype == TType.STOP:
32377 
        break
32378 
      if fid == 0:
32379 
        if ftype == TType.LIST:
32380 
          self.success = []
32381 
          (_etype761, _size758) = iprot.readListBegin()
32382 
          for _i762 in xrange(_size758):
32383 
            _elem763 = RechargeTransaction()
32384 
            _elem763.read(iprot)
32385 
            self.success.append(_elem763)
32386 
          iprot.readListEnd()
32387 
        else:
32388 
          iprot.skip(ftype)
32389 
      else:
32390 
        iprot.skip(ftype)
32391 
      iprot.readFieldEnd()
32392 
    iprot.readStructEnd()
32393 
 
32394 
  def write(self, oprot):
32395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32397 
      return
32398 
    oprot.writeStructBegin('getRechargeTransactionsByNumber_result')
32399 
    if self.success is not None:
32400 
      oprot.writeFieldBegin('success', TType.LIST, 0)
32401 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
32402 
      for iter764 in self.success:
32403 
        iter764.write(oprot)
32404 
      oprot.writeListEnd()
32405 
      oprot.writeFieldEnd()
32406 
    oprot.writeFieldStop()
32407 
    oprot.writeStructEnd()
32408 
 
32409 
  def validate(self):
32410 
    return
32411 
 
32412 
 
32413 
  def __repr__(self):
32414 
    L = ['%s=%r' % (key, value)
32415 
      for key, value in self.__dict__.iteritems()]
32416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32417 
 
32418 
  def __eq__(self, other):
32419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32420 
 
32421 
  def __ne__(self, other):
32422 
    return not (self == other)
32423 
 
32424 
class updateHotspotStorePassword_args:
32425 
  """
32426 
  Attributes:
32427 
   - storeId
32428 
   - password
32429 
  """
32430 
 
32431 
  thrift_spec = (
32432 
    None, # 0
32433 
    (1, TType.I64, 'storeId', None, None, ), # 1
32434 
    (2, TType.STRING, 'password', None, None, ), # 2
32435 
  )
32436 
 
32437 
  def __init__(self, storeId=None, password=None,):
32438 
    self.storeId = storeId
32439 
    self.password = password
32440 
 
32441 
  def read(self, iprot):
32442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32444 
      return
32445 
    iprot.readStructBegin()
32446 
    while True:
32447 
      (fname, ftype, fid) = iprot.readFieldBegin()
32448 
      if ftype == TType.STOP:
32449 
        break
32450 
      if fid == 1:
32451 
        if ftype == TType.I64:
32452 
          self.storeId = iprot.readI64();
32453 
        else:
32454 
          iprot.skip(ftype)
32455 
      elif fid == 2:
32456 
        if ftype == TType.STRING:
32457 
          self.password = iprot.readString();
32458 
        else:
32459 
          iprot.skip(ftype)
32460 
      else:
32461 
        iprot.skip(ftype)
32462 
      iprot.readFieldEnd()
32463 
    iprot.readStructEnd()
32464 
 
32465 
  def write(self, oprot):
32466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32468 
      return
32469 
    oprot.writeStructBegin('updateHotspotStorePassword_args')
32470 
    if self.storeId is not None:
32471 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
32472 
      oprot.writeI64(self.storeId)
32473 
      oprot.writeFieldEnd()
32474 
    if self.password is not None:
32475 
      oprot.writeFieldBegin('password', TType.STRING, 2)
32476 
      oprot.writeString(self.password)
32477 
      oprot.writeFieldEnd()
32478 
    oprot.writeFieldStop()
32479 
    oprot.writeStructEnd()
32480 
 
32481 
  def validate(self):
32482 
    return
32483 
 
32484 
 
32485 
  def __repr__(self):
32486 
    L = ['%s=%r' % (key, value)
32487 
      for key, value in self.__dict__.iteritems()]
32488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32489 
 
32490 
  def __eq__(self, other):
32491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32492 
 
32493 
  def __ne__(self, other):
32494 
    return not (self == other)
32495 
 
32496 
class updateHotspotStorePassword_result:
32497 
  """
32498 
  Attributes:
32499 
   - success
32500 
  """
32501 
 
32502 
  thrift_spec = (
32503 
    (0, TType.BOOL, 'success', None, None, ), # 0
32504 
  )
32505 
 
32506 
  def __init__(self, success=None,):
32507 
    self.success = success
32508 
 
32509 
  def read(self, iprot):
32510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32512 
      return
32513 
    iprot.readStructBegin()
32514 
    while True:
32515 
      (fname, ftype, fid) = iprot.readFieldBegin()
32516 
      if ftype == TType.STOP:
32517 
        break
32518 
      if fid == 0:
32519 
        if ftype == TType.BOOL:
32520 
          self.success = iprot.readBool();
32521 
        else:
32522 
          iprot.skip(ftype)
32523 
      else:
32524 
        iprot.skip(ftype)
32525 
      iprot.readFieldEnd()
32526 
    iprot.readStructEnd()
32527 
 
32528 
  def write(self, oprot):
32529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32531 
      return
32532 
    oprot.writeStructBegin('updateHotspotStorePassword_result')
32533 
    if self.success is not None:
32534 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
32535 
      oprot.writeBool(self.success)
32536 
      oprot.writeFieldEnd()
32537 
    oprot.writeFieldStop()
32538 
    oprot.writeStructEnd()
32539 
 
32540 
  def validate(self):
32541 
    return
32542 
 
32543 
 
32544 
  def __repr__(self):
32545 
    L = ['%s=%r' % (key, value)
32546 
      for key, value in self.__dict__.iteritems()]
32547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32548 
 
32549 
  def __eq__(self, other):
32550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32551 
 
32552 
  def __ne__(self, other):
32553 
    return not (self == other)
7263 anupam.sin 32554 
 
32555 
class getSourceDetail_args:
32556 
  """
32557 
  Attributes:
32558 
   - source
32559 
  """
32560 
 
32561 
  thrift_spec = (
32562 
    None, # 0
32563 
    (1, TType.I64, 'source', None, None, ), # 1
32564 
  )
32565 
 
32566 
  def __init__(self, source=None,):
32567 
    self.source = source
32568 
 
32569 
  def read(self, iprot):
32570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32572 
      return
32573 
    iprot.readStructBegin()
32574 
    while True:
32575 
      (fname, ftype, fid) = iprot.readFieldBegin()
32576 
      if ftype == TType.STOP:
32577 
        break
32578 
      if fid == 1:
32579 
        if ftype == TType.I64:
32580 
          self.source = iprot.readI64();
32581 
        else:
32582 
          iprot.skip(ftype)
32583 
      else:
32584 
        iprot.skip(ftype)
32585 
      iprot.readFieldEnd()
32586 
    iprot.readStructEnd()
32587 
 
32588 
  def write(self, oprot):
32589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32591 
      return
32592 
    oprot.writeStructBegin('getSourceDetail_args')
32593 
    if self.source is not None:
32594 
      oprot.writeFieldBegin('source', TType.I64, 1)
32595 
      oprot.writeI64(self.source)
32596 
      oprot.writeFieldEnd()
32597 
    oprot.writeFieldStop()
32598 
    oprot.writeStructEnd()
32599 
 
32600 
  def validate(self):
32601 
    return
32602 
 
32603 
 
32604 
  def __repr__(self):
32605 
    L = ['%s=%r' % (key, value)
32606 
      for key, value in self.__dict__.iteritems()]
32607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32608 
 
32609 
  def __eq__(self, other):
32610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32611 
 
32612 
  def __ne__(self, other):
32613 
    return not (self == other)
32614 
 
32615 
class getSourceDetail_result:
32616 
  """
32617 
  Attributes:
32618 
   - success
32619 
  """
32620 
 
32621 
  thrift_spec = (
32622 
    (0, TType.STRUCT, 'success', (SourceDetail, SourceDetail.thrift_spec), None, ), # 0
32623 
  )
32624 
 
32625 
  def __init__(self, success=None,):
32626 
    self.success = success
32627 
 
32628 
  def read(self, iprot):
32629 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
32630 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
32631 
      return
32632 
    iprot.readStructBegin()
32633 
    while True:
32634 
      (fname, ftype, fid) = iprot.readFieldBegin()
32635 
      if ftype == TType.STOP:
32636 
        break
32637 
      if fid == 0:
32638 
        if ftype == TType.STRUCT:
32639 
          self.success = SourceDetail()
32640 
          self.success.read(iprot)
32641 
        else:
32642 
          iprot.skip(ftype)
32643 
      else:
32644 
        iprot.skip(ftype)
32645 
      iprot.readFieldEnd()
32646 
    iprot.readStructEnd()
32647 
 
32648 
  def write(self, oprot):
32649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
32650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
32651 
      return
32652 
    oprot.writeStructBegin('getSourceDetail_result')
32653 
    if self.success is not None:
32654 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
32655 
      self.success.write(oprot)
32656 
      oprot.writeFieldEnd()
32657 
    oprot.writeFieldStop()
32658 
    oprot.writeStructEnd()
32659 
 
32660 
  def validate(self):
32661 
    return
32662 
 
32663 
 
32664 
  def __repr__(self):
32665 
    L = ['%s=%r' % (key, value)
32666 
      for key, value in self.__dict__.iteritems()]
32667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
32668 
 
32669 
  def __eq__(self, other):
32670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
32671 
 
32672 
  def __ne__(self, other):
32673 
    return not (self == other)