Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
5527 anupam.sin 58 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
5527 anupam.sin 64 
     - pickUp
65 
     - orderType
94 ashish 66 
    """
67 
    pass
68 
 
1398 varun.gupt 69 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 70 
    """
71 
    Parameters:
72 
     - transactionId
73 
    """
74 
    pass
75 
 
4801 anupam.sin 76 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 77 
    """
78 
    Parameters:
4801 anupam.sin 79 
     - statuses
483 rajveer 80 
     - from_date
81 
     - to_date
82 
     - warehouse_id
94 ashish 83 
    """
84 
    pass
85 
 
4133 chandransh 86 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
87 
    """
88 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
89 
    Pass the status as null and the limit as 0 to ignore them.
90 
 
91 
    Parameters:
92 
     - statuses
93 
     - offset
94 
     - limit
95 
     - warehouse_id
96 
    """
97 
    pass
98 
 
99 
  def getOrderCount(self, statuses, warehouseId):
100 
    """
101 
    Returns the count of orders with the given statuses assigned to the given warehouse.
102 
 
103 
    Parameters:
104 
     - statuses
105 
     - warehouseId
106 
    """
107 
    pass
108 
 
999 varun.gupt 109 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
110 
    """
1132 chandransh 111 
    Returns orders within a range of their billing dates
3431 rajveer 112 
 
999 varun.gupt 113 
    Parameters:
114 
     - status
115 
     - start_billing_date
116 
     - end_billing_date
117 
     - warehouse_id
118 
    """
119 
    pass
120 
 
3451 chandransh 121 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 122 
    """
123 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 124 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
125 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 126 
 
3427 chandransh 127 
    Parameters:
128 
     - fromShippingDate
129 
     - toShippingDate
130 
     - providerId
131 
     - warehouseId
3451 chandransh 132 
     - cod
3427 chandransh 133 
    """
134 
    pass
135 
 
1382 varun.gupt 136 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
137 
    """
138 
    Returns order ids for orders which can be returned
3431 rajveer 139 
 
1382 varun.gupt 140 
    Parameters:
141 
     - customer_id
142 
     - limit
143 
    """
144 
    pass
145 
 
146 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
147 
    """
148 
    Returns order ids for orders which can be cancelled
3431 rajveer 149 
 
1382 varun.gupt 150 
    Parameters:
151 
     - customer_id
152 
     - limit
153 
    """
154 
    pass
155 
 
483 rajveer 156 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 157 
    """
158 
    Parameters:
483 rajveer 159 
     - orderId
160 
     - status
161 
     - description
94 ashish 162 
    """
163 
    pass
164 
 
1528 ankur.sing 165 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 166 
    """
1528 ankur.sing 167 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
168 
    only user who owns the transaction can view its order details.
3431 rajveer 169 
 
94 ashish 170 
    Parameters:
171 
     - transactionId
1528 ankur.sing 172 
     - customerId
94 ashish 173 
    """
174 
    pass
175 
 
3014 chandransh 176 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 177 
    """
3014 chandransh 178 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
179 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 180 
 
94 ashish 181 
    Parameters:
483 rajveer 182 
     - customerId
183 
     - from_date
184 
     - to_date
3014 chandransh 185 
     - statuses
94 ashish 186 
    """
187 
    pass
188 
 
483 rajveer 189 
  def createOrder(self, order):
94 ashish 190 
    """
191 
    Parameters:
483 rajveer 192 
     - order
94 ashish 193 
    """
194 
    pass
195 
 
483 rajveer 196 
  def getOrder(self, id):
94 ashish 197 
    """
198 
    Parameters:
483 rajveer 199 
     - id
94 ashish 200 
    """
201 
    pass
202 
 
483 rajveer 203 
  def getLineItemsForOrder(self, orderId):
94 ashish 204 
    """
205 
    Parameters:
483 rajveer 206 
     - orderId
94 ashish 207 
    """
208 
    pass
209 
 
4999 phani.kuma 210 
  def getOrderList(self, order_ids):
211 
    """
212 
    Parameters:
213 
     - order_ids
214 
    """
215 
    pass
216 
 
5386 phani.kuma 217 
  def getOrderListForVendor(self, order_ids, vendorId):
218 
    """
219 
    Parameters:
220 
     - order_ids
221 
     - vendorId
222 
    """
223 
    pass
224 
 
1528 ankur.sing 225 
  def getOrderForCustomer(self, orderId, customerId):
226 
    """
227 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
228 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 229 
 
1528 ankur.sing 230 
    Parameters:
231 
     - orderId
232 
     - customerId
233 
    """
234 
    pass
235 
 
4444 rajveer 236 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 237 
    """
238 
    Parameters:
4394 rajveer 239 
     - type
4444 rajveer 240 
     - warehouseId
4394 rajveer 241 
     - status
242 
     - timestamp
3064 chandransh 243 
    """
244 
    pass
245 
 
4444 rajveer 246 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 247 
    """
248 
    Parameters:
249 
     - type
4444 rajveer 250 
     - warehouseId
4394 rajveer 251 
     - description
3064 chandransh 252 
    """
253 
    pass
254 
 
4444 rajveer 255 
  def markAlertsAsSeen(self, warehouseId):
256 
    """
257 
    Parameters:
258 
     - warehouseId
259 
    """
260 
    pass
261 
 
3064 chandransh 262 
  def getValidOrderCount(self, ):
263 
    """
264 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
265 
    """
266 
    pass
267 
 
268 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
269 
    """
270 
    Returns the number of distinct customers who have done successful transactions
271 
    """
272 
    pass
273 
 
274 
  def getValidOrdersAmountRange(self, ):
275 
    """
276 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
277 
    List contains two values, first minimum amount and second maximum amount.
278 
    """
279 
    pass
280 
 
5874 rajveer 281 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 282 
    """
283 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
284 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 285 
 
3064 chandransh 286 
    Parameters:
287 
     - limit
5874 rajveer 288 
     - onlyStore
3064 chandransh 289 
    """
290 
    pass
291 
 
1220 chandransh 292 
  def batchOrders(self, warehouseId):
293 
    """
294 
    Create a batch of all the pending orders for the given warehouse.
295 
    The returned list is orderd by created_timestamp.
296 
    If there are no pending orders, an empty list is returned.
3431 rajveer 297 
 
1220 chandransh 298 
    Parameters:
299 
     - warehouseId
300 
    """
301 
    pass
302 
 
1208 chandransh 303 
  def markOrderAsOutOfStock(self, orderId):
304 
    """
305 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 306 
 
1208 chandransh 307 
    Parameters:
308 
     - orderId
309 
    """
310 
    pass
311 
 
3064 chandransh 312 
  def verifyOrder(self, orderId):
759 chandransh 313 
    """
3064 chandransh 314 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
315 
    timestamp. It is intended to be used for COD orders but can be harmlessly
316 
    used for all other orders as well.
317 
    Throws an exception if no such order exists.
3431 rajveer 318 
 
759 chandransh 319 
    Parameters:
3064 chandransh 320 
     - orderId
321 
    """
322 
    pass
323 
 
324 
  def acceptOrder(self, orderId):
325 
    """
326 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
327 
    given order is not a COD order, it also captures the payment if the same has
328 
    not been captured.
329 
    Throws an exception if no such order exists.
3431 rajveer 330 
 
3064 chandransh 331 
    Parameters:
332 
     - orderId
333 
    """
334 
    pass
335 
 
5110 mandeep.dh 336 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 337 
    """
338 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 339 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 340 
    the IMEI no. if a -1 is supplied.
341 
    Also, it generates an invoice number for the order, marks the order as
342 
    BILLED and sets the billing timestamp.
343 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 344 
 
3064 chandransh 345 
    Parameters:
346 
     - orderId
4283 anupam.sin 347 
     - invoice_number
4658 mandeep.dh 348 
     - serialNumber
3064 chandransh 349 
     - itemNumber
4283 anupam.sin 350 
     - billed_by
351 
     - jacketNumber
3064 chandransh 352 
     - billingType
5110 mandeep.dh 353 
     - fulfilmentWarehouseId
4763 rajveer 354 
     - authorize
3064 chandransh 355 
    """
356 
    pass
357 
 
6756 amar.kumar 358 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 359 
    """
360 
    Add the invoice number to the order.
361 
 
362 
    Parameters:
363 
     - orderId
364 
     - invoiceNumber
4763 rajveer 365 
     - color
6756 amar.kumar 366 
     - serialNumber
367 
     - itemNumber
4579 rajveer 368 
    """
369 
    pass
370 
 
4910 phani.kuma 371 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 372 
    """
373 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 374 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 375 
 
376 
    Parameters:
377 
     - warehouseId
378 
     - providerId
379 
     - cod
4910 phani.kuma 380 
     - orderIds
4410 rajveer 381 
    """
382 
    pass
383 
 
5713 rajveer 384 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 385 
    """
386 
    Parameters:
387 
     - providerId
388 
     - orderIds
5713 rajveer 389 
     - awbs
5676 rajveer 390 
    """
391 
    pass
392 
 
4910 phani.kuma 393 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 394 
    """
4910 phani.kuma 395 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
396 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 397 
 
3064 chandransh 398 
    Parameters:
759 chandransh 399 
     - providerId
4910 phani.kuma 400 
     - pickupDetails
759 chandransh 401 
    """
402 
    pass
403 
 
4910 phani.kuma 404 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 405 
    """
406 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 407 
 
1113 chandransh 408 
    Parameters:
409 
     - providerId
410 
    """
411 
    pass
412 
 
1132 chandransh 413 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
414 
    """
415 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
416 
    the name of the receiver.
417 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 418 
 
1132 chandransh 419 
    Parameters:
420 
     - providerId
421 
     - deliveredOrders
422 
    """
423 
    pass
424 
 
4910 phani.kuma 425 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 426 
    """
4910 phani.kuma 427 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 428 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 429 
 
1135 chandransh 430 
    Parameters:
431 
     - providerId
432 
     - returnedOrders
433 
    """
434 
    pass
435 
 
4910 phani.kuma 436 
  def getRTOrders(self, providerId):
437 
    """
438 
    Returns a list of orders that were returned by courier.
439 
 
440 
    Parameters:
441 
     - providerId
442 
    """
443 
    pass
444 
 
1246 chandransh 445 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
446 
    """
447 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 448 
 
1246 chandransh 449 
    Parameters:
450 
     - providerId
451 
     - undeliveredOrders
452 
    """
453 
    pass
454 
 
4910 phani.kuma 455 
  def getNonDeliveredOrdersbyCourier(self, providerId):
456 
    """
457 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
458 
 
459 
    Parameters:
460 
     - providerId
461 
    """
462 
    pass
463 
 
464 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
465 
    """
466 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
467 
 
468 
    Parameters:
469 
     - providerId
470 
     - local_connected_orders
471 
    """
472 
    pass
473 
 
474 
  def getOrdersNotLocalConnected(self, providerId):
475 
    """
476 
    Returns a list of orders that were picked up or shipped but pending local connection.
477 
 
478 
    Parameters:
479 
     - providerId
480 
    """
481 
    pass
482 
 
483 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
484 
    """
485 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
486 
 
487 
    Parameters:
488 
     - providerId
489 
     - destination_city_reached_orders
490 
    """
491 
    pass
492 
 
493 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
494 
    """
495 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
496 
 
497 
    Parameters:
498 
     - providerId
499 
     - first_atdl_orders
500 
    """
501 
    pass
502 
 
1408 ankur.sing 503 
  def getUndeliveredOrders(self, providerId, warehouseId):
504 
    """
505 
    Returns the list of orders whose delivery time has passed but have not been
506 
    delivered yet for the given provider and warehouse. To get a complete list of
507 
    undelivered orders, pass them as -1.
508 
    Returns an empty list if no such orders exist.
3431 rajveer 509 
 
1408 ankur.sing 510 
    Parameters:
511 
     - providerId
512 
     - warehouseId
513 
    """
514 
    pass
515 
 
4783 phani.kuma 516 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
517 
    """
518 
    Returns the list of orders whose expected delivery date has passed but have not been
519 
    delivered yet.
520 
    Returns an empty list if no such orders exist.
521 
    """
522 
    pass
523 
 
2536 chandransh 524 
  def toggleDOAFlag(self, orderId):
525 
    """
526 
    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.
527 
    Returns the final flag status.
528 
    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 529 
 
2536 chandransh 530 
    Parameters:
531 
     - orderId
532 
    """
533 
    pass
1886 ankur.sing 534 
 
4712 rajveer 535 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
536 
    """
537 
    Parameters:
538 
     - orderId
539 
     - deliveryTimestamp
540 
     - receiver
541 
    """
542 
    pass
543 
 
5553 rajveer 544 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
545 
    """
546 
    Parameters:
547 
     - orderId
548 
     - deliveryTimestamp
549 
    """
550 
    pass
551 
 
4454 rajveer 552 
  def markOrderDoaRequestReceived(self, orderId):
553 
    """
554 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
555 
 
556 
    Parameters:
557 
     - orderId
558 
    """
559 
    pass
560 
 
561 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
562 
    """
563 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
564 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
565 
 
566 
    Parameters:
567 
     - orderId
568 
     - isAuthorized
569 
    """
570 
    pass
571 
 
4488 rajveer 572 
  def markOrderReturnRequestReceived(self, orderId):
573 
    """
574 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
575 
 
576 
    Parameters:
577 
     - orderId
578 
    """
579 
    pass
580 
 
581 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
582 
    """
583 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
584 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
585 
 
586 
    Parameters:
587 
     - orderId
588 
     - isAuthorized
589 
    """
590 
    pass
591 
 
4579 rajveer 592 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 593 
    """
594 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 595 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
596 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 597 
    For any other status, it returns false.
598 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 599 
 
2536 chandransh 600 
    Parameters:
601 
     - orderId
4579 rajveer 602 
     - providerId
2536 chandransh 603 
    """
604 
    pass
605 
 
4602 rajveer 606 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 607 
    """
4452 rajveer 608 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 609 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
610 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
611 
    	3. Returns true
2591 chandransh 612 
    If the order is in any other status, it returns false.
2536 chandransh 613 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 614 
 
2536 chandransh 615 
    Parameters:
616 
     - orderId
617 
     - pickupNumber
4602 rajveer 618 
     - providerId
2536 chandransh 619 
    """
620 
    pass
621 
 
2764 chandransh 622 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
623 
    """
624 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 625 
 
2764 chandransh 626 
    Parameters:
627 
     - providerId
628 
     - pickupDetails
629 
    """
630 
    pass
631 
 
4910 phani.kuma 632 
  def getDoasNotPickedUp(self, providerId):
633 
    """
634 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
635 
 
636 
    Parameters:
637 
     - providerId
638 
    """
639 
    pass
640 
 
4741 phani.kuma 641 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
642 
    """
643 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
644 
 
645 
    Parameters:
646 
     - providerId
647 
     - pickupDetails
648 
    """
649 
    pass
650 
 
4910 phani.kuma 651 
  def getReturnOrdersNotPickedUp(self, providerId):
652 
    """
653 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
654 
 
655 
    Parameters:
656 
     - providerId
657 
    """
658 
    pass
659 
 
4479 rajveer 660 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 661 
    """
4452 rajveer 662 
    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 663 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 664 
    If the order is in any other state, it returns false.
665 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 666 
 
2591 chandransh 667 
    Parameters:
668 
     - orderId
4479 rajveer 669 
     - receiveCondition
2591 chandransh 670 
    """
671 
    pass
2536 chandransh 672 
 
2591 chandransh 673 
  def validateDoa(self, orderId, isValid):
674 
    """
4452 rajveer 675 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 676 
    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 677 
    If the order is in any other state, it returns false.
678 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 679 
 
2591 chandransh 680 
    Parameters:
681 
     - orderId
682 
     - isValid
683 
    """
684 
    pass
685 
 
4495 rajveer 686 
  def validateReturnProduct(self, orderId, isUsable):
687 
    """
688 
    Parameters:
689 
     - orderId
690 
     - isUsable
691 
    """
692 
    pass
693 
 
2616 chandransh 694 
  def reshipOrder(self, orderId):
695 
    """
4484 rajveer 696 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 697 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 698 
    	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 699 
 
700 
    If the order is in DOA_CERT_VALID state, it does the following:
701 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
702 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 703 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 704 
 
2616 chandransh 705 
    Returns the id of the newly created order.
3431 rajveer 706 
 
2616 chandransh 707 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 708 
 
2616 chandransh 709 
    Parameters:
710 
     - orderId
711 
    """
712 
    pass
2591 chandransh 713 
 
3226 chandransh 714 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 715 
    """
4484 rajveer 716 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 717 
    	1. Creates a refund request for batch processing.
718 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 719 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 720 
 
2616 chandransh 721 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
722 
    	1. Creates a refund request for batch processing.
3226 chandransh 723 
    	2. Cancels the reservation of the item in the warehouse.
724 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 725 
 
3226 chandransh 726 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
727 
    	1. Cancels the reservation of the item in the warehouse.
728 
    	2. Marks the current order as CANCELED.
729 
 
730 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
731 
 
2616 chandransh 732 
    Returns True if it is successful, False otherwise.
3431 rajveer 733 
 
2616 chandransh 734 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 735 
 
2616 chandransh 736 
    Parameters:
737 
     - orderId
3226 chandransh 738 
     - refundedBy
739 
     - reason
2616 chandransh 740 
    """
741 
    pass
742 
 
2690 chandransh 743 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
744 
    """
745 
    Get all return orders created between the from and to dates for the given warehouse.
746 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 747 
 
2690 chandransh 748 
    Parameters:
749 
     - warehouseId
750 
     - fromDate
751 
     - toDate
752 
    """
753 
    pass
2616 chandransh 754 
 
5481 phani.kuma 755 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
756 
    """
757 
    Get all return orders created between the from and to dates.
758 
 
759 
    Parameters:
760 
     - onlyNotProcessed
761 
     - fromDate
762 
     - toDate
763 
    """
764 
    pass
765 
 
2700 chandransh 766 
  def getReturnOrder(self, id):
767 
    """
768 
    Returns the ReturnOrder corresponding to the given id.
769 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 770 
 
2700 chandransh 771 
    Parameters:
772 
     - id
773 
    """
774 
    pass
775 
 
2690 chandransh 776 
  def processReturn(self, returnOrderId):
777 
    """
778 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 779 
 
2690 chandransh 780 
    Parameters:
781 
     - returnOrderId
782 
    """
783 
    pass
784 
 
3451 chandransh 785 
  def updateWeight(self, orderId, weight):
786 
    """
787 
    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 788 
 
3451 chandransh 789 
    Parameters:
790 
     - orderId
791 
     - weight
792 
    """
793 
    pass
794 
 
3469 chandransh 795 
  def changeItem(self, orderId, itemId):
796 
    """
797 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
798 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 799 
 
3469 chandransh 800 
    Parameters:
801 
     - orderId
802 
     - itemId
803 
    """
804 
    pass
805 
 
806 
  def shiftToWarehouse(self, orderId, warehouseId):
807 
    """
808 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
809 
 
810 
    Parameters:
811 
     - orderId
812 
     - warehouseId
813 
    """
814 
    pass
815 
 
4647 rajveer 816 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 817 
    """
818 
    Adds the given delay reason to the given order.
3986 chandransh 819 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 820 
    Raises an exception if no order with the given id can be found.
3469 chandransh 821 
 
3553 chandransh 822 
    Parameters:
823 
     - orderId
824 
     - delayReason
3986 chandransh 825 
     - furtherDelay
4647 rajveer 826 
     - delayReasonText
3553 chandransh 827 
    """
828 
    pass
829 
 
3956 chandransh 830 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
831 
    """
832 
    Marks the COD orders with given AWB nos. as having been processed.
833 
    Updates the captured amount for the corresponding payment.
3553 chandransh 834 
 
3956 chandransh 835 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
836 
    1. There is no order corresponding to an AWB number.
837 
    2. The captured amount for a payment exceeds the total payment.
838 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
839 
 
840 
    Parameters:
841 
     - collectedAmountMap
842 
     - xferBy
843 
     - xferTxnId
844 
     - xferDate
845 
    """
846 
    pass
847 
 
4008 mandeep.dh 848 
  def getTransactionsRequiringExtraProcessing(self, category):
849 
    """
4065 mandeep.dh 850 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 851 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 852 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 853 
 
4008 mandeep.dh 854 
    Parameters:
855 
     - category
856 
    """
857 
    pass
858 
 
859 
  def markTransactionAsProcessed(self, transactionId, category):
860 
    """
861 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 862 
    It essentially deletes the transaction id record for a particular
863 
    processing type category (if present) from DB.
864 
    This is currently used by CRM application.
4008 mandeep.dh 865 
 
866 
    Parameters:
867 
     - transactionId
868 
     - category
869 
    """
870 
    pass
871 
 
4018 chandransh 872 
  def getItemWiseRiskyOrdersCount(self, ):
873 
    """
874 
    Returns a map containing the number of risky orders keyed by item id. A risky order
875 
    is defined as one whose shipping date is about to expire.
876 
    """
877 
    pass
4008 mandeep.dh 878 
 
4295 varun.gupt 879 
  def getOrdersForItemIds(self, itemIds):
880 
    """
881 
    Returns a list of all orders which have items with given id
882 
 
883 
    Parameters:
884 
     - itemIds
885 
    """
886 
    pass
887 
 
4247 rajveer 888 
  def markOrderCancellationRequestReceived(self, orderId):
889 
    """
890 
    Mark order as cancellation request received. If customer sends request of cancellation of
891 
    a particular order, this method will be called. It will just change status of the order
892 
    depending on its current status. It also records the previous status, so that we can move
893 
    back to that status if cancellation request is denied.
4018 chandransh 894 
 
4247 rajveer 895 
    Parameters:
896 
     - orderId
897 
    """
898 
    pass
899 
 
900 
  def markOrderCancellationRequestConfirmed(self, orderId):
901 
    """
902 
    If we decide to to cancel order, CRM will call this method to move the status of order to
903 
    cancellation request confirmed. After this OM will be able to cancel the order.
904 
 
905 
    Parameters:
906 
     - orderId
907 
    """
908 
    pass
909 
 
910 
  def markOrderCancellationRequestDenied(self, orderId):
911 
    """
912 
    If we decide to not to cancel order, we will move the order ro previous status.
913 
 
914 
    Parameters:
915 
     - orderId
916 
    """
917 
    pass
918 
 
4258 rajveer 919 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 920 
    """
4258 rajveer 921 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
922 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 923 
 
924 
    Parameters:
4258 rajveer 925 
     - transactionId
4247 rajveer 926 
    """
927 
    pass
928 
 
4259 anupam.sin 929 
  def refundTransaction(self, transactionId, refundedBy, reason):
930 
    """
931 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
932 
    need to be cancelled
4247 rajveer 933 
 
4259 anupam.sin 934 
    Parameters:
935 
     - transactionId
936 
     - refundedBy
937 
     - reason
938 
    """
939 
    pass
940 
 
4324 mandeep.dh 941 
  def updateShipmentAddress(self, orderId, addressId):
942 
    """
943 
    Updates shipment address of an order. Delivery and shipping date estimates
944 
    etc. are also updated here.
945 
 
946 
    Throws TransactionServiceException in case address change is not
947 
    possible due to certain reasons such as new pincode in address is
948 
    not serviceable etc.
949 
 
950 
    Parameters:
951 
     - orderId
952 
     - addressId
953 
    """
954 
    pass
955 
 
4285 rajveer 956 
  def acceptOrdersForItemId(self, itemId, inventory):
957 
    """
958 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
959 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 960 
 
4285 rajveer 961 
    Parameters:
962 
     - itemId
963 
     - inventory
964 
    """
965 
    pass
966 
 
4369 rajveer 967 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 968 
    """
969 
    Parameters:
970 
     - vendorId
971 
     - itemId
972 
     - quantity
973 
     - estimate
4369 rajveer 974 
     - isReminder
4303 rajveer 975 
    """
976 
    pass
4285 rajveer 977 
 
4369 rajveer 978 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 979 
    """
980 
    Parameters:
981 
     - vendorId
982 
     - itemId
983 
     - quantity
984 
     - estimate
4369 rajveer 985 
     - isReminder
4303 rajveer 986 
    """
987 
    pass
988 
 
4369 rajveer 989 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 990 
    """
991 
    Parameters:
992 
     - vendorId
993 
     - itemId
994 
     - quantity
995 
     - estimate
4369 rajveer 996 
     - isReminder
4303 rajveer 997 
    """
998 
    pass
999 
 
4369 rajveer 1000 
  def markOrdersAsTimeout(self, vendorId):
1001 
    """
1002 
    Parameters:
1003 
     - vendorId
1004 
    """
1005 
    pass
4303 rajveer 1006 
 
4662 rajveer 1007 
  def markOrderAsLostInTransit(self, orderId):
1008 
    """
1009 
    Mark order as LOST_IN_TRANSIT
1010 
 
1011 
    Parameters:
1012 
     - orderId
1013 
    """
1014 
    pass
1015 
 
4386 anupam.sin 1016 
  def getOrderForAwb(self, awb):
1017 
    """
1018 
    Returns the order corresponding to an AWB number
4369 rajveer 1019 
 
4386 anupam.sin 1020 
    Parameters:
1021 
     - awb
1022 
    """
1023 
    pass
1024 
 
4910 phani.kuma 1025 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1026 
    """
4910 phani.kuma 1027 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1028 
 
4506 phani.kuma 1029 
    Parameters:
1030 
     - logistics_provider_id
4910 phani.kuma 1031 
     - order_status_list
4506 phani.kuma 1032 
    """
1033 
    pass
1034 
 
4600 varun.gupt 1035 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1036 
    """
1037 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1038 
 
4600 varun.gupt 1039 
    Parameters:
1040 
     - vendorId
1041 
     - billingDateFrom
1042 
     - billingDateTo
1043 
    """
1044 
    pass
1045 
 
4607 rajveer 1046 
  def getSlippedSippingDateOrders(self, ):
1047 
    pass
1048 
 
4709 rajveer 1049 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1050 
    """
1051 
    Parameters:
1052 
     - cancelDateFrom
1053 
     - cancelDateTo
1054 
    """
1055 
    pass
1056 
 
4600 varun.gupt 1057 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1058 
    """
1059 
    Parameters:
1060 
     - mapAWBAndAmount
1061 
    """
1062 
    pass
1063 
 
4905 varun.gupt 1064 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1065 
    """
1066 
    Parameters:
1067 
     - settlementDate
1068 
     - paymentGatewayId
4905 varun.gupt 1069 
     - referenceId
4600 varun.gupt 1070 
     - serviceTax
1071 
     - otherCharges
1072 
     - netCollection
1073 
    """
1074 
    pass
1075 
 
1076 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1077 
    """
1078 
    Parameters:
1079 
     - settlementId
1080 
     - settlementDate
1081 
     - transactionDateFrom
1082 
     - transactionDateTo
1083 
     - amount
1084 
    """
1085 
    pass
1086 
 
5386 phani.kuma 1087 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1088 
    """
1089 
    Parameters:
5189 varun.gupt 1090 
     - referenceId
1091 
     - isRefund
4600 varun.gupt 1092 
    """
1093 
    pass
1094 
 
5386 phani.kuma 1095 
  def getSettlementForCod(self, orderId, isRefund):
1096 
    """
1097 
    Parameters:
1098 
     - orderId
1099 
     - isRefund
1100 
    """
1101 
    pass
1102 
 
4600 varun.gupt 1103 
  def getEBSSettlementSummaries(self, ):
1104 
    pass
1105 
 
1106 
  def markEBSSettlementUploaded(self, settlementId):
1107 
    """
1108 
    Parameters:
1109 
     - settlementId
1110 
    """
1111 
    pass
1112 
 
1113 
  def getEBSSettlementDate(self, settlementId):
1114 
    """
1115 
    Parameters:
1116 
     - settlementId
1117 
    """
1118 
    pass
1119 
 
4715 varun.gupt 1120 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1121 
    """
1122 
    Parameters:
1123 
     - settlementDateFrom
1124 
     - settlementDateTo
1125 
     - isRefund
1126 
    """
1127 
    pass
4600 varun.gupt 1128 
 
4715 varun.gupt 1129 
  def getReshippedOrderIds(self, orderIds):
1130 
    """
1131 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1132 
 
1133 
    Parameters:
1134 
     - orderIds
1135 
    """
1136 
    pass
1137 
 
5481 phani.kuma 1138 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1139 
    """
1140 
    Parameters:
1141 
     - vendorId
5481 phani.kuma 1142 
     - onlyVendorNotPaid
1143 
     - billingDateFrom
1144 
     - billingDateTo
4875 varun.gupt 1145 
    """
1146 
    pass
4757 mandeep.dh 1147 
 
5031 varun.gupt 1148 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1149 
    """
1150 
    Parameters:
1151 
     - startDate
1152 
     - endDate
1153 
    """
1154 
    pass
4875 varun.gupt 1155 
 
5067 varun.gupt 1156 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1157 
    """
1158 
    Parameters:
1159 
     - status
1160 
     - startDatetime
1161 
     - endDatetime
1162 
    """
1163 
    pass
5031 varun.gupt 1164 
 
5348 anupam.sin 1165 
  def updateCODAgent(self, agent, orderId):
1166 
    """
1167 
    Updates the agent who handled the COD verification call
1168 
 
1169 
    Parameters:
1170 
     - agent
1171 
     - orderId
1172 
    """
1173 
    pass
1174 
 
5099 varun.gupt 1175 
  def updateOrderAsPaidToVendor(self, orderId):
1176 
    """
1177 
    Parameters:
1178 
     - orderId
1179 
    """
1180 
    pass
5067 varun.gupt 1181 
 
5386 phani.kuma 1182 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1183 
    """
1184 
    Parameters:
1185 
     - orderId
1186 
    """
1187 
    pass
1188 
 
5208 varun.gupt 1189 
  def getRefundedOrdersMarkedPaid(self, ):
1190 
    pass
5099 varun.gupt 1191 
 
5447 anupam.sin 1192 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1193 
    """
1194 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1195 
 
5447 anupam.sin 1196 
 
1197 
    Parameters:
1198 
     - minOrderId
1199 
     - maxOrderId
1200 
    """
1201 
    pass
1202 
 
5527 anupam.sin 1203 
  def getAllAttributesForOrderId(self, orderId):
1204 
    """
1205 
    gets all attributes for a given orderId
5447 anupam.sin 1206 
 
5527 anupam.sin 1207 
    Parameters:
1208 
     - orderId
1209 
    """
1210 
    pass
1211 
 
5676 rajveer 1212 
  def setOrderAttributes(self, orderId, attributes):
1213 
    """
1214 
    sets attributes for an order
1215 
 
1216 
    Parameters:
1217 
     - orderId
1218 
     - attributes
1219 
    """
1220 
    pass
1221 
 
5527 anupam.sin 1222 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1223 
    """
1224 
    sets attributes for all orders in a transaction
1225 
 
1226 
    Parameters:
1227 
     - transactionId
1228 
     - attribute
1229 
    """
1230 
    pass
1231 
 
5553 rajveer 1232 
  def getReceivePendingOrders(self, storeId):
1233 
    """
1234 
    Parameters:
1235 
     - storeId
1236 
    """
1237 
    pass
5527 anupam.sin 1238 
 
5553 rajveer 1239 
  def getReceivedAtStoreOrders(self, storeId):
1240 
    """
1241 
    Parameters:
1242 
     - storeId
1243 
    """
1244 
    pass
1245 
 
5713 rajveer 1246 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
1247 
    """
1248 
    Parameters:
1249 
     - storeId
1250 
     - fromDate
1251 
     - toDate
1252 
     - onlyCod
1253 
    """
1254 
    pass
1255 
 
5833 rajveer 1256 
  def getOrderAttributeValue(self, orderId, attributeName):
1257 
    """
1258 
    Parameters:
1259 
     - orderId
1260 
     - attributeName
1261 
    """
1262 
    pass
1263 
 
6019 rajveer 1264 
  def changeJacketNumber(self, orderId, jacketNumber):
1265 
    """
1266 
    Parameters:
1267 
     - orderId
1268 
     - jacketNumber
1269 
    """
1270 
    pass
1271 
 
1272 
  def markOrderAsRtoInTransit(self, orderId):
1273 
    """
1274 
    Parameters:
1275 
     - orderId
1276 
    """
1277 
    pass
1278 
 
5593 mandeep.dh 1279 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1280 
    """
1281 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1282 
    invoked while scanning IN of items.
5553 rajveer 1283 
 
5593 mandeep.dh 1284 
    Parameters:
1285 
     - itemId
1286 
     - quantity
1287 
     - fulfilmentWarehouseId
1288 
     - billingWarehouseId
1289 
    """
1290 
    pass
1291 
 
6000 mandeep.dh 1292 
  def createRechargeOrder(self, rechargeOrder):
1293 
    """
1294 
    Parameters:
1295 
     - rechargeOrder
1296 
    """
1297 
    pass
5593 mandeep.dh 1298 
 
6031 rajveer 1299 
  def getRechargeOrder(self, rechargeRrderId):
1300 
    """
1301 
    Parameters:
1302 
     - rechargeRrderId
1303 
    """
1304 
    pass
1305 
 
1306 
  def getRechargeOrders(self, userId):
1307 
    """
1308 
    Parameters:
1309 
     - userId
1310 
    """
1311 
    pass
1312 
 
6000 mandeep.dh 1313 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
1314 
    """
1315 
    Parameters:
1316 
     - rechargeOrderId
1317 
     - rechargeOrderStatus
1318 
    """
1319 
    pass
1320 
 
6031 rajveer 1321 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 1322 
    """
1323 
    Parameters:
6031 rajveer 1324 
     - rechargeOrderId
6000 mandeep.dh 1325 
    """
1326 
    pass
1327 
 
6031 rajveer 1328 
  def getUserWallet(self, userId):
6000 mandeep.dh 1329 
    """
1330 
    Parameters:
6031 rajveer 1331 
     - userId
6000 mandeep.dh 1332 
    """
1333 
    pass
1334 
 
6031 rajveer 1335 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 1336 
    """
1337 
    Parameters:
6031 rajveer 1338 
     - userId
6000 mandeep.dh 1339 
    """
1340 
    pass
1341 
 
6050 anupam.sin 1342 
  def getRechargeOrdersForTransaction(self, txnId):
1343 
    """
1344 
    Returns a recharge order for a given transactionId
1345 
 
1346 
    Parameters:
1347 
     - txnId
1348 
    """
1349 
    pass
1350 
 
6206 rajveer 1351 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 1352 
    """
1353 
    Parameters:
1354 
     - rechargeType
6206 rajveer 1355 
     - onlyActive
6048 rajveer 1356 
    """
1357 
    pass
6000 mandeep.dh 1358 
 
6049 rajveer 1359 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 1360 
    """
1361 
    Parameters:
6049 rajveer 1362 
     - rechargeType
6048 rajveer 1363 
     - deviceNumber
1364 
    """
1365 
    pass
1366 
 
6591 anupam.sin 1367 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 1368 
    """
1369 
    Parameters:
1370 
     - rechargeType
1371 
     - deviceNumber
6307 anupam.sin 1372 
     - userSelectedProviderId
6591 anupam.sin 1373 
     - clientAddress
6269 rajveer 1374 
    """
1375 
    pass
1376 
 
6094 rajveer 1377 
  def getRechargeOrdersForDevice(self, deviceNumber):
1378 
    """
1379 
    Parameters:
1380 
     - deviceNumber
1381 
    """
1382 
    pass
6048 rajveer 1383 
 
6094 rajveer 1384 
  def addAmountToWallet(self, userId, orderId, amount):
1385 
    """
1386 
    Parameters:
1387 
     - userId
1388 
     - orderId
1389 
     - amount
1390 
    """
1391 
    pass
1392 
 
6188 rajveer 1393 
  def getRechargeStatistics(self, ):
1394 
    pass
1395 
 
6154 rajveer 1396 
  def getRechargeOrdersForStatus(self, status):
1397 
    """
1398 
    Parameters:
1399 
     - status
1400 
    """
1401 
    pass
6094 rajveer 1402 
 
6159 rajveer 1403 
  def getPlansForOperator(self, operatorId):
1404 
    """
1405 
    Parameters:
1406 
     - operatorId
1407 
    """
1408 
    pass
6154 rajveer 1409 
 
6307 anupam.sin 1410 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 1411 
    """
1412 
    Returns denominations for a given operator and circle
6159 rajveer 1413 
 
6289 anupam.sin 1414 
    Parameters:
1415 
     - operatorId
6307 anupam.sin 1416 
     - circleCode
6289 anupam.sin 1417 
     - denominationType
1418 
    """
1419 
    pass
1420 
 
6371 rajveer 1421 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
1422 
    """
1423 
    Parameters:
1424 
     - operatorId
1425 
     - circleId
1426 
     - isAvailable
1427 
    """
1428 
    pass
6289 anupam.sin 1429 
 
6389 rajveer 1430 
  def getAvailableEmiSchemes(self, ):
1431 
    pass
6371 rajveer 1432 
 
6389 rajveer 1433 
  def getMiscCharges(self, transactionId):
1434 
    """
1435 
    Parameters:
1436 
     - transactionId
1437 
    """
1438 
    pass
1439 
 
6507 anupam.sin 1440 
  def refundRechargeOrder(self, rechargeOrderId):
1441 
    """
1442 
    Parameters:
1443 
     - rechargeOrderId
1444 
    """
1445 
    pass
6389 rajveer 1446 
 
6821 amar.kumar 1447 
  def getPhysicalOrders(self, fromDate, toDate):
1448 
    """
1449 
    Parameters:
1450 
     - fromDate
1451 
     - toDate
1452 
    """
1453 
    pass
6507 anupam.sin 1454 
 
6906 rajveer 1455 
  def getDocument(self, docType, docSource):
1456 
    """
1457 
    Parameters:
1458 
     - docType
1459 
     - docSource
1460 
    """
1461 
    pass
6821 amar.kumar 1462 
 
6985 anupam.sin 1463 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
1464 
    """
1465 
    Parameters:
1466 
     - orderId
1467 
     - line1
1468 
     - line2
1469 
     - city
1470 
     - state
1471 
     - pin
1472 
    """
1473 
    pass
6906 rajveer 1474 
 
6988 rajveer 1475 
  def retrieveInvoice(self, orderId):
1476 
    """
1477 
    Parameters:
1478 
     - orderId
1479 
    """
1480 
    pass
6985 anupam.sin 1481 
 
7026 rajveer 1482 
  def receiveUpdatesForRedExpress(self, awbNumber):
1483 
    """
1484 
    Parameters:
1485 
     - awbNumber
1486 
    """
1487 
    pass
6988 rajveer 1488 
 
7026 rajveer 1489 
 
3376 rajveer 1490 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1491 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1492 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1493 
 
1494 
  def createTransaction(self, transaction):
1495 
    """
1496 
    Parameters:
1497 
     - transaction
1498 
    """
1499 
    self.send_createTransaction(transaction)
132 ashish 1500 
    return self.recv_createTransaction()
94 ashish 1501 
 
1502 
  def send_createTransaction(self, transaction):
1503 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1504 
    args = createTransaction_args()
1505 
    args.transaction = transaction
1506 
    args.write(self._oprot)
1507 
    self._oprot.writeMessageEnd()
1508 
    self._oprot.trans.flush()
1509 
 
1510 
  def recv_createTransaction(self, ):
1511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1512 
    if mtype == TMessageType.EXCEPTION:
1513 
      x = TApplicationException()
1514 
      x.read(self._iprot)
1515 
      self._iprot.readMessageEnd()
1516 
      raise x
1517 
    result = createTransaction_result()
1518 
    result.read(self._iprot)
1519 
    self._iprot.readMessageEnd()
3431 rajveer 1520 
    if result.success is not None:
132 ashish 1521 
      return result.success
3431 rajveer 1522 
    if result.ex is not None:
94 ashish 1523 
      raise result.ex
132 ashish 1524 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1525 
 
1526 
  def getTransaction(self, id):
1527 
    """
1528 
    Parameters:
1529 
     - id
1530 
    """
1531 
    self.send_getTransaction(id)
1532 
    return self.recv_getTransaction()
1533 
 
1534 
  def send_getTransaction(self, id):
1535 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1536 
    args = getTransaction_args()
1537 
    args.id = id
1538 
    args.write(self._oprot)
1539 
    self._oprot.writeMessageEnd()
1540 
    self._oprot.trans.flush()
1541 
 
1542 
  def recv_getTransaction(self, ):
1543 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1544 
    if mtype == TMessageType.EXCEPTION:
1545 
      x = TApplicationException()
1546 
      x.read(self._iprot)
1547 
      self._iprot.readMessageEnd()
1548 
      raise x
1549 
    result = getTransaction_result()
1550 
    result.read(self._iprot)
1551 
    self._iprot.readMessageEnd()
3431 rajveer 1552 
    if result.success is not None:
94 ashish 1553 
      return result.success
3431 rajveer 1554 
    if result.ex is not None:
94 ashish 1555 
      raise result.ex
1556 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1557 
 
1558 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1559 
    """
1560 
    Parameters:
1561 
     - customerId
1562 
     - from_date
1563 
     - to_date
1564 
     - status
1565 
    """
1566 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1567 
    return self.recv_getTransactionsForCustomer()
1568 
 
1569 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1570 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1571 
    args = getTransactionsForCustomer_args()
1572 
    args.customerId = customerId
1573 
    args.from_date = from_date
1574 
    args.to_date = to_date
1575 
    args.status = status
1576 
    args.write(self._oprot)
1577 
    self._oprot.writeMessageEnd()
1578 
    self._oprot.trans.flush()
1579 
 
1580 
  def recv_getTransactionsForCustomer(self, ):
1581 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1582 
    if mtype == TMessageType.EXCEPTION:
1583 
      x = TApplicationException()
1584 
      x.read(self._iprot)
1585 
      self._iprot.readMessageEnd()
1586 
      raise x
1587 
    result = getTransactionsForCustomer_result()
1588 
    result.read(self._iprot)
1589 
    self._iprot.readMessageEnd()
3431 rajveer 1590 
    if result.success is not None:
94 ashish 1591 
      return result.success
3431 rajveer 1592 
    if result.ex is not None:
94 ashish 1593 
      raise result.ex
1594 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1595 
 
132 ashish 1596 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1597 
    """
1598 
    Parameters:
1599 
     - shoppingCartId
1600 
    """
1601 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1602 
    return self.recv_getTransactionsForShoppingCartId()
1603 
 
1604 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1605 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1606 
    args = getTransactionsForShoppingCartId_args()
1607 
    args.shoppingCartId = shoppingCartId
1608 
    args.write(self._oprot)
1609 
    self._oprot.writeMessageEnd()
1610 
    self._oprot.trans.flush()
1611 
 
1612 
  def recv_getTransactionsForShoppingCartId(self, ):
1613 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1614 
    if mtype == TMessageType.EXCEPTION:
1615 
      x = TApplicationException()
1616 
      x.read(self._iprot)
1617 
      self._iprot.readMessageEnd()
1618 
      raise x
1619 
    result = getTransactionsForShoppingCartId_result()
1620 
    result.read(self._iprot)
1621 
    self._iprot.readMessageEnd()
3431 rajveer 1622 
    if result.success is not None:
132 ashish 1623 
      return result.success
3431 rajveer 1624 
    if result.ex is not None:
132 ashish 1625 
      raise result.ex
1626 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1627 
 
94 ashish 1628 
  def getTransactionStatus(self, transactionId):
1629 
    """
1630 
    Parameters:
1631 
     - transactionId
1632 
    """
1633 
    self.send_getTransactionStatus(transactionId)
1634 
    return self.recv_getTransactionStatus()
1635 
 
1636 
  def send_getTransactionStatus(self, transactionId):
1637 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1638 
    args = getTransactionStatus_args()
1639 
    args.transactionId = transactionId
1640 
    args.write(self._oprot)
1641 
    self._oprot.writeMessageEnd()
1642 
    self._oprot.trans.flush()
1643 
 
1644 
  def recv_getTransactionStatus(self, ):
1645 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1646 
    if mtype == TMessageType.EXCEPTION:
1647 
      x = TApplicationException()
1648 
      x.read(self._iprot)
1649 
      self._iprot.readMessageEnd()
1650 
      raise x
1651 
    result = getTransactionStatus_result()
1652 
    result.read(self._iprot)
1653 
    self._iprot.readMessageEnd()
3431 rajveer 1654 
    if result.success is not None:
94 ashish 1655 
      return result.success
3431 rajveer 1656 
    if result.ex is not None:
94 ashish 1657 
      raise result.ex
1658 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1659 
 
5527 anupam.sin 1660 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1661 
    """
1662 
    Parameters:
1663 
     - transactionId
1664 
     - status
1665 
     - description
5527 anupam.sin 1666 
     - pickUp
1667 
     - orderType
94 ashish 1668 
    """
5527 anupam.sin 1669 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1670 
    return self.recv_changeTransactionStatus()
1671 
 
5527 anupam.sin 1672 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1673 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1674 
    args = changeTransactionStatus_args()
1675 
    args.transactionId = transactionId
1676 
    args.status = status
1677 
    args.description = description
5527 anupam.sin 1678 
    args.pickUp = pickUp
1679 
    args.orderType = orderType
94 ashish 1680 
    args.write(self._oprot)
1681 
    self._oprot.writeMessageEnd()
1682 
    self._oprot.trans.flush()
1683 
 
1684 
  def recv_changeTransactionStatus(self, ):
1685 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1686 
    if mtype == TMessageType.EXCEPTION:
1687 
      x = TApplicationException()
1688 
      x.read(self._iprot)
1689 
      self._iprot.readMessageEnd()
1690 
      raise x
1691 
    result = changeTransactionStatus_result()
1692 
    result.read(self._iprot)
1693 
    self._iprot.readMessageEnd()
3431 rajveer 1694 
    if result.success is not None:
94 ashish 1695 
      return result.success
3431 rajveer 1696 
    if result.ex is not None:
94 ashish 1697 
      raise result.ex
1698 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1699 
 
1398 varun.gupt 1700 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1701 
    """
1702 
    Parameters:
1703 
     - transactionId
1704 
    """
1398 varun.gupt 1705 
    self.send_enqueueTransactionInfoEmail(transactionId)
1706 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1707 
 
1398 varun.gupt 1708 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1709 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1710 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1711 
    args.transactionId = transactionId
1712 
    args.write(self._oprot)
1713 
    self._oprot.writeMessageEnd()
1714 
    self._oprot.trans.flush()
1715 
 
1398 varun.gupt 1716 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1717 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1718 
    if mtype == TMessageType.EXCEPTION:
1719 
      x = TApplicationException()
1720 
      x.read(self._iprot)
1721 
      self._iprot.readMessageEnd()
1722 
      raise x
1398 varun.gupt 1723 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1724 
    result.read(self._iprot)
1725 
    self._iprot.readMessageEnd()
3431 rajveer 1726 
    if result.success is not None:
1382 varun.gupt 1727 
      return result.success
3431 rajveer 1728 
    if result.ex is not None:
1382 varun.gupt 1729 
      raise result.ex
1398 varun.gupt 1730 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1731 
 
4801 anupam.sin 1732 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1733 
    """
1734 
    Parameters:
4801 anupam.sin 1735 
     - statuses
483 rajveer 1736 
     - from_date
1737 
     - to_date
1738 
     - warehouse_id
94 ashish 1739 
    """
4801 anupam.sin 1740 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1741 
    return self.recv_getAllOrders()
94 ashish 1742 
 
4801 anupam.sin 1743 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1744 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1745 
    args = getAllOrders_args()
4801 anupam.sin 1746 
    args.statuses = statuses
483 rajveer 1747 
    args.from_date = from_date
1748 
    args.to_date = to_date
1749 
    args.warehouse_id = warehouse_id
94 ashish 1750 
    args.write(self._oprot)
1751 
    self._oprot.writeMessageEnd()
1752 
    self._oprot.trans.flush()
1753 
 
483 rajveer 1754 
  def recv_getAllOrders(self, ):
94 ashish 1755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1756 
    if mtype == TMessageType.EXCEPTION:
1757 
      x = TApplicationException()
1758 
      x.read(self._iprot)
1759 
      self._iprot.readMessageEnd()
1760 
      raise x
483 rajveer 1761 
    result = getAllOrders_result()
94 ashish 1762 
    result.read(self._iprot)
1763 
    self._iprot.readMessageEnd()
3431 rajveer 1764 
    if result.success is not None:
94 ashish 1765 
      return result.success
3431 rajveer 1766 
    if result.ex is not None:
94 ashish 1767 
      raise result.ex
483 rajveer 1768 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1769 
 
4133 chandransh 1770 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1771 
    """
1772 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1773 
    Pass the status as null and the limit as 0 to ignore them.
1774 
 
1775 
    Parameters:
1776 
     - statuses
1777 
     - offset
1778 
     - limit
1779 
     - warehouse_id
1780 
    """
1781 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1782 
    return self.recv_getOrdersInBatch()
1783 
 
1784 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1785 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1786 
    args = getOrdersInBatch_args()
1787 
    args.statuses = statuses
1788 
    args.offset = offset
1789 
    args.limit = limit
1790 
    args.warehouse_id = warehouse_id
1791 
    args.write(self._oprot)
1792 
    self._oprot.writeMessageEnd()
1793 
    self._oprot.trans.flush()
1794 
 
1795 
  def recv_getOrdersInBatch(self, ):
1796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1797 
    if mtype == TMessageType.EXCEPTION:
1798 
      x = TApplicationException()
1799 
      x.read(self._iprot)
1800 
      self._iprot.readMessageEnd()
1801 
      raise x
1802 
    result = getOrdersInBatch_result()
1803 
    result.read(self._iprot)
1804 
    self._iprot.readMessageEnd()
1805 
    if result.success is not None:
1806 
      return result.success
1807 
    if result.ex is not None:
1808 
      raise result.ex
1809 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1810 
 
1811 
  def getOrderCount(self, statuses, warehouseId):
1812 
    """
1813 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1814 
 
1815 
    Parameters:
1816 
     - statuses
1817 
     - warehouseId
1818 
    """
1819 
    self.send_getOrderCount(statuses, warehouseId)
1820 
    return self.recv_getOrderCount()
1821 
 
1822 
  def send_getOrderCount(self, statuses, warehouseId):
1823 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1824 
    args = getOrderCount_args()
1825 
    args.statuses = statuses
1826 
    args.warehouseId = warehouseId
1827 
    args.write(self._oprot)
1828 
    self._oprot.writeMessageEnd()
1829 
    self._oprot.trans.flush()
1830 
 
1831 
  def recv_getOrderCount(self, ):
1832 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1833 
    if mtype == TMessageType.EXCEPTION:
1834 
      x = TApplicationException()
1835 
      x.read(self._iprot)
1836 
      self._iprot.readMessageEnd()
1837 
      raise x
1838 
    result = getOrderCount_result()
1839 
    result.read(self._iprot)
1840 
    self._iprot.readMessageEnd()
1841 
    if result.success is not None:
1842 
      return result.success
1843 
    if result.ex is not None:
1844 
      raise result.ex
1845 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1846 
 
999 varun.gupt 1847 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1848 
    """
1132 chandransh 1849 
    Returns orders within a range of their billing dates
3431 rajveer 1850 
 
999 varun.gupt 1851 
    Parameters:
1852 
     - status
1853 
     - start_billing_date
1854 
     - end_billing_date
1855 
     - warehouse_id
1856 
    """
1857 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1858 
    return self.recv_getOrdersByBillingDate()
1859 
 
1860 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1861 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1862 
    args = getOrdersByBillingDate_args()
1863 
    args.status = status
1864 
    args.start_billing_date = start_billing_date
1865 
    args.end_billing_date = end_billing_date
1866 
    args.warehouse_id = warehouse_id
1867 
    args.write(self._oprot)
1868 
    self._oprot.writeMessageEnd()
1869 
    self._oprot.trans.flush()
1870 
 
1871 
  def recv_getOrdersByBillingDate(self, ):
1872 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1873 
    if mtype == TMessageType.EXCEPTION:
1874 
      x = TApplicationException()
1875 
      x.read(self._iprot)
1876 
      self._iprot.readMessageEnd()
1877 
      raise x
1878 
    result = getOrdersByBillingDate_result()
1879 
    result.read(self._iprot)
1880 
    self._iprot.readMessageEnd()
3431 rajveer 1881 
    if result.success is not None:
999 varun.gupt 1882 
      return result.success
3431 rajveer 1883 
    if result.ex is not None:
999 varun.gupt 1884 
      raise result.ex
1885 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1886 
 
3451 chandransh 1887 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1888 
    """
1889 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1890 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1891 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1892 
 
3427 chandransh 1893 
    Parameters:
1894 
     - fromShippingDate
1895 
     - toShippingDate
1896 
     - providerId
1897 
     - warehouseId
3451 chandransh 1898 
     - cod
3427 chandransh 1899 
    """
3451 chandransh 1900 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1901 
    return self.recv_getOrdersByShippingDate()
1902 
 
3451 chandransh 1903 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1904 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1905 
    args = getOrdersByShippingDate_args()
1906 
    args.fromShippingDate = fromShippingDate
1907 
    args.toShippingDate = toShippingDate
1908 
    args.providerId = providerId
1909 
    args.warehouseId = warehouseId
3451 chandransh 1910 
    args.cod = cod
3427 chandransh 1911 
    args.write(self._oprot)
1912 
    self._oprot.writeMessageEnd()
1913 
    self._oprot.trans.flush()
1914 
 
1915 
  def recv_getOrdersByShippingDate(self, ):
1916 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1917 
    if mtype == TMessageType.EXCEPTION:
1918 
      x = TApplicationException()
1919 
      x.read(self._iprot)
1920 
      self._iprot.readMessageEnd()
1921 
      raise x
1922 
    result = getOrdersByShippingDate_result()
1923 
    result.read(self._iprot)
1924 
    self._iprot.readMessageEnd()
3431 rajveer 1925 
    if result.success is not None:
3427 chandransh 1926 
      return result.success
3431 rajveer 1927 
    if result.ex is not None:
3427 chandransh 1928 
      raise result.ex
1929 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1930 
 
1382 varun.gupt 1931 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1932 
    """
1933 
    Returns order ids for orders which can be returned
3431 rajveer 1934 
 
1382 varun.gupt 1935 
    Parameters:
1936 
     - customer_id
1937 
     - limit
1938 
    """
1939 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1940 
    return self.recv_getReturnableOrdersForCustomer()
1941 
 
1942 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1943 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1944 
    args = getReturnableOrdersForCustomer_args()
1945 
    args.customer_id = customer_id
1946 
    args.limit = limit
1947 
    args.write(self._oprot)
1948 
    self._oprot.writeMessageEnd()
1949 
    self._oprot.trans.flush()
1950 
 
1951 
  def recv_getReturnableOrdersForCustomer(self, ):
1952 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1953 
    if mtype == TMessageType.EXCEPTION:
1954 
      x = TApplicationException()
1955 
      x.read(self._iprot)
1956 
      self._iprot.readMessageEnd()
1957 
      raise x
1958 
    result = getReturnableOrdersForCustomer_result()
1959 
    result.read(self._iprot)
1960 
    self._iprot.readMessageEnd()
3431 rajveer 1961 
    if result.success is not None:
1382 varun.gupt 1962 
      return result.success
3431 rajveer 1963 
    if result.ex is not None:
1382 varun.gupt 1964 
      raise result.ex
1965 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1966 
 
1967 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1968 
    """
1969 
    Returns order ids for orders which can be cancelled
3431 rajveer 1970 
 
1382 varun.gupt 1971 
    Parameters:
1972 
     - customer_id
1973 
     - limit
1974 
    """
1975 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1976 
    return self.recv_getCancellableOrdersForCustomer()
1977 
 
1978 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1979 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1980 
    args = getCancellableOrdersForCustomer_args()
1981 
    args.customer_id = customer_id
1982 
    args.limit = limit
1983 
    args.write(self._oprot)
1984 
    self._oprot.writeMessageEnd()
1985 
    self._oprot.trans.flush()
1986 
 
1987 
  def recv_getCancellableOrdersForCustomer(self, ):
1988 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1989 
    if mtype == TMessageType.EXCEPTION:
1990 
      x = TApplicationException()
1991 
      x.read(self._iprot)
1992 
      self._iprot.readMessageEnd()
1993 
      raise x
1994 
    result = getCancellableOrdersForCustomer_result()
1995 
    result.read(self._iprot)
1996 
    self._iprot.readMessageEnd()
3431 rajveer 1997 
    if result.success is not None:
1382 varun.gupt 1998 
      return result.success
3431 rajveer 1999 
    if result.ex is not None:
1382 varun.gupt 2000 
      raise result.ex
2001 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
2002 
 
483 rajveer 2003 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 2004 
    """
2005 
    Parameters:
483 rajveer 2006 
     - orderId
2007 
     - status
2008 
     - description
94 ashish 2009 
    """
483 rajveer 2010 
    self.send_changeOrderStatus(orderId, status, description)
2011 
    return self.recv_changeOrderStatus()
94 ashish 2012 
 
483 rajveer 2013 
  def send_changeOrderStatus(self, orderId, status, description):
2014 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
2015 
    args = changeOrderStatus_args()
2016 
    args.orderId = orderId
2017 
    args.status = status
2018 
    args.description = description
94 ashish 2019 
    args.write(self._oprot)
2020 
    self._oprot.writeMessageEnd()
2021 
    self._oprot.trans.flush()
2022 
 
483 rajveer 2023 
  def recv_changeOrderStatus(self, ):
94 ashish 2024 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2025 
    if mtype == TMessageType.EXCEPTION:
2026 
      x = TApplicationException()
2027 
      x.read(self._iprot)
2028 
      self._iprot.readMessageEnd()
2029 
      raise x
483 rajveer 2030 
    result = changeOrderStatus_result()
94 ashish 2031 
    result.read(self._iprot)
2032 
    self._iprot.readMessageEnd()
3431 rajveer 2033 
    if result.success is not None:
94 ashish 2034 
      return result.success
3431 rajveer 2035 
    if result.ex is not None:
94 ashish 2036 
      raise result.ex
483 rajveer 2037 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 2038 
 
1528 ankur.sing 2039 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 2040 
    """
1528 ankur.sing 2041 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
2042 
    only user who owns the transaction can view its order details.
3431 rajveer 2043 
 
94 ashish 2044 
    Parameters:
2045 
     - transactionId
1528 ankur.sing 2046 
     - customerId
94 ashish 2047 
    """
1528 ankur.sing 2048 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2049 
    return self.recv_getOrdersForTransaction()
94 ashish 2050 
 
1528 ankur.sing 2051 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2052 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2053 
    args = getOrdersForTransaction_args()
94 ashish 2054 
    args.transactionId = transactionId
1528 ankur.sing 2055 
    args.customerId = customerId
94 ashish 2056 
    args.write(self._oprot)
2057 
    self._oprot.writeMessageEnd()
2058 
    self._oprot.trans.flush()
2059 
 
483 rajveer 2060 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2061 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2062 
    if mtype == TMessageType.EXCEPTION:
2063 
      x = TApplicationException()
2064 
      x.read(self._iprot)
2065 
      self._iprot.readMessageEnd()
2066 
      raise x
483 rajveer 2067 
    result = getOrdersForTransaction_result()
94 ashish 2068 
    result.read(self._iprot)
2069 
    self._iprot.readMessageEnd()
3431 rajveer 2070 
    if result.success is not None:
94 ashish 2071 
      return result.success
3431 rajveer 2072 
    if result.ex is not None:
94 ashish 2073 
      raise result.ex
483 rajveer 2074 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2075 
 
3014 chandransh 2076 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2077 
    """
3014 chandransh 2078 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2079 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2080 
 
94 ashish 2081 
    Parameters:
483 rajveer 2082 
     - customerId
2083 
     - from_date
2084 
     - to_date
3014 chandransh 2085 
     - statuses
94 ashish 2086 
    """
3014 chandransh 2087 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2088 
    return self.recv_getOrdersForCustomer()
94 ashish 2089 
 
3014 chandransh 2090 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2091 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2092 
    args = getOrdersForCustomer_args()
2093 
    args.customerId = customerId
2094 
    args.from_date = from_date
2095 
    args.to_date = to_date
3014 chandransh 2096 
    args.statuses = statuses
94 ashish 2097 
    args.write(self._oprot)
2098 
    self._oprot.writeMessageEnd()
2099 
    self._oprot.trans.flush()
2100 
 
483 rajveer 2101 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2103 
    if mtype == TMessageType.EXCEPTION:
2104 
      x = TApplicationException()
2105 
      x.read(self._iprot)
2106 
      self._iprot.readMessageEnd()
2107 
      raise x
483 rajveer 2108 
    result = getOrdersForCustomer_result()
94 ashish 2109 
    result.read(self._iprot)
2110 
    self._iprot.readMessageEnd()
3431 rajveer 2111 
    if result.success is not None:
94 ashish 2112 
      return result.success
3431 rajveer 2113 
    if result.ex is not None:
94 ashish 2114 
      raise result.ex
483 rajveer 2115 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2116 
 
483 rajveer 2117 
  def createOrder(self, order):
94 ashish 2118 
    """
2119 
    Parameters:
483 rajveer 2120 
     - order
94 ashish 2121 
    """
483 rajveer 2122 
    self.send_createOrder(order)
2123 
    return self.recv_createOrder()
94 ashish 2124 
 
483 rajveer 2125 
  def send_createOrder(self, order):
2126 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2127 
    args = createOrder_args()
2128 
    args.order = order
94 ashish 2129 
    args.write(self._oprot)
2130 
    self._oprot.writeMessageEnd()
2131 
    self._oprot.trans.flush()
2132 
 
483 rajveer 2133 
  def recv_createOrder(self, ):
94 ashish 2134 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2135 
    if mtype == TMessageType.EXCEPTION:
2136 
      x = TApplicationException()
2137 
      x.read(self._iprot)
2138 
      self._iprot.readMessageEnd()
2139 
      raise x
483 rajveer 2140 
    result = createOrder_result()
94 ashish 2141 
    result.read(self._iprot)
2142 
    self._iprot.readMessageEnd()
3431 rajveer 2143 
    if result.success is not None:
94 ashish 2144 
      return result.success
3431 rajveer 2145 
    if result.ex is not None:
94 ashish 2146 
      raise result.ex
483 rajveer 2147 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2148 
 
483 rajveer 2149 
  def getOrder(self, id):
94 ashish 2150 
    """
2151 
    Parameters:
483 rajveer 2152 
     - id
94 ashish 2153 
    """
483 rajveer 2154 
    self.send_getOrder(id)
2155 
    return self.recv_getOrder()
94 ashish 2156 
 
483 rajveer 2157 
  def send_getOrder(self, id):
2158 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2159 
    args = getOrder_args()
2160 
    args.id = id
94 ashish 2161 
    args.write(self._oprot)
2162 
    self._oprot.writeMessageEnd()
2163 
    self._oprot.trans.flush()
2164 
 
483 rajveer 2165 
  def recv_getOrder(self, ):
94 ashish 2166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2167 
    if mtype == TMessageType.EXCEPTION:
2168 
      x = TApplicationException()
2169 
      x.read(self._iprot)
2170 
      self._iprot.readMessageEnd()
2171 
      raise x
483 rajveer 2172 
    result = getOrder_result()
94 ashish 2173 
    result.read(self._iprot)
2174 
    self._iprot.readMessageEnd()
3431 rajveer 2175 
    if result.success is not None:
94 ashish 2176 
      return result.success
3431 rajveer 2177 
    if result.ex is not None:
94 ashish 2178 
      raise result.ex
483 rajveer 2179 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2180 
 
483 rajveer 2181 
  def getLineItemsForOrder(self, orderId):
94 ashish 2182 
    """
2183 
    Parameters:
483 rajveer 2184 
     - orderId
94 ashish 2185 
    """
483 rajveer 2186 
    self.send_getLineItemsForOrder(orderId)
2187 
    return self.recv_getLineItemsForOrder()
94 ashish 2188 
 
483 rajveer 2189 
  def send_getLineItemsForOrder(self, orderId):
2190 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2191 
    args = getLineItemsForOrder_args()
2192 
    args.orderId = orderId
94 ashish 2193 
    args.write(self._oprot)
2194 
    self._oprot.writeMessageEnd()
2195 
    self._oprot.trans.flush()
2196 
 
483 rajveer 2197 
  def recv_getLineItemsForOrder(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 = getLineItemsForOrder_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, "getLineItemsForOrder failed: unknown result");
94 ashish 2212 
 
4999 phani.kuma 2213 
  def getOrderList(self, order_ids):
2214 
    """
2215 
    Parameters:
2216 
     - order_ids
2217 
    """
2218 
    self.send_getOrderList(order_ids)
2219 
    return self.recv_getOrderList()
2220 
 
2221 
  def send_getOrderList(self, order_ids):
2222 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2223 
    args = getOrderList_args()
2224 
    args.order_ids = order_ids
2225 
    args.write(self._oprot)
2226 
    self._oprot.writeMessageEnd()
2227 
    self._oprot.trans.flush()
2228 
 
2229 
  def recv_getOrderList(self, ):
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
2236 
    result = getOrderList_result()
2237 
    result.read(self._iprot)
2238 
    self._iprot.readMessageEnd()
2239 
    if result.success is not None:
2240 
      return result.success
2241 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2242 
 
5386 phani.kuma 2243 
  def getOrderListForVendor(self, order_ids, vendorId):
2244 
    """
2245 
    Parameters:
2246 
     - order_ids
2247 
     - vendorId
2248 
    """
2249 
    self.send_getOrderListForVendor(order_ids, vendorId)
2250 
    return self.recv_getOrderListForVendor()
2251 
 
2252 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2253 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2254 
    args = getOrderListForVendor_args()
2255 
    args.order_ids = order_ids
2256 
    args.vendorId = vendorId
2257 
    args.write(self._oprot)
2258 
    self._oprot.writeMessageEnd()
2259 
    self._oprot.trans.flush()
2260 
 
2261 
  def recv_getOrderListForVendor(self, ):
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
2268 
    result = getOrderListForVendor_result()
2269 
    result.read(self._iprot)
2270 
    self._iprot.readMessageEnd()
2271 
    if result.success is not None:
2272 
      return result.success
2273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2274 
 
1528 ankur.sing 2275 
  def getOrderForCustomer(self, orderId, customerId):
2276 
    """
2277 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2278 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2279 
 
1528 ankur.sing 2280 
    Parameters:
2281 
     - orderId
2282 
     - customerId
2283 
    """
2284 
    self.send_getOrderForCustomer(orderId, customerId)
2285 
    return self.recv_getOrderForCustomer()
2286 
 
2287 
  def send_getOrderForCustomer(self, orderId, customerId):
2288 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2289 
    args = getOrderForCustomer_args()
2290 
    args.orderId = orderId
2291 
    args.customerId = customerId
2292 
    args.write(self._oprot)
2293 
    self._oprot.writeMessageEnd()
2294 
    self._oprot.trans.flush()
2295 
 
2296 
  def recv_getOrderForCustomer(self, ):
2297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2298 
    if mtype == TMessageType.EXCEPTION:
2299 
      x = TApplicationException()
2300 
      x.read(self._iprot)
2301 
      self._iprot.readMessageEnd()
2302 
      raise x
2303 
    result = getOrderForCustomer_result()
2304 
    result.read(self._iprot)
2305 
    self._iprot.readMessageEnd()
3431 rajveer 2306 
    if result.success is not None:
1528 ankur.sing 2307 
      return result.success
3431 rajveer 2308 
    if result.ex is not None:
1528 ankur.sing 2309 
      raise result.ex
2310 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2311 
 
4444 rajveer 2312 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2313 
    """
2314 
    Parameters:
4394 rajveer 2315 
     - type
4444 rajveer 2316 
     - warehouseId
4394 rajveer 2317 
     - status
2318 
     - timestamp
3064 chandransh 2319 
    """
4444 rajveer 2320 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2321 
    return self.recv_getAlerts()
2322 
 
4444 rajveer 2323 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2324 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2325 
    args = getAlerts_args()
4394 rajveer 2326 
    args.type = type
4444 rajveer 2327 
    args.warehouseId = warehouseId
4394 rajveer 2328 
    args.status = status
2329 
    args.timestamp = timestamp
3064 chandransh 2330 
    args.write(self._oprot)
2331 
    self._oprot.writeMessageEnd()
2332 
    self._oprot.trans.flush()
2333 
 
2334 
  def recv_getAlerts(self, ):
2335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2336 
    if mtype == TMessageType.EXCEPTION:
2337 
      x = TApplicationException()
2338 
      x.read(self._iprot)
2339 
      self._iprot.readMessageEnd()
2340 
      raise x
2341 
    result = getAlerts_result()
2342 
    result.read(self._iprot)
2343 
    self._iprot.readMessageEnd()
3431 rajveer 2344 
    if result.success is not None:
3064 chandransh 2345 
      return result.success
2346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2347 
 
4444 rajveer 2348 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2349 
    """
2350 
    Parameters:
2351 
     - type
4444 rajveer 2352 
     - warehouseId
4394 rajveer 2353 
     - description
3064 chandransh 2354 
    """
4444 rajveer 2355 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2356 
    self.recv_addAlert()
3064 chandransh 2357 
 
4444 rajveer 2358 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2359 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2360 
    args = addAlert_args()
3064 chandransh 2361 
    args.type = type
4444 rajveer 2362 
    args.warehouseId = warehouseId
4394 rajveer 2363 
    args.description = description
3064 chandransh 2364 
    args.write(self._oprot)
2365 
    self._oprot.writeMessageEnd()
2366 
    self._oprot.trans.flush()
2367 
 
4394 rajveer 2368 
  def recv_addAlert(self, ):
3064 chandransh 2369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2370 
    if mtype == TMessageType.EXCEPTION:
2371 
      x = TApplicationException()
2372 
      x.read(self._iprot)
2373 
      self._iprot.readMessageEnd()
2374 
      raise x
4394 rajveer 2375 
    result = addAlert_result()
3064 chandransh 2376 
    result.read(self._iprot)
2377 
    self._iprot.readMessageEnd()
2378 
    return
2379 
 
4444 rajveer 2380 
  def markAlertsAsSeen(self, warehouseId):
2381 
    """
2382 
    Parameters:
2383 
     - warehouseId
2384 
    """
2385 
    self.send_markAlertsAsSeen(warehouseId)
2386 
    self.recv_markAlertsAsSeen()
2387 
 
2388 
  def send_markAlertsAsSeen(self, warehouseId):
2389 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2390 
    args = markAlertsAsSeen_args()
2391 
    args.warehouseId = warehouseId
2392 
    args.write(self._oprot)
2393 
    self._oprot.writeMessageEnd()
2394 
    self._oprot.trans.flush()
2395 
 
2396 
  def recv_markAlertsAsSeen(self, ):
2397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2398 
    if mtype == TMessageType.EXCEPTION:
2399 
      x = TApplicationException()
2400 
      x.read(self._iprot)
2401 
      self._iprot.readMessageEnd()
2402 
      raise x
2403 
    result = markAlertsAsSeen_result()
2404 
    result.read(self._iprot)
2405 
    self._iprot.readMessageEnd()
2406 
    return
2407 
 
3064 chandransh 2408 
  def getValidOrderCount(self, ):
2409 
    """
2410 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2411 
    """
2412 
    self.send_getValidOrderCount()
2413 
    return self.recv_getValidOrderCount()
2414 
 
2415 
  def send_getValidOrderCount(self, ):
2416 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2417 
    args = getValidOrderCount_args()
2418 
    args.write(self._oprot)
2419 
    self._oprot.writeMessageEnd()
2420 
    self._oprot.trans.flush()
2421 
 
2422 
  def recv_getValidOrderCount(self, ):
2423 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2424 
    if mtype == TMessageType.EXCEPTION:
2425 
      x = TApplicationException()
2426 
      x.read(self._iprot)
2427 
      self._iprot.readMessageEnd()
2428 
      raise x
2429 
    result = getValidOrderCount_result()
2430 
    result.read(self._iprot)
2431 
    self._iprot.readMessageEnd()
3431 rajveer 2432 
    if result.success is not None:
3064 chandransh 2433 
      return result.success
2434 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2435 
 
2436 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2437 
    """
2438 
    Returns the number of distinct customers who have done successful transactions
2439 
    """
2440 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2441 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2442 
 
2443 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2444 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2445 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2446 
    args.write(self._oprot)
2447 
    self._oprot.writeMessageEnd()
2448 
    self._oprot.trans.flush()
2449 
 
2450 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2451 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2452 
    if mtype == TMessageType.EXCEPTION:
2453 
      x = TApplicationException()
2454 
      x.read(self._iprot)
2455 
      self._iprot.readMessageEnd()
2456 
      raise x
2457 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2458 
    result.read(self._iprot)
2459 
    self._iprot.readMessageEnd()
3431 rajveer 2460 
    if result.success is not None:
3064 chandransh 2461 
      return result.success
2462 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2463 
 
2464 
  def getValidOrdersAmountRange(self, ):
2465 
    """
2466 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2467 
    List contains two values, first minimum amount and second maximum amount.
2468 
    """
2469 
    self.send_getValidOrdersAmountRange()
2470 
    return self.recv_getValidOrdersAmountRange()
2471 
 
2472 
  def send_getValidOrdersAmountRange(self, ):
2473 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2474 
    args = getValidOrdersAmountRange_args()
2475 
    args.write(self._oprot)
2476 
    self._oprot.writeMessageEnd()
2477 
    self._oprot.trans.flush()
2478 
 
2479 
  def recv_getValidOrdersAmountRange(self, ):
2480 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2481 
    if mtype == TMessageType.EXCEPTION:
2482 
      x = TApplicationException()
2483 
      x.read(self._iprot)
2484 
      self._iprot.readMessageEnd()
2485 
      raise x
2486 
    result = getValidOrdersAmountRange_result()
2487 
    result.read(self._iprot)
2488 
    self._iprot.readMessageEnd()
3431 rajveer 2489 
    if result.success is not None:
3064 chandransh 2490 
      return result.success
2491 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2492 
 
5874 rajveer 2493 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2494 
    """
2495 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2496 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2497 
 
3064 chandransh 2498 
    Parameters:
2499 
     - limit
5874 rajveer 2500 
     - onlyStore
3064 chandransh 2501 
    """
5874 rajveer 2502 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2503 
    return self.recv_getValidOrders()
2504 
 
5874 rajveer 2505 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2506 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2507 
    args = getValidOrders_args()
2508 
    args.limit = limit
5874 rajveer 2509 
    args.onlyStore = onlyStore
3064 chandransh 2510 
    args.write(self._oprot)
2511 
    self._oprot.writeMessageEnd()
2512 
    self._oprot.trans.flush()
2513 
 
2514 
  def recv_getValidOrders(self, ):
2515 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2516 
    if mtype == TMessageType.EXCEPTION:
2517 
      x = TApplicationException()
2518 
      x.read(self._iprot)
2519 
      self._iprot.readMessageEnd()
2520 
      raise x
2521 
    result = getValidOrders_result()
2522 
    result.read(self._iprot)
2523 
    self._iprot.readMessageEnd()
3431 rajveer 2524 
    if result.success is not None:
3064 chandransh 2525 
      return result.success
2526 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2527 
 
1220 chandransh 2528 
  def batchOrders(self, warehouseId):
2529 
    """
2530 
    Create a batch of all the pending orders for the given warehouse.
2531 
    The returned list is orderd by created_timestamp.
2532 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2533 
 
1220 chandransh 2534 
    Parameters:
2535 
     - warehouseId
2536 
    """
2537 
    self.send_batchOrders(warehouseId)
2538 
    return self.recv_batchOrders()
2539 
 
2540 
  def send_batchOrders(self, warehouseId):
2541 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2542 
    args = batchOrders_args()
2543 
    args.warehouseId = warehouseId
2544 
    args.write(self._oprot)
2545 
    self._oprot.writeMessageEnd()
2546 
    self._oprot.trans.flush()
2547 
 
2548 
  def recv_batchOrders(self, ):
2549 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2550 
    if mtype == TMessageType.EXCEPTION:
2551 
      x = TApplicationException()
2552 
      x.read(self._iprot)
2553 
      self._iprot.readMessageEnd()
2554 
      raise x
2555 
    result = batchOrders_result()
2556 
    result.read(self._iprot)
2557 
    self._iprot.readMessageEnd()
3431 rajveer 2558 
    if result.success is not None:
1220 chandransh 2559 
      return result.success
3431 rajveer 2560 
    if result.ex is not None:
1220 chandransh 2561 
      raise result.ex
2562 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2563 
 
1208 chandransh 2564 
  def markOrderAsOutOfStock(self, orderId):
2565 
    """
2566 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2567 
 
1208 chandransh 2568 
    Parameters:
2569 
     - orderId
2570 
    """
2571 
    self.send_markOrderAsOutOfStock(orderId)
2572 
    return self.recv_markOrderAsOutOfStock()
2573 
 
2574 
  def send_markOrderAsOutOfStock(self, orderId):
2575 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2576 
    args = markOrderAsOutOfStock_args()
2577 
    args.orderId = orderId
2578 
    args.write(self._oprot)
2579 
    self._oprot.writeMessageEnd()
2580 
    self._oprot.trans.flush()
2581 
 
2582 
  def recv_markOrderAsOutOfStock(self, ):
2583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2584 
    if mtype == TMessageType.EXCEPTION:
2585 
      x = TApplicationException()
2586 
      x.read(self._iprot)
2587 
      self._iprot.readMessageEnd()
2588 
      raise x
2589 
    result = markOrderAsOutOfStock_result()
2590 
    result.read(self._iprot)
2591 
    self._iprot.readMessageEnd()
3431 rajveer 2592 
    if result.success is not None:
1208 chandransh 2593 
      return result.success
3431 rajveer 2594 
    if result.ex is not None:
1208 chandransh 2595 
      raise result.ex
2596 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2597 
 
3064 chandransh 2598 
  def verifyOrder(self, orderId):
759 chandransh 2599 
    """
3064 chandransh 2600 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2601 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2602 
    used for all other orders as well.
2603 
    Throws an exception if no such order exists.
3431 rajveer 2604 
 
759 chandransh 2605 
    Parameters:
3064 chandransh 2606 
     - orderId
759 chandransh 2607 
    """
3064 chandransh 2608 
    self.send_verifyOrder(orderId)
2609 
    return self.recv_verifyOrder()
759 chandransh 2610 
 
3064 chandransh 2611 
  def send_verifyOrder(self, orderId):
2612 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2613 
    args = verifyOrder_args()
2614 
    args.orderId = orderId
759 chandransh 2615 
    args.write(self._oprot)
2616 
    self._oprot.writeMessageEnd()
2617 
    self._oprot.trans.flush()
2618 
 
3064 chandransh 2619 
  def recv_verifyOrder(self, ):
759 chandransh 2620 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2621 
    if mtype == TMessageType.EXCEPTION:
2622 
      x = TApplicationException()
2623 
      x.read(self._iprot)
2624 
      self._iprot.readMessageEnd()
2625 
      raise x
3064 chandransh 2626 
    result = verifyOrder_result()
759 chandransh 2627 
    result.read(self._iprot)
2628 
    self._iprot.readMessageEnd()
3431 rajveer 2629 
    if result.success is not None:
759 chandransh 2630 
      return result.success
3431 rajveer 2631 
    if result.ex is not None:
759 chandransh 2632 
      raise result.ex
3064 chandransh 2633 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2634 
 
3064 chandransh 2635 
  def acceptOrder(self, orderId):
1113 chandransh 2636 
    """
3064 chandransh 2637 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2638 
    given order is not a COD order, it also captures the payment if the same has
2639 
    not been captured.
2640 
    Throws an exception if no such order exists.
3431 rajveer 2641 
 
1113 chandransh 2642 
    Parameters:
3064 chandransh 2643 
     - orderId
1113 chandransh 2644 
    """
3064 chandransh 2645 
    self.send_acceptOrder(orderId)
2646 
    return self.recv_acceptOrder()
1113 chandransh 2647 
 
3064 chandransh 2648 
  def send_acceptOrder(self, orderId):
2649 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2650 
    args = acceptOrder_args()
2651 
    args.orderId = orderId
1113 chandransh 2652 
    args.write(self._oprot)
2653 
    self._oprot.writeMessageEnd()
2654 
    self._oprot.trans.flush()
2655 
 
3064 chandransh 2656 
  def recv_acceptOrder(self, ):
1113 chandransh 2657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2658 
    if mtype == TMessageType.EXCEPTION:
2659 
      x = TApplicationException()
2660 
      x.read(self._iprot)
2661 
      self._iprot.readMessageEnd()
2662 
      raise x
3064 chandransh 2663 
    result = acceptOrder_result()
1113 chandransh 2664 
    result.read(self._iprot)
2665 
    self._iprot.readMessageEnd()
3431 rajveer 2666 
    if result.success is not None:
1113 chandransh 2667 
      return result.success
3431 rajveer 2668 
    if result.ex is not None:
1113 chandransh 2669 
      raise result.ex
3064 chandransh 2670 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2671 
 
5110 mandeep.dh 2672 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2673 
    """
3064 chandransh 2674 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2675 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2676 
    the IMEI no. if a -1 is supplied.
2677 
    Also, it generates an invoice number for the order, marks the order as
2678 
    BILLED and sets the billing timestamp.
2679 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2680 
 
1135 chandransh 2681 
    Parameters:
3064 chandransh 2682 
     - orderId
2683 
     - invoice_number
4658 mandeep.dh 2684 
     - serialNumber
4283 anupam.sin 2685 
     - itemNumber
3064 chandransh 2686 
     - billed_by
4264 rajveer 2687 
     - jacketNumber
4283 anupam.sin 2688 
     - billingType
5110 mandeep.dh 2689 
     - fulfilmentWarehouseId
4763 rajveer 2690 
     - authorize
1135 chandransh 2691 
    """
5110 mandeep.dh 2692 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2693 
    return self.recv_addBillingDetails()
1135 chandransh 2694 
 
5110 mandeep.dh 2695 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2696 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2697 
    args = addBillingDetails_args()
2698 
    args.orderId = orderId
2699 
    args.invoice_number = invoice_number
4658 mandeep.dh 2700 
    args.serialNumber = serialNumber
4283 anupam.sin 2701 
    args.itemNumber = itemNumber
3064 chandransh 2702 
    args.billed_by = billed_by
4264 rajveer 2703 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2704 
    args.billingType = billingType
5110 mandeep.dh 2705 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2706 
    args.authorize = authorize
1135 chandransh 2707 
    args.write(self._oprot)
2708 
    self._oprot.writeMessageEnd()
2709 
    self._oprot.trans.flush()
2710 
 
3064 chandransh 2711 
  def recv_addBillingDetails(self, ):
1135 chandransh 2712 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2713 
    if mtype == TMessageType.EXCEPTION:
2714 
      x = TApplicationException()
2715 
      x.read(self._iprot)
2716 
      self._iprot.readMessageEnd()
2717 
      raise x
3064 chandransh 2718 
    result = addBillingDetails_result()
1135 chandransh 2719 
    result.read(self._iprot)
2720 
    self._iprot.readMessageEnd()
3431 rajveer 2721 
    if result.success is not None:
3064 chandransh 2722 
      return result.success
3431 rajveer 2723 
    if result.ex is not None:
1135 chandransh 2724 
      raise result.ex
3064 chandransh 2725 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2726 
 
6756 amar.kumar 2727 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2728 
    """
2729 
    Add the invoice number to the order.
2730 
 
2731 
    Parameters:
2732 
     - orderId
2733 
     - invoiceNumber
4763 rajveer 2734 
     - color
6756 amar.kumar 2735 
     - serialNumber
2736 
     - itemNumber
4579 rajveer 2737 
    """
6756 amar.kumar 2738 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color, serialNumber, itemNumber)
4579 rajveer 2739 
    self.recv_addInvoiceNumber()
2740 
 
6756 amar.kumar 2741 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2742 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2743 
    args = addInvoiceNumber_args()
2744 
    args.orderId = orderId
2745 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2746 
    args.color = color
6756 amar.kumar 2747 
    args.serialNumber = serialNumber
2748 
    args.itemNumber = itemNumber
4579 rajveer 2749 
    args.write(self._oprot)
2750 
    self._oprot.writeMessageEnd()
2751 
    self._oprot.trans.flush()
2752 
 
2753 
  def recv_addInvoiceNumber(self, ):
2754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2755 
    if mtype == TMessageType.EXCEPTION:
2756 
      x = TApplicationException()
2757 
      x.read(self._iprot)
2758 
      self._iprot.readMessageEnd()
2759 
      raise x
2760 
    result = addInvoiceNumber_result()
2761 
    result.read(self._iprot)
2762 
    self._iprot.readMessageEnd()
2763 
    if result.ex is not None:
2764 
      raise result.ex
2765 
    return
2766 
 
4910 phani.kuma 2767 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2768 
    """
3064 chandransh 2769 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2770 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2771 
 
1408 ankur.sing 2772 
    Parameters:
3064 chandransh 2773 
     - warehouseId
1408 ankur.sing 2774 
     - providerId
3064 chandransh 2775 
     - cod
4910 phani.kuma 2776 
     - orderIds
1408 ankur.sing 2777 
    """
4910 phani.kuma 2778 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2779 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2780 
 
4910 phani.kuma 2781 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2782 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2783 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2784 
    args.warehouseId = warehouseId
1408 ankur.sing 2785 
    args.providerId = providerId
3064 chandransh 2786 
    args.cod = cod
4910 phani.kuma 2787 
    args.orderIds = orderIds
1408 ankur.sing 2788 
    args.write(self._oprot)
2789 
    self._oprot.writeMessageEnd()
2790 
    self._oprot.trans.flush()
2791 
 
4910 phani.kuma 2792 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2794 
    if mtype == TMessageType.EXCEPTION:
2795 
      x = TApplicationException()
2796 
      x.read(self._iprot)
2797 
      self._iprot.readMessageEnd()
2798 
      raise x
4910 phani.kuma 2799 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2800 
    result.read(self._iprot)
2801 
    self._iprot.readMessageEnd()
3431 rajveer 2802 
    if result.success is not None:
1408 ankur.sing 2803 
      return result.success
3431 rajveer 2804 
    if result.ex is not None:
3064 chandransh 2805 
      raise result.ex
4910 phani.kuma 2806 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2807 
 
5713 rajveer 2808 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2809 
    """
2810 
    Parameters:
2811 
     - providerId
2812 
     - orderIds
5713 rajveer 2813 
     - awbs
5676 rajveer 2814 
    """
5713 rajveer 2815 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2816 
    return self.recv_markOrdersAsReturnedFromStore()
2817 
 
5713 rajveer 2818 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2819 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2820 
    args = markOrdersAsReturnedFromStore_args()
2821 
    args.providerId = providerId
2822 
    args.orderIds = orderIds
5713 rajveer 2823 
    args.awbs = awbs
5676 rajveer 2824 
    args.write(self._oprot)
2825 
    self._oprot.writeMessageEnd()
2826 
    self._oprot.trans.flush()
2827 
 
2828 
  def recv_markOrdersAsReturnedFromStore(self, ):
2829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2830 
    if mtype == TMessageType.EXCEPTION:
2831 
      x = TApplicationException()
2832 
      x.read(self._iprot)
2833 
      self._iprot.readMessageEnd()
2834 
      raise x
2835 
    result = markOrdersAsReturnedFromStore_result()
2836 
    result.read(self._iprot)
2837 
    self._iprot.readMessageEnd()
2838 
    if result.success is not None:
2839 
      return result.success
2840 
    if result.ex is not None:
2841 
      raise result.ex
2842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2843 
 
4910 phani.kuma 2844 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2845 
    """
4910 phani.kuma 2846 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2847 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2848 
 
2849 
    Parameters:
2850 
     - providerId
4910 phani.kuma 2851 
     - pickupDetails
4410 rajveer 2852 
    """
4910 phani.kuma 2853 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2854 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2855 
 
4910 phani.kuma 2856 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2857 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2858 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2859 
    args.providerId = providerId
4910 phani.kuma 2860 
    args.pickupDetails = pickupDetails
4410 rajveer 2861 
    args.write(self._oprot)
2862 
    self._oprot.writeMessageEnd()
2863 
    self._oprot.trans.flush()
2864 
 
4910 phani.kuma 2865 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2867 
    if mtype == TMessageType.EXCEPTION:
2868 
      x = TApplicationException()
2869 
      x.read(self._iprot)
2870 
      self._iprot.readMessageEnd()
2871 
      raise x
4910 phani.kuma 2872 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2873 
    result.read(self._iprot)
2874 
    self._iprot.readMessageEnd()
2875 
    if result.ex is not None:
2876 
      raise result.ex
4910 phani.kuma 2877 
    return
4410 rajveer 2878 
 
4910 phani.kuma 2879 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2880 
    """
3064 chandransh 2881 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2882 
 
94 ashish 2883 
    Parameters:
3064 chandransh 2884 
     - providerId
304 ashish 2885 
    """
4910 phani.kuma 2886 
    self.send_getOrdersNotPickedUp(providerId)
2887 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2888 
 
4910 phani.kuma 2889 
  def send_getOrdersNotPickedUp(self, providerId):
2890 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2891 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2892 
    args.providerId = providerId
304 ashish 2893 
    args.write(self._oprot)
2894 
    self._oprot.writeMessageEnd()
2895 
    self._oprot.trans.flush()
2896 
 
4910 phani.kuma 2897 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2898 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2899 
    if mtype == TMessageType.EXCEPTION:
2900 
      x = TApplicationException()
2901 
      x.read(self._iprot)
2902 
      self._iprot.readMessageEnd()
2903 
      raise x
4910 phani.kuma 2904 
    result = getOrdersNotPickedUp_result()
304 ashish 2905 
    result.read(self._iprot)
2906 
    self._iprot.readMessageEnd()
3431 rajveer 2907 
    if result.success is not None:
304 ashish 2908 
      return result.success
4910 phani.kuma 2909 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2910 
 
3064 chandransh 2911 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2912 
    """
3064 chandransh 2913 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2914 
    the name of the receiver.
2915 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2916 
 
304 ashish 2917 
    Parameters:
3064 chandransh 2918 
     - providerId
2919 
     - deliveredOrders
304 ashish 2920 
    """
3064 chandransh 2921 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2922 
    self.recv_markOrdersAsDelivered()
304 ashish 2923 
 
3064 chandransh 2924 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2925 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2926 
    args = markOrdersAsDelivered_args()
2927 
    args.providerId = providerId
2928 
    args.deliveredOrders = deliveredOrders
304 ashish 2929 
    args.write(self._oprot)
2930 
    self._oprot.writeMessageEnd()
2931 
    self._oprot.trans.flush()
2932 
 
3064 chandransh 2933 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2934 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2935 
    if mtype == TMessageType.EXCEPTION:
2936 
      x = TApplicationException()
2937 
      x.read(self._iprot)
2938 
      self._iprot.readMessageEnd()
2939 
      raise x
3064 chandransh 2940 
    result = markOrdersAsDelivered_result()
304 ashish 2941 
    result.read(self._iprot)
2942 
    self._iprot.readMessageEnd()
3431 rajveer 2943 
    if result.ex is not None:
3064 chandransh 2944 
      raise result.ex
304 ashish 2945 
    return
2946 
 
4910 phani.kuma 2947 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2948 
    """
4910 phani.kuma 2949 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2950 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2951 
 
3064 chandransh 2952 
    Parameters:
2953 
     - providerId
2954 
     - returnedOrders
1596 ankur.sing 2955 
    """
4910 phani.kuma 2956 
    self.send_markAsRTOrders(providerId, returnedOrders)
2957 
    self.recv_markAsRTOrders()
304 ashish 2958 
 
4910 phani.kuma 2959 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2960 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2961 
    args = markAsRTOrders_args()
3064 chandransh 2962 
    args.providerId = providerId
2963 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2964 
    args.write(self._oprot)
2965 
    self._oprot.writeMessageEnd()
2966 
    self._oprot.trans.flush()
2967 
 
4910 phani.kuma 2968 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2969 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2970 
    if mtype == TMessageType.EXCEPTION:
2971 
      x = TApplicationException()
2972 
      x.read(self._iprot)
2973 
      self._iprot.readMessageEnd()
2974 
      raise x
4910 phani.kuma 2975 
    result = markAsRTOrders_result()
1596 ankur.sing 2976 
    result.read(self._iprot)
2977 
    self._iprot.readMessageEnd()
3431 rajveer 2978 
    if result.ex is not None:
3064 chandransh 2979 
      raise result.ex
2980 
    return
1596 ankur.sing 2981 
 
4910 phani.kuma 2982 
  def getRTOrders(self, providerId):
2983 
    """
2984 
    Returns a list of orders that were returned by courier.
2985 
 
2986 
    Parameters:
2987 
     - providerId
2988 
    """
2989 
    self.send_getRTOrders(providerId)
2990 
    return self.recv_getRTOrders()
2991 
 
2992 
  def send_getRTOrders(self, providerId):
2993 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2994 
    args = getRTOrders_args()
2995 
    args.providerId = providerId
2996 
    args.write(self._oprot)
2997 
    self._oprot.writeMessageEnd()
2998 
    self._oprot.trans.flush()
2999 
 
3000 
  def recv_getRTOrders(self, ):
3001 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3002 
    if mtype == TMessageType.EXCEPTION:
3003 
      x = TApplicationException()
3004 
      x.read(self._iprot)
3005 
      self._iprot.readMessageEnd()
3006 
      raise x
3007 
    result = getRTOrders_result()
3008 
    result.read(self._iprot)
3009 
    self._iprot.readMessageEnd()
3010 
    if result.success is not None:
3011 
      return result.success
3012 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
3013 
 
3064 chandransh 3014 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 3015 
    """
3064 chandransh 3016 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 3017 
 
3064 chandransh 3018 
    Parameters:
3019 
     - providerId
3020 
     - undeliveredOrders
1627 ankur.sing 3021 
    """
3064 chandransh 3022 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 3023 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 3024 
 
3064 chandransh 3025 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
3026 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
3027 
    args = updateNonDeliveryReason_args()
3028 
    args.providerId = providerId
3029 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 3030 
    args.write(self._oprot)
3031 
    self._oprot.writeMessageEnd()
3032 
    self._oprot.trans.flush()
3033 
 
3064 chandransh 3034 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 3035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3036 
    if mtype == TMessageType.EXCEPTION:
3037 
      x = TApplicationException()
3038 
      x.read(self._iprot)
3039 
      self._iprot.readMessageEnd()
3040 
      raise x
3064 chandransh 3041 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 3042 
    result.read(self._iprot)
3043 
    self._iprot.readMessageEnd()
4910 phani.kuma 3044 
    if result.ex is not None:
3045 
      raise result.ex
3046 
    return
3047 
 
3048 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3049 
    """
3050 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3051 
 
3052 
    Parameters:
3053 
     - providerId
3054 
    """
3055 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3056 
    return self.recv_getNonDeliveredOrdersbyCourier()
3057 
 
3058 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3059 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3060 
    args = getNonDeliveredOrdersbyCourier_args()
3061 
    args.providerId = providerId
3062 
    args.write(self._oprot)
3063 
    self._oprot.writeMessageEnd()
3064 
    self._oprot.trans.flush()
3065 
 
3066 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
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
3073 
    result = getNonDeliveredOrdersbyCourier_result()
3074 
    result.read(self._iprot)
3075 
    self._iprot.readMessageEnd()
4581 phani.kuma 3076 
    if result.success is not None:
3077 
      return result.success
4910 phani.kuma 3078 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3079 
 
3080 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3081 
    """
3082 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3083 
 
3084 
    Parameters:
3085 
     - providerId
3086 
     - local_connected_orders
3087 
    """
3088 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3089 
    self.recv_markOrdersAsLocalConnected()
3090 
 
3091 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3092 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3093 
    args = markOrdersAsLocalConnected_args()
3094 
    args.providerId = providerId
3095 
    args.local_connected_orders = local_connected_orders
3096 
    args.write(self._oprot)
3097 
    self._oprot.writeMessageEnd()
3098 
    self._oprot.trans.flush()
3099 
 
3100 
  def recv_markOrdersAsLocalConnected(self, ):
3101 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3102 
    if mtype == TMessageType.EXCEPTION:
3103 
      x = TApplicationException()
3104 
      x.read(self._iprot)
3105 
      self._iprot.readMessageEnd()
3106 
      raise x
3107 
    result = markOrdersAsLocalConnected_result()
3108 
    result.read(self._iprot)
3109 
    self._iprot.readMessageEnd()
3431 rajveer 3110 
    if result.ex is not None:
3064 chandransh 3111 
      raise result.ex
4910 phani.kuma 3112 
    return
1627 ankur.sing 3113 
 
4910 phani.kuma 3114 
  def getOrdersNotLocalConnected(self, providerId):
3115 
    """
3116 
    Returns a list of orders that were picked up or shipped but pending local connection.
3117 
 
3118 
    Parameters:
3119 
     - providerId
3120 
    """
3121 
    self.send_getOrdersNotLocalConnected(providerId)
3122 
    return self.recv_getOrdersNotLocalConnected()
3123 
 
3124 
  def send_getOrdersNotLocalConnected(self, providerId):
3125 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3126 
    args = getOrdersNotLocalConnected_args()
3127 
    args.providerId = providerId
3128 
    args.write(self._oprot)
3129 
    self._oprot.writeMessageEnd()
3130 
    self._oprot.trans.flush()
3131 
 
3132 
  def recv_getOrdersNotLocalConnected(self, ):
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
3139 
    result = getOrdersNotLocalConnected_result()
3140 
    result.read(self._iprot)
3141 
    self._iprot.readMessageEnd()
3142 
    if result.success is not None:
3143 
      return result.success
3144 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3145 
 
3146 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3147 
    """
3148 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3149 
 
3150 
    Parameters:
3151 
     - providerId
3152 
     - destination_city_reached_orders
3153 
    """
3154 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3155 
    self.recv_markOrdersAsDestinationCityReached()
3156 
 
3157 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3158 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3159 
    args = markOrdersAsDestinationCityReached_args()
3160 
    args.providerId = providerId
3161 
    args.destination_city_reached_orders = destination_city_reached_orders
3162 
    args.write(self._oprot)
3163 
    self._oprot.writeMessageEnd()
3164 
    self._oprot.trans.flush()
3165 
 
3166 
  def recv_markOrdersAsDestinationCityReached(self, ):
3167 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3168 
    if mtype == TMessageType.EXCEPTION:
3169 
      x = TApplicationException()
3170 
      x.read(self._iprot)
3171 
      self._iprot.readMessageEnd()
3172 
      raise x
3173 
    result = markOrdersAsDestinationCityReached_result()
3174 
    result.read(self._iprot)
3175 
    self._iprot.readMessageEnd()
3176 
    if result.ex is not None:
3177 
      raise result.ex
3178 
    return
3179 
 
3180 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3181 
    """
3182 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3183 
 
3184 
    Parameters:
3185 
     - providerId
3186 
     - first_atdl_orders
3187 
    """
3188 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3189 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3190 
 
3191 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3192 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3193 
    args = markOrdersAsFirstDeliveryAttempted_args()
3194 
    args.providerId = providerId
3195 
    args.first_atdl_orders = first_atdl_orders
3196 
    args.write(self._oprot)
3197 
    self._oprot.writeMessageEnd()
3198 
    self._oprot.trans.flush()
3199 
 
3200 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3201 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3202 
    if mtype == TMessageType.EXCEPTION:
3203 
      x = TApplicationException()
3204 
      x.read(self._iprot)
3205 
      self._iprot.readMessageEnd()
3206 
      raise x
3207 
    result = markOrdersAsFirstDeliveryAttempted_result()
3208 
    result.read(self._iprot)
3209 
    self._iprot.readMessageEnd()
3210 
    if result.ex is not None:
3211 
      raise result.ex
3212 
    return
3213 
 
3064 chandransh 3214 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3215 
    """
3064 chandransh 3216 
    Returns the list of orders whose delivery time has passed but have not been
3217 
    delivered yet for the given provider and warehouse. To get a complete list of
3218 
    undelivered orders, pass them as -1.
3219 
    Returns an empty list if no such orders exist.
3431 rajveer 3220 
 
1886 ankur.sing 3221 
    Parameters:
3064 chandransh 3222 
     - providerId
3223 
     - warehouseId
1886 ankur.sing 3224 
    """
3064 chandransh 3225 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3226 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3227 
 
3064 chandransh 3228 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3229 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3230 
    args = getUndeliveredOrders_args()
3231 
    args.providerId = providerId
3232 
    args.warehouseId = warehouseId
1886 ankur.sing 3233 
    args.write(self._oprot)
3234 
    self._oprot.writeMessageEnd()
3235 
    self._oprot.trans.flush()
3236 
 
3064 chandransh 3237 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3238 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3239 
    if mtype == TMessageType.EXCEPTION:
3240 
      x = TApplicationException()
3241 
      x.read(self._iprot)
3242 
      self._iprot.readMessageEnd()
3243 
      raise x
3064 chandransh 3244 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3245 
    result.read(self._iprot)
3246 
    self._iprot.readMessageEnd()
3431 rajveer 3247 
    if result.success is not None:
1886 ankur.sing 3248 
      return result.success
3064 chandransh 3249 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3250 
 
4783 phani.kuma 3251 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3252 
    """
3253 
    Returns the list of orders whose expected delivery date has passed but have not been
3254 
    delivered yet.
3255 
    Returns an empty list if no such orders exist.
3256 
    """
3257 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3258 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3259 
 
3260 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3261 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3262 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3263 
    args.write(self._oprot)
3264 
    self._oprot.writeMessageEnd()
3265 
    self._oprot.trans.flush()
3266 
 
3267 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3268 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3269 
    if mtype == TMessageType.EXCEPTION:
3270 
      x = TApplicationException()
3271 
      x.read(self._iprot)
3272 
      self._iprot.readMessageEnd()
3273 
      raise x
3274 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3275 
    result.read(self._iprot)
3276 
    self._iprot.readMessageEnd()
3277 
    if result.success is not None:
3278 
      return result.success
3279 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3280 
 
2536 chandransh 3281 
  def toggleDOAFlag(self, orderId):
3282 
    """
3283 
    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.
3284 
    Returns the final flag status.
3285 
    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 3286 
 
2536 chandransh 3287 
    Parameters:
3288 
     - orderId
3289 
    """
3290 
    self.send_toggleDOAFlag(orderId)
3291 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3292 
 
2536 chandransh 3293 
  def send_toggleDOAFlag(self, orderId):
3294 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3295 
    args = toggleDOAFlag_args()
3296 
    args.orderId = orderId
3297 
    args.write(self._oprot)
3298 
    self._oprot.writeMessageEnd()
3299 
    self._oprot.trans.flush()
3300 
 
3301 
  def recv_toggleDOAFlag(self, ):
3302 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3303 
    if mtype == TMessageType.EXCEPTION:
3304 
      x = TApplicationException()
3305 
      x.read(self._iprot)
3306 
      self._iprot.readMessageEnd()
3307 
      raise x
3308 
    result = toggleDOAFlag_result()
3309 
    result.read(self._iprot)
3310 
    self._iprot.readMessageEnd()
3431 rajveer 3311 
    if result.success is not None:
2536 chandransh 3312 
      return result.success
3431 rajveer 3313 
    if result.ex is not None:
2536 chandransh 3314 
      raise result.ex
3315 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3316 
 
4712 rajveer 3317 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3318 
    """
3319 
    Parameters:
3320 
     - orderId
3321 
     - deliveryTimestamp
3322 
     - receiver
3323 
    """
3324 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3325 
    self.recv_markOrderAsDelivered()
3326 
 
3327 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3328 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3329 
    args = markOrderAsDelivered_args()
3330 
    args.orderId = orderId
3331 
    args.deliveryTimestamp = deliveryTimestamp
3332 
    args.receiver = receiver
3333 
    args.write(self._oprot)
3334 
    self._oprot.writeMessageEnd()
3335 
    self._oprot.trans.flush()
3336 
 
3337 
  def recv_markOrderAsDelivered(self, ):
3338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3339 
    if mtype == TMessageType.EXCEPTION:
3340 
      x = TApplicationException()
3341 
      x.read(self._iprot)
3342 
      self._iprot.readMessageEnd()
3343 
      raise x
3344 
    result = markOrderAsDelivered_result()
3345 
    result.read(self._iprot)
3346 
    self._iprot.readMessageEnd()
3347 
    if result.ex is not None:
3348 
      raise result.ex
3349 
    return
3350 
 
5553 rajveer 3351 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3352 
    """
3353 
    Parameters:
3354 
     - orderId
3355 
     - deliveryTimestamp
3356 
    """
3357 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3358 
    self.recv_markOrderAsReceivedAtStore()
3359 
 
3360 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3361 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3362 
    args = markOrderAsReceivedAtStore_args()
3363 
    args.orderId = orderId
3364 
    args.deliveryTimestamp = deliveryTimestamp
3365 
    args.write(self._oprot)
3366 
    self._oprot.writeMessageEnd()
3367 
    self._oprot.trans.flush()
3368 
 
3369 
  def recv_markOrderAsReceivedAtStore(self, ):
3370 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3371 
    if mtype == TMessageType.EXCEPTION:
3372 
      x = TApplicationException()
3373 
      x.read(self._iprot)
3374 
      self._iprot.readMessageEnd()
3375 
      raise x
3376 
    result = markOrderAsReceivedAtStore_result()
3377 
    result.read(self._iprot)
3378 
    self._iprot.readMessageEnd()
3379 
    if result.ex is not None:
3380 
      raise result.ex
3381 
    return
3382 
 
4454 rajveer 3383 
  def markOrderDoaRequestReceived(self, orderId):
3384 
    """
3385 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3386 
 
3387 
    Parameters:
3388 
     - orderId
3389 
    """
3390 
    self.send_markOrderDoaRequestReceived(orderId)
3391 
    return self.recv_markOrderDoaRequestReceived()
3392 
 
3393 
  def send_markOrderDoaRequestReceived(self, orderId):
3394 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3395 
    args = markOrderDoaRequestReceived_args()
3396 
    args.orderId = orderId
3397 
    args.write(self._oprot)
3398 
    self._oprot.writeMessageEnd()
3399 
    self._oprot.trans.flush()
3400 
 
3401 
  def recv_markOrderDoaRequestReceived(self, ):
3402 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3403 
    if mtype == TMessageType.EXCEPTION:
3404 
      x = TApplicationException()
3405 
      x.read(self._iprot)
3406 
      self._iprot.readMessageEnd()
3407 
      raise x
3408 
    result = markOrderDoaRequestReceived_result()
3409 
    result.read(self._iprot)
3410 
    self._iprot.readMessageEnd()
3411 
    if result.success is not None:
3412 
      return result.success
3413 
    if result.ex is not None:
3414 
      raise result.ex
3415 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3416 
 
3417 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3418 
    """
3419 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3420 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3421 
 
3422 
    Parameters:
3423 
     - orderId
3424 
     - isAuthorized
3425 
    """
3426 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3427 
    return self.recv_markOrderDoaRequestAuthorized()
3428 
 
3429 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3430 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3431 
    args = markOrderDoaRequestAuthorized_args()
3432 
    args.orderId = orderId
3433 
    args.isAuthorized = isAuthorized
3434 
    args.write(self._oprot)
3435 
    self._oprot.writeMessageEnd()
3436 
    self._oprot.trans.flush()
3437 
 
3438 
  def recv_markOrderDoaRequestAuthorized(self, ):
3439 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3440 
    if mtype == TMessageType.EXCEPTION:
3441 
      x = TApplicationException()
3442 
      x.read(self._iprot)
3443 
      self._iprot.readMessageEnd()
3444 
      raise x
3445 
    result = markOrderDoaRequestAuthorized_result()
3446 
    result.read(self._iprot)
3447 
    self._iprot.readMessageEnd()
3448 
    if result.success is not None:
3449 
      return result.success
3450 
    if result.ex is not None:
3451 
      raise result.ex
3452 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3453 
 
4488 rajveer 3454 
  def markOrderReturnRequestReceived(self, orderId):
3455 
    """
3456 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3457 
 
3458 
    Parameters:
3459 
     - orderId
3460 
    """
3461 
    self.send_markOrderReturnRequestReceived(orderId)
3462 
    return self.recv_markOrderReturnRequestReceived()
3463 
 
3464 
  def send_markOrderReturnRequestReceived(self, orderId):
3465 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3466 
    args = markOrderReturnRequestReceived_args()
3467 
    args.orderId = orderId
3468 
    args.write(self._oprot)
3469 
    self._oprot.writeMessageEnd()
3470 
    self._oprot.trans.flush()
3471 
 
3472 
  def recv_markOrderReturnRequestReceived(self, ):
3473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3474 
    if mtype == TMessageType.EXCEPTION:
3475 
      x = TApplicationException()
3476 
      x.read(self._iprot)
3477 
      self._iprot.readMessageEnd()
3478 
      raise x
3479 
    result = markOrderReturnRequestReceived_result()
3480 
    result.read(self._iprot)
3481 
    self._iprot.readMessageEnd()
3482 
    if result.success is not None:
3483 
      return result.success
3484 
    if result.ex is not None:
3485 
      raise result.ex
3486 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3487 
 
3488 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3489 
    """
3490 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3491 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3492 
 
3493 
    Parameters:
3494 
     - orderId
3495 
     - isAuthorized
3496 
    """
3497 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3498 
    return self.recv_markOrderReturnRequestAuthorized()
3499 
 
3500 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3501 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3502 
    args = markOrderReturnRequestAuthorized_args()
3503 
    args.orderId = orderId
3504 
    args.isAuthorized = isAuthorized
3505 
    args.write(self._oprot)
3506 
    self._oprot.writeMessageEnd()
3507 
    self._oprot.trans.flush()
3508 
 
3509 
  def recv_markOrderReturnRequestAuthorized(self, ):
3510 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3511 
    if mtype == TMessageType.EXCEPTION:
3512 
      x = TApplicationException()
3513 
      x.read(self._iprot)
3514 
      self._iprot.readMessageEnd()
3515 
      raise x
3516 
    result = markOrderReturnRequestAuthorized_result()
3517 
    result.read(self._iprot)
3518 
    self._iprot.readMessageEnd()
3519 
    if result.success is not None:
3520 
      return result.success
3521 
    if result.ex is not None:
3522 
      raise result.ex
3523 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3524 
 
4579 rajveer 3525 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3526 
    """
3527 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3528 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3529 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3530 
    For any other status, it returns false.
3531 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3532 
 
2536 chandransh 3533 
    Parameters:
3534 
     - orderId
4579 rajveer 3535 
     - providerId
2536 chandransh 3536 
    """
4579 rajveer 3537 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3538 
    return self.recv_requestPickupNumber()
3539 
 
4579 rajveer 3540 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3541 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3542 
    args = requestPickupNumber_args()
3543 
    args.orderId = orderId
4579 rajveer 3544 
    args.providerId = providerId
2536 chandransh 3545 
    args.write(self._oprot)
3546 
    self._oprot.writeMessageEnd()
3547 
    self._oprot.trans.flush()
3548 
 
3549 
  def recv_requestPickupNumber(self, ):
3550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3551 
    if mtype == TMessageType.EXCEPTION:
3552 
      x = TApplicationException()
3553 
      x.read(self._iprot)
3554 
      self._iprot.readMessageEnd()
3555 
      raise x
3556 
    result = requestPickupNumber_result()
3557 
    result.read(self._iprot)
3558 
    self._iprot.readMessageEnd()
3431 rajveer 3559 
    if result.success is not None:
2536 chandransh 3560 
      return result.success
3431 rajveer 3561 
    if result.ex is not None:
2536 chandransh 3562 
      raise result.ex
3563 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3564 
 
4602 rajveer 3565 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3566 
    """
4452 rajveer 3567 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3568 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3569 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3570 
    	3. Returns true
2591 chandransh 3571 
    If the order is in any other status, it returns false.
2536 chandransh 3572 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3573 
 
2536 chandransh 3574 
    Parameters:
3575 
     - orderId
3576 
     - pickupNumber
4602 rajveer 3577 
     - providerId
2536 chandransh 3578 
    """
4602 rajveer 3579 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3580 
    return self.recv_authorizePickup()
3581 
 
4602 rajveer 3582 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3583 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3584 
    args = authorizePickup_args()
3585 
    args.orderId = orderId
3586 
    args.pickupNumber = pickupNumber
4602 rajveer 3587 
    args.providerId = providerId
2536 chandransh 3588 
    args.write(self._oprot)
3589 
    self._oprot.writeMessageEnd()
3590 
    self._oprot.trans.flush()
3591 
 
3592 
  def recv_authorizePickup(self, ):
3593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3594 
    if mtype == TMessageType.EXCEPTION:
3595 
      x = TApplicationException()
3596 
      x.read(self._iprot)
3597 
      self._iprot.readMessageEnd()
3598 
      raise x
3599 
    result = authorizePickup_result()
3600 
    result.read(self._iprot)
3601 
    self._iprot.readMessageEnd()
3431 rajveer 3602 
    if result.success is not None:
2536 chandransh 3603 
      return result.success
3431 rajveer 3604 
    if result.ex is not None:
2536 chandransh 3605 
      raise result.ex
3606 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3607 
 
2764 chandransh 3608 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3609 
    """
3610 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3611 
 
2764 chandransh 3612 
    Parameters:
3613 
     - providerId
3614 
     - pickupDetails
3615 
    """
3616 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3617 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3618 
 
3619 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3620 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3621 
    args = markDoasAsPickedUp_args()
3622 
    args.providerId = providerId
3623 
    args.pickupDetails = pickupDetails
3624 
    args.write(self._oprot)
3625 
    self._oprot.writeMessageEnd()
3626 
    self._oprot.trans.flush()
3627 
 
3628 
  def recv_markDoasAsPickedUp(self, ):
3629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3630 
    if mtype == TMessageType.EXCEPTION:
3631 
      x = TApplicationException()
3632 
      x.read(self._iprot)
3633 
      self._iprot.readMessageEnd()
3634 
      raise x
3635 
    result = markDoasAsPickedUp_result()
3636 
    result.read(self._iprot)
3637 
    self._iprot.readMessageEnd()
4910 phani.kuma 3638 
    return
3639 
 
3640 
  def getDoasNotPickedUp(self, providerId):
3641 
    """
3642 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3643 
 
3644 
    Parameters:
3645 
     - providerId
3646 
    """
3647 
    self.send_getDoasNotPickedUp(providerId)
3648 
    return self.recv_getDoasNotPickedUp()
3649 
 
3650 
  def send_getDoasNotPickedUp(self, providerId):
3651 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3652 
    args = getDoasNotPickedUp_args()
3653 
    args.providerId = providerId
3654 
    args.write(self._oprot)
3655 
    self._oprot.writeMessageEnd()
3656 
    self._oprot.trans.flush()
3657 
 
3658 
  def recv_getDoasNotPickedUp(self, ):
3659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3660 
    if mtype == TMessageType.EXCEPTION:
3661 
      x = TApplicationException()
3662 
      x.read(self._iprot)
3663 
      self._iprot.readMessageEnd()
3664 
      raise x
3665 
    result = getDoasNotPickedUp_result()
3666 
    result.read(self._iprot)
3667 
    self._iprot.readMessageEnd()
3431 rajveer 3668 
    if result.success is not None:
2764 chandransh 3669 
      return result.success
4910 phani.kuma 3670 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3671 
 
4741 phani.kuma 3672 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3673 
    """
3674 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3675 
 
3676 
    Parameters:
3677 
     - providerId
3678 
     - pickupDetails
3679 
    """
3680 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3681 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3682 
 
3683 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3684 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3685 
    args = markReturnOrdersAsPickedUp_args()
3686 
    args.providerId = providerId
3687 
    args.pickupDetails = pickupDetails
3688 
    args.write(self._oprot)
3689 
    self._oprot.writeMessageEnd()
3690 
    self._oprot.trans.flush()
3691 
 
3692 
  def recv_markReturnOrdersAsPickedUp(self, ):
3693 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3694 
    if mtype == TMessageType.EXCEPTION:
3695 
      x = TApplicationException()
3696 
      x.read(self._iprot)
3697 
      self._iprot.readMessageEnd()
3698 
      raise x
3699 
    result = markReturnOrdersAsPickedUp_result()
3700 
    result.read(self._iprot)
3701 
    self._iprot.readMessageEnd()
4910 phani.kuma 3702 
    return
3703 
 
3704 
  def getReturnOrdersNotPickedUp(self, providerId):
3705 
    """
3706 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3707 
 
3708 
    Parameters:
3709 
     - providerId
3710 
    """
3711 
    self.send_getReturnOrdersNotPickedUp(providerId)
3712 
    return self.recv_getReturnOrdersNotPickedUp()
3713 
 
3714 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3715 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3716 
    args = getReturnOrdersNotPickedUp_args()
3717 
    args.providerId = providerId
3718 
    args.write(self._oprot)
3719 
    self._oprot.writeMessageEnd()
3720 
    self._oprot.trans.flush()
3721 
 
3722 
  def recv_getReturnOrdersNotPickedUp(self, ):
3723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3724 
    if mtype == TMessageType.EXCEPTION:
3725 
      x = TApplicationException()
3726 
      x.read(self._iprot)
3727 
      self._iprot.readMessageEnd()
3728 
      raise x
3729 
    result = getReturnOrdersNotPickedUp_result()
3730 
    result.read(self._iprot)
3731 
    self._iprot.readMessageEnd()
4741 phani.kuma 3732 
    if result.success is not None:
3733 
      return result.success
4910 phani.kuma 3734 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3735 
 
4479 rajveer 3736 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3737 
    """
4452 rajveer 3738 
    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 3739 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3740 
    If the order is in any other state, it returns false.
3741 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3742 
 
2591 chandransh 3743 
    Parameters:
3744 
     - orderId
4479 rajveer 3745 
     - receiveCondition
2591 chandransh 3746 
    """
4479 rajveer 3747 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3748 
    return self.recv_receiveReturn()
2536 chandransh 3749 
 
4479 rajveer 3750 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3751 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3752 
    args = receiveReturn_args()
2591 chandransh 3753 
    args.orderId = orderId
4479 rajveer 3754 
    args.receiveCondition = receiveCondition
2591 chandransh 3755 
    args.write(self._oprot)
3756 
    self._oprot.writeMessageEnd()
3757 
    self._oprot.trans.flush()
3758 
 
2616 chandransh 3759 
  def recv_receiveReturn(self, ):
2591 chandransh 3760 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3761 
    if mtype == TMessageType.EXCEPTION:
3762 
      x = TApplicationException()
3763 
      x.read(self._iprot)
3764 
      self._iprot.readMessageEnd()
3765 
      raise x
2616 chandransh 3766 
    result = receiveReturn_result()
2591 chandransh 3767 
    result.read(self._iprot)
3768 
    self._iprot.readMessageEnd()
3431 rajveer 3769 
    if result.success is not None:
2591 chandransh 3770 
      return result.success
3431 rajveer 3771 
    if result.ex is not None:
2591 chandransh 3772 
      raise result.ex
2616 chandransh 3773 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3774 
 
3775 
  def validateDoa(self, orderId, isValid):
3776 
    """
4452 rajveer 3777 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3778 
    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 3779 
    If the order is in any other state, it returns false.
3780 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3781 
 
2591 chandransh 3782 
    Parameters:
3783 
     - orderId
3784 
     - isValid
3785 
    """
3786 
    self.send_validateDoa(orderId, isValid)
3787 
    return self.recv_validateDoa()
3788 
 
3789 
  def send_validateDoa(self, orderId, isValid):
3790 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3791 
    args = validateDoa_args()
3792 
    args.orderId = orderId
3793 
    args.isValid = isValid
3794 
    args.write(self._oprot)
3795 
    self._oprot.writeMessageEnd()
3796 
    self._oprot.trans.flush()
3797 
 
3798 
  def recv_validateDoa(self, ):
3799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3800 
    if mtype == TMessageType.EXCEPTION:
3801 
      x = TApplicationException()
3802 
      x.read(self._iprot)
3803 
      self._iprot.readMessageEnd()
3804 
      raise x
3805 
    result = validateDoa_result()
3806 
    result.read(self._iprot)
3807 
    self._iprot.readMessageEnd()
3431 rajveer 3808 
    if result.success is not None:
2591 chandransh 3809 
      return result.success
3431 rajveer 3810 
    if result.ex is not None:
2591 chandransh 3811 
      raise result.ex
3812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3813 
 
4495 rajveer 3814 
  def validateReturnProduct(self, orderId, isUsable):
3815 
    """
3816 
    Parameters:
3817 
     - orderId
3818 
     - isUsable
3819 
    """
3820 
    self.send_validateReturnProduct(orderId, isUsable)
3821 
    return self.recv_validateReturnProduct()
3822 
 
3823 
  def send_validateReturnProduct(self, orderId, isUsable):
3824 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3825 
    args = validateReturnProduct_args()
3826 
    args.orderId = orderId
3827 
    args.isUsable = isUsable
3828 
    args.write(self._oprot)
3829 
    self._oprot.writeMessageEnd()
3830 
    self._oprot.trans.flush()
3831 
 
3832 
  def recv_validateReturnProduct(self, ):
3833 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3834 
    if mtype == TMessageType.EXCEPTION:
3835 
      x = TApplicationException()
3836 
      x.read(self._iprot)
3837 
      self._iprot.readMessageEnd()
3838 
      raise x
3839 
    result = validateReturnProduct_result()
3840 
    result.read(self._iprot)
3841 
    self._iprot.readMessageEnd()
3842 
    if result.success is not None:
3843 
      return result.success
3844 
    if result.ex is not None:
3845 
      raise result.ex
3846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3847 
 
2616 chandransh 3848 
  def reshipOrder(self, orderId):
3849 
    """
4484 rajveer 3850 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3851 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3852 
    	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 3853 
 
3854 
    If the order is in DOA_CERT_VALID state, it does the following:
3855 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3856 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3857 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3858 
 
2616 chandransh 3859 
    Returns the id of the newly created order.
3431 rajveer 3860 
 
2616 chandransh 3861 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3862 
 
2616 chandransh 3863 
    Parameters:
3864 
     - orderId
3865 
    """
3866 
    self.send_reshipOrder(orderId)
3867 
    return self.recv_reshipOrder()
2591 chandransh 3868 
 
2616 chandransh 3869 
  def send_reshipOrder(self, orderId):
3870 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3871 
    args = reshipOrder_args()
3872 
    args.orderId = orderId
3873 
    args.write(self._oprot)
3874 
    self._oprot.writeMessageEnd()
3875 
    self._oprot.trans.flush()
3876 
 
3877 
  def recv_reshipOrder(self, ):
3878 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3879 
    if mtype == TMessageType.EXCEPTION:
3880 
      x = TApplicationException()
3881 
      x.read(self._iprot)
3882 
      self._iprot.readMessageEnd()
3883 
      raise x
3884 
    result = reshipOrder_result()
3885 
    result.read(self._iprot)
3886 
    self._iprot.readMessageEnd()
3431 rajveer 3887 
    if result.success is not None:
2616 chandransh 3888 
      return result.success
3431 rajveer 3889 
    if result.ex is not None:
2616 chandransh 3890 
      raise result.ex
3891 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3892 
 
3226 chandransh 3893 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3894 
    """
4484 rajveer 3895 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3896 
    	1. Creates a refund request for batch processing.
3897 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3898 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3899 
 
2616 chandransh 3900 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3901 
    	1. Creates a refund request for batch processing.
3226 chandransh 3902 
    	2. Cancels the reservation of the item in the warehouse.
3903 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3904 
 
3226 chandransh 3905 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3906 
    	1. Cancels the reservation of the item in the warehouse.
3907 
    	2. Marks the current order as CANCELED.
3908 
 
3909 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3910 
 
2616 chandransh 3911 
    Returns True if it is successful, False otherwise.
3431 rajveer 3912 
 
2616 chandransh 3913 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3914 
 
2616 chandransh 3915 
    Parameters:
3916 
     - orderId
3226 chandransh 3917 
     - refundedBy
3918 
     - reason
2616 chandransh 3919 
    """
3226 chandransh 3920 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3921 
    return self.recv_refundOrder()
3922 
 
3226 chandransh 3923 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3924 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3925 
    args = refundOrder_args()
3926 
    args.orderId = orderId
3226 chandransh 3927 
    args.refundedBy = refundedBy
3928 
    args.reason = reason
2616 chandransh 3929 
    args.write(self._oprot)
3930 
    self._oprot.writeMessageEnd()
3931 
    self._oprot.trans.flush()
3932 
 
3933 
  def recv_refundOrder(self, ):
3934 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3935 
    if mtype == TMessageType.EXCEPTION:
3936 
      x = TApplicationException()
3937 
      x.read(self._iprot)
3938 
      self._iprot.readMessageEnd()
3939 
      raise x
3940 
    result = refundOrder_result()
3941 
    result.read(self._iprot)
3942 
    self._iprot.readMessageEnd()
3431 rajveer 3943 
    if result.success is not None:
2616 chandransh 3944 
      return result.success
3431 rajveer 3945 
    if result.ex is not None:
2616 chandransh 3946 
      raise result.ex
3947 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3948 
 
2690 chandransh 3949 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3950 
    """
3951 
    Get all return orders created between the from and to dates for the given warehouse.
3952 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3953 
 
2690 chandransh 3954 
    Parameters:
3955 
     - warehouseId
3956 
     - fromDate
3957 
     - toDate
3958 
    """
3959 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3960 
    return self.recv_getReturnOrders()
2616 chandransh 3961 
 
2690 chandransh 3962 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3963 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3964 
    args = getReturnOrders_args()
3965 
    args.warehouseId = warehouseId
3966 
    args.fromDate = fromDate
3967 
    args.toDate = toDate
3968 
    args.write(self._oprot)
3969 
    self._oprot.writeMessageEnd()
3970 
    self._oprot.trans.flush()
3971 
 
3972 
  def recv_getReturnOrders(self, ):
3973 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3974 
    if mtype == TMessageType.EXCEPTION:
3975 
      x = TApplicationException()
3976 
      x.read(self._iprot)
3977 
      self._iprot.readMessageEnd()
3978 
      raise x
3979 
    result = getReturnOrders_result()
3980 
    result.read(self._iprot)
3981 
    self._iprot.readMessageEnd()
3431 rajveer 3982 
    if result.success is not None:
2690 chandransh 3983 
      return result.success
3984 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3985 
 
5481 phani.kuma 3986 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3987 
    """
3988 
    Get all return orders created between the from and to dates.
3989 
 
3990 
    Parameters:
3991 
     - onlyNotProcessed
3992 
     - fromDate
3993 
     - toDate
3994 
    """
3995 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3996 
    return self.recv_getAllReturnOrders()
3997 
 
3998 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3999 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
4000 
    args = getAllReturnOrders_args()
4001 
    args.onlyNotProcessed = onlyNotProcessed
4002 
    args.fromDate = fromDate
4003 
    args.toDate = toDate
4004 
    args.write(self._oprot)
4005 
    self._oprot.writeMessageEnd()
4006 
    self._oprot.trans.flush()
4007 
 
4008 
  def recv_getAllReturnOrders(self, ):
4009 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4010 
    if mtype == TMessageType.EXCEPTION:
4011 
      x = TApplicationException()
4012 
      x.read(self._iprot)
4013 
      self._iprot.readMessageEnd()
4014 
      raise x
4015 
    result = getAllReturnOrders_result()
4016 
    result.read(self._iprot)
4017 
    self._iprot.readMessageEnd()
4018 
    if result.success is not None:
4019 
      return result.success
4020 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
4021 
 
2700 chandransh 4022 
  def getReturnOrder(self, id):
4023 
    """
4024 
    Returns the ReturnOrder corresponding to the given id.
4025 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 4026 
 
2700 chandransh 4027 
    Parameters:
4028 
     - id
4029 
    """
4030 
    self.send_getReturnOrder(id)
4031 
    return self.recv_getReturnOrder()
4032 
 
4033 
  def send_getReturnOrder(self, id):
4034 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
4035 
    args = getReturnOrder_args()
4036 
    args.id = id
4037 
    args.write(self._oprot)
4038 
    self._oprot.writeMessageEnd()
4039 
    self._oprot.trans.flush()
4040 
 
4041 
  def recv_getReturnOrder(self, ):
4042 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4043 
    if mtype == TMessageType.EXCEPTION:
4044 
      x = TApplicationException()
4045 
      x.read(self._iprot)
4046 
      self._iprot.readMessageEnd()
4047 
      raise x
4048 
    result = getReturnOrder_result()
4049 
    result.read(self._iprot)
4050 
    self._iprot.readMessageEnd()
3431 rajveer 4051 
    if result.success is not None:
2700 chandransh 4052 
      return result.success
3431 rajveer 4053 
    if result.ex is not None:
2700 chandransh 4054 
      raise result.ex
4055 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4056 
 
2690 chandransh 4057 
  def processReturn(self, returnOrderId):
4058 
    """
4059 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4060 
 
2690 chandransh 4061 
    Parameters:
4062 
     - returnOrderId
4063 
    """
4064 
    self.send_processReturn(returnOrderId)
4065 
    self.recv_processReturn()
4066 
 
4067 
  def send_processReturn(self, returnOrderId):
4068 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4069 
    args = processReturn_args()
4070 
    args.returnOrderId = returnOrderId
4071 
    args.write(self._oprot)
4072 
    self._oprot.writeMessageEnd()
4073 
    self._oprot.trans.flush()
4074 
 
4075 
  def recv_processReturn(self, ):
4076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4077 
    if mtype == TMessageType.EXCEPTION:
4078 
      x = TApplicationException()
4079 
      x.read(self._iprot)
4080 
      self._iprot.readMessageEnd()
4081 
      raise x
4082 
    result = processReturn_result()
4083 
    result.read(self._iprot)
4084 
    self._iprot.readMessageEnd()
3431 rajveer 4085 
    if result.ex is not None:
2690 chandransh 4086 
      raise result.ex
4087 
    return
4088 
 
3451 chandransh 4089 
  def updateWeight(self, orderId, weight):
4090 
    """
4091 
    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 4092 
 
3451 chandransh 4093 
    Parameters:
4094 
     - orderId
4095 
     - weight
4096 
    """
4097 
    self.send_updateWeight(orderId, weight)
4098 
    return self.recv_updateWeight()
4099 
 
4100 
  def send_updateWeight(self, orderId, weight):
4101 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4102 
    args = updateWeight_args()
4103 
    args.orderId = orderId
4104 
    args.weight = weight
4105 
    args.write(self._oprot)
4106 
    self._oprot.writeMessageEnd()
4107 
    self._oprot.trans.flush()
4108 
 
4109 
  def recv_updateWeight(self, ):
4110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4111 
    if mtype == TMessageType.EXCEPTION:
4112 
      x = TApplicationException()
4113 
      x.read(self._iprot)
4114 
      self._iprot.readMessageEnd()
4115 
      raise x
4116 
    result = updateWeight_result()
4117 
    result.read(self._iprot)
4118 
    self._iprot.readMessageEnd()
4119 
    if result.success is not None:
4120 
      return result.success
4121 
    if result.ex is not None:
4122 
      raise result.ex
4123 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4124 
 
3469 chandransh 4125 
  def changeItem(self, orderId, itemId):
4126 
    """
4127 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4128 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4129 
 
3469 chandransh 4130 
    Parameters:
4131 
     - orderId
4132 
     - itemId
4133 
    """
4134 
    self.send_changeItem(orderId, itemId)
4135 
    return self.recv_changeItem()
4136 
 
4137 
  def send_changeItem(self, orderId, itemId):
4138 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4139 
    args = changeItem_args()
4140 
    args.orderId = orderId
4141 
    args.itemId = itemId
4142 
    args.write(self._oprot)
4143 
    self._oprot.writeMessageEnd()
4144 
    self._oprot.trans.flush()
4145 
 
4146 
  def recv_changeItem(self, ):
4147 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4148 
    if mtype == TMessageType.EXCEPTION:
4149 
      x = TApplicationException()
4150 
      x.read(self._iprot)
4151 
      self._iprot.readMessageEnd()
4152 
      raise x
4153 
    result = changeItem_result()
4154 
    result.read(self._iprot)
4155 
    self._iprot.readMessageEnd()
4156 
    if result.success is not None:
4157 
      return result.success
4158 
    if result.ex is not None:
4159 
      raise result.ex
4160 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4161 
 
4162 
  def shiftToWarehouse(self, orderId, warehouseId):
4163 
    """
4164 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4165 
 
4166 
    Parameters:
4167 
     - orderId
4168 
     - warehouseId
4169 
    """
4170 
    self.send_shiftToWarehouse(orderId, warehouseId)
4171 
    return self.recv_shiftToWarehouse()
4172 
 
4173 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4174 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4175 
    args = shiftToWarehouse_args()
4176 
    args.orderId = orderId
4177 
    args.warehouseId = warehouseId
4178 
    args.write(self._oprot)
4179 
    self._oprot.writeMessageEnd()
4180 
    self._oprot.trans.flush()
4181 
 
4182 
  def recv_shiftToWarehouse(self, ):
4183 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4184 
    if mtype == TMessageType.EXCEPTION:
4185 
      x = TApplicationException()
4186 
      x.read(self._iprot)
4187 
      self._iprot.readMessageEnd()
4188 
      raise x
4189 
    result = shiftToWarehouse_result()
4190 
    result.read(self._iprot)
4191 
    self._iprot.readMessageEnd()
4192 
    if result.success is not None:
4193 
      return result.success
4194 
    if result.ex is not None:
4195 
      raise result.ex
4196 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4197 
 
4647 rajveer 4198 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4199 
    """
4200 
    Adds the given delay reason to the given order.
3986 chandransh 4201 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4202 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4203 
 
3553 chandransh 4204 
    Parameters:
4205 
     - orderId
4206 
     - delayReason
3986 chandransh 4207 
     - furtherDelay
4647 rajveer 4208 
     - delayReasonText
3553 chandransh 4209 
    """
4647 rajveer 4210 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4211 
    return self.recv_addDelayReason()
4212 
 
4647 rajveer 4213 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4214 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4215 
    args = addDelayReason_args()
4216 
    args.orderId = orderId
4217 
    args.delayReason = delayReason
3986 chandransh 4218 
    args.furtherDelay = furtherDelay
4647 rajveer 4219 
    args.delayReasonText = delayReasonText
3553 chandransh 4220 
    args.write(self._oprot)
4221 
    self._oprot.writeMessageEnd()
4222 
    self._oprot.trans.flush()
4223 
 
4224 
  def recv_addDelayReason(self, ):
4225 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4226 
    if mtype == TMessageType.EXCEPTION:
4227 
      x = TApplicationException()
4228 
      x.read(self._iprot)
4229 
      self._iprot.readMessageEnd()
4230 
      raise x
4231 
    result = addDelayReason_result()
4232 
    result.read(self._iprot)
4233 
    self._iprot.readMessageEnd()
4234 
    if result.success is not None:
4235 
      return result.success
4236 
    if result.ex is not None:
4237 
      raise result.ex
4238 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4239 
 
3956 chandransh 4240 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4241 
    """
4242 
    Marks the COD orders with given AWB nos. as having been processed.
4243 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4244 
 
3956 chandransh 4245 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4246 
    1. There is no order corresponding to an AWB number.
4247 
    2. The captured amount for a payment exceeds the total payment.
4248 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4249 
 
4250 
    Parameters:
4251 
     - collectedAmountMap
4252 
     - xferBy
4253 
     - xferTxnId
4254 
     - xferDate
4255 
    """
4256 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4257 
    return self.recv_reconcileCodCollection()
4258 
 
4259 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4260 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4261 
    args = reconcileCodCollection_args()
4262 
    args.collectedAmountMap = collectedAmountMap
4263 
    args.xferBy = xferBy
4264 
    args.xferTxnId = xferTxnId
4265 
    args.xferDate = xferDate
4266 
    args.write(self._oprot)
4267 
    self._oprot.writeMessageEnd()
4268 
    self._oprot.trans.flush()
4269 
 
4270 
  def recv_reconcileCodCollection(self, ):
4271 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4272 
    if mtype == TMessageType.EXCEPTION:
4273 
      x = TApplicationException()
4274 
      x.read(self._iprot)
4275 
      self._iprot.readMessageEnd()
4276 
      raise x
4277 
    result = reconcileCodCollection_result()
4278 
    result.read(self._iprot)
4279 
    self._iprot.readMessageEnd()
4280 
    if result.success is not None:
4281 
      return result.success
4282 
    if result.ex is not None:
4283 
      raise result.ex
4284 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4285 
 
4008 mandeep.dh 4286 
  def getTransactionsRequiringExtraProcessing(self, category):
4287 
    """
4065 mandeep.dh 4288 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4289 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4290 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4291 
 
4008 mandeep.dh 4292 
    Parameters:
4293 
     - category
4294 
    """
4295 
    self.send_getTransactionsRequiringExtraProcessing(category)
4296 
    return self.recv_getTransactionsRequiringExtraProcessing()
4297 
 
4298 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4299 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4300 
    args = getTransactionsRequiringExtraProcessing_args()
4301 
    args.category = category
4302 
    args.write(self._oprot)
4303 
    self._oprot.writeMessageEnd()
4304 
    self._oprot.trans.flush()
4305 
 
4306 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4307 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4308 
    if mtype == TMessageType.EXCEPTION:
4309 
      x = TApplicationException()
4310 
      x.read(self._iprot)
4311 
      self._iprot.readMessageEnd()
4312 
      raise x
4313 
    result = getTransactionsRequiringExtraProcessing_result()
4314 
    result.read(self._iprot)
4315 
    self._iprot.readMessageEnd()
4316 
    if result.success is not None:
4317 
      return result.success
4318 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4319 
 
4320 
  def markTransactionAsProcessed(self, transactionId, category):
4321 
    """
4322 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4323 
    It essentially deletes the transaction id record for a particular
4324 
    processing type category (if present) from DB.
4325 
    This is currently used by CRM application.
4008 mandeep.dh 4326 
 
4327 
    Parameters:
4328 
     - transactionId
4329 
     - category
4330 
    """
4331 
    self.send_markTransactionAsProcessed(transactionId, category)
4332 
    self.recv_markTransactionAsProcessed()
4333 
 
4334 
  def send_markTransactionAsProcessed(self, transactionId, category):
4335 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4336 
    args = markTransactionAsProcessed_args()
4337 
    args.transactionId = transactionId
4338 
    args.category = category
4339 
    args.write(self._oprot)
4340 
    self._oprot.writeMessageEnd()
4341 
    self._oprot.trans.flush()
4342 
 
4343 
  def recv_markTransactionAsProcessed(self, ):
4344 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4345 
    if mtype == TMessageType.EXCEPTION:
4346 
      x = TApplicationException()
4347 
      x.read(self._iprot)
4348 
      self._iprot.readMessageEnd()
4349 
      raise x
4350 
    result = markTransactionAsProcessed_result()
4351 
    result.read(self._iprot)
4352 
    self._iprot.readMessageEnd()
4353 
    return
4354 
 
4018 chandransh 4355 
  def getItemWiseRiskyOrdersCount(self, ):
4356 
    """
4357 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4358 
    is defined as one whose shipping date is about to expire.
4359 
    """
4360 
    self.send_getItemWiseRiskyOrdersCount()
4361 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4362 
 
4018 chandransh 4363 
  def send_getItemWiseRiskyOrdersCount(self, ):
4364 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4365 
    args = getItemWiseRiskyOrdersCount_args()
4366 
    args.write(self._oprot)
4367 
    self._oprot.writeMessageEnd()
4368 
    self._oprot.trans.flush()
4369 
 
4370 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4371 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4372 
    if mtype == TMessageType.EXCEPTION:
4373 
      x = TApplicationException()
4374 
      x.read(self._iprot)
4375 
      self._iprot.readMessageEnd()
4376 
      raise x
4377 
    result = getItemWiseRiskyOrdersCount_result()
4378 
    result.read(self._iprot)
4379 
    self._iprot.readMessageEnd()
4380 
    if result.success is not None:
4381 
      return result.success
4382 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4383 
 
4295 varun.gupt 4384 
  def getOrdersForItemIds(self, itemIds):
4385 
    """
4386 
    Returns a list of all orders which have items with given id
4387 
 
4388 
    Parameters:
4389 
     - itemIds
4390 
    """
4391 
    self.send_getOrdersForItemIds(itemIds)
4392 
    return self.recv_getOrdersForItemIds()
4393 
 
4394 
  def send_getOrdersForItemIds(self, itemIds):
4395 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4396 
    args = getOrdersForItemIds_args()
4397 
    args.itemIds = itemIds
4398 
    args.write(self._oprot)
4399 
    self._oprot.writeMessageEnd()
4400 
    self._oprot.trans.flush()
4401 
 
4402 
  def recv_getOrdersForItemIds(self, ):
4403 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4404 
    if mtype == TMessageType.EXCEPTION:
4405 
      x = TApplicationException()
4406 
      x.read(self._iprot)
4407 
      self._iprot.readMessageEnd()
4408 
      raise x
4409 
    result = getOrdersForItemIds_result()
4410 
    result.read(self._iprot)
4411 
    self._iprot.readMessageEnd()
4412 
    if result.success is not None:
4413 
      return result.success
4414 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4415 
 
4247 rajveer 4416 
  def markOrderCancellationRequestReceived(self, orderId):
4417 
    """
4418 
    Mark order as cancellation request received. If customer sends request of cancellation of
4419 
    a particular order, this method will be called. It will just change status of the order
4420 
    depending on its current status. It also records the previous status, so that we can move
4421 
    back to that status if cancellation request is denied.
4018 chandransh 4422 
 
4247 rajveer 4423 
    Parameters:
4424 
     - orderId
4425 
    """
4426 
    self.send_markOrderCancellationRequestReceived(orderId)
4427 
    self.recv_markOrderCancellationRequestReceived()
4428 
 
4429 
  def send_markOrderCancellationRequestReceived(self, orderId):
4430 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4431 
    args = markOrderCancellationRequestReceived_args()
4432 
    args.orderId = orderId
4433 
    args.write(self._oprot)
4434 
    self._oprot.writeMessageEnd()
4435 
    self._oprot.trans.flush()
4436 
 
4437 
  def recv_markOrderCancellationRequestReceived(self, ):
4438 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4439 
    if mtype == TMessageType.EXCEPTION:
4440 
      x = TApplicationException()
4441 
      x.read(self._iprot)
4442 
      self._iprot.readMessageEnd()
4443 
      raise x
4444 
    result = markOrderCancellationRequestReceived_result()
4445 
    result.read(self._iprot)
4446 
    self._iprot.readMessageEnd()
4447 
    if result.ex is not None:
4448 
      raise result.ex
4449 
    return
4450 
 
4451 
  def markOrderCancellationRequestConfirmed(self, orderId):
4452 
    """
4453 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4454 
    cancellation request confirmed. After this OM will be able to cancel the order.
4455 
 
4456 
    Parameters:
4457 
     - orderId
4458 
    """
4459 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4460 
    self.recv_markOrderCancellationRequestConfirmed()
4461 
 
4462 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4463 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4464 
    args = markOrderCancellationRequestConfirmed_args()
4465 
    args.orderId = orderId
4466 
    args.write(self._oprot)
4467 
    self._oprot.writeMessageEnd()
4468 
    self._oprot.trans.flush()
4469 
 
4470 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4472 
    if mtype == TMessageType.EXCEPTION:
4473 
      x = TApplicationException()
4474 
      x.read(self._iprot)
4475 
      self._iprot.readMessageEnd()
4476 
      raise x
4477 
    result = markOrderCancellationRequestConfirmed_result()
4478 
    result.read(self._iprot)
4479 
    self._iprot.readMessageEnd()
4480 
    if result.ex is not None:
4481 
      raise result.ex
4482 
    return
4483 
 
4484 
  def markOrderCancellationRequestDenied(self, orderId):
4485 
    """
4486 
    If we decide to not to cancel order, we will move the order ro previous status.
4487 
 
4488 
    Parameters:
4489 
     - orderId
4490 
    """
4491 
    self.send_markOrderCancellationRequestDenied(orderId)
4492 
    self.recv_markOrderCancellationRequestDenied()
4493 
 
4494 
  def send_markOrderCancellationRequestDenied(self, orderId):
4495 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4496 
    args = markOrderCancellationRequestDenied_args()
4497 
    args.orderId = orderId
4498 
    args.write(self._oprot)
4499 
    self._oprot.writeMessageEnd()
4500 
    self._oprot.trans.flush()
4501 
 
4502 
  def recv_markOrderCancellationRequestDenied(self, ):
4503 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4504 
    if mtype == TMessageType.EXCEPTION:
4505 
      x = TApplicationException()
4506 
      x.read(self._iprot)
4507 
      self._iprot.readMessageEnd()
4508 
      raise x
4509 
    result = markOrderCancellationRequestDenied_result()
4510 
    result.read(self._iprot)
4511 
    self._iprot.readMessageEnd()
4512 
    if result.ex is not None:
4513 
      raise result.ex
4514 
    return
4515 
 
4258 rajveer 4516 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4517 
    """
4258 rajveer 4518 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4519 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4520 
 
4521 
    Parameters:
4258 rajveer 4522 
     - transactionId
4247 rajveer 4523 
    """
4258 rajveer 4524 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4525 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4526 
 
4258 rajveer 4527 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4528 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4529 
    args = markTransactionAsPaymentFlagRemoved_args()
4530 
    args.transactionId = transactionId
4247 rajveer 4531 
    args.write(self._oprot)
4532 
    self._oprot.writeMessageEnd()
4533 
    self._oprot.trans.flush()
4534 
 
4258 rajveer 4535 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 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
4258 rajveer 4542 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4543 
    result.read(self._iprot)
4544 
    self._iprot.readMessageEnd()
4545 
    if result.ex is not None:
4546 
      raise result.ex
4547 
    return
4548 
 
4259 anupam.sin 4549 
  def refundTransaction(self, transactionId, refundedBy, reason):
4550 
    """
4551 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4552 
    need to be cancelled
4247 rajveer 4553 
 
4259 anupam.sin 4554 
    Parameters:
4555 
     - transactionId
4556 
     - refundedBy
4557 
     - reason
4558 
    """
4559 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4560 
    self.recv_refundTransaction()
4561 
 
4562 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4563 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4564 
    args = refundTransaction_args()
4565 
    args.transactionId = transactionId
4566 
    args.refundedBy = refundedBy
4567 
    args.reason = reason
4568 
    args.write(self._oprot)
4569 
    self._oprot.writeMessageEnd()
4570 
    self._oprot.trans.flush()
4571 
 
4572 
  def recv_refundTransaction(self, ):
4573 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4574 
    if mtype == TMessageType.EXCEPTION:
4575 
      x = TApplicationException()
4576 
      x.read(self._iprot)
4577 
      self._iprot.readMessageEnd()
4578 
      raise x
4579 
    result = refundTransaction_result()
4580 
    result.read(self._iprot)
4581 
    self._iprot.readMessageEnd()
4582 
    if result.ex is not None:
4583 
      raise result.ex
4584 
    return
4585 
 
4324 mandeep.dh 4586 
  def updateShipmentAddress(self, orderId, addressId):
4587 
    """
4588 
    Updates shipment address of an order. Delivery and shipping date estimates
4589 
    etc. are also updated here.
4590 
 
4591 
    Throws TransactionServiceException in case address change is not
4592 
    possible due to certain reasons such as new pincode in address is
4593 
    not serviceable etc.
4594 
 
4595 
    Parameters:
4596 
     - orderId
4597 
     - addressId
4598 
    """
4599 
    self.send_updateShipmentAddress(orderId, addressId)
4600 
    self.recv_updateShipmentAddress()
4601 
 
4602 
  def send_updateShipmentAddress(self, orderId, addressId):
4603 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4604 
    args = updateShipmentAddress_args()
4605 
    args.orderId = orderId
4606 
    args.addressId = addressId
4607 
    args.write(self._oprot)
4608 
    self._oprot.writeMessageEnd()
4609 
    self._oprot.trans.flush()
4610 
 
4611 
  def recv_updateShipmentAddress(self, ):
4612 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4613 
    if mtype == TMessageType.EXCEPTION:
4614 
      x = TApplicationException()
4615 
      x.read(self._iprot)
4616 
      self._iprot.readMessageEnd()
4617 
      raise x
4618 
    result = updateShipmentAddress_result()
4619 
    result.read(self._iprot)
4620 
    self._iprot.readMessageEnd()
4621 
    if result.ex is not None:
4622 
      raise result.ex
4623 
    return
4624 
 
4285 rajveer 4625 
  def acceptOrdersForItemId(self, itemId, inventory):
4626 
    """
4627 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4628 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4629 
 
4285 rajveer 4630 
    Parameters:
4631 
     - itemId
4632 
     - inventory
4633 
    """
4634 
    self.send_acceptOrdersForItemId(itemId, inventory)
4635 
    return self.recv_acceptOrdersForItemId()
4636 
 
4637 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4638 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4639 
    args = acceptOrdersForItemId_args()
4640 
    args.itemId = itemId
4641 
    args.inventory = inventory
4642 
    args.write(self._oprot)
4643 
    self._oprot.writeMessageEnd()
4644 
    self._oprot.trans.flush()
4645 
 
4646 
  def recv_acceptOrdersForItemId(self, ):
4647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4648 
    if mtype == TMessageType.EXCEPTION:
4649 
      x = TApplicationException()
4650 
      x.read(self._iprot)
4651 
      self._iprot.readMessageEnd()
4652 
      raise x
4653 
    result = acceptOrdersForItemId_result()
4654 
    result.read(self._iprot)
4655 
    self._iprot.readMessageEnd()
4656 
    if result.success is not None:
4657 
      return result.success
4658 
    if result.ex is not None:
4659 
      raise result.ex
4660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4661 
 
4369 rajveer 4662 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4663 
    """
4664 
    Parameters:
4665 
     - vendorId
4666 
     - itemId
4667 
     - quantity
4668 
     - estimate
4369 rajveer 4669 
     - isReminder
4303 rajveer 4670 
    """
4369 rajveer 4671 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4672 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4673 
 
4369 rajveer 4674 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4675 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4676 
    args = markOrdersAsPORaised_args()
4677 
    args.vendorId = vendorId
4678 
    args.itemId = itemId
4679 
    args.quantity = quantity
4680 
    args.estimate = estimate
4369 rajveer 4681 
    args.isReminder = isReminder
4303 rajveer 4682 
    args.write(self._oprot)
4683 
    self._oprot.writeMessageEnd()
4684 
    self._oprot.trans.flush()
4685 
 
4686 
  def recv_markOrdersAsPORaised(self, ):
4687 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4688 
    if mtype == TMessageType.EXCEPTION:
4689 
      x = TApplicationException()
4690 
      x.read(self._iprot)
4691 
      self._iprot.readMessageEnd()
4692 
      raise x
4693 
    result = markOrdersAsPORaised_result()
4694 
    result.read(self._iprot)
4695 
    self._iprot.readMessageEnd()
4696 
    if result.ex is not None:
4697 
      raise result.ex
4698 
    return
4699 
 
4369 rajveer 4700 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4701 
    """
4702 
    Parameters:
4703 
     - vendorId
4704 
     - itemId
4705 
     - quantity
4706 
     - estimate
4369 rajveer 4707 
     - isReminder
4303 rajveer 4708 
    """
4369 rajveer 4709 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4710 
    self.recv_markOrdersAsReversalInitiated()
4711 
 
4369 rajveer 4712 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4713 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4714 
    args = markOrdersAsReversalInitiated_args()
4715 
    args.vendorId = vendorId
4716 
    args.itemId = itemId
4717 
    args.quantity = quantity
4718 
    args.estimate = estimate
4369 rajveer 4719 
    args.isReminder = isReminder
4303 rajveer 4720 
    args.write(self._oprot)
4721 
    self._oprot.writeMessageEnd()
4722 
    self._oprot.trans.flush()
4723 
 
4724 
  def recv_markOrdersAsReversalInitiated(self, ):
4725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4726 
    if mtype == TMessageType.EXCEPTION:
4727 
      x = TApplicationException()
4728 
      x.read(self._iprot)
4729 
      self._iprot.readMessageEnd()
4730 
      raise x
4731 
    result = markOrdersAsReversalInitiated_result()
4732 
    result.read(self._iprot)
4733 
    self._iprot.readMessageEnd()
4734 
    if result.ex is not None:
4735 
      raise result.ex
4736 
    return
4737 
 
4369 rajveer 4738 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4739 
    """
4740 
    Parameters:
4741 
     - vendorId
4742 
     - itemId
4743 
     - quantity
4744 
     - estimate
4369 rajveer 4745 
     - isReminder
4303 rajveer 4746 
    """
4369 rajveer 4747 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4748 
    self.recv_markOrdersAsNotAvailabke()
4749 
 
4369 rajveer 4750 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4751 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4752 
    args = markOrdersAsNotAvailabke_args()
4753 
    args.vendorId = vendorId
4754 
    args.itemId = itemId
4755 
    args.quantity = quantity
4756 
    args.estimate = estimate
4369 rajveer 4757 
    args.isReminder = isReminder
4303 rajveer 4758 
    args.write(self._oprot)
4759 
    self._oprot.writeMessageEnd()
4760 
    self._oprot.trans.flush()
4761 
 
4762 
  def recv_markOrdersAsNotAvailabke(self, ):
4763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4764 
    if mtype == TMessageType.EXCEPTION:
4765 
      x = TApplicationException()
4766 
      x.read(self._iprot)
4767 
      self._iprot.readMessageEnd()
4768 
      raise x
4769 
    result = markOrdersAsNotAvailabke_result()
4770 
    result.read(self._iprot)
4771 
    self._iprot.readMessageEnd()
4772 
    if result.ex is not None:
4773 
      raise result.ex
4774 
    return
4775 
 
4369 rajveer 4776 
  def markOrdersAsTimeout(self, vendorId):
4777 
    """
4778 
    Parameters:
4779 
     - vendorId
4780 
    """
4781 
    self.send_markOrdersAsTimeout(vendorId)
4782 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4783 
 
4369 rajveer 4784 
  def send_markOrdersAsTimeout(self, vendorId):
4785 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4786 
    args = markOrdersAsTimeout_args()
4787 
    args.vendorId = vendorId
4788 
    args.write(self._oprot)
4789 
    self._oprot.writeMessageEnd()
4790 
    self._oprot.trans.flush()
4791 
 
4792 
  def recv_markOrdersAsTimeout(self, ):
4793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4794 
    if mtype == TMessageType.EXCEPTION:
4795 
      x = TApplicationException()
4796 
      x.read(self._iprot)
4797 
      self._iprot.readMessageEnd()
4798 
      raise x
4799 
    result = markOrdersAsTimeout_result()
4800 
    result.read(self._iprot)
4801 
    self._iprot.readMessageEnd()
4802 
    if result.success is not None:
4803 
      return result.success
4804 
    if result.ex is not None:
4805 
      raise result.ex
4806 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4807 
 
4662 rajveer 4808 
  def markOrderAsLostInTransit(self, orderId):
4809 
    """
4810 
    Mark order as LOST_IN_TRANSIT
4811 
 
4812 
    Parameters:
4813 
     - orderId
4814 
    """
4815 
    self.send_markOrderAsLostInTransit(orderId)
4816 
    return self.recv_markOrderAsLostInTransit()
4817 
 
4818 
  def send_markOrderAsLostInTransit(self, orderId):
4819 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4820 
    args = markOrderAsLostInTransit_args()
4821 
    args.orderId = orderId
4822 
    args.write(self._oprot)
4823 
    self._oprot.writeMessageEnd()
4824 
    self._oprot.trans.flush()
4825 
 
4826 
  def recv_markOrderAsLostInTransit(self, ):
4827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4828 
    if mtype == TMessageType.EXCEPTION:
4829 
      x = TApplicationException()
4830 
      x.read(self._iprot)
4831 
      self._iprot.readMessageEnd()
4832 
      raise x
4833 
    result = markOrderAsLostInTransit_result()
4834 
    result.read(self._iprot)
4835 
    self._iprot.readMessageEnd()
4836 
    if result.success is not None:
4837 
      return result.success
4838 
    if result.ex is not None:
4839 
      raise result.ex
4840 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4841 
 
4386 anupam.sin 4842 
  def getOrderForAwb(self, awb):
4843 
    """
4844 
    Returns the order corresponding to an AWB number
4369 rajveer 4845 
 
4386 anupam.sin 4846 
    Parameters:
4847 
     - awb
4848 
    """
4849 
    self.send_getOrderForAwb(awb)
4850 
    return self.recv_getOrderForAwb()
4851 
 
4852 
  def send_getOrderForAwb(self, awb):
4853 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4854 
    args = getOrderForAwb_args()
4855 
    args.awb = awb
4856 
    args.write(self._oprot)
4857 
    self._oprot.writeMessageEnd()
4858 
    self._oprot.trans.flush()
4859 
 
4860 
  def recv_getOrderForAwb(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 = getOrderForAwb_result()
4868 
    result.read(self._iprot)
4869 
    self._iprot.readMessageEnd()
4870 
    if result.success is not None:
4871 
      return result.success
4872 
    if result.ex is not None:
4873 
      raise result.ex
4874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4875 
 
4910 phani.kuma 4876 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4877 
    """
4910 phani.kuma 4878 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4879 
 
4506 phani.kuma 4880 
    Parameters:
4881 
     - logistics_provider_id
4910 phani.kuma 4882 
     - order_status_list
4506 phani.kuma 4883 
    """
4910 phani.kuma 4884 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4885 
    return self.recv_getOrdersForProviderForStatus()
4886 
 
4910 phani.kuma 4887 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4888 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4889 
    args = getOrdersForProviderForStatus_args()
4890 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4891 
    args.order_status_list = order_status_list
4506 phani.kuma 4892 
    args.write(self._oprot)
4893 
    self._oprot.writeMessageEnd()
4894 
    self._oprot.trans.flush()
4895 
 
4896 
  def recv_getOrdersForProviderForStatus(self, ):
4897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4898 
    if mtype == TMessageType.EXCEPTION:
4899 
      x = TApplicationException()
4900 
      x.read(self._iprot)
4901 
      self._iprot.readMessageEnd()
4902 
      raise x
4903 
    result = getOrdersForProviderForStatus_result()
4904 
    result.read(self._iprot)
4905 
    self._iprot.readMessageEnd()
4906 
    if result.success is not None:
4907 
      return result.success
4908 
    if result.ex is not None:
4909 
      raise result.ex
4910 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4911 
 
4600 varun.gupt 4912 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4913 
    """
4914 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4915 
 
4600 varun.gupt 4916 
    Parameters:
4917 
     - vendorId
4918 
     - billingDateFrom
4919 
     - billingDateTo
4920 
    """
4921 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4922 
    return self.recv_getBilledOrdersForVendor()
4923 
 
4924 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4925 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4926 
    args = getBilledOrdersForVendor_args()
4927 
    args.vendorId = vendorId
4928 
    args.billingDateFrom = billingDateFrom
4929 
    args.billingDateTo = billingDateTo
4930 
    args.write(self._oprot)
4931 
    self._oprot.writeMessageEnd()
4932 
    self._oprot.trans.flush()
4933 
 
4934 
  def recv_getBilledOrdersForVendor(self, ):
4935 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4936 
    if mtype == TMessageType.EXCEPTION:
4937 
      x = TApplicationException()
4938 
      x.read(self._iprot)
4939 
      self._iprot.readMessageEnd()
4940 
      raise x
4941 
    result = getBilledOrdersForVendor_result()
4942 
    result.read(self._iprot)
4943 
    self._iprot.readMessageEnd()
4944 
    if result.success is not None:
4945 
      return result.success
4946 
    if result.ex is not None:
4947 
      raise result.ex
4948 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4949 
 
4607 rajveer 4950 
  def getSlippedSippingDateOrders(self, ):
4951 
    self.send_getSlippedSippingDateOrders()
4952 
    return self.recv_getSlippedSippingDateOrders()
4953 
 
4954 
  def send_getSlippedSippingDateOrders(self, ):
4955 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4956 
    args = getSlippedSippingDateOrders_args()
4957 
    args.write(self._oprot)
4958 
    self._oprot.writeMessageEnd()
4959 
    self._oprot.trans.flush()
4960 
 
4961 
  def recv_getSlippedSippingDateOrders(self, ):
4962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4963 
    if mtype == TMessageType.EXCEPTION:
4964 
      x = TApplicationException()
4965 
      x.read(self._iprot)
4966 
      self._iprot.readMessageEnd()
4967 
      raise x
4968 
    result = getSlippedSippingDateOrders_result()
4969 
    result.read(self._iprot)
4970 
    self._iprot.readMessageEnd()
4971 
    if result.success is not None:
4972 
      return result.success
4973 
    if result.ex is not None:
4974 
      raise result.ex
4975 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4976 
 
4709 rajveer 4977 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4978 
    """
4979 
    Parameters:
4980 
     - cancelDateFrom
4981 
     - cancelDateTo
4982 
    """
4983 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4984 
    return self.recv_getCancelledOrders()
4985 
 
4986 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4987 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4988 
    args = getCancelledOrders_args()
4989 
    args.cancelDateFrom = cancelDateFrom
4990 
    args.cancelDateTo = cancelDateTo
4991 
    args.write(self._oprot)
4992 
    self._oprot.writeMessageEnd()
4993 
    self._oprot.trans.flush()
4994 
 
4995 
  def recv_getCancelledOrders(self, ):
4996 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4997 
    if mtype == TMessageType.EXCEPTION:
4998 
      x = TApplicationException()
4999 
      x.read(self._iprot)
5000 
      self._iprot.readMessageEnd()
5001 
      raise x
5002 
    result = getCancelledOrders_result()
5003 
    result.read(self._iprot)
5004 
    self._iprot.readMessageEnd()
5005 
    if result.success is not None:
5006 
      return result.success
5007 
    if result.ex is not None:
5008 
      raise result.ex
5009 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
5010 
 
4600 varun.gupt 5011 
  def saveBluedartSettlements(self, mapAWBAndAmount):
5012 
    """
5013 
    Parameters:
5014 
     - mapAWBAndAmount
5015 
    """
5016 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
5017 
    self.recv_saveBluedartSettlements()
5018 
 
5019 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
5020 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
5021 
    args = saveBluedartSettlements_args()
5022 
    args.mapAWBAndAmount = mapAWBAndAmount
5023 
    args.write(self._oprot)
5024 
    self._oprot.writeMessageEnd()
5025 
    self._oprot.trans.flush()
5026 
 
5027 
  def recv_saveBluedartSettlements(self, ):
5028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5029 
    if mtype == TMessageType.EXCEPTION:
5030 
      x = TApplicationException()
5031 
      x.read(self._iprot)
5032 
      self._iprot.readMessageEnd()
5033 
      raise x
5034 
    result = saveBluedartSettlements_result()
5035 
    result.read(self._iprot)
5036 
    self._iprot.readMessageEnd()
5037 
    if result.ex is not None:
5038 
      raise result.ex
5039 
    return
5040 
 
4905 varun.gupt 5041 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5042 
    """
5043 
    Parameters:
5044 
     - settlementDate
5045 
     - paymentGatewayId
4905 varun.gupt 5046 
     - referenceId
4600 varun.gupt 5047 
     - serviceTax
5048 
     - otherCharges
5049 
     - netCollection
5050 
    """
4905 varun.gupt 5051 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5052 
    self.recv_savePaymentSettlements()
5053 
 
4905 varun.gupt 5054 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5055 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5056 
    args = savePaymentSettlements_args()
5057 
    args.settlementDate = settlementDate
5058 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5059 
    args.referenceId = referenceId
4600 varun.gupt 5060 
    args.serviceTax = serviceTax
5061 
    args.otherCharges = otherCharges
5062 
    args.netCollection = netCollection
5063 
    args.write(self._oprot)
5064 
    self._oprot.writeMessageEnd()
5065 
    self._oprot.trans.flush()
5066 
 
5067 
  def recv_savePaymentSettlements(self, ):
5068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5069 
    if mtype == TMessageType.EXCEPTION:
5070 
      x = TApplicationException()
5071 
      x.read(self._iprot)
5072 
      self._iprot.readMessageEnd()
5073 
      raise x
5074 
    result = savePaymentSettlements_result()
5075 
    result.read(self._iprot)
5076 
    self._iprot.readMessageEnd()
5077 
    if result.ex is not None:
5078 
      raise result.ex
5079 
    return
5080 
 
5081 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5082 
    """
5083 
    Parameters:
5084 
     - settlementId
5085 
     - settlementDate
5086 
     - transactionDateFrom
5087 
     - transactionDateTo
5088 
     - amount
5089 
    """
5090 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5091 
    self.recv_saveEBSSettlementSummary()
5092 
 
5093 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5094 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5095 
    args = saveEBSSettlementSummary_args()
5096 
    args.settlementId = settlementId
5097 
    args.settlementDate = settlementDate
5098 
    args.transactionDateFrom = transactionDateFrom
5099 
    args.transactionDateTo = transactionDateTo
5100 
    args.amount = amount
5101 
    args.write(self._oprot)
5102 
    self._oprot.writeMessageEnd()
5103 
    self._oprot.trans.flush()
5104 
 
5105 
  def recv_saveEBSSettlementSummary(self, ):
5106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5107 
    if mtype == TMessageType.EXCEPTION:
5108 
      x = TApplicationException()
5109 
      x.read(self._iprot)
5110 
      self._iprot.readMessageEnd()
5111 
      raise x
5112 
    result = saveEBSSettlementSummary_result()
5113 
    result.read(self._iprot)
5114 
    self._iprot.readMessageEnd()
5115 
    if result.ex is not None:
5116 
      raise result.ex
5117 
    return
5118 
 
5386 phani.kuma 5119 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5120 
    """
5121 
    Parameters:
5189 varun.gupt 5122 
     - referenceId
5123 
     - isRefund
4600 varun.gupt 5124 
    """
5386 phani.kuma 5125 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5126 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5127 
 
5386 phani.kuma 5128 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5129 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5130 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5131 
    args.referenceId = referenceId
5132 
    args.isRefund = isRefund
4600 varun.gupt 5133 
    args.write(self._oprot)
5134 
    self._oprot.writeMessageEnd()
5135 
    self._oprot.trans.flush()
5136 
 
5386 phani.kuma 5137 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5138 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5139 
    if mtype == TMessageType.EXCEPTION:
5140 
      x = TApplicationException()
5141 
      x.read(self._iprot)
5142 
      self._iprot.readMessageEnd()
5143 
      raise x
5386 phani.kuma 5144 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5145 
    result.read(self._iprot)
5146 
    self._iprot.readMessageEnd()
5147 
    if result.success is not None:
5148 
      return result.success
5149 
    if result.ex is not None:
5150 
      raise result.ex
5386 phani.kuma 5151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5152 
 
5386 phani.kuma 5153 
  def getSettlementForCod(self, orderId, isRefund):
5154 
    """
5155 
    Parameters:
5156 
     - orderId
5157 
     - isRefund
5158 
    """
5159 
    self.send_getSettlementForCod(orderId, isRefund)
5160 
    return self.recv_getSettlementForCod()
5161 
 
5162 
  def send_getSettlementForCod(self, orderId, isRefund):
5163 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5164 
    args = getSettlementForCod_args()
5165 
    args.orderId = orderId
5166 
    args.isRefund = isRefund
5167 
    args.write(self._oprot)
5168 
    self._oprot.writeMessageEnd()
5169 
    self._oprot.trans.flush()
5170 
 
5171 
  def recv_getSettlementForCod(self, ):
5172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5173 
    if mtype == TMessageType.EXCEPTION:
5174 
      x = TApplicationException()
5175 
      x.read(self._iprot)
5176 
      self._iprot.readMessageEnd()
5177 
      raise x
5178 
    result = getSettlementForCod_result()
5179 
    result.read(self._iprot)
5180 
    self._iprot.readMessageEnd()
5181 
    if result.success is not None:
5182 
      return result.success
5183 
    if result.ex is not None:
5184 
      raise result.ex
5185 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5186 
 
4600 varun.gupt 5187 
  def getEBSSettlementSummaries(self, ):
5188 
    self.send_getEBSSettlementSummaries()
5189 
    return self.recv_getEBSSettlementSummaries()
5190 
 
5191 
  def send_getEBSSettlementSummaries(self, ):
5192 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5193 
    args = getEBSSettlementSummaries_args()
5194 
    args.write(self._oprot)
5195 
    self._oprot.writeMessageEnd()
5196 
    self._oprot.trans.flush()
5197 
 
5198 
  def recv_getEBSSettlementSummaries(self, ):
5199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5200 
    if mtype == TMessageType.EXCEPTION:
5201 
      x = TApplicationException()
5202 
      x.read(self._iprot)
5203 
      self._iprot.readMessageEnd()
5204 
      raise x
5205 
    result = getEBSSettlementSummaries_result()
5206 
    result.read(self._iprot)
5207 
    self._iprot.readMessageEnd()
5208 
    if result.success is not None:
5209 
      return result.success
5210 
    if result.ex is not None:
5211 
      raise result.ex
5212 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5213 
 
5214 
  def markEBSSettlementUploaded(self, settlementId):
5215 
    """
5216 
    Parameters:
5217 
     - settlementId
5218 
    """
5219 
    self.send_markEBSSettlementUploaded(settlementId)
5220 
    self.recv_markEBSSettlementUploaded()
5221 
 
5222 
  def send_markEBSSettlementUploaded(self, settlementId):
5223 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5224 
    args = markEBSSettlementUploaded_args()
5225 
    args.settlementId = settlementId
5226 
    args.write(self._oprot)
5227 
    self._oprot.writeMessageEnd()
5228 
    self._oprot.trans.flush()
5229 
 
5230 
  def recv_markEBSSettlementUploaded(self, ):
5231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5232 
    if mtype == TMessageType.EXCEPTION:
5233 
      x = TApplicationException()
5234 
      x.read(self._iprot)
5235 
      self._iprot.readMessageEnd()
5236 
      raise x
5237 
    result = markEBSSettlementUploaded_result()
5238 
    result.read(self._iprot)
5239 
    self._iprot.readMessageEnd()
5240 
    if result.ex is not None:
5241 
      raise result.ex
5242 
    return
5243 
 
5244 
  def getEBSSettlementDate(self, settlementId):
5245 
    """
5246 
    Parameters:
5247 
     - settlementId
5248 
    """
5249 
    self.send_getEBSSettlementDate(settlementId)
5250 
    return self.recv_getEBSSettlementDate()
5251 
 
5252 
  def send_getEBSSettlementDate(self, settlementId):
5253 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5254 
    args = getEBSSettlementDate_args()
5255 
    args.settlementId = settlementId
5256 
    args.write(self._oprot)
5257 
    self._oprot.writeMessageEnd()
5258 
    self._oprot.trans.flush()
5259 
 
5260 
  def recv_getEBSSettlementDate(self, ):
5261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5262 
    if mtype == TMessageType.EXCEPTION:
5263 
      x = TApplicationException()
5264 
      x.read(self._iprot)
5265 
      self._iprot.readMessageEnd()
5266 
      raise x
5267 
    result = getEBSSettlementDate_result()
5268 
    result.read(self._iprot)
5269 
    self._iprot.readMessageEnd()
5270 
    if result.success is not None:
5271 
      return result.success
5272 
    if result.ex is not None:
5273 
      raise result.ex
5274 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5275 
 
4715 varun.gupt 5276 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5277 
    """
5278 
    Parameters:
5279 
     - settlementDateFrom
5280 
     - settlementDateTo
5281 
     - isRefund
5282 
    """
5283 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5284 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5285 
 
4715 varun.gupt 5286 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5287 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5288 
    args = getSettlementsByDate_args()
5289 
    args.settlementDateFrom = settlementDateFrom
5290 
    args.settlementDateTo = settlementDateTo
5291 
    args.isRefund = isRefund
5292 
    args.write(self._oprot)
5293 
    self._oprot.writeMessageEnd()
5294 
    self._oprot.trans.flush()
5295 
 
5296 
  def recv_getSettlementsByDate(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 = getSettlementsByDate_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, "getSettlementsByDate failed: unknown result");
5311 
 
5312 
  def getReshippedOrderIds(self, orderIds):
5313 
    """
5314 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5315 
 
5316 
    Parameters:
5317 
     - orderIds
5318 
    """
5319 
    self.send_getReshippedOrderIds(orderIds)
5320 
    return self.recv_getReshippedOrderIds()
5321 
 
5322 
  def send_getReshippedOrderIds(self, orderIds):
5323 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5324 
    args = getReshippedOrderIds_args()
5325 
    args.orderIds = orderIds
5326 
    args.write(self._oprot)
5327 
    self._oprot.writeMessageEnd()
5328 
    self._oprot.trans.flush()
5329 
 
5330 
  def recv_getReshippedOrderIds(self, ):
5331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5332 
    if mtype == TMessageType.EXCEPTION:
5333 
      x = TApplicationException()
5334 
      x.read(self._iprot)
5335 
      self._iprot.readMessageEnd()
5336 
      raise x
5337 
    result = getReshippedOrderIds_result()
5338 
    result.read(self._iprot)
5339 
    self._iprot.readMessageEnd()
5340 
    if result.success is not None:
5341 
      return result.success
5342 
    if result.ex is not None:
5343 
      raise result.ex
5344 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5345 
 
5481 phani.kuma 5346 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5347 
    """
5348 
    Parameters:
5349 
     - vendorId
5481 phani.kuma 5350 
     - onlyVendorNotPaid
5351 
     - billingDateFrom
5352 
     - billingDateTo
4875 varun.gupt 5353 
    """
5481 phani.kuma 5354 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5355 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5356 
 
5481 phani.kuma 5357 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5358 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5359 
    args = getBilledOrders_args()
4875 varun.gupt 5360 
    args.vendorId = vendorId
5481 phani.kuma 5361 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5362 
    args.billingDateFrom = billingDateFrom
5363 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5364 
    args.write(self._oprot)
5365 
    self._oprot.writeMessageEnd()
5366 
    self._oprot.trans.flush()
5367 
 
5481 phani.kuma 5368 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5369 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5370 
    if mtype == TMessageType.EXCEPTION:
5371 
      x = TApplicationException()
5372 
      x.read(self._iprot)
5373 
      self._iprot.readMessageEnd()
5374 
      raise x
5481 phani.kuma 5375 
    result = getBilledOrders_result()
4875 varun.gupt 5376 
    result.read(self._iprot)
5377 
    self._iprot.readMessageEnd()
5378 
    if result.success is not None:
5379 
      return result.success
5380 
    if result.ex is not None:
5381 
      raise result.ex
5481 phani.kuma 5382 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5383 
 
5031 varun.gupt 5384 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5385 
    """
5386 
    Parameters:
5387 
     - startDate
5388 
     - endDate
5389 
    """
5390 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5391 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5392 
 
5031 varun.gupt 5393 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5394 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5395 
    args = getStatusDistributionOfOrders_args()
5396 
    args.startDate = startDate
5397 
    args.endDate = endDate
5398 
    args.write(self._oprot)
5399 
    self._oprot.writeMessageEnd()
5400 
    self._oprot.trans.flush()
5401 
 
5402 
  def recv_getStatusDistributionOfOrders(self, ):
5403 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5404 
    if mtype == TMessageType.EXCEPTION:
5405 
      x = TApplicationException()
5406 
      x.read(self._iprot)
5407 
      self._iprot.readMessageEnd()
5408 
      raise x
5409 
    result = getStatusDistributionOfOrders_result()
5410 
    result.read(self._iprot)
5411 
    self._iprot.readMessageEnd()
5412 
    if result.success is not None:
5413 
      return result.success
5414 
    if result.ex is not None:
5415 
      raise result.ex
5416 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5417 
 
5067 varun.gupt 5418 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5419 
    """
5420 
    Parameters:
5421 
     - status
5422 
     - startDatetime
5423 
     - endDatetime
5424 
    """
5425 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5426 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5427 
 
5067 varun.gupt 5428 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5429 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5430 
    args = getOrderIdsForStatus_args()
5431 
    args.status = status
5432 
    args.startDatetime = startDatetime
5433 
    args.endDatetime = endDatetime
5434 
    args.write(self._oprot)
5435 
    self._oprot.writeMessageEnd()
5436 
    self._oprot.trans.flush()
5437 
 
5438 
  def recv_getOrderIdsForStatus(self, ):
5439 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5440 
    if mtype == TMessageType.EXCEPTION:
5441 
      x = TApplicationException()
5442 
      x.read(self._iprot)
5443 
      self._iprot.readMessageEnd()
5444 
      raise x
5445 
    result = getOrderIdsForStatus_result()
5446 
    result.read(self._iprot)
5447 
    self._iprot.readMessageEnd()
5448 
    if result.success is not None:
5449 
      return result.success
5450 
    if result.ex is not None:
5451 
      raise result.ex
5452 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5453 
 
5348 anupam.sin 5454 
  def updateCODAgent(self, agent, orderId):
5455 
    """
5456 
    Updates the agent who handled the COD verification call
5457 
 
5458 
    Parameters:
5459 
     - agent
5460 
     - orderId
5461 
    """
5462 
    self.send_updateCODAgent(agent, orderId)
5463 
    self.recv_updateCODAgent()
5464 
 
5465 
  def send_updateCODAgent(self, agent, orderId):
5466 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5467 
    args = updateCODAgent_args()
5468 
    args.agent = agent
5469 
    args.orderId = orderId
5470 
    args.write(self._oprot)
5471 
    self._oprot.writeMessageEnd()
5472 
    self._oprot.trans.flush()
5473 
 
5474 
  def recv_updateCODAgent(self, ):
5475 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5476 
    if mtype == TMessageType.EXCEPTION:
5477 
      x = TApplicationException()
5478 
      x.read(self._iprot)
5479 
      self._iprot.readMessageEnd()
5480 
      raise x
5481 
    result = updateCODAgent_result()
5482 
    result.read(self._iprot)
5483 
    self._iprot.readMessageEnd()
5484 
    if result.ex is not None:
5485 
      raise result.ex
5486 
    return
5487 
 
5099 varun.gupt 5488 
  def updateOrderAsPaidToVendor(self, orderId):
5489 
    """
5490 
    Parameters:
5491 
     - orderId
5492 
    """
5493 
    self.send_updateOrderAsPaidToVendor(orderId)
5494 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5495 
 
5099 varun.gupt 5496 
  def send_updateOrderAsPaidToVendor(self, orderId):
5497 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5498 
    args = updateOrderAsPaidToVendor_args()
5499 
    args.orderId = orderId
5500 
    args.write(self._oprot)
5501 
    self._oprot.writeMessageEnd()
5502 
    self._oprot.trans.flush()
5503 
 
5504 
  def recv_updateOrderAsPaidToVendor(self, ):
5505 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5506 
    if mtype == TMessageType.EXCEPTION:
5507 
      x = TApplicationException()
5508 
      x.read(self._iprot)
5509 
      self._iprot.readMessageEnd()
5510 
      raise x
5511 
    result = updateOrderAsPaidToVendor_result()
5512 
    result.read(self._iprot)
5513 
    self._iprot.readMessageEnd()
5514 
    if result.ex is not None:
5515 
      raise result.ex
5516 
    return
5517 
 
5386 phani.kuma 5518 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5519 
    """
5520 
    Parameters:
5521 
     - orderId
5522 
    """
5523 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5524 
    self.recv_updateOrderOnlyAsPaidToVendor()
5525 
 
5526 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5527 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5528 
    args = updateOrderOnlyAsPaidToVendor_args()
5529 
    args.orderId = orderId
5530 
    args.write(self._oprot)
5531 
    self._oprot.writeMessageEnd()
5532 
    self._oprot.trans.flush()
5533 
 
5534 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5535 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5536 
    if mtype == TMessageType.EXCEPTION:
5537 
      x = TApplicationException()
5538 
      x.read(self._iprot)
5539 
      self._iprot.readMessageEnd()
5540 
      raise x
5541 
    result = updateOrderOnlyAsPaidToVendor_result()
5542 
    result.read(self._iprot)
5543 
    self._iprot.readMessageEnd()
5544 
    if result.ex is not None:
5545 
      raise result.ex
5546 
    return
5547 
 
5208 varun.gupt 5548 
  def getRefundedOrdersMarkedPaid(self, ):
5549 
    self.send_getRefundedOrdersMarkedPaid()
5550 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5551 
 
5208 varun.gupt 5552 
  def send_getRefundedOrdersMarkedPaid(self, ):
5553 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5554 
    args = getRefundedOrdersMarkedPaid_args()
5555 
    args.write(self._oprot)
5556 
    self._oprot.writeMessageEnd()
5557 
    self._oprot.trans.flush()
5558 
 
5559 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5560 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5561 
    if mtype == TMessageType.EXCEPTION:
5562 
      x = TApplicationException()
5563 
      x.read(self._iprot)
5564 
      self._iprot.readMessageEnd()
5565 
      raise x
5566 
    result = getRefundedOrdersMarkedPaid_result()
5567 
    result.read(self._iprot)
5568 
    self._iprot.readMessageEnd()
5569 
    if result.success is not None:
5570 
      return result.success
5571 
    if result.ex is not None:
5572 
      raise result.ex
5573 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5574 
 
5447 anupam.sin 5575 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5576 
    """
5577 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5578 
 
5447 anupam.sin 5579 
 
5580 
    Parameters:
5581 
     - minOrderId
5582 
     - maxOrderId
5583 
    """
5584 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5585 
    return self.recv_getAllVerificationAgents()
5586 
 
5587 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5588 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5589 
    args = getAllVerificationAgents_args()
5590 
    args.minOrderId = minOrderId
5591 
    args.maxOrderId = maxOrderId
5592 
    args.write(self._oprot)
5593 
    self._oprot.writeMessageEnd()
5594 
    self._oprot.trans.flush()
5595 
 
5596 
  def recv_getAllVerificationAgents(self, ):
5597 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5598 
    if mtype == TMessageType.EXCEPTION:
5599 
      x = TApplicationException()
5600 
      x.read(self._iprot)
5601 
      self._iprot.readMessageEnd()
5602 
      raise x
5603 
    result = getAllVerificationAgents_result()
5604 
    result.read(self._iprot)
5605 
    self._iprot.readMessageEnd()
5606 
    if result.success is not None:
5607 
      return result.success
5608 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5609 
 
5527 anupam.sin 5610 
  def getAllAttributesForOrderId(self, orderId):
5611 
    """
5612 
    gets all attributes for a given orderId
5447 anupam.sin 5613 
 
5527 anupam.sin 5614 
    Parameters:
5615 
     - orderId
5616 
    """
5617 
    self.send_getAllAttributesForOrderId(orderId)
5618 
    return self.recv_getAllAttributesForOrderId()
5619 
 
5620 
  def send_getAllAttributesForOrderId(self, orderId):
5621 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5622 
    args = getAllAttributesForOrderId_args()
5623 
    args.orderId = orderId
5624 
    args.write(self._oprot)
5625 
    self._oprot.writeMessageEnd()
5626 
    self._oprot.trans.flush()
5627 
 
5628 
  def recv_getAllAttributesForOrderId(self, ):
5629 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5630 
    if mtype == TMessageType.EXCEPTION:
5631 
      x = TApplicationException()
5632 
      x.read(self._iprot)
5633 
      self._iprot.readMessageEnd()
5634 
      raise x
5635 
    result = getAllAttributesForOrderId_result()
5636 
    result.read(self._iprot)
5637 
    self._iprot.readMessageEnd()
5638 
    if result.success is not None:
5639 
      return result.success
5640 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5641 
 
5676 rajveer 5642 
  def setOrderAttributes(self, orderId, attributes):
5643 
    """
5644 
    sets attributes for an order
5645 
 
5646 
    Parameters:
5647 
     - orderId
5648 
     - attributes
5649 
    """
5650 
    self.send_setOrderAttributes(orderId, attributes)
5651 
    self.recv_setOrderAttributes()
5652 
 
5653 
  def send_setOrderAttributes(self, orderId, attributes):
5654 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5655 
    args = setOrderAttributes_args()
5656 
    args.orderId = orderId
5657 
    args.attributes = attributes
5658 
    args.write(self._oprot)
5659 
    self._oprot.writeMessageEnd()
5660 
    self._oprot.trans.flush()
5661 
 
5662 
  def recv_setOrderAttributes(self, ):
5663 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5664 
    if mtype == TMessageType.EXCEPTION:
5665 
      x = TApplicationException()
5666 
      x.read(self._iprot)
5667 
      self._iprot.readMessageEnd()
5668 
      raise x
5669 
    result = setOrderAttributes_result()
5670 
    result.read(self._iprot)
5671 
    self._iprot.readMessageEnd()
5672 
    return
5673 
 
5527 anupam.sin 5674 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5675 
    """
5676 
    sets attributes for all orders in a transaction
5677 
 
5678 
    Parameters:
5679 
     - transactionId
5680 
     - attribute
5681 
    """
5682 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5683 
    self.recv_setOrderAttributeForTransaction()
5684 
 
5685 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5686 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5687 
    args = setOrderAttributeForTransaction_args()
5688 
    args.transactionId = transactionId
5689 
    args.attribute = attribute
5690 
    args.write(self._oprot)
5691 
    self._oprot.writeMessageEnd()
5692 
    self._oprot.trans.flush()
5693 
 
5694 
  def recv_setOrderAttributeForTransaction(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 = setOrderAttributeForTransaction_result()
5702 
    result.read(self._iprot)
5703 
    self._iprot.readMessageEnd()
5704 
    return
5705 
 
5553 rajveer 5706 
  def getReceivePendingOrders(self, storeId):
5707 
    """
5708 
    Parameters:
5709 
     - storeId
5710 
    """
5711 
    self.send_getReceivePendingOrders(storeId)
5712 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5713 
 
5553 rajveer 5714 
  def send_getReceivePendingOrders(self, storeId):
5715 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5716 
    args = getReceivePendingOrders_args()
5717 
    args.storeId = storeId
5718 
    args.write(self._oprot)
5719 
    self._oprot.writeMessageEnd()
5720 
    self._oprot.trans.flush()
5721 
 
5722 
  def recv_getReceivePendingOrders(self, ):
5723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5724 
    if mtype == TMessageType.EXCEPTION:
5725 
      x = TApplicationException()
5726 
      x.read(self._iprot)
5727 
      self._iprot.readMessageEnd()
5728 
      raise x
5729 
    result = getReceivePendingOrders_result()
5730 
    result.read(self._iprot)
5731 
    self._iprot.readMessageEnd()
5732 
    if result.success is not None:
5733 
      return result.success
5734 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5735 
 
5736 
  def getReceivedAtStoreOrders(self, storeId):
5737 
    """
5738 
    Parameters:
5739 
     - storeId
5740 
    """
5741 
    self.send_getReceivedAtStoreOrders(storeId)
5742 
    return self.recv_getReceivedAtStoreOrders()
5743 
 
5744 
  def send_getReceivedAtStoreOrders(self, storeId):
5745 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5746 
    args = getReceivedAtStoreOrders_args()
5747 
    args.storeId = storeId
5748 
    args.write(self._oprot)
5749 
    self._oprot.writeMessageEnd()
5750 
    self._oprot.trans.flush()
5751 
 
5752 
  def recv_getReceivedAtStoreOrders(self, ):
5753 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5754 
    if mtype == TMessageType.EXCEPTION:
5755 
      x = TApplicationException()
5756 
      x.read(self._iprot)
5757 
      self._iprot.readMessageEnd()
5758 
      raise x
5759 
    result = getReceivedAtStoreOrders_result()
5760 
    result.read(self._iprot)
5761 
    self._iprot.readMessageEnd()
5762 
    if result.success is not None:
5763 
      return result.success
5764 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5765 
 
5713 rajveer 5766 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5767 
    """
5768 
    Parameters:
5769 
     - storeId
5770 
     - fromDate
5771 
     - toDate
5772 
     - onlyCod
5773 
    """
5774 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5775 
    return self.recv_getOrdersCollectionAtStore()
5776 
 
5777 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5778 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5779 
    args = getOrdersCollectionAtStore_args()
5780 
    args.storeId = storeId
5781 
    args.fromDate = fromDate
5782 
    args.toDate = toDate
5783 
    args.onlyCod = onlyCod
5784 
    args.write(self._oprot)
5785 
    self._oprot.writeMessageEnd()
5786 
    self._oprot.trans.flush()
5787 
 
5788 
  def recv_getOrdersCollectionAtStore(self, ):
5789 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5790 
    if mtype == TMessageType.EXCEPTION:
5791 
      x = TApplicationException()
5792 
      x.read(self._iprot)
5793 
      self._iprot.readMessageEnd()
5794 
      raise x
5795 
    result = getOrdersCollectionAtStore_result()
5796 
    result.read(self._iprot)
5797 
    self._iprot.readMessageEnd()
5798 
    if result.success is not None:
5799 
      return result.success
5800 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5801 
 
5833 rajveer 5802 
  def getOrderAttributeValue(self, orderId, attributeName):
5803 
    """
5804 
    Parameters:
5805 
     - orderId
5806 
     - attributeName
5807 
    """
5808 
    self.send_getOrderAttributeValue(orderId, attributeName)
5809 
    return self.recv_getOrderAttributeValue()
5810 
 
5811 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5812 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5813 
    args = getOrderAttributeValue_args()
5814 
    args.orderId = orderId
5815 
    args.attributeName = attributeName
5816 
    args.write(self._oprot)
5817 
    self._oprot.writeMessageEnd()
5818 
    self._oprot.trans.flush()
5819 
 
5820 
  def recv_getOrderAttributeValue(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 = getOrderAttributeValue_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, "getOrderAttributeValue failed: unknown result");
5833 
 
6019 rajveer 5834 
  def changeJacketNumber(self, orderId, jacketNumber):
5835 
    """
5836 
    Parameters:
5837 
     - orderId
5838 
     - jacketNumber
5839 
    """
5840 
    self.send_changeJacketNumber(orderId, jacketNumber)
5841 
    return self.recv_changeJacketNumber()
5842 
 
5843 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5844 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5845 
    args = changeJacketNumber_args()
5846 
    args.orderId = orderId
5847 
    args.jacketNumber = jacketNumber
5848 
    args.write(self._oprot)
5849 
    self._oprot.writeMessageEnd()
5850 
    self._oprot.trans.flush()
5851 
 
5852 
  def recv_changeJacketNumber(self, ):
5853 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5854 
    if mtype == TMessageType.EXCEPTION:
5855 
      x = TApplicationException()
5856 
      x.read(self._iprot)
5857 
      self._iprot.readMessageEnd()
5858 
      raise x
5859 
    result = changeJacketNumber_result()
5860 
    result.read(self._iprot)
5861 
    self._iprot.readMessageEnd()
5862 
    if result.success is not None:
5863 
      return result.success
5864 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5865 
 
5866 
  def markOrderAsRtoInTransit(self, orderId):
5867 
    """
5868 
    Parameters:
5869 
     - orderId
5870 
    """
5871 
    self.send_markOrderAsRtoInTransit(orderId)
5872 
    return self.recv_markOrderAsRtoInTransit()
5873 
 
5874 
  def send_markOrderAsRtoInTransit(self, orderId):
5875 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5876 
    args = markOrderAsRtoInTransit_args()
5877 
    args.orderId = orderId
5878 
    args.write(self._oprot)
5879 
    self._oprot.writeMessageEnd()
5880 
    self._oprot.trans.flush()
5881 
 
5882 
  def recv_markOrderAsRtoInTransit(self, ):
5883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5884 
    if mtype == TMessageType.EXCEPTION:
5885 
      x = TApplicationException()
5886 
      x.read(self._iprot)
5887 
      self._iprot.readMessageEnd()
5888 
      raise x
5889 
    result = markOrderAsRtoInTransit_result()
5890 
    result.read(self._iprot)
5891 
    self._iprot.readMessageEnd()
5892 
    if result.success is not None:
5893 
      return result.success
5894 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5895 
 
5593 mandeep.dh 5896 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5897 
    """
5898 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5899 
    invoked while scanning IN of items.
5553 rajveer 5900 
 
5593 mandeep.dh 5901 
    Parameters:
5902 
     - itemId
5903 
     - quantity
5904 
     - fulfilmentWarehouseId
5905 
     - billingWarehouseId
5906 
    """
5907 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5908 
    self.recv_acceptOrderForItem()
5909 
 
5910 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5911 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5912 
    args = acceptOrderForItem_args()
5913 
    args.itemId = itemId
5914 
    args.quantity = quantity
5915 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5916 
    args.billingWarehouseId = billingWarehouseId
5917 
    args.write(self._oprot)
5918 
    self._oprot.writeMessageEnd()
5919 
    self._oprot.trans.flush()
5920 
 
5921 
  def recv_acceptOrderForItem(self, ):
5922 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5923 
    if mtype == TMessageType.EXCEPTION:
5924 
      x = TApplicationException()
5925 
      x.read(self._iprot)
5926 
      self._iprot.readMessageEnd()
5927 
      raise x
5928 
    result = acceptOrderForItem_result()
5929 
    result.read(self._iprot)
5930 
    self._iprot.readMessageEnd()
5931 
    return
5932 
 
6000 mandeep.dh 5933 
  def createRechargeOrder(self, rechargeOrder):
5934 
    """
5935 
    Parameters:
5936 
     - rechargeOrder
5937 
    """
5938 
    self.send_createRechargeOrder(rechargeOrder)
5939 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5940 
 
6000 mandeep.dh 5941 
  def send_createRechargeOrder(self, rechargeOrder):
5942 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5943 
    args = createRechargeOrder_args()
5944 
    args.rechargeOrder = rechargeOrder
5945 
    args.write(self._oprot)
5946 
    self._oprot.writeMessageEnd()
5947 
    self._oprot.trans.flush()
5948 
 
5949 
  def recv_createRechargeOrder(self, ):
5950 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5951 
    if mtype == TMessageType.EXCEPTION:
5952 
      x = TApplicationException()
5953 
      x.read(self._iprot)
5954 
      self._iprot.readMessageEnd()
5955 
      raise x
5956 
    result = createRechargeOrder_result()
5957 
    result.read(self._iprot)
5958 
    self._iprot.readMessageEnd()
5959 
    if result.success is not None:
5960 
      return result.success
5961 
    if result.ex is not None:
5962 
      raise result.ex
5963 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5964 
 
6031 rajveer 5965 
  def getRechargeOrder(self, rechargeRrderId):
5966 
    """
5967 
    Parameters:
5968 
     - rechargeRrderId
5969 
    """
5970 
    self.send_getRechargeOrder(rechargeRrderId)
5971 
    return self.recv_getRechargeOrder()
5972 
 
5973 
  def send_getRechargeOrder(self, rechargeRrderId):
5974 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5975 
    args = getRechargeOrder_args()
5976 
    args.rechargeRrderId = rechargeRrderId
5977 
    args.write(self._oprot)
5978 
    self._oprot.writeMessageEnd()
5979 
    self._oprot.trans.flush()
5980 
 
5981 
  def recv_getRechargeOrder(self, ):
5982 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5983 
    if mtype == TMessageType.EXCEPTION:
5984 
      x = TApplicationException()
5985 
      x.read(self._iprot)
5986 
      self._iprot.readMessageEnd()
5987 
      raise x
5988 
    result = getRechargeOrder_result()
5989 
    result.read(self._iprot)
5990 
    self._iprot.readMessageEnd()
5991 
    if result.success is not None:
5992 
      return result.success
5993 
    if result.ex is not None:
5994 
      raise result.ex
5995 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
5996 
 
5997 
  def getRechargeOrders(self, userId):
5998 
    """
5999 
    Parameters:
6000 
     - userId
6001 
    """
6002 
    self.send_getRechargeOrders(userId)
6003 
    return self.recv_getRechargeOrders()
6004 
 
6005 
  def send_getRechargeOrders(self, userId):
6006 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
6007 
    args = getRechargeOrders_args()
6008 
    args.userId = userId
6009 
    args.write(self._oprot)
6010 
    self._oprot.writeMessageEnd()
6011 
    self._oprot.trans.flush()
6012 
 
6013 
  def recv_getRechargeOrders(self, ):
6014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6015 
    if mtype == TMessageType.EXCEPTION:
6016 
      x = TApplicationException()
6017 
      x.read(self._iprot)
6018 
      self._iprot.readMessageEnd()
6019 
      raise x
6020 
    result = getRechargeOrders_result()
6021 
    result.read(self._iprot)
6022 
    self._iprot.readMessageEnd()
6023 
    if result.success is not None:
6024 
      return result.success
6025 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
6026 
 
6000 mandeep.dh 6027 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6028 
    """
6029 
    Parameters:
6030 
     - rechargeOrderId
6031 
     - rechargeOrderStatus
6032 
    """
6033 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 6034 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 6035 
 
6036 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6037 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
6038 
    args = updateRechargeOrderStatus_args()
6039 
    args.rechargeOrderId = rechargeOrderId
6040 
    args.rechargeOrderStatus = rechargeOrderStatus
6041 
    args.write(self._oprot)
6042 
    self._oprot.writeMessageEnd()
6043 
    self._oprot.trans.flush()
6044 
 
6045 
  def recv_updateRechargeOrderStatus(self, ):
6046 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6047 
    if mtype == TMessageType.EXCEPTION:
6048 
      x = TApplicationException()
6049 
      x.read(self._iprot)
6050 
      self._iprot.readMessageEnd()
6051 
      raise x
6052 
    result = updateRechargeOrderStatus_result()
6053 
    result.read(self._iprot)
6054 
    self._iprot.readMessageEnd()
6031 rajveer 6055 
    if result.success is not None:
6056 
      return result.success
6000 mandeep.dh 6057 
    if result.ex is not None:
6058 
      raise result.ex
6031 rajveer 6059 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6060 
 
6031 rajveer 6061 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6062 
    """
6063 
    Parameters:
6031 rajveer 6064 
     - rechargeOrderId
6000 mandeep.dh 6065 
    """
6031 rajveer 6066 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6067 
    return self.recv_activateRechargeTxn()
6068 
 
6031 rajveer 6069 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6070 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6071 
    args = activateRechargeTxn_args()
6031 rajveer 6072 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6073 
    args.write(self._oprot)
6074 
    self._oprot.writeMessageEnd()
6075 
    self._oprot.trans.flush()
6076 
 
6077 
  def recv_activateRechargeTxn(self, ):
6078 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6079 
    if mtype == TMessageType.EXCEPTION:
6080 
      x = TApplicationException()
6081 
      x.read(self._iprot)
6082 
      self._iprot.readMessageEnd()
6083 
      raise x
6084 
    result = activateRechargeTxn_result()
6085 
    result.read(self._iprot)
6086 
    self._iprot.readMessageEnd()
6087 
    if result.success is not None:
6088 
      return result.success
6089 
    if result.ex is not None:
6090 
      raise result.ex
6091 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6092 
 
6031 rajveer 6093 
  def getUserWallet(self, userId):
6000 mandeep.dh 6094 
    """
6095 
    Parameters:
6031 rajveer 6096 
     - userId
6000 mandeep.dh 6097 
    """
6031 rajveer 6098 
    self.send_getUserWallet(userId)
6099 
    return self.recv_getUserWallet()
6000 mandeep.dh 6100 
 
6031 rajveer 6101 
  def send_getUserWallet(self, userId):
6102 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6103 
    args = getUserWallet_args()
6104 
    args.userId = userId
6000 mandeep.dh 6105 
    args.write(self._oprot)
6106 
    self._oprot.writeMessageEnd()
6107 
    self._oprot.trans.flush()
6108 
 
6031 rajveer 6109 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6110 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6111 
    if mtype == TMessageType.EXCEPTION:
6112 
      x = TApplicationException()
6113 
      x.read(self._iprot)
6114 
      self._iprot.readMessageEnd()
6115 
      raise x
6031 rajveer 6116 
    result = getUserWallet_result()
6000 mandeep.dh 6117 
    result.read(self._iprot)
6118 
    self._iprot.readMessageEnd()
6119 
    if result.success is not None:
6120 
      return result.success
6031 rajveer 6121 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6122 
 
6031 rajveer 6123 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6124 
    """
6125 
    Parameters:
6031 rajveer 6126 
     - userId
6000 mandeep.dh 6127 
    """
6031 rajveer 6128 
    self.send_getUserWalletHistory(userId)
6129 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6130 
 
6031 rajveer 6131 
  def send_getUserWalletHistory(self, userId):
6132 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6133 
    args = getUserWalletHistory_args()
6134 
    args.userId = userId
6000 mandeep.dh 6135 
    args.write(self._oprot)
6136 
    self._oprot.writeMessageEnd()
6137 
    self._oprot.trans.flush()
6138 
 
6031 rajveer 6139 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6141 
    if mtype == TMessageType.EXCEPTION:
6142 
      x = TApplicationException()
6143 
      x.read(self._iprot)
6144 
      self._iprot.readMessageEnd()
6145 
      raise x
6031 rajveer 6146 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6147 
    result.read(self._iprot)
6148 
    self._iprot.readMessageEnd()
6149 
    if result.success is not None:
6150 
      return result.success
6031 rajveer 6151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6152 
 
6050 anupam.sin 6153 
  def getRechargeOrdersForTransaction(self, txnId):
6154 
    """
6155 
    Returns a recharge order for a given transactionId
6156 
 
6157 
    Parameters:
6158 
     - txnId
6159 
    """
6160 
    self.send_getRechargeOrdersForTransaction(txnId)
6161 
    return self.recv_getRechargeOrdersForTransaction()
6162 
 
6163 
  def send_getRechargeOrdersForTransaction(self, txnId):
6164 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6165 
    args = getRechargeOrdersForTransaction_args()
6166 
    args.txnId = txnId
6167 
    args.write(self._oprot)
6168 
    self._oprot.writeMessageEnd()
6169 
    self._oprot.trans.flush()
6170 
 
6171 
  def recv_getRechargeOrdersForTransaction(self, ):
6172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6173 
    if mtype == TMessageType.EXCEPTION:
6174 
      x = TApplicationException()
6175 
      x.read(self._iprot)
6176 
      self._iprot.readMessageEnd()
6177 
      raise x
6178 
    result = getRechargeOrdersForTransaction_result()
6179 
    result.read(self._iprot)
6180 
    self._iprot.readMessageEnd()
6181 
    if result.success is not None:
6182 
      return result.success
6183 
    if result.ex is not None:
6184 
      raise result.ex
6185 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6186 
 
6206 rajveer 6187 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6188 
    """
6189 
    Parameters:
6190 
     - rechargeType
6206 rajveer 6191 
     - onlyActive
6048 rajveer 6192 
    """
6206 rajveer 6193 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6194 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6195 
 
6206 rajveer 6196 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6197 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6198 
    args = getServiceProviders_args()
6199 
    args.rechargeType = rechargeType
6206 rajveer 6200 
    args.onlyActive = onlyActive
6048 rajveer 6201 
    args.write(self._oprot)
6202 
    self._oprot.writeMessageEnd()
6203 
    self._oprot.trans.flush()
6204 
 
6205 
  def recv_getServiceProviders(self, ):
6206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6207 
    if mtype == TMessageType.EXCEPTION:
6208 
      x = TApplicationException()
6209 
      x.read(self._iprot)
6210 
      self._iprot.readMessageEnd()
6211 
      raise x
6212 
    result = getServiceProviders_result()
6213 
    result.read(self._iprot)
6214 
    self._iprot.readMessageEnd()
6215 
    if result.success is not None:
6216 
      return result.success
6217 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6218 
 
6049 rajveer 6219 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6220 
    """
6221 
    Parameters:
6049 rajveer 6222 
     - rechargeType
6048 rajveer 6223 
     - deviceNumber
6224 
    """
6049 rajveer 6225 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6226 
    return self.recv_getServiceProviderForDevice()
6227 
 
6049 rajveer 6228 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6229 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6230 
    args = getServiceProviderForDevice_args()
6049 rajveer 6231 
    args.rechargeType = rechargeType
6048 rajveer 6232 
    args.deviceNumber = deviceNumber
6233 
    args.write(self._oprot)
6234 
    self._oprot.writeMessageEnd()
6235 
    self._oprot.trans.flush()
6236 
 
6237 
  def recv_getServiceProviderForDevice(self, ):
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
6244 
    result = getServiceProviderForDevice_result()
6245 
    result.read(self._iprot)
6246 
    self._iprot.readMessageEnd()
6247 
    if result.success is not None:
6248 
      return result.success
6249 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6250 
 
6591 anupam.sin 6251 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6252 
    """
6253 
    Parameters:
6254 
     - rechargeType
6255 
     - deviceNumber
6307 anupam.sin 6256 
     - userSelectedProviderId
6591 anupam.sin 6257 
     - clientAddress
6269 rajveer 6258 
    """
6591 anupam.sin 6259 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId, clientAddress)
6269 rajveer 6260 
    return self.recv_validateRecharge()
6261 
 
6591 anupam.sin 6262 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6263 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6264 
    args = validateRecharge_args()
6265 
    args.rechargeType = rechargeType
6266 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6267 
    args.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 6268 
    args.clientAddress = clientAddress
6269 rajveer 6269 
    args.write(self._oprot)
6270 
    self._oprot.writeMessageEnd()
6271 
    self._oprot.trans.flush()
6272 
 
6273 
  def recv_validateRecharge(self, ):
6274 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6275 
    if mtype == TMessageType.EXCEPTION:
6276 
      x = TApplicationException()
6277 
      x.read(self._iprot)
6278 
      self._iprot.readMessageEnd()
6279 
      raise x
6280 
    result = validateRecharge_result()
6281 
    result.read(self._iprot)
6282 
    self._iprot.readMessageEnd()
6283 
    if result.success is not None:
6284 
      return result.success
6285 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6286 
 
6094 rajveer 6287 
  def getRechargeOrdersForDevice(self, deviceNumber):
6288 
    """
6289 
    Parameters:
6290 
     - deviceNumber
6291 
    """
6292 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6293 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6294 
 
6094 rajveer 6295 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6296 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6297 
    args = getRechargeOrdersForDevice_args()
6298 
    args.deviceNumber = deviceNumber
6299 
    args.write(self._oprot)
6300 
    self._oprot.writeMessageEnd()
6301 
    self._oprot.trans.flush()
6302 
 
6303 
  def recv_getRechargeOrdersForDevice(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 = getRechargeOrdersForDevice_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, "getRechargeOrdersForDevice failed: unknown result");
6316 
 
6317 
  def addAmountToWallet(self, userId, orderId, amount):
6318 
    """
6319 
    Parameters:
6320 
     - userId
6321 
     - orderId
6322 
     - amount
6323 
    """
6324 
    self.send_addAmountToWallet(userId, orderId, amount)
6325 
    self.recv_addAmountToWallet()
6326 
 
6327 
  def send_addAmountToWallet(self, userId, orderId, amount):
6328 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6329 
    args = addAmountToWallet_args()
6330 
    args.userId = userId
6331 
    args.orderId = orderId
6332 
    args.amount = amount
6333 
    args.write(self._oprot)
6334 
    self._oprot.writeMessageEnd()
6335 
    self._oprot.trans.flush()
6336 
 
6337 
  def recv_addAmountToWallet(self, ):
6338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6339 
    if mtype == TMessageType.EXCEPTION:
6340 
      x = TApplicationException()
6341 
      x.read(self._iprot)
6342 
      self._iprot.readMessageEnd()
6343 
      raise x
6344 
    result = addAmountToWallet_result()
6345 
    result.read(self._iprot)
6346 
    self._iprot.readMessageEnd()
6347 
    return
6348 
 
6188 rajveer 6349 
  def getRechargeStatistics(self, ):
6350 
    self.send_getRechargeStatistics()
6351 
    return self.recv_getRechargeStatistics()
6352 
 
6353 
  def send_getRechargeStatistics(self, ):
6354 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6355 
    args = getRechargeStatistics_args()
6356 
    args.write(self._oprot)
6357 
    self._oprot.writeMessageEnd()
6358 
    self._oprot.trans.flush()
6359 
 
6360 
  def recv_getRechargeStatistics(self, ):
6361 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6362 
    if mtype == TMessageType.EXCEPTION:
6363 
      x = TApplicationException()
6364 
      x.read(self._iprot)
6365 
      self._iprot.readMessageEnd()
6366 
      raise x
6367 
    result = getRechargeStatistics_result()
6368 
    result.read(self._iprot)
6369 
    self._iprot.readMessageEnd()
6370 
    if result.success is not None:
6371 
      return result.success
6372 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6373 
 
6154 rajveer 6374 
  def getRechargeOrdersForStatus(self, status):
6375 
    """
6376 
    Parameters:
6377 
     - status
6378 
    """
6379 
    self.send_getRechargeOrdersForStatus(status)
6380 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6381 
 
6154 rajveer 6382 
  def send_getRechargeOrdersForStatus(self, status):
6383 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6384 
    args = getRechargeOrdersForStatus_args()
6385 
    args.status = status
6386 
    args.write(self._oprot)
6387 
    self._oprot.writeMessageEnd()
6388 
    self._oprot.trans.flush()
6389 
 
6390 
  def recv_getRechargeOrdersForStatus(self, ):
6391 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6392 
    if mtype == TMessageType.EXCEPTION:
6393 
      x = TApplicationException()
6394 
      x.read(self._iprot)
6395 
      self._iprot.readMessageEnd()
6396 
      raise x
6397 
    result = getRechargeOrdersForStatus_result()
6398 
    result.read(self._iprot)
6399 
    self._iprot.readMessageEnd()
6400 
    if result.success is not None:
6401 
      return result.success
6402 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6403 
 
6159 rajveer 6404 
  def getPlansForOperator(self, operatorId):
6405 
    """
6406 
    Parameters:
6407 
     - operatorId
6408 
    """
6409 
    self.send_getPlansForOperator(operatorId)
6410 
    return self.recv_getPlansForOperator()
6154 rajveer 6411 
 
6159 rajveer 6412 
  def send_getPlansForOperator(self, operatorId):
6413 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6414 
    args = getPlansForOperator_args()
6415 
    args.operatorId = operatorId
6416 
    args.write(self._oprot)
6417 
    self._oprot.writeMessageEnd()
6418 
    self._oprot.trans.flush()
6419 
 
6420 
  def recv_getPlansForOperator(self, ):
6421 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6422 
    if mtype == TMessageType.EXCEPTION:
6423 
      x = TApplicationException()
6424 
      x.read(self._iprot)
6425 
      self._iprot.readMessageEnd()
6426 
      raise x
6427 
    result = getPlansForOperator_result()
6428 
    result.read(self._iprot)
6429 
    self._iprot.readMessageEnd()
6430 
    if result.success is not None:
6431 
      return result.success
6432 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6433 
 
6307 anupam.sin 6434 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6435 
    """
6436 
    Returns denominations for a given operator and circle
6159 rajveer 6437 
 
6289 anupam.sin 6438 
    Parameters:
6439 
     - operatorId
6307 anupam.sin 6440 
     - circleCode
6289 anupam.sin 6441 
     - denominationType
6442 
    """
6307 anupam.sin 6443 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6444 
    return self.recv_getRechargeDenominations()
6445 
 
6307 anupam.sin 6446 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6447 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6448 
    args = getRechargeDenominations_args()
6449 
    args.operatorId = operatorId
6307 anupam.sin 6450 
    args.circleCode = circleCode
6289 anupam.sin 6451 
    args.denominationType = denominationType
6452 
    args.write(self._oprot)
6453 
    self._oprot.writeMessageEnd()
6454 
    self._oprot.trans.flush()
6455 
 
6456 
  def recv_getRechargeDenominations(self, ):
6457 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6458 
    if mtype == TMessageType.EXCEPTION:
6459 
      x = TApplicationException()
6460 
      x.read(self._iprot)
6461 
      self._iprot.readMessageEnd()
6462 
      raise x
6463 
    result = getRechargeDenominations_result()
6464 
    result.read(self._iprot)
6465 
    self._iprot.readMessageEnd()
6466 
    if result.success is not None:
6467 
      return result.success
6468 
    if result.ex is not None:
6469 
      raise result.ex
6470 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6471 
 
6371 rajveer 6472 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6473 
    """
6474 
    Parameters:
6475 
     - operatorId
6476 
     - circleId
6477 
     - isAvailable
6478 
    """
6479 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6480 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6481 
 
6371 rajveer 6482 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6483 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6484 
    args = updateAvailabilityStatus_args()
6485 
    args.operatorId = operatorId
6486 
    args.circleId = circleId
6487 
    args.isAvailable = isAvailable
6488 
    args.write(self._oprot)
6489 
    self._oprot.writeMessageEnd()
6490 
    self._oprot.trans.flush()
6491 
 
6492 
  def recv_updateAvailabilityStatus(self, ):
6493 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6494 
    if mtype == TMessageType.EXCEPTION:
6495 
      x = TApplicationException()
6496 
      x.read(self._iprot)
6497 
      self._iprot.readMessageEnd()
6498 
      raise x
6499 
    result = updateAvailabilityStatus_result()
6500 
    result.read(self._iprot)
6501 
    self._iprot.readMessageEnd()
6502 
    return
6503 
 
6389 rajveer 6504 
  def getAvailableEmiSchemes(self, ):
6505 
    self.send_getAvailableEmiSchemes()
6506 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6507 
 
6389 rajveer 6508 
  def send_getAvailableEmiSchemes(self, ):
6509 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6510 
    args = getAvailableEmiSchemes_args()
6511 
    args.write(self._oprot)
6512 
    self._oprot.writeMessageEnd()
6513 
    self._oprot.trans.flush()
6514 
 
6515 
  def recv_getAvailableEmiSchemes(self, ):
6516 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6517 
    if mtype == TMessageType.EXCEPTION:
6518 
      x = TApplicationException()
6519 
      x.read(self._iprot)
6520 
      self._iprot.readMessageEnd()
6521 
      raise x
6522 
    result = getAvailableEmiSchemes_result()
6523 
    result.read(self._iprot)
6524 
    self._iprot.readMessageEnd()
6525 
    if result.success is not None:
6526 
      return result.success
6527 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6528 
 
6529 
  def getMiscCharges(self, transactionId):
6530 
    """
6531 
    Parameters:
6532 
     - transactionId
6533 
    """
6534 
    self.send_getMiscCharges(transactionId)
6535 
    return self.recv_getMiscCharges()
6536 
 
6537 
  def send_getMiscCharges(self, transactionId):
6538 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6539 
    args = getMiscCharges_args()
6540 
    args.transactionId = transactionId
6541 
    args.write(self._oprot)
6542 
    self._oprot.writeMessageEnd()
6543 
    self._oprot.trans.flush()
6544 
 
6545 
  def recv_getMiscCharges(self, ):
6546 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6547 
    if mtype == TMessageType.EXCEPTION:
6548 
      x = TApplicationException()
6549 
      x.read(self._iprot)
6550 
      self._iprot.readMessageEnd()
6551 
      raise x
6552 
    result = getMiscCharges_result()
6553 
    result.read(self._iprot)
6554 
    self._iprot.readMessageEnd()
6555 
    if result.success is not None:
6556 
      return result.success
6557 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6558 
 
6507 anupam.sin 6559 
  def refundRechargeOrder(self, rechargeOrderId):
6560 
    """
6561 
    Parameters:
6562 
     - rechargeOrderId
6563 
    """
6564 
    self.send_refundRechargeOrder(rechargeOrderId)
6565 
    return self.recv_refundRechargeOrder()
6389 rajveer 6566 
 
6507 anupam.sin 6567 
  def send_refundRechargeOrder(self, rechargeOrderId):
6568 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6569 
    args = refundRechargeOrder_args()
6570 
    args.rechargeOrderId = rechargeOrderId
6571 
    args.write(self._oprot)
6572 
    self._oprot.writeMessageEnd()
6573 
    self._oprot.trans.flush()
6574 
 
6575 
  def recv_refundRechargeOrder(self, ):
6576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6577 
    if mtype == TMessageType.EXCEPTION:
6578 
      x = TApplicationException()
6579 
      x.read(self._iprot)
6580 
      self._iprot.readMessageEnd()
6581 
      raise x
6582 
    result = refundRechargeOrder_result()
6583 
    result.read(self._iprot)
6584 
    self._iprot.readMessageEnd()
6585 
    if result.success is not None:
6586 
      return result.success
6587 
    if result.ex is not None:
6588 
      raise result.ex
6589 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6590 
 
6821 amar.kumar 6591 
  def getPhysicalOrders(self, fromDate, toDate):
6592 
    """
6593 
    Parameters:
6594 
     - fromDate
6595 
     - toDate
6596 
    """
6597 
    self.send_getPhysicalOrders(fromDate, toDate)
6598 
    return self.recv_getPhysicalOrders()
6507 anupam.sin 6599 
 
6821 amar.kumar 6600 
  def send_getPhysicalOrders(self, fromDate, toDate):
6601 
    self._oprot.writeMessageBegin('getPhysicalOrders', TMessageType.CALL, self._seqid)
6602 
    args = getPhysicalOrders_args()
6603 
    args.fromDate = fromDate
6604 
    args.toDate = toDate
6605 
    args.write(self._oprot)
6606 
    self._oprot.writeMessageEnd()
6607 
    self._oprot.trans.flush()
6608 
 
6609 
  def recv_getPhysicalOrders(self, ):
6610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6611 
    if mtype == TMessageType.EXCEPTION:
6612 
      x = TApplicationException()
6613 
      x.read(self._iprot)
6614 
      self._iprot.readMessageEnd()
6615 
      raise x
6616 
    result = getPhysicalOrders_result()
6617 
    result.read(self._iprot)
6618 
    self._iprot.readMessageEnd()
6619 
    if result.success is not None:
6620 
      return result.success
6621 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPhysicalOrders failed: unknown result");
6622 
 
6906 rajveer 6623 
  def getDocument(self, docType, docSource):
6624 
    """
6625 
    Parameters:
6626 
     - docType
6627 
     - docSource
6628 
    """
6629 
    self.send_getDocument(docType, docSource)
6630 
    return self.recv_getDocument()
6821 amar.kumar 6631 
 
6906 rajveer 6632 
  def send_getDocument(self, docType, docSource):
6633 
    self._oprot.writeMessageBegin('getDocument', TMessageType.CALL, self._seqid)
6634 
    args = getDocument_args()
6635 
    args.docType = docType
6636 
    args.docSource = docSource
6637 
    args.write(self._oprot)
6638 
    self._oprot.writeMessageEnd()
6639 
    self._oprot.trans.flush()
6640 
 
6641 
  def recv_getDocument(self, ):
6642 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6643 
    if mtype == TMessageType.EXCEPTION:
6644 
      x = TApplicationException()
6645 
      x.read(self._iprot)
6646 
      self._iprot.readMessageEnd()
6647 
      raise x
6648 
    result = getDocument_result()
6649 
    result.read(self._iprot)
6650 
    self._iprot.readMessageEnd()
6651 
    if result.success is not None:
6652 
      return result.success
6653 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDocument failed: unknown result");
6654 
 
6985 anupam.sin 6655 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6656 
    """
6657 
    Parameters:
6658 
     - orderId
6659 
     - line1
6660 
     - line2
6661 
     - city
6662 
     - state
6663 
     - pin
6664 
    """
6665 
    self.send_changeShippingAddress(orderId, line1, line2, city, state, pin)
6666 
    return self.recv_changeShippingAddress()
6906 rajveer 6667 
 
6985 anupam.sin 6668 
  def send_changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6669 
    self._oprot.writeMessageBegin('changeShippingAddress', TMessageType.CALL, self._seqid)
6670 
    args = changeShippingAddress_args()
6671 
    args.orderId = orderId
6672 
    args.line1 = line1
6673 
    args.line2 = line2
6674 
    args.city = city
6675 
    args.state = state
6676 
    args.pin = pin
6677 
    args.write(self._oprot)
6678 
    self._oprot.writeMessageEnd()
6679 
    self._oprot.trans.flush()
6680 
 
6681 
  def recv_changeShippingAddress(self, ):
6682 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6683 
    if mtype == TMessageType.EXCEPTION:
6684 
      x = TApplicationException()
6685 
      x.read(self._iprot)
6686 
      self._iprot.readMessageEnd()
6687 
      raise x
6688 
    result = changeShippingAddress_result()
6689 
    result.read(self._iprot)
6690 
    self._iprot.readMessageEnd()
6691 
    if result.success is not None:
6692 
      return result.success
6693 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeShippingAddress failed: unknown result");
6694 
 
6988 rajveer 6695 
  def retrieveInvoice(self, orderId):
6696 
    """
6697 
    Parameters:
6698 
     - orderId
6699 
    """
6700 
    self.send_retrieveInvoice(orderId)
6701 
    return self.recv_retrieveInvoice()
6985 anupam.sin 6702 
 
6988 rajveer 6703 
  def send_retrieveInvoice(self, orderId):
6704 
    self._oprot.writeMessageBegin('retrieveInvoice', TMessageType.CALL, self._seqid)
6705 
    args = retrieveInvoice_args()
6706 
    args.orderId = orderId
6707 
    args.write(self._oprot)
6708 
    self._oprot.writeMessageEnd()
6709 
    self._oprot.trans.flush()
6710 
 
6711 
  def recv_retrieveInvoice(self, ):
6712 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6713 
    if mtype == TMessageType.EXCEPTION:
6714 
      x = TApplicationException()
6715 
      x.read(self._iprot)
6716 
      self._iprot.readMessageEnd()
6717 
      raise x
6718 
    result = retrieveInvoice_result()
6719 
    result.read(self._iprot)
6720 
    self._iprot.readMessageEnd()
6721 
    if result.success is not None:
6722 
      return result.success
6723 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "retrieveInvoice failed: unknown result");
6724 
 
7026 rajveer 6725 
  def receiveUpdatesForRedExpress(self, awbNumber):
6726 
    """
6727 
    Parameters:
6728 
     - awbNumber
6729 
    """
6730 
    self.send_receiveUpdatesForRedExpress(awbNumber)
6731 
    return self.recv_receiveUpdatesForRedExpress()
6988 rajveer 6732 
 
7026 rajveer 6733 
  def send_receiveUpdatesForRedExpress(self, awbNumber):
6734 
    self._oprot.writeMessageBegin('receiveUpdatesForRedExpress', TMessageType.CALL, self._seqid)
6735 
    args = receiveUpdatesForRedExpress_args()
6736 
    args.awbNumber = awbNumber
6737 
    args.write(self._oprot)
6738 
    self._oprot.writeMessageEnd()
6739 
    self._oprot.trans.flush()
6740 
 
6741 
  def recv_receiveUpdatesForRedExpress(self, ):
6742 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6743 
    if mtype == TMessageType.EXCEPTION:
6744 
      x = TApplicationException()
6745 
      x.read(self._iprot)
6746 
      self._iprot.readMessageEnd()
6747 
      raise x
6748 
    result = receiveUpdatesForRedExpress_result()
6749 
    result.read(self._iprot)
6750 
    self._iprot.readMessageEnd()
6751 
    if result.success is not None:
6752 
      return result.success
6753 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveUpdatesForRedExpress failed: unknown result");
6754 
 
6755 
 
3376 rajveer 6756 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6757 
  def __init__(self, handler):
3376 rajveer 6758 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6759 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6760 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6761 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6762 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6763 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6764 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6765 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6766 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6767 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6768 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6769 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6770 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6771 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6772 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6773 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6774 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6775 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6776 
    self._processMap["createOrder"] = Processor.process_createOrder
6777 
    self._processMap["getOrder"] = Processor.process_getOrder
6778 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6779 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6780 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6781 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6782 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6783 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6784 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6785 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6786 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6787 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6788 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6789 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6790 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6791 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6792 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6793 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6794 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6795 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6796 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6797 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6798 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6799 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6800 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6801 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6802 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6803 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6804 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6805 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6806 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6807 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6808 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6809 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6810 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6811 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6812 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6813 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6814 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6815 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6816 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6817 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6818 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6819 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6820 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6821 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6822 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6823 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6824 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6825 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6826 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6827 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6828 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6829 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6830 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6831 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6832 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6833 
    self._processMap["changeItem"] = Processor.process_changeItem
6834 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6835 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6836 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6837 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6838 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6839 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6840 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6841 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6842 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6843 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6844 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6845 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6846 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6847 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6848 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6849 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6850 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6851 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6852 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6853 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6854 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6855 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6856 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6857 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6858 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6859 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6860 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6861 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6862 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6863 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6864 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6865 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6866 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6867 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6868 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6869 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6870 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6871 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6872 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6873 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6874 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6875 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6876 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6877 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6878 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6879 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6880 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6881 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6882 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6883 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6884 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6885 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6886 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6887 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6888 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6889 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6890 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6891 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6892 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 6893 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 6894 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6895 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 6896 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 6897 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
6898 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 6899 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 6900 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 6901 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 6902 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 6903 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 6904 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
6905 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 6906 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
6821 amar.kumar 6907 
    self._processMap["getPhysicalOrders"] = Processor.process_getPhysicalOrders
6906 rajveer 6908 
    self._processMap["getDocument"] = Processor.process_getDocument
6985 anupam.sin 6909 
    self._processMap["changeShippingAddress"] = Processor.process_changeShippingAddress
6988 rajveer 6910 
    self._processMap["retrieveInvoice"] = Processor.process_retrieveInvoice
7026 rajveer 6911 
    self._processMap["receiveUpdatesForRedExpress"] = Processor.process_receiveUpdatesForRedExpress
94 ashish 6912 
 
6913 
  def process(self, iprot, oprot):
6914 
    (name, type, seqid) = iprot.readMessageBegin()
6915 
    if name not in self._processMap:
6916 
      iprot.skip(TType.STRUCT)
6917 
      iprot.readMessageEnd()
6918 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6919 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6920 
      x.write(oprot)
6921 
      oprot.writeMessageEnd()
6922 
      oprot.trans.flush()
6923 
      return
6924 
    else:
6925 
      self._processMap[name](self, seqid, iprot, oprot)
6926 
    return True
6927 
 
6928 
  def process_createTransaction(self, seqid, iprot, oprot):
6929 
    args = createTransaction_args()
6930 
    args.read(iprot)
6931 
    iprot.readMessageEnd()
6932 
    result = createTransaction_result()
6933 
    try:
132 ashish 6934 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6935 
    except TransactionServiceException, ex:
6936 
      result.ex = ex
6937 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6938 
    result.write(oprot)
6939 
    oprot.writeMessageEnd()
6940 
    oprot.trans.flush()
6941 
 
6942 
  def process_getTransaction(self, seqid, iprot, oprot):
6943 
    args = getTransaction_args()
6944 
    args.read(iprot)
6945 
    iprot.readMessageEnd()
6946 
    result = getTransaction_result()
6947 
    try:
6948 
      result.success = self._handler.getTransaction(args.id)
6949 
    except TransactionServiceException, ex:
6950 
      result.ex = ex
6951 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6952 
    result.write(oprot)
6953 
    oprot.writeMessageEnd()
6954 
    oprot.trans.flush()
6955 
 
6956 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6957 
    args = getTransactionsForCustomer_args()
6958 
    args.read(iprot)
6959 
    iprot.readMessageEnd()
6960 
    result = getTransactionsForCustomer_result()
6961 
    try:
6962 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6963 
    except TransactionServiceException, ex:
6964 
      result.ex = ex
6965 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6966 
    result.write(oprot)
6967 
    oprot.writeMessageEnd()
6968 
    oprot.trans.flush()
6969 
 
132 ashish 6970 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6971 
    args = getTransactionsForShoppingCartId_args()
6972 
    args.read(iprot)
6973 
    iprot.readMessageEnd()
6974 
    result = getTransactionsForShoppingCartId_result()
6975 
    try:
6976 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6977 
    except TransactionServiceException, ex:
6978 
      result.ex = ex
6979 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6980 
    result.write(oprot)
6981 
    oprot.writeMessageEnd()
6982 
    oprot.trans.flush()
6983 
 
94 ashish 6984 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6985 
    args = getTransactionStatus_args()
6986 
    args.read(iprot)
6987 
    iprot.readMessageEnd()
6988 
    result = getTransactionStatus_result()
6989 
    try:
6990 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6991 
    except TransactionServiceException, ex:
6992 
      result.ex = ex
6993 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6994 
    result.write(oprot)
6995 
    oprot.writeMessageEnd()
6996 
    oprot.trans.flush()
6997 
 
6998 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6999 
    args = changeTransactionStatus_args()
7000 
    args.read(iprot)
7001 
    iprot.readMessageEnd()
7002 
    result = changeTransactionStatus_result()
7003 
    try:
5527 anupam.sin 7004 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 7005 
    except TransactionServiceException, ex:
7006 
      result.ex = ex
7007 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
7008 
    result.write(oprot)
7009 
    oprot.writeMessageEnd()
7010 
    oprot.trans.flush()
7011 
 
1398 varun.gupt 7012 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
7013 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 7014 
    args.read(iprot)
7015 
    iprot.readMessageEnd()
1398 varun.gupt 7016 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 7017 
    try:
1398 varun.gupt 7018 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 7019 
    except TransactionServiceException, ex:
7020 
      result.ex = ex
1398 varun.gupt 7021 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 7022 
    result.write(oprot)
7023 
    oprot.writeMessageEnd()
7024 
    oprot.trans.flush()
7025 
 
483 rajveer 7026 
  def process_getAllOrders(self, seqid, iprot, oprot):
7027 
    args = getAllOrders_args()
94 ashish 7028 
    args.read(iprot)
7029 
    iprot.readMessageEnd()
483 rajveer 7030 
    result = getAllOrders_result()
94 ashish 7031 
    try:
4801 anupam.sin 7032 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 7033 
    except TransactionServiceException, ex:
7034 
      result.ex = ex
483 rajveer 7035 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 7036 
    result.write(oprot)
7037 
    oprot.writeMessageEnd()
7038 
    oprot.trans.flush()
7039 
 
4133 chandransh 7040 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
7041 
    args = getOrdersInBatch_args()
7042 
    args.read(iprot)
7043 
    iprot.readMessageEnd()
7044 
    result = getOrdersInBatch_result()
7045 
    try:
7046 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
7047 
    except TransactionServiceException, ex:
7048 
      result.ex = ex
7049 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
7050 
    result.write(oprot)
7051 
    oprot.writeMessageEnd()
7052 
    oprot.trans.flush()
7053 
 
7054 
  def process_getOrderCount(self, seqid, iprot, oprot):
7055 
    args = getOrderCount_args()
7056 
    args.read(iprot)
7057 
    iprot.readMessageEnd()
7058 
    result = getOrderCount_result()
7059 
    try:
7060 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
7061 
    except TransactionServiceException, ex:
7062 
      result.ex = ex
7063 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
7064 
    result.write(oprot)
7065 
    oprot.writeMessageEnd()
7066 
    oprot.trans.flush()
7067 
 
999 varun.gupt 7068 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
7069 
    args = getOrdersByBillingDate_args()
7070 
    args.read(iprot)
7071 
    iprot.readMessageEnd()
7072 
    result = getOrdersByBillingDate_result()
7073 
    try:
7074 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
7075 
    except TransactionServiceException, ex:
7076 
      result.ex = ex
7077 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
7078 
    result.write(oprot)
7079 
    oprot.writeMessageEnd()
7080 
    oprot.trans.flush()
7081 
 
3427 chandransh 7082 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
7083 
    args = getOrdersByShippingDate_args()
7084 
    args.read(iprot)
7085 
    iprot.readMessageEnd()
7086 
    result = getOrdersByShippingDate_result()
7087 
    try:
3451 chandransh 7088 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 7089 
    except TransactionServiceException, ex:
7090 
      result.ex = ex
7091 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
7092 
    result.write(oprot)
7093 
    oprot.writeMessageEnd()
7094 
    oprot.trans.flush()
7095 
 
1382 varun.gupt 7096 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
7097 
    args = getReturnableOrdersForCustomer_args()
7098 
    args.read(iprot)
7099 
    iprot.readMessageEnd()
7100 
    result = getReturnableOrdersForCustomer_result()
7101 
    try:
7102 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
7103 
    except TransactionServiceException, ex:
7104 
      result.ex = ex
7105 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
7106 
    result.write(oprot)
7107 
    oprot.writeMessageEnd()
7108 
    oprot.trans.flush()
7109 
 
7110 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
7111 
    args = getCancellableOrdersForCustomer_args()
7112 
    args.read(iprot)
7113 
    iprot.readMessageEnd()
7114 
    result = getCancellableOrdersForCustomer_result()
7115 
    try:
7116 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
7117 
    except TransactionServiceException, ex:
7118 
      result.ex = ex
7119 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
7120 
    result.write(oprot)
7121 
    oprot.writeMessageEnd()
7122 
    oprot.trans.flush()
7123 
 
483 rajveer 7124 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
7125 
    args = changeOrderStatus_args()
94 ashish 7126 
    args.read(iprot)
7127 
    iprot.readMessageEnd()
483 rajveer 7128 
    result = changeOrderStatus_result()
94 ashish 7129 
    try:
483 rajveer 7130 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 7131 
    except TransactionServiceException, ex:
7132 
      result.ex = ex
483 rajveer 7133 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 7134 
    result.write(oprot)
7135 
    oprot.writeMessageEnd()
7136 
    oprot.trans.flush()
7137 
 
483 rajveer 7138 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
7139 
    args = getOrdersForTransaction_args()
94 ashish 7140 
    args.read(iprot)
7141 
    iprot.readMessageEnd()
483 rajveer 7142 
    result = getOrdersForTransaction_result()
94 ashish 7143 
    try:
1528 ankur.sing 7144 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 7145 
    except TransactionServiceException, ex:
7146 
      result.ex = ex
483 rajveer 7147 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 7148 
    result.write(oprot)
7149 
    oprot.writeMessageEnd()
7150 
    oprot.trans.flush()
7151 
 
483 rajveer 7152 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
7153 
    args = getOrdersForCustomer_args()
94 ashish 7154 
    args.read(iprot)
7155 
    iprot.readMessageEnd()
483 rajveer 7156 
    result = getOrdersForCustomer_result()
94 ashish 7157 
    try:
3014 chandransh 7158 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 7159 
    except TransactionServiceException, ex:
7160 
      result.ex = ex
483 rajveer 7161 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 7162 
    result.write(oprot)
7163 
    oprot.writeMessageEnd()
7164 
    oprot.trans.flush()
7165 
 
483 rajveer 7166 
  def process_createOrder(self, seqid, iprot, oprot):
7167 
    args = createOrder_args()
94 ashish 7168 
    args.read(iprot)
7169 
    iprot.readMessageEnd()
483 rajveer 7170 
    result = createOrder_result()
94 ashish 7171 
    try:
483 rajveer 7172 
      result.success = self._handler.createOrder(args.order)
94 ashish 7173 
    except TransactionServiceException, ex:
7174 
      result.ex = ex
483 rajveer 7175 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 7176 
    result.write(oprot)
7177 
    oprot.writeMessageEnd()
7178 
    oprot.trans.flush()
7179 
 
483 rajveer 7180 
  def process_getOrder(self, seqid, iprot, oprot):
7181 
    args = getOrder_args()
94 ashish 7182 
    args.read(iprot)
7183 
    iprot.readMessageEnd()
483 rajveer 7184 
    result = getOrder_result()
94 ashish 7185 
    try:
483 rajveer 7186 
      result.success = self._handler.getOrder(args.id)
94 ashish 7187 
    except TransactionServiceException, ex:
7188 
      result.ex = ex
483 rajveer 7189 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 7190 
    result.write(oprot)
7191 
    oprot.writeMessageEnd()
7192 
    oprot.trans.flush()
7193 
 
483 rajveer 7194 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
7195 
    args = getLineItemsForOrder_args()
94 ashish 7196 
    args.read(iprot)
7197 
    iprot.readMessageEnd()
483 rajveer 7198 
    result = getLineItemsForOrder_result()
94 ashish 7199 
    try:
483 rajveer 7200 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 7201 
    except TransactionServiceException, ex:
7202 
      result.ex = ex
483 rajveer 7203 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 7204 
    result.write(oprot)
7205 
    oprot.writeMessageEnd()
7206 
    oprot.trans.flush()
7207 
 
4999 phani.kuma 7208 
  def process_getOrderList(self, seqid, iprot, oprot):
7209 
    args = getOrderList_args()
7210 
    args.read(iprot)
7211 
    iprot.readMessageEnd()
7212 
    result = getOrderList_result()
7213 
    result.success = self._handler.getOrderList(args.order_ids)
7214 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
7215 
    result.write(oprot)
7216 
    oprot.writeMessageEnd()
7217 
    oprot.trans.flush()
7218 
 
5386 phani.kuma 7219 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
7220 
    args = getOrderListForVendor_args()
7221 
    args.read(iprot)
7222 
    iprot.readMessageEnd()
7223 
    result = getOrderListForVendor_result()
7224 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
7225 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
7226 
    result.write(oprot)
7227 
    oprot.writeMessageEnd()
7228 
    oprot.trans.flush()
7229 
 
1528 ankur.sing 7230 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
7231 
    args = getOrderForCustomer_args()
7232 
    args.read(iprot)
7233 
    iprot.readMessageEnd()
7234 
    result = getOrderForCustomer_result()
7235 
    try:
7236 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
7237 
    except TransactionServiceException, ex:
7238 
      result.ex = ex
7239 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
7240 
    result.write(oprot)
7241 
    oprot.writeMessageEnd()
7242 
    oprot.trans.flush()
7243 
 
3064 chandransh 7244 
  def process_getAlerts(self, seqid, iprot, oprot):
7245 
    args = getAlerts_args()
7246 
    args.read(iprot)
7247 
    iprot.readMessageEnd()
7248 
    result = getAlerts_result()
4444 rajveer 7249 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 7250 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
7251 
    result.write(oprot)
7252 
    oprot.writeMessageEnd()
7253 
    oprot.trans.flush()
7254 
 
4394 rajveer 7255 
  def process_addAlert(self, seqid, iprot, oprot):
7256 
    args = addAlert_args()
3064 chandransh 7257 
    args.read(iprot)
7258 
    iprot.readMessageEnd()
4394 rajveer 7259 
    result = addAlert_result()
4444 rajveer 7260 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 7261 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 7262 
    result.write(oprot)
7263 
    oprot.writeMessageEnd()
7264 
    oprot.trans.flush()
7265 
 
4444 rajveer 7266 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
7267 
    args = markAlertsAsSeen_args()
7268 
    args.read(iprot)
7269 
    iprot.readMessageEnd()
7270 
    result = markAlertsAsSeen_result()
7271 
    self._handler.markAlertsAsSeen(args.warehouseId)
7272 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
7273 
    result.write(oprot)
7274 
    oprot.writeMessageEnd()
7275 
    oprot.trans.flush()
7276 
 
3064 chandransh 7277 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
7278 
    args = getValidOrderCount_args()
7279 
    args.read(iprot)
7280 
    iprot.readMessageEnd()
7281 
    result = getValidOrderCount_result()
7282 
    result.success = self._handler.getValidOrderCount()
7283 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
7284 
    result.write(oprot)
7285 
    oprot.writeMessageEnd()
7286 
    oprot.trans.flush()
7287 
 
7288 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
7289 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
7290 
    args.read(iprot)
7291 
    iprot.readMessageEnd()
7292 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
7293 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
7294 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
7295 
    result.write(oprot)
7296 
    oprot.writeMessageEnd()
7297 
    oprot.trans.flush()
7298 
 
7299 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
7300 
    args = getValidOrdersAmountRange_args()
7301 
    args.read(iprot)
7302 
    iprot.readMessageEnd()
7303 
    result = getValidOrdersAmountRange_result()
7304 
    result.success = self._handler.getValidOrdersAmountRange()
7305 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
7306 
    result.write(oprot)
7307 
    oprot.writeMessageEnd()
7308 
    oprot.trans.flush()
7309 
 
7310 
  def process_getValidOrders(self, seqid, iprot, oprot):
7311 
    args = getValidOrders_args()
7312 
    args.read(iprot)
7313 
    iprot.readMessageEnd()
7314 
    result = getValidOrders_result()
5874 rajveer 7315 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 7316 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
7317 
    result.write(oprot)
7318 
    oprot.writeMessageEnd()
7319 
    oprot.trans.flush()
7320 
 
1220 chandransh 7321 
  def process_batchOrders(self, seqid, iprot, oprot):
7322 
    args = batchOrders_args()
7323 
    args.read(iprot)
7324 
    iprot.readMessageEnd()
7325 
    result = batchOrders_result()
7326 
    try:
7327 
      result.success = self._handler.batchOrders(args.warehouseId)
7328 
    except TransactionServiceException, ex:
7329 
      result.ex = ex
7330 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
7331 
    result.write(oprot)
7332 
    oprot.writeMessageEnd()
7333 
    oprot.trans.flush()
7334 
 
1208 chandransh 7335 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
7336 
    args = markOrderAsOutOfStock_args()
7337 
    args.read(iprot)
7338 
    iprot.readMessageEnd()
7339 
    result = markOrderAsOutOfStock_result()
7340 
    try:
7341 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
7342 
    except TransactionServiceException, ex:
7343 
      result.ex = ex
7344 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
7345 
    result.write(oprot)
7346 
    oprot.writeMessageEnd()
7347 
    oprot.trans.flush()
7348 
 
3064 chandransh 7349 
  def process_verifyOrder(self, seqid, iprot, oprot):
7350 
    args = verifyOrder_args()
759 chandransh 7351 
    args.read(iprot)
7352 
    iprot.readMessageEnd()
3064 chandransh 7353 
    result = verifyOrder_result()
759 chandransh 7354 
    try:
3064 chandransh 7355 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 7356 
    except TransactionServiceException, ex:
7357 
      result.ex = ex
3064 chandransh 7358 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 7359 
    result.write(oprot)
7360 
    oprot.writeMessageEnd()
7361 
    oprot.trans.flush()
7362 
 
3064 chandransh 7363 
  def process_acceptOrder(self, seqid, iprot, oprot):
7364 
    args = acceptOrder_args()
1113 chandransh 7365 
    args.read(iprot)
7366 
    iprot.readMessageEnd()
3064 chandransh 7367 
    result = acceptOrder_result()
1113 chandransh 7368 
    try:
3064 chandransh 7369 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7370 
    except TransactionServiceException, ex:
7371 
      result.ex = ex
3064 chandransh 7372 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7373 
    result.write(oprot)
7374 
    oprot.writeMessageEnd()
7375 
    oprot.trans.flush()
7376 
 
3064 chandransh 7377 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7378 
    args = addBillingDetails_args()
1135 chandransh 7379 
    args.read(iprot)
7380 
    iprot.readMessageEnd()
3064 chandransh 7381 
    result = addBillingDetails_result()
1135 chandransh 7382 
    try:
5110 mandeep.dh 7383 
      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.serialNumber, args.itemNumber, args.billed_by, args.jacketNumber, args.billingType, args.fulfilmentWarehouseId, args.authorize)
1135 chandransh 7384 
    except TransactionServiceException, ex:
7385 
      result.ex = ex
3064 chandransh 7386 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7387 
    result.write(oprot)
7388 
    oprot.writeMessageEnd()
7389 
    oprot.trans.flush()
7390 
 
4579 rajveer 7391 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7392 
    args = addInvoiceNumber_args()
7393 
    args.read(iprot)
7394 
    iprot.readMessageEnd()
7395 
    result = addInvoiceNumber_result()
7396 
    try:
6756 amar.kumar 7397 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color, args.serialNumber, args.itemNumber)
4579 rajveer 7398 
    except TransactionServiceException, ex:
7399 
      result.ex = ex
7400 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7401 
    result.write(oprot)
7402 
    oprot.writeMessageEnd()
7403 
    oprot.trans.flush()
7404 
 
4410 rajveer 7405 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7406 
    args = markOrdersAsShippedFromWarehouse_args()
7407 
    args.read(iprot)
7408 
    iprot.readMessageEnd()
7409 
    result = markOrdersAsShippedFromWarehouse_result()
7410 
    try:
4789 rajveer 7411 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7412 
    except TransactionServiceException, ex:
7413 
      result.ex = ex
7414 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7415 
    result.write(oprot)
7416 
    oprot.writeMessageEnd()
7417 
    oprot.trans.flush()
7418 
 
5676 rajveer 7419 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7420 
    args = markOrdersAsReturnedFromStore_args()
7421 
    args.read(iprot)
7422 
    iprot.readMessageEnd()
7423 
    result = markOrdersAsReturnedFromStore_result()
7424 
    try:
5713 rajveer 7425 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7426 
    except TransactionServiceException, ex:
7427 
      result.ex = ex
7428 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7429 
    result.write(oprot)
7430 
    oprot.writeMessageEnd()
7431 
    oprot.trans.flush()
7432 
 
3064 chandransh 7433 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7434 
    args = markOrdersAsPickedUp_args()
304 ashish 7435 
    args.read(iprot)
7436 
    iprot.readMessageEnd()
3064 chandransh 7437 
    result = markOrdersAsPickedUp_result()
7438 
    try:
4910 phani.kuma 7439 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7440 
    except TransactionServiceException, ex:
7441 
      result.ex = ex
7442 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7443 
    result.write(oprot)
7444 
    oprot.writeMessageEnd()
7445 
    oprot.trans.flush()
94 ashish 7446 
 
4910 phani.kuma 7447 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7448 
    args = getOrdersNotPickedUp_args()
7449 
    args.read(iprot)
7450 
    iprot.readMessageEnd()
7451 
    result = getOrdersNotPickedUp_result()
7452 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7453 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7454 
    result.write(oprot)
7455 
    oprot.writeMessageEnd()
7456 
    oprot.trans.flush()
7457 
 
3064 chandransh 7458 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7459 
    args = markOrdersAsDelivered_args()
304 ashish 7460 
    args.read(iprot)
7461 
    iprot.readMessageEnd()
3064 chandransh 7462 
    result = markOrdersAsDelivered_result()
7463 
    try:
7464 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7465 
    except TransactionServiceException, ex:
7466 
      result.ex = ex
7467 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7468 
    result.write(oprot)
7469 
    oprot.writeMessageEnd()
7470 
    oprot.trans.flush()
7471 
 
4910 phani.kuma 7472 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7473 
    args = markAsRTOrders_args()
1596 ankur.sing 7474 
    args.read(iprot)
7475 
    iprot.readMessageEnd()
4910 phani.kuma 7476 
    result = markAsRTOrders_result()
3064 chandransh 7477 
    try:
4910 phani.kuma 7478 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7479 
    except TransactionServiceException, ex:
7480 
      result.ex = ex
4910 phani.kuma 7481 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7482 
    result.write(oprot)
7483 
    oprot.writeMessageEnd()
7484 
    oprot.trans.flush()
304 ashish 7485 
 
4910 phani.kuma 7486 
  def process_getRTOrders(self, seqid, iprot, oprot):
7487 
    args = getRTOrders_args()
7488 
    args.read(iprot)
7489 
    iprot.readMessageEnd()
7490 
    result = getRTOrders_result()
7491 
    result.success = self._handler.getRTOrders(args.providerId)
7492 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7493 
    result.write(oprot)
7494 
    oprot.writeMessageEnd()
7495 
    oprot.trans.flush()
7496 
 
3064 chandransh 7497 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7498 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7499 
    args.read(iprot)
7500 
    iprot.readMessageEnd()
3064 chandransh 7501 
    result = updateNonDeliveryReason_result()
7502 
    try:
4910 phani.kuma 7503 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7504 
    except TransactionServiceException, ex:
7505 
      result.ex = ex
7506 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7507 
    result.write(oprot)
7508 
    oprot.writeMessageEnd()
7509 
    oprot.trans.flush()
1596 ankur.sing 7510 
 
4910 phani.kuma 7511 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7512 
    args = getNonDeliveredOrdersbyCourier_args()
7513 
    args.read(iprot)
7514 
    iprot.readMessageEnd()
7515 
    result = getNonDeliveredOrdersbyCourier_result()
7516 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7517 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7518 
    result.write(oprot)
7519 
    oprot.writeMessageEnd()
7520 
    oprot.trans.flush()
7521 
 
7522 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7523 
    args = markOrdersAsLocalConnected_args()
7524 
    args.read(iprot)
7525 
    iprot.readMessageEnd()
7526 
    result = markOrdersAsLocalConnected_result()
7527 
    try:
7528 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7529 
    except TransactionServiceException, ex:
7530 
      result.ex = ex
7531 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7532 
    result.write(oprot)
7533 
    oprot.writeMessageEnd()
7534 
    oprot.trans.flush()
7535 
 
7536 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7537 
    args = getOrdersNotLocalConnected_args()
7538 
    args.read(iprot)
7539 
    iprot.readMessageEnd()
7540 
    result = getOrdersNotLocalConnected_result()
7541 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7542 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7543 
    result.write(oprot)
7544 
    oprot.writeMessageEnd()
7545 
    oprot.trans.flush()
7546 
 
7547 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7548 
    args = markOrdersAsDestinationCityReached_args()
7549 
    args.read(iprot)
7550 
    iprot.readMessageEnd()
7551 
    result = markOrdersAsDestinationCityReached_result()
7552 
    try:
7553 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7554 
    except TransactionServiceException, ex:
7555 
      result.ex = ex
7556 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7557 
    result.write(oprot)
7558 
    oprot.writeMessageEnd()
7559 
    oprot.trans.flush()
7560 
 
7561 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7562 
    args = markOrdersAsFirstDeliveryAttempted_args()
7563 
    args.read(iprot)
7564 
    iprot.readMessageEnd()
7565 
    result = markOrdersAsFirstDeliveryAttempted_result()
7566 
    try:
7567 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7568 
    except TransactionServiceException, ex:
7569 
      result.ex = ex
7570 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7571 
    result.write(oprot)
7572 
    oprot.writeMessageEnd()
7573 
    oprot.trans.flush()
7574 
 
3064 chandransh 7575 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7576 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7577 
    args.read(iprot)
7578 
    iprot.readMessageEnd()
3064 chandransh 7579 
    result = getUndeliveredOrders_result()
7580 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7581 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7582 
    result.write(oprot)
7583 
    oprot.writeMessageEnd()
7584 
    oprot.trans.flush()
7585 
 
4783 phani.kuma 7586 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7587 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7588 
    args.read(iprot)
7589 
    iprot.readMessageEnd()
7590 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7591 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7592 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7593 
    result.write(oprot)
7594 
    oprot.writeMessageEnd()
7595 
    oprot.trans.flush()
7596 
 
2536 chandransh 7597 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7598 
    args = toggleDOAFlag_args()
7599 
    args.read(iprot)
7600 
    iprot.readMessageEnd()
7601 
    result = toggleDOAFlag_result()
7602 
    try:
7603 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7604 
    except TransactionServiceException, ex:
7605 
      result.ex = ex
7606 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7607 
    result.write(oprot)
7608 
    oprot.writeMessageEnd()
7609 
    oprot.trans.flush()
1886 ankur.sing 7610 
 
4712 rajveer 7611 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7612 
    args = markOrderAsDelivered_args()
7613 
    args.read(iprot)
7614 
    iprot.readMessageEnd()
7615 
    result = markOrderAsDelivered_result()
7616 
    try:
7617 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7618 
    except TransactionServiceException, ex:
7619 
      result.ex = ex
7620 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7621 
    result.write(oprot)
7622 
    oprot.writeMessageEnd()
7623 
    oprot.trans.flush()
7624 
 
5553 rajveer 7625 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7626 
    args = markOrderAsReceivedAtStore_args()
7627 
    args.read(iprot)
7628 
    iprot.readMessageEnd()
7629 
    result = markOrderAsReceivedAtStore_result()
7630 
    try:
7631 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7632 
    except TransactionServiceException, ex:
7633 
      result.ex = ex
7634 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7635 
    result.write(oprot)
7636 
    oprot.writeMessageEnd()
7637 
    oprot.trans.flush()
7638 
 
4454 rajveer 7639 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7640 
    args = markOrderDoaRequestReceived_args()
7641 
    args.read(iprot)
7642 
    iprot.readMessageEnd()
7643 
    result = markOrderDoaRequestReceived_result()
7644 
    try:
7645 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7646 
    except TransactionServiceException, ex:
7647 
      result.ex = ex
7648 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7649 
    result.write(oprot)
7650 
    oprot.writeMessageEnd()
7651 
    oprot.trans.flush()
7652 
 
7653 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7654 
    args = markOrderDoaRequestAuthorized_args()
7655 
    args.read(iprot)
7656 
    iprot.readMessageEnd()
7657 
    result = markOrderDoaRequestAuthorized_result()
7658 
    try:
7659 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7660 
    except TransactionServiceException, ex:
7661 
      result.ex = ex
7662 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7663 
    result.write(oprot)
7664 
    oprot.writeMessageEnd()
7665 
    oprot.trans.flush()
7666 
 
4488 rajveer 7667 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7668 
    args = markOrderReturnRequestReceived_args()
7669 
    args.read(iprot)
7670 
    iprot.readMessageEnd()
7671 
    result = markOrderReturnRequestReceived_result()
7672 
    try:
7673 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7674 
    except TransactionServiceException, ex:
7675 
      result.ex = ex
7676 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7677 
    result.write(oprot)
7678 
    oprot.writeMessageEnd()
7679 
    oprot.trans.flush()
7680 
 
7681 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7682 
    args = markOrderReturnRequestAuthorized_args()
7683 
    args.read(iprot)
7684 
    iprot.readMessageEnd()
7685 
    result = markOrderReturnRequestAuthorized_result()
7686 
    try:
7687 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7688 
    except TransactionServiceException, ex:
7689 
      result.ex = ex
7690 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7691 
    result.write(oprot)
7692 
    oprot.writeMessageEnd()
7693 
    oprot.trans.flush()
7694 
 
2536 chandransh 7695 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7696 
    args = requestPickupNumber_args()
7697 
    args.read(iprot)
7698 
    iprot.readMessageEnd()
7699 
    result = requestPickupNumber_result()
7700 
    try:
4579 rajveer 7701 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7702 
    except TransactionServiceException, ex:
7703 
      result.ex = ex
7704 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7705 
    result.write(oprot)
7706 
    oprot.writeMessageEnd()
7707 
    oprot.trans.flush()
7708 
 
7709 
  def process_authorizePickup(self, seqid, iprot, oprot):
7710 
    args = authorizePickup_args()
7711 
    args.read(iprot)
7712 
    iprot.readMessageEnd()
7713 
    result = authorizePickup_result()
7714 
    try:
4602 rajveer 7715 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7716 
    except TransactionServiceException, ex:
7717 
      result.ex = ex
7718 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7719 
    result.write(oprot)
7720 
    oprot.writeMessageEnd()
7721 
    oprot.trans.flush()
7722 
 
2764 chandransh 7723 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7724 
    args = markDoasAsPickedUp_args()
7725 
    args.read(iprot)
7726 
    iprot.readMessageEnd()
7727 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7728 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7729 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7730 
    result.write(oprot)
7731 
    oprot.writeMessageEnd()
7732 
    oprot.trans.flush()
7733 
 
4910 phani.kuma 7734 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7735 
    args = getDoasNotPickedUp_args()
7736 
    args.read(iprot)
7737 
    iprot.readMessageEnd()
7738 
    result = getDoasNotPickedUp_result()
7739 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7740 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7741 
    result.write(oprot)
7742 
    oprot.writeMessageEnd()
7743 
    oprot.trans.flush()
7744 
 
4741 phani.kuma 7745 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7746 
    args = markReturnOrdersAsPickedUp_args()
7747 
    args.read(iprot)
7748 
    iprot.readMessageEnd()
7749 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7750 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7751 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7752 
    result.write(oprot)
7753 
    oprot.writeMessageEnd()
7754 
    oprot.trans.flush()
7755 
 
4910 phani.kuma 7756 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7757 
    args = getReturnOrdersNotPickedUp_args()
7758 
    args.read(iprot)
7759 
    iprot.readMessageEnd()
7760 
    result = getReturnOrdersNotPickedUp_result()
7761 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7762 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7763 
    result.write(oprot)
7764 
    oprot.writeMessageEnd()
7765 
    oprot.trans.flush()
7766 
 
2616 chandransh 7767 
  def process_receiveReturn(self, seqid, iprot, oprot):
7768 
    args = receiveReturn_args()
2591 chandransh 7769 
    args.read(iprot)
7770 
    iprot.readMessageEnd()
2616 chandransh 7771 
    result = receiveReturn_result()
2591 chandransh 7772 
    try:
4479 rajveer 7773 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7774 
    except TransactionServiceException, ex:
7775 
      result.ex = ex
2616 chandransh 7776 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7777 
    result.write(oprot)
7778 
    oprot.writeMessageEnd()
7779 
    oprot.trans.flush()
2536 chandransh 7780 
 
2591 chandransh 7781 
  def process_validateDoa(self, seqid, iprot, oprot):
7782 
    args = validateDoa_args()
7783 
    args.read(iprot)
7784 
    iprot.readMessageEnd()
7785 
    result = validateDoa_result()
7786 
    try:
7787 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7788 
    except TransactionServiceException, ex:
7789 
      result.ex = ex
7790 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7791 
    result.write(oprot)
7792 
    oprot.writeMessageEnd()
7793 
    oprot.trans.flush()
7794 
 
4495 rajveer 7795 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7796 
    args = validateReturnProduct_args()
7797 
    args.read(iprot)
7798 
    iprot.readMessageEnd()
7799 
    result = validateReturnProduct_result()
7800 
    try:
7801 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7802 
    except TransactionServiceException, ex:
7803 
      result.ex = ex
7804 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7805 
    result.write(oprot)
7806 
    oprot.writeMessageEnd()
7807 
    oprot.trans.flush()
7808 
 
2616 chandransh 7809 
  def process_reshipOrder(self, seqid, iprot, oprot):
7810 
    args = reshipOrder_args()
7811 
    args.read(iprot)
7812 
    iprot.readMessageEnd()
7813 
    result = reshipOrder_result()
7814 
    try:
7815 
      result.success = self._handler.reshipOrder(args.orderId)
7816 
    except TransactionServiceException, ex:
7817 
      result.ex = ex
7818 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7819 
    result.write(oprot)
7820 
    oprot.writeMessageEnd()
7821 
    oprot.trans.flush()
2591 chandransh 7822 
 
2616 chandransh 7823 
  def process_refundOrder(self, seqid, iprot, oprot):
7824 
    args = refundOrder_args()
7825 
    args.read(iprot)
7826 
    iprot.readMessageEnd()
7827 
    result = refundOrder_result()
7828 
    try:
3226 chandransh 7829 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7830 
    except TransactionServiceException, ex:
7831 
      result.ex = ex
7832 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7833 
    result.write(oprot)
7834 
    oprot.writeMessageEnd()
7835 
    oprot.trans.flush()
7836 
 
2690 chandransh 7837 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7838 
    args = getReturnOrders_args()
7839 
    args.read(iprot)
7840 
    iprot.readMessageEnd()
7841 
    result = getReturnOrders_result()
7842 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7843 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7844 
    result.write(oprot)
7845 
    oprot.writeMessageEnd()
7846 
    oprot.trans.flush()
2616 chandransh 7847 
 
5481 phani.kuma 7848 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7849 
    args = getAllReturnOrders_args()
7850 
    args.read(iprot)
7851 
    iprot.readMessageEnd()
7852 
    result = getAllReturnOrders_result()
7853 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7854 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7855 
    result.write(oprot)
7856 
    oprot.writeMessageEnd()
7857 
    oprot.trans.flush()
7858 
 
2700 chandransh 7859 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7860 
    args = getReturnOrder_args()
7861 
    args.read(iprot)
7862 
    iprot.readMessageEnd()
7863 
    result = getReturnOrder_result()
7864 
    try:
7865 
      result.success = self._handler.getReturnOrder(args.id)
7866 
    except TransactionServiceException, ex:
7867 
      result.ex = ex
7868 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7869 
    result.write(oprot)
7870 
    oprot.writeMessageEnd()
7871 
    oprot.trans.flush()
7872 
 
2690 chandransh 7873 
  def process_processReturn(self, seqid, iprot, oprot):
7874 
    args = processReturn_args()
7875 
    args.read(iprot)
7876 
    iprot.readMessageEnd()
7877 
    result = processReturn_result()
7878 
    try:
7879 
      self._handler.processReturn(args.returnOrderId)
7880 
    except TransactionServiceException, ex:
7881 
      result.ex = ex
7882 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7883 
    result.write(oprot)
7884 
    oprot.writeMessageEnd()
7885 
    oprot.trans.flush()
7886 
 
3451 chandransh 7887 
  def process_updateWeight(self, seqid, iprot, oprot):
7888 
    args = updateWeight_args()
7889 
    args.read(iprot)
7890 
    iprot.readMessageEnd()
7891 
    result = updateWeight_result()
7892 
    try:
7893 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7894 
    except TransactionServiceException, ex:
7895 
      result.ex = ex
7896 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7897 
    result.write(oprot)
7898 
    oprot.writeMessageEnd()
7899 
    oprot.trans.flush()
2819 chandransh 7900 
 
3469 chandransh 7901 
  def process_changeItem(self, seqid, iprot, oprot):
7902 
    args = changeItem_args()
7903 
    args.read(iprot)
7904 
    iprot.readMessageEnd()
7905 
    result = changeItem_result()
7906 
    try:
7907 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7908 
    except TransactionServiceException, ex:
7909 
      result.ex = ex
7910 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7911 
    result.write(oprot)
7912 
    oprot.writeMessageEnd()
7913 
    oprot.trans.flush()
3451 chandransh 7914 
 
3469 chandransh 7915 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7916 
    args = shiftToWarehouse_args()
7917 
    args.read(iprot)
7918 
    iprot.readMessageEnd()
7919 
    result = shiftToWarehouse_result()
7920 
    try:
7921 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7922 
    except TransactionServiceException, ex:
7923 
      result.ex = ex
7924 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7925 
    result.write(oprot)
7926 
    oprot.writeMessageEnd()
7927 
    oprot.trans.flush()
7928 
 
3553 chandransh 7929 
  def process_addDelayReason(self, seqid, iprot, oprot):
7930 
    args = addDelayReason_args()
7931 
    args.read(iprot)
7932 
    iprot.readMessageEnd()
7933 
    result = addDelayReason_result()
7934 
    try:
4647 rajveer 7935 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7936 
    except TransactionServiceException, ex:
7937 
      result.ex = ex
7938 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7939 
    result.write(oprot)
7940 
    oprot.writeMessageEnd()
7941 
    oprot.trans.flush()
3469 chandransh 7942 
 
3956 chandransh 7943 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7944 
    args = reconcileCodCollection_args()
7945 
    args.read(iprot)
7946 
    iprot.readMessageEnd()
7947 
    result = reconcileCodCollection_result()
7948 
    try:
7949 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7950 
    except TransactionServiceException, ex:
7951 
      result.ex = ex
7952 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7953 
    result.write(oprot)
7954 
    oprot.writeMessageEnd()
7955 
    oprot.trans.flush()
3553 chandransh 7956 
 
4008 mandeep.dh 7957 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7958 
    args = getTransactionsRequiringExtraProcessing_args()
7959 
    args.read(iprot)
7960 
    iprot.readMessageEnd()
7961 
    result = getTransactionsRequiringExtraProcessing_result()
7962 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7963 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7964 
    result.write(oprot)
7965 
    oprot.writeMessageEnd()
7966 
    oprot.trans.flush()
3956 chandransh 7967 
 
4008 mandeep.dh 7968 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7969 
    args = markTransactionAsProcessed_args()
7970 
    args.read(iprot)
7971 
    iprot.readMessageEnd()
7972 
    result = markTransactionAsProcessed_result()
7973 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7974 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7975 
    result.write(oprot)
7976 
    oprot.writeMessageEnd()
7977 
    oprot.trans.flush()
7978 
 
4018 chandransh 7979 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7980 
    args = getItemWiseRiskyOrdersCount_args()
7981 
    args.read(iprot)
7982 
    iprot.readMessageEnd()
7983 
    result = getItemWiseRiskyOrdersCount_result()
7984 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7985 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7986 
    result.write(oprot)
7987 
    oprot.writeMessageEnd()
7988 
    oprot.trans.flush()
4008 mandeep.dh 7989 
 
4295 varun.gupt 7990 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7991 
    args = getOrdersForItemIds_args()
7992 
    args.read(iprot)
7993 
    iprot.readMessageEnd()
7994 
    result = getOrdersForItemIds_result()
7995 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7996 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7997 
    result.write(oprot)
7998 
    oprot.writeMessageEnd()
7999 
    oprot.trans.flush()
8000 
 
4247 rajveer 8001 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
8002 
    args = markOrderCancellationRequestReceived_args()
8003 
    args.read(iprot)
8004 
    iprot.readMessageEnd()
8005 
    result = markOrderCancellationRequestReceived_result()
8006 
    try:
8007 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
8008 
    except TransactionServiceException, ex:
8009 
      result.ex = ex
8010 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
8011 
    result.write(oprot)
8012 
    oprot.writeMessageEnd()
8013 
    oprot.trans.flush()
4018 chandransh 8014 
 
4247 rajveer 8015 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
8016 
    args = markOrderCancellationRequestConfirmed_args()
8017 
    args.read(iprot)
8018 
    iprot.readMessageEnd()
8019 
    result = markOrderCancellationRequestConfirmed_result()
8020 
    try:
8021 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
8022 
    except TransactionServiceException, ex:
8023 
      result.ex = ex
8024 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
8025 
    result.write(oprot)
8026 
    oprot.writeMessageEnd()
8027 
    oprot.trans.flush()
8028 
 
8029 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
8030 
    args = markOrderCancellationRequestDenied_args()
8031 
    args.read(iprot)
8032 
    iprot.readMessageEnd()
8033 
    result = markOrderCancellationRequestDenied_result()
8034 
    try:
8035 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
8036 
    except TransactionServiceException, ex:
8037 
      result.ex = ex
8038 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
8039 
    result.write(oprot)
8040 
    oprot.writeMessageEnd()
8041 
    oprot.trans.flush()
8042 
 
4258 rajveer 8043 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
8044 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 8045 
    args.read(iprot)
8046 
    iprot.readMessageEnd()
4258 rajveer 8047 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 8048 
    try:
4258 rajveer 8049 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 8050 
    except TransactionServiceException, ex:
8051 
      result.ex = ex
4258 rajveer 8052 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 8053 
    result.write(oprot)
8054 
    oprot.writeMessageEnd()
8055 
    oprot.trans.flush()
8056 
 
4259 anupam.sin 8057 
  def process_refundTransaction(self, seqid, iprot, oprot):
8058 
    args = refundTransaction_args()
8059 
    args.read(iprot)
8060 
    iprot.readMessageEnd()
8061 
    result = refundTransaction_result()
8062 
    try:
8063 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
8064 
    except TransactionServiceException, ex:
8065 
      result.ex = ex
8066 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
8067 
    result.write(oprot)
8068 
    oprot.writeMessageEnd()
8069 
    oprot.trans.flush()
4247 rajveer 8070 
 
4324 mandeep.dh 8071 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
8072 
    args = updateShipmentAddress_args()
8073 
    args.read(iprot)
8074 
    iprot.readMessageEnd()
8075 
    result = updateShipmentAddress_result()
8076 
    try:
8077 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
8078 
    except TransactionServiceException, ex:
8079 
      result.ex = ex
8080 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
8081 
    result.write(oprot)
8082 
    oprot.writeMessageEnd()
8083 
    oprot.trans.flush()
8084 
 
4285 rajveer 8085 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
8086 
    args = acceptOrdersForItemId_args()
8087 
    args.read(iprot)
8088 
    iprot.readMessageEnd()
8089 
    result = acceptOrdersForItemId_result()
8090 
    try:
8091 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
8092 
    except TransactionServiceException, ex:
8093 
      result.ex = ex
8094 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
8095 
    result.write(oprot)
8096 
    oprot.writeMessageEnd()
8097 
    oprot.trans.flush()
4259 anupam.sin 8098 
 
4303 rajveer 8099 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
8100 
    args = markOrdersAsPORaised_args()
8101 
    args.read(iprot)
8102 
    iprot.readMessageEnd()
8103 
    result = markOrdersAsPORaised_result()
8104 
    try:
4369 rajveer 8105 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8106 
    except TransactionServiceException, ex:
8107 
      result.ex = ex
8108 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
8109 
    result.write(oprot)
8110 
    oprot.writeMessageEnd()
8111 
    oprot.trans.flush()
4285 rajveer 8112 
 
4303 rajveer 8113 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
8114 
    args = markOrdersAsReversalInitiated_args()
8115 
    args.read(iprot)
8116 
    iprot.readMessageEnd()
8117 
    result = markOrdersAsReversalInitiated_result()
8118 
    try:
4369 rajveer 8119 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8120 
    except TransactionServiceException, ex:
8121 
      result.ex = ex
8122 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
8123 
    result.write(oprot)
8124 
    oprot.writeMessageEnd()
8125 
    oprot.trans.flush()
8126 
 
8127 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
8128 
    args = markOrdersAsNotAvailabke_args()
8129 
    args.read(iprot)
8130 
    iprot.readMessageEnd()
8131 
    result = markOrdersAsNotAvailabke_result()
8132 
    try:
4369 rajveer 8133 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8134 
    except TransactionServiceException, ex:
8135 
      result.ex = ex
8136 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
8137 
    result.write(oprot)
8138 
    oprot.writeMessageEnd()
8139 
    oprot.trans.flush()
8140 
 
4369 rajveer 8141 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
8142 
    args = markOrdersAsTimeout_args()
8143 
    args.read(iprot)
8144 
    iprot.readMessageEnd()
8145 
    result = markOrdersAsTimeout_result()
8146 
    try:
8147 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
8148 
    except TransactionServiceException, ex:
8149 
      result.ex = ex
8150 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
8151 
    result.write(oprot)
8152 
    oprot.writeMessageEnd()
8153 
    oprot.trans.flush()
4303 rajveer 8154 
 
4662 rajveer 8155 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
8156 
    args = markOrderAsLostInTransit_args()
8157 
    args.read(iprot)
8158 
    iprot.readMessageEnd()
8159 
    result = markOrderAsLostInTransit_result()
8160 
    try:
8161 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
8162 
    except TransactionServiceException, ex:
8163 
      result.ex = ex
8164 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
8165 
    result.write(oprot)
8166 
    oprot.writeMessageEnd()
8167 
    oprot.trans.flush()
8168 
 
4386 anupam.sin 8169 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
8170 
    args = getOrderForAwb_args()
8171 
    args.read(iprot)
8172 
    iprot.readMessageEnd()
8173 
    result = getOrderForAwb_result()
8174 
    try:
8175 
      result.success = self._handler.getOrderForAwb(args.awb)
8176 
    except TransactionServiceException, ex:
8177 
      result.ex = ex
8178 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
8179 
    result.write(oprot)
8180 
    oprot.writeMessageEnd()
8181 
    oprot.trans.flush()
4369 rajveer 8182 
 
4506 phani.kuma 8183 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
8184 
    args = getOrdersForProviderForStatus_args()
8185 
    args.read(iprot)
8186 
    iprot.readMessageEnd()
8187 
    result = getOrdersForProviderForStatus_result()
8188 
    try:
4910 phani.kuma 8189 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 8190 
    except TransactionServiceException, ex:
8191 
      result.ex = ex
8192 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
8193 
    result.write(oprot)
8194 
    oprot.writeMessageEnd()
8195 
    oprot.trans.flush()
4386 anupam.sin 8196 
 
4600 varun.gupt 8197 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
8198 
    args = getBilledOrdersForVendor_args()
8199 
    args.read(iprot)
8200 
    iprot.readMessageEnd()
8201 
    result = getBilledOrdersForVendor_result()
8202 
    try:
8203 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
8204 
    except TransactionServiceException, ex:
8205 
      result.ex = ex
8206 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
8207 
    result.write(oprot)
8208 
    oprot.writeMessageEnd()
8209 
    oprot.trans.flush()
4506 phani.kuma 8210 
 
4607 rajveer 8211 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
8212 
    args = getSlippedSippingDateOrders_args()
8213 
    args.read(iprot)
8214 
    iprot.readMessageEnd()
8215 
    result = getSlippedSippingDateOrders_result()
8216 
    try:
8217 
      result.success = self._handler.getSlippedSippingDateOrders()
8218 
    except TransactionServiceException, ex:
8219 
      result.ex = ex
8220 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
8221 
    result.write(oprot)
8222 
    oprot.writeMessageEnd()
8223 
    oprot.trans.flush()
8224 
 
4709 rajveer 8225 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
8226 
    args = getCancelledOrders_args()
8227 
    args.read(iprot)
8228 
    iprot.readMessageEnd()
8229 
    result = getCancelledOrders_result()
8230 
    try:
8231 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
8232 
    except TransactionServiceException, ex:
8233 
      result.ex = ex
8234 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
8235 
    result.write(oprot)
8236 
    oprot.writeMessageEnd()
8237 
    oprot.trans.flush()
8238 
 
4600 varun.gupt 8239 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
8240 
    args = saveBluedartSettlements_args()
8241 
    args.read(iprot)
8242 
    iprot.readMessageEnd()
8243 
    result = saveBluedartSettlements_result()
8244 
    try:
8245 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
8246 
    except TransactionServiceException, ex:
8247 
      result.ex = ex
8248 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
8249 
    result.write(oprot)
8250 
    oprot.writeMessageEnd()
8251 
    oprot.trans.flush()
8252 
 
8253 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
8254 
    args = savePaymentSettlements_args()
8255 
    args.read(iprot)
8256 
    iprot.readMessageEnd()
8257 
    result = savePaymentSettlements_result()
8258 
    try:
4905 varun.gupt 8259 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 8260 
    except TransactionServiceException, ex:
8261 
      result.ex = ex
8262 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
8263 
    result.write(oprot)
8264 
    oprot.writeMessageEnd()
8265 
    oprot.trans.flush()
8266 
 
8267 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
8268 
    args = saveEBSSettlementSummary_args()
8269 
    args.read(iprot)
8270 
    iprot.readMessageEnd()
8271 
    result = saveEBSSettlementSummary_result()
8272 
    try:
8273 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
8274 
    except TransactionServiceException, ex:
8275 
      result.ex = ex
8276 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
8277 
    result.write(oprot)
8278 
    oprot.writeMessageEnd()
8279 
    oprot.trans.flush()
8280 
 
5386 phani.kuma 8281 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
8282 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 8283 
    args.read(iprot)
8284 
    iprot.readMessageEnd()
5386 phani.kuma 8285 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 8286 
    try:
5386 phani.kuma 8287 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 8288 
    except TransactionServiceException, ex:
8289 
      result.ex = ex
5386 phani.kuma 8290 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 8291 
    result.write(oprot)
8292 
    oprot.writeMessageEnd()
8293 
    oprot.trans.flush()
8294 
 
5386 phani.kuma 8295 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
8296 
    args = getSettlementForCod_args()
8297 
    args.read(iprot)
8298 
    iprot.readMessageEnd()
8299 
    result = getSettlementForCod_result()
8300 
    try:
8301 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
8302 
    except TransactionServiceException, ex:
8303 
      result.ex = ex
8304 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
8305 
    result.write(oprot)
8306 
    oprot.writeMessageEnd()
8307 
    oprot.trans.flush()
8308 
 
4600 varun.gupt 8309 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
8310 
    args = getEBSSettlementSummaries_args()
8311 
    args.read(iprot)
8312 
    iprot.readMessageEnd()
8313 
    result = getEBSSettlementSummaries_result()
8314 
    try:
8315 
      result.success = self._handler.getEBSSettlementSummaries()
8316 
    except TransactionServiceException, ex:
8317 
      result.ex = ex
8318 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
8319 
    result.write(oprot)
8320 
    oprot.writeMessageEnd()
8321 
    oprot.trans.flush()
8322 
 
8323 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
8324 
    args = markEBSSettlementUploaded_args()
8325 
    args.read(iprot)
8326 
    iprot.readMessageEnd()
8327 
    result = markEBSSettlementUploaded_result()
8328 
    try:
8329 
      self._handler.markEBSSettlementUploaded(args.settlementId)
8330 
    except TransactionServiceException, ex:
8331 
      result.ex = ex
8332 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
8333 
    result.write(oprot)
8334 
    oprot.writeMessageEnd()
8335 
    oprot.trans.flush()
8336 
 
8337 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
8338 
    args = getEBSSettlementDate_args()
8339 
    args.read(iprot)
8340 
    iprot.readMessageEnd()
8341 
    result = getEBSSettlementDate_result()
8342 
    try:
8343 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
8344 
    except TransactionServiceException, ex:
8345 
      result.ex = ex
8346 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
8347 
    result.write(oprot)
8348 
    oprot.writeMessageEnd()
8349 
    oprot.trans.flush()
8350 
 
4715 varun.gupt 8351 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
8352 
    args = getSettlementsByDate_args()
8353 
    args.read(iprot)
8354 
    iprot.readMessageEnd()
8355 
    result = getSettlementsByDate_result()
8356 
    try:
8357 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
8358 
    except TransactionServiceException, ex:
8359 
      result.ex = ex
8360 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
8361 
    result.write(oprot)
8362 
    oprot.writeMessageEnd()
8363 
    oprot.trans.flush()
4600 varun.gupt 8364 
 
4715 varun.gupt 8365 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
8366 
    args = getReshippedOrderIds_args()
8367 
    args.read(iprot)
8368 
    iprot.readMessageEnd()
8369 
    result = getReshippedOrderIds_result()
8370 
    try:
8371 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8372 
    except TransactionServiceException, ex:
8373 
      result.ex = ex
8374 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8375 
    result.write(oprot)
8376 
    oprot.writeMessageEnd()
8377 
    oprot.trans.flush()
8378 
 
5481 phani.kuma 8379 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8380 
    args = getBilledOrders_args()
4875 varun.gupt 8381 
    args.read(iprot)
8382 
    iprot.readMessageEnd()
5481 phani.kuma 8383 
    result = getBilledOrders_result()
4875 varun.gupt 8384 
    try:
5481 phani.kuma 8385 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8386 
    except TransactionServiceException, ex:
8387 
      result.ex = ex
5481 phani.kuma 8388 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8389 
    result.write(oprot)
8390 
    oprot.writeMessageEnd()
8391 
    oprot.trans.flush()
4757 mandeep.dh 8392 
 
5031 varun.gupt 8393 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8394 
    args = getStatusDistributionOfOrders_args()
8395 
    args.read(iprot)
8396 
    iprot.readMessageEnd()
8397 
    result = getStatusDistributionOfOrders_result()
8398 
    try:
8399 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8400 
    except TransactionServiceException, ex:
8401 
      result.ex = ex
8402 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8403 
    result.write(oprot)
8404 
    oprot.writeMessageEnd()
8405 
    oprot.trans.flush()
4875 varun.gupt 8406 
 
5067 varun.gupt 8407 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8408 
    args = getOrderIdsForStatus_args()
8409 
    args.read(iprot)
8410 
    iprot.readMessageEnd()
8411 
    result = getOrderIdsForStatus_result()
8412 
    try:
8413 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8414 
    except TransactionServiceException, ex:
8415 
      result.ex = ex
8416 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8417 
    result.write(oprot)
8418 
    oprot.writeMessageEnd()
8419 
    oprot.trans.flush()
5031 varun.gupt 8420 
 
5348 anupam.sin 8421 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8422 
    args = updateCODAgent_args()
8423 
    args.read(iprot)
8424 
    iprot.readMessageEnd()
8425 
    result = updateCODAgent_result()
8426 
    try:
8427 
      self._handler.updateCODAgent(args.agent, args.orderId)
8428 
    except TransactionServiceException, ex:
8429 
      result.ex = ex
8430 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8431 
    result.write(oprot)
8432 
    oprot.writeMessageEnd()
8433 
    oprot.trans.flush()
8434 
 
5099 varun.gupt 8435 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8436 
    args = updateOrderAsPaidToVendor_args()
8437 
    args.read(iprot)
8438 
    iprot.readMessageEnd()
8439 
    result = updateOrderAsPaidToVendor_result()
8440 
    try:
8441 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8442 
    except TransactionServiceException, ex:
8443 
      result.ex = ex
8444 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8445 
    result.write(oprot)
8446 
    oprot.writeMessageEnd()
8447 
    oprot.trans.flush()
5067 varun.gupt 8448 
 
5386 phani.kuma 8449 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8450 
    args = updateOrderOnlyAsPaidToVendor_args()
8451 
    args.read(iprot)
8452 
    iprot.readMessageEnd()
8453 
    result = updateOrderOnlyAsPaidToVendor_result()
8454 
    try:
8455 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8456 
    except TransactionServiceException, ex:
8457 
      result.ex = ex
8458 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8459 
    result.write(oprot)
8460 
    oprot.writeMessageEnd()
8461 
    oprot.trans.flush()
8462 
 
5208 varun.gupt 8463 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8464 
    args = getRefundedOrdersMarkedPaid_args()
8465 
    args.read(iprot)
8466 
    iprot.readMessageEnd()
8467 
    result = getRefundedOrdersMarkedPaid_result()
8468 
    try:
8469 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8470 
    except TransactionServiceException, ex:
8471 
      result.ex = ex
8472 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8473 
    result.write(oprot)
8474 
    oprot.writeMessageEnd()
8475 
    oprot.trans.flush()
5099 varun.gupt 8476 
 
5447 anupam.sin 8477 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8478 
    args = getAllVerificationAgents_args()
8479 
    args.read(iprot)
8480 
    iprot.readMessageEnd()
8481 
    result = getAllVerificationAgents_result()
8482 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8483 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8484 
    result.write(oprot)
8485 
    oprot.writeMessageEnd()
8486 
    oprot.trans.flush()
5208 varun.gupt 8487 
 
5527 anupam.sin 8488 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8489 
    args = getAllAttributesForOrderId_args()
8490 
    args.read(iprot)
8491 
    iprot.readMessageEnd()
8492 
    result = getAllAttributesForOrderId_result()
8493 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8494 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8495 
    result.write(oprot)
8496 
    oprot.writeMessageEnd()
8497 
    oprot.trans.flush()
5447 anupam.sin 8498 
 
5676 rajveer 8499 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8500 
    args = setOrderAttributes_args()
8501 
    args.read(iprot)
8502 
    iprot.readMessageEnd()
8503 
    result = setOrderAttributes_result()
8504 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8505 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8506 
    result.write(oprot)
8507 
    oprot.writeMessageEnd()
8508 
    oprot.trans.flush()
8509 
 
5527 anupam.sin 8510 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8511 
    args = setOrderAttributeForTransaction_args()
8512 
    args.read(iprot)
8513 
    iprot.readMessageEnd()
8514 
    result = setOrderAttributeForTransaction_result()
8515 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8516 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8517 
    result.write(oprot)
8518 
    oprot.writeMessageEnd()
8519 
    oprot.trans.flush()
8520 
 
5553 rajveer 8521 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8522 
    args = getReceivePendingOrders_args()
8523 
    args.read(iprot)
8524 
    iprot.readMessageEnd()
8525 
    result = getReceivePendingOrders_result()
8526 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8527 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8528 
    result.write(oprot)
8529 
    oprot.writeMessageEnd()
8530 
    oprot.trans.flush()
5527 anupam.sin 8531 
 
5553 rajveer 8532 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8533 
    args = getReceivedAtStoreOrders_args()
8534 
    args.read(iprot)
8535 
    iprot.readMessageEnd()
8536 
    result = getReceivedAtStoreOrders_result()
8537 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8538 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8539 
    result.write(oprot)
8540 
    oprot.writeMessageEnd()
8541 
    oprot.trans.flush()
8542 
 
5713 rajveer 8543 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8544 
    args = getOrdersCollectionAtStore_args()
8545 
    args.read(iprot)
8546 
    iprot.readMessageEnd()
8547 
    result = getOrdersCollectionAtStore_result()
8548 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8549 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8550 
    result.write(oprot)
8551 
    oprot.writeMessageEnd()
8552 
    oprot.trans.flush()
8553 
 
5833 rajveer 8554 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8555 
    args = getOrderAttributeValue_args()
8556 
    args.read(iprot)
8557 
    iprot.readMessageEnd()
8558 
    result = getOrderAttributeValue_result()
8559 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8560 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8561 
    result.write(oprot)
8562 
    oprot.writeMessageEnd()
8563 
    oprot.trans.flush()
8564 
 
6019 rajveer 8565 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8566 
    args = changeJacketNumber_args()
8567 
    args.read(iprot)
8568 
    iprot.readMessageEnd()
8569 
    result = changeJacketNumber_result()
8570 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8571 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8572 
    result.write(oprot)
8573 
    oprot.writeMessageEnd()
8574 
    oprot.trans.flush()
8575 
 
8576 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8577 
    args = markOrderAsRtoInTransit_args()
8578 
    args.read(iprot)
8579 
    iprot.readMessageEnd()
8580 
    result = markOrderAsRtoInTransit_result()
8581 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8582 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8583 
    result.write(oprot)
8584 
    oprot.writeMessageEnd()
8585 
    oprot.trans.flush()
8586 
 
5593 mandeep.dh 8587 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8588 
    args = acceptOrderForItem_args()
8589 
    args.read(iprot)
8590 
    iprot.readMessageEnd()
8591 
    result = acceptOrderForItem_result()
8592 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8593 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8594 
    result.write(oprot)
8595 
    oprot.writeMessageEnd()
8596 
    oprot.trans.flush()
5553 rajveer 8597 
 
6000 mandeep.dh 8598 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8599 
    args = createRechargeOrder_args()
8600 
    args.read(iprot)
8601 
    iprot.readMessageEnd()
8602 
    result = createRechargeOrder_result()
8603 
    try:
8604 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8605 
    except TransactionServiceException, ex:
8606 
      result.ex = ex
8607 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8608 
    result.write(oprot)
8609 
    oprot.writeMessageEnd()
8610 
    oprot.trans.flush()
5593 mandeep.dh 8611 
 
6031 rajveer 8612 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8613 
    args = getRechargeOrder_args()
8614 
    args.read(iprot)
8615 
    iprot.readMessageEnd()
8616 
    result = getRechargeOrder_result()
8617 
    try:
8618 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8619 
    except TransactionServiceException, ex:
8620 
      result.ex = ex
8621 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8622 
    result.write(oprot)
8623 
    oprot.writeMessageEnd()
8624 
    oprot.trans.flush()
8625 
 
8626 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8627 
    args = getRechargeOrders_args()
8628 
    args.read(iprot)
8629 
    iprot.readMessageEnd()
8630 
    result = getRechargeOrders_result()
8631 
    result.success = self._handler.getRechargeOrders(args.userId)
8632 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8633 
    result.write(oprot)
8634 
    oprot.writeMessageEnd()
8635 
    oprot.trans.flush()
8636 
 
6000 mandeep.dh 8637 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8638 
    args = updateRechargeOrderStatus_args()
8639 
    args.read(iprot)
8640 
    iprot.readMessageEnd()
8641 
    result = updateRechargeOrderStatus_result()
8642 
    try:
6031 rajveer 8643 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8644 
    except TransactionServiceException, ex:
8645 
      result.ex = ex
8646 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8647 
    result.write(oprot)
8648 
    oprot.writeMessageEnd()
8649 
    oprot.trans.flush()
8650 
 
8651 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8652 
    args = activateRechargeTxn_args()
8653 
    args.read(iprot)
8654 
    iprot.readMessageEnd()
8655 
    result = activateRechargeTxn_result()
8656 
    try:
6031 rajveer 8657 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8658 
    except TransactionServiceException, ex:
8659 
      result.ex = ex
8660 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8661 
    result.write(oprot)
8662 
    oprot.writeMessageEnd()
8663 
    oprot.trans.flush()
8664 
 
6031 rajveer 8665 
  def process_getUserWallet(self, seqid, iprot, oprot):
8666 
    args = getUserWallet_args()
6000 mandeep.dh 8667 
    args.read(iprot)
8668 
    iprot.readMessageEnd()
6031 rajveer 8669 
    result = getUserWallet_result()
8670 
    result.success = self._handler.getUserWallet(args.userId)
8671 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8672 
    result.write(oprot)
8673 
    oprot.writeMessageEnd()
8674 
    oprot.trans.flush()
8675 
 
6031 rajveer 8676 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8677 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8678 
    args.read(iprot)
8679 
    iprot.readMessageEnd()
6031 rajveer 8680 
    result = getUserWalletHistory_result()
8681 
    result.success = self._handler.getUserWalletHistory(args.userId)
8682 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8683 
    result.write(oprot)
8684 
    oprot.writeMessageEnd()
8685 
    oprot.trans.flush()
8686 
 
6050 anupam.sin 8687 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8688 
    args = getRechargeOrdersForTransaction_args()
8689 
    args.read(iprot)
8690 
    iprot.readMessageEnd()
8691 
    result = getRechargeOrdersForTransaction_result()
8692 
    try:
8693 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8694 
    except TransactionServiceException, ex:
8695 
      result.ex = ex
8696 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8697 
    result.write(oprot)
8698 
    oprot.writeMessageEnd()
8699 
    oprot.trans.flush()
8700 
 
6048 rajveer 8701 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8702 
    args = getServiceProviders_args()
8703 
    args.read(iprot)
8704 
    iprot.readMessageEnd()
8705 
    result = getServiceProviders_result()
6206 rajveer 8706 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 8707 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8708 
    result.write(oprot)
8709 
    oprot.writeMessageEnd()
8710 
    oprot.trans.flush()
6000 mandeep.dh 8711 
 
6048 rajveer 8712 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8713 
    args = getServiceProviderForDevice_args()
8714 
    args.read(iprot)
8715 
    iprot.readMessageEnd()
8716 
    result = getServiceProviderForDevice_result()
6049 rajveer 8717 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8718 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8719 
    result.write(oprot)
8720 
    oprot.writeMessageEnd()
8721 
    oprot.trans.flush()
8722 
 
6269 rajveer 8723 
  def process_validateRecharge(self, seqid, iprot, oprot):
8724 
    args = validateRecharge_args()
8725 
    args.read(iprot)
8726 
    iprot.readMessageEnd()
8727 
    result = validateRecharge_result()
6591 anupam.sin 8728 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId, args.clientAddress)
6269 rajveer 8729 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
8730 
    result.write(oprot)
8731 
    oprot.writeMessageEnd()
8732 
    oprot.trans.flush()
8733 
 
6094 rajveer 8734 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8735 
    args = getRechargeOrdersForDevice_args()
8736 
    args.read(iprot)
8737 
    iprot.readMessageEnd()
8738 
    result = getRechargeOrdersForDevice_result()
8739 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8740 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8741 
    result.write(oprot)
8742 
    oprot.writeMessageEnd()
8743 
    oprot.trans.flush()
6048 rajveer 8744 
 
6094 rajveer 8745 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8746 
    args = addAmountToWallet_args()
8747 
    args.read(iprot)
8748 
    iprot.readMessageEnd()
8749 
    result = addAmountToWallet_result()
8750 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8751 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8752 
    result.write(oprot)
8753 
    oprot.writeMessageEnd()
8754 
    oprot.trans.flush()
8755 
 
6188 rajveer 8756 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
8757 
    args = getRechargeStatistics_args()
8758 
    args.read(iprot)
8759 
    iprot.readMessageEnd()
8760 
    result = getRechargeStatistics_result()
8761 
    result.success = self._handler.getRechargeStatistics()
8762 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
8763 
    result.write(oprot)
8764 
    oprot.writeMessageEnd()
8765 
    oprot.trans.flush()
8766 
 
6154 rajveer 8767 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
8768 
    args = getRechargeOrdersForStatus_args()
8769 
    args.read(iprot)
8770 
    iprot.readMessageEnd()
8771 
    result = getRechargeOrdersForStatus_result()
8772 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
8773 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
8774 
    result.write(oprot)
8775 
    oprot.writeMessageEnd()
8776 
    oprot.trans.flush()
6094 rajveer 8777 
 
6159 rajveer 8778 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
8779 
    args = getPlansForOperator_args()
8780 
    args.read(iprot)
8781 
    iprot.readMessageEnd()
8782 
    result = getPlansForOperator_result()
8783 
    result.success = self._handler.getPlansForOperator(args.operatorId)
8784 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
8785 
    result.write(oprot)
8786 
    oprot.writeMessageEnd()
8787 
    oprot.trans.flush()
6154 rajveer 8788 
 
6289 anupam.sin 8789 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
8790 
    args = getRechargeDenominations_args()
8791 
    args.read(iprot)
8792 
    iprot.readMessageEnd()
8793 
    result = getRechargeDenominations_result()
8794 
    try:
6307 anupam.sin 8795 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 8796 
    except TransactionServiceException, ex:
8797 
      result.ex = ex
8798 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
8799 
    result.write(oprot)
8800 
    oprot.writeMessageEnd()
8801 
    oprot.trans.flush()
6159 rajveer 8802 
 
6371 rajveer 8803 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
8804 
    args = updateAvailabilityStatus_args()
8805 
    args.read(iprot)
8806 
    iprot.readMessageEnd()
8807 
    result = updateAvailabilityStatus_result()
8808 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
8809 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
8810 
    result.write(oprot)
8811 
    oprot.writeMessageEnd()
8812 
    oprot.trans.flush()
6289 anupam.sin 8813 
 
6389 rajveer 8814 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
8815 
    args = getAvailableEmiSchemes_args()
8816 
    args.read(iprot)
8817 
    iprot.readMessageEnd()
8818 
    result = getAvailableEmiSchemes_result()
8819 
    result.success = self._handler.getAvailableEmiSchemes()
8820 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
8821 
    result.write(oprot)
8822 
    oprot.writeMessageEnd()
8823 
    oprot.trans.flush()
6371 rajveer 8824 
 
6389 rajveer 8825 
  def process_getMiscCharges(self, seqid, iprot, oprot):
8826 
    args = getMiscCharges_args()
8827 
    args.read(iprot)
8828 
    iprot.readMessageEnd()
8829 
    result = getMiscCharges_result()
8830 
    result.success = self._handler.getMiscCharges(args.transactionId)
8831 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
8832 
    result.write(oprot)
8833 
    oprot.writeMessageEnd()
8834 
    oprot.trans.flush()
8835 
 
6507 anupam.sin 8836 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
8837 
    args = refundRechargeOrder_args()
8838 
    args.read(iprot)
8839 
    iprot.readMessageEnd()
8840 
    result = refundRechargeOrder_result()
8841 
    try:
8842 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
8843 
    except TransactionServiceException, ex:
8844 
      result.ex = ex
8845 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
8846 
    result.write(oprot)
8847 
    oprot.writeMessageEnd()
8848 
    oprot.trans.flush()
6389 rajveer 8849 
 
6821 amar.kumar 8850 
  def process_getPhysicalOrders(self, seqid, iprot, oprot):
8851 
    args = getPhysicalOrders_args()
8852 
    args.read(iprot)
8853 
    iprot.readMessageEnd()
8854 
    result = getPhysicalOrders_result()
8855 
    result.success = self._handler.getPhysicalOrders(args.fromDate, args.toDate)
8856 
    oprot.writeMessageBegin("getPhysicalOrders", TMessageType.REPLY, seqid)
8857 
    result.write(oprot)
8858 
    oprot.writeMessageEnd()
8859 
    oprot.trans.flush()
6507 anupam.sin 8860 
 
6906 rajveer 8861 
  def process_getDocument(self, seqid, iprot, oprot):
8862 
    args = getDocument_args()
8863 
    args.read(iprot)
8864 
    iprot.readMessageEnd()
8865 
    result = getDocument_result()
8866 
    result.success = self._handler.getDocument(args.docType, args.docSource)
8867 
    oprot.writeMessageBegin("getDocument", TMessageType.REPLY, seqid)
8868 
    result.write(oprot)
8869 
    oprot.writeMessageEnd()
8870 
    oprot.trans.flush()
6821 amar.kumar 8871 
 
6985 anupam.sin 8872 
  def process_changeShippingAddress(self, seqid, iprot, oprot):
8873 
    args = changeShippingAddress_args()
8874 
    args.read(iprot)
8875 
    iprot.readMessageEnd()
8876 
    result = changeShippingAddress_result()
8877 
    result.success = self._handler.changeShippingAddress(args.orderId, args.line1, args.line2, args.city, args.state, args.pin)
8878 
    oprot.writeMessageBegin("changeShippingAddress", TMessageType.REPLY, seqid)
8879 
    result.write(oprot)
8880 
    oprot.writeMessageEnd()
8881 
    oprot.trans.flush()
6906 rajveer 8882 
 
6988 rajveer 8883 
  def process_retrieveInvoice(self, seqid, iprot, oprot):
8884 
    args = retrieveInvoice_args()
8885 
    args.read(iprot)
8886 
    iprot.readMessageEnd()
8887 
    result = retrieveInvoice_result()
8888 
    result.success = self._handler.retrieveInvoice(args.orderId)
8889 
    oprot.writeMessageBegin("retrieveInvoice", TMessageType.REPLY, seqid)
8890 
    result.write(oprot)
8891 
    oprot.writeMessageEnd()
8892 
    oprot.trans.flush()
6985 anupam.sin 8893 
 
7026 rajveer 8894 
  def process_receiveUpdatesForRedExpress(self, seqid, iprot, oprot):
8895 
    args = receiveUpdatesForRedExpress_args()
8896 
    args.read(iprot)
8897 
    iprot.readMessageEnd()
8898 
    result = receiveUpdatesForRedExpress_result()
8899 
    result.success = self._handler.receiveUpdatesForRedExpress(args.awbNumber)
8900 
    oprot.writeMessageBegin("receiveUpdatesForRedExpress", TMessageType.REPLY, seqid)
8901 
    result.write(oprot)
8902 
    oprot.writeMessageEnd()
8903 
    oprot.trans.flush()
6988 rajveer 8904 
 
7026 rajveer 8905 
 
94 ashish 8906 
# HELPER FUNCTIONS AND STRUCTURES
8907 
 
8908 
class createTransaction_args:
8909 
  """
8910 
  Attributes:
8911 
   - transaction
8912 
  """
8913 
 
8914 
  thrift_spec = (
8915 
    None, # 0
8916 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8917 
  )
8918 
 
8919 
  def __init__(self, transaction=None,):
8920 
    self.transaction = transaction
8921 
 
8922 
  def read(self, iprot):
8923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8925 
      return
8926 
    iprot.readStructBegin()
8927 
    while True:
8928 
      (fname, ftype, fid) = iprot.readFieldBegin()
8929 
      if ftype == TType.STOP:
8930 
        break
8931 
      if fid == 1:
8932 
        if ftype == TType.STRUCT:
8933 
          self.transaction = Transaction()
8934 
          self.transaction.read(iprot)
8935 
        else:
8936 
          iprot.skip(ftype)
8937 
      else:
8938 
        iprot.skip(ftype)
8939 
      iprot.readFieldEnd()
8940 
    iprot.readStructEnd()
8941 
 
8942 
  def write(self, oprot):
8943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8945 
      return
8946 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8947 
    if self.transaction is not None:
94 ashish 8948 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
8949 
      self.transaction.write(oprot)
8950 
      oprot.writeFieldEnd()
8951 
    oprot.writeFieldStop()
8952 
    oprot.writeStructEnd()
8953 
 
3431 rajveer 8954 
  def validate(self):
8955 
    return
8956 
 
8957 
 
94 ashish 8958 
  def __repr__(self):
8959 
    L = ['%s=%r' % (key, value)
8960 
      for key, value in self.__dict__.iteritems()]
8961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8962 
 
8963 
  def __eq__(self, other):
8964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8965 
 
8966 
  def __ne__(self, other):
8967 
    return not (self == other)
8968 
 
8969 
class createTransaction_result:
8970 
  """
8971 
  Attributes:
132 ashish 8972 
   - success
94 ashish 8973 
   - ex
8974 
  """
8975 
 
8976 
  thrift_spec = (
132 ashish 8977 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8978 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8979 
  )
8980 
 
132 ashish 8981 
  def __init__(self, success=None, ex=None,):
8982 
    self.success = success
94 ashish 8983 
    self.ex = ex
8984 
 
8985 
  def read(self, iprot):
8986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8988 
      return
8989 
    iprot.readStructBegin()
8990 
    while True:
8991 
      (fname, ftype, fid) = iprot.readFieldBegin()
8992 
      if ftype == TType.STOP:
8993 
        break
132 ashish 8994 
      if fid == 0:
8995 
        if ftype == TType.I64:
8996 
          self.success = iprot.readI64();
8997 
        else:
8998 
          iprot.skip(ftype)
8999 
      elif fid == 1:
94 ashish 9000 
        if ftype == TType.STRUCT:
9001 
          self.ex = TransactionServiceException()
9002 
          self.ex.read(iprot)
9003 
        else:
9004 
          iprot.skip(ftype)
9005 
      else:
9006 
        iprot.skip(ftype)
9007 
      iprot.readFieldEnd()
9008 
    iprot.readStructEnd()
9009 
 
9010 
  def write(self, oprot):
9011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9013 
      return
9014 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 9015 
    if self.success is not None:
132 ashish 9016 
      oprot.writeFieldBegin('success', TType.I64, 0)
9017 
      oprot.writeI64(self.success)
9018 
      oprot.writeFieldEnd()
3431 rajveer 9019 
    if self.ex is not None:
94 ashish 9020 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9021 
      self.ex.write(oprot)
9022 
      oprot.writeFieldEnd()
9023 
    oprot.writeFieldStop()
9024 
    oprot.writeStructEnd()
9025 
 
3431 rajveer 9026 
  def validate(self):
9027 
    return
9028 
 
9029 
 
94 ashish 9030 
  def __repr__(self):
9031 
    L = ['%s=%r' % (key, value)
9032 
      for key, value in self.__dict__.iteritems()]
9033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9034 
 
9035 
  def __eq__(self, other):
9036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9037 
 
9038 
  def __ne__(self, other):
9039 
    return not (self == other)
9040 
 
9041 
class getTransaction_args:
9042 
  """
9043 
  Attributes:
9044 
   - id
9045 
  """
9046 
 
9047 
  thrift_spec = (
9048 
    None, # 0
9049 
    (1, TType.I64, 'id', None, None, ), # 1
9050 
  )
9051 
 
9052 
  def __init__(self, id=None,):
9053 
    self.id = id
9054 
 
9055 
  def read(self, iprot):
9056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9058 
      return
9059 
    iprot.readStructBegin()
9060 
    while True:
9061 
      (fname, ftype, fid) = iprot.readFieldBegin()
9062 
      if ftype == TType.STOP:
9063 
        break
9064 
      if fid == 1:
9065 
        if ftype == TType.I64:
9066 
          self.id = iprot.readI64();
9067 
        else:
9068 
          iprot.skip(ftype)
9069 
      else:
9070 
        iprot.skip(ftype)
9071 
      iprot.readFieldEnd()
9072 
    iprot.readStructEnd()
9073 
 
9074 
  def write(self, oprot):
9075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9077 
      return
9078 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 9079 
    if self.id is not None:
94 ashish 9080 
      oprot.writeFieldBegin('id', TType.I64, 1)
9081 
      oprot.writeI64(self.id)
9082 
      oprot.writeFieldEnd()
9083 
    oprot.writeFieldStop()
9084 
    oprot.writeStructEnd()
9085 
 
3431 rajveer 9086 
  def validate(self):
9087 
    return
9088 
 
9089 
 
94 ashish 9090 
  def __repr__(self):
9091 
    L = ['%s=%r' % (key, value)
9092 
      for key, value in self.__dict__.iteritems()]
9093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9094 
 
9095 
  def __eq__(self, other):
9096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9097 
 
9098 
  def __ne__(self, other):
9099 
    return not (self == other)
9100 
 
9101 
class getTransaction_result:
9102 
  """
9103 
  Attributes:
9104 
   - success
9105 
   - ex
9106 
  """
9107 
 
9108 
  thrift_spec = (
9109 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
9110 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9111 
  )
9112 
 
9113 
  def __init__(self, success=None, ex=None,):
9114 
    self.success = success
9115 
    self.ex = ex
9116 
 
9117 
  def read(self, iprot):
9118 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9119 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9120 
      return
9121 
    iprot.readStructBegin()
9122 
    while True:
9123 
      (fname, ftype, fid) = iprot.readFieldBegin()
9124 
      if ftype == TType.STOP:
9125 
        break
9126 
      if fid == 0:
9127 
        if ftype == TType.STRUCT:
9128 
          self.success = Transaction()
9129 
          self.success.read(iprot)
9130 
        else:
9131 
          iprot.skip(ftype)
9132 
      elif fid == 1:
9133 
        if ftype == TType.STRUCT:
9134 
          self.ex = TransactionServiceException()
9135 
          self.ex.read(iprot)
9136 
        else:
9137 
          iprot.skip(ftype)
9138 
      else:
9139 
        iprot.skip(ftype)
9140 
      iprot.readFieldEnd()
9141 
    iprot.readStructEnd()
9142 
 
9143 
  def write(self, oprot):
9144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9146 
      return
9147 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 9148 
    if self.success is not None:
94 ashish 9149 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9150 
      self.success.write(oprot)
9151 
      oprot.writeFieldEnd()
3431 rajveer 9152 
    if self.ex is not None:
94 ashish 9153 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9154 
      self.ex.write(oprot)
9155 
      oprot.writeFieldEnd()
9156 
    oprot.writeFieldStop()
9157 
    oprot.writeStructEnd()
9158 
 
3431 rajveer 9159 
  def validate(self):
9160 
    return
9161 
 
9162 
 
94 ashish 9163 
  def __repr__(self):
9164 
    L = ['%s=%r' % (key, value)
9165 
      for key, value in self.__dict__.iteritems()]
9166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9167 
 
9168 
  def __eq__(self, other):
9169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9170 
 
9171 
  def __ne__(self, other):
9172 
    return not (self == other)
9173 
 
9174 
class getTransactionsForCustomer_args:
9175 
  """
9176 
  Attributes:
9177 
   - customerId
9178 
   - from_date
9179 
   - to_date
9180 
   - status
9181 
  """
9182 
 
9183 
  thrift_spec = (
9184 
    None, # 0
9185 
    (1, TType.I64, 'customerId', None, None, ), # 1
9186 
    (2, TType.I64, 'from_date', None, None, ), # 2
9187 
    (3, TType.I64, 'to_date', None, None, ), # 3
9188 
    (4, TType.I32, 'status', None, None, ), # 4
9189 
  )
9190 
 
9191 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
9192 
    self.customerId = customerId
9193 
    self.from_date = from_date
9194 
    self.to_date = to_date
9195 
    self.status = status
9196 
 
9197 
  def read(self, iprot):
9198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9200 
      return
9201 
    iprot.readStructBegin()
9202 
    while True:
9203 
      (fname, ftype, fid) = iprot.readFieldBegin()
9204 
      if ftype == TType.STOP:
9205 
        break
9206 
      if fid == 1:
9207 
        if ftype == TType.I64:
9208 
          self.customerId = iprot.readI64();
9209 
        else:
9210 
          iprot.skip(ftype)
9211 
      elif fid == 2:
9212 
        if ftype == TType.I64:
9213 
          self.from_date = iprot.readI64();
9214 
        else:
9215 
          iprot.skip(ftype)
9216 
      elif fid == 3:
9217 
        if ftype == TType.I64:
9218 
          self.to_date = iprot.readI64();
9219 
        else:
9220 
          iprot.skip(ftype)
9221 
      elif fid == 4:
9222 
        if ftype == TType.I32:
9223 
          self.status = iprot.readI32();
9224 
        else:
9225 
          iprot.skip(ftype)
9226 
      else:
9227 
        iprot.skip(ftype)
9228 
      iprot.readFieldEnd()
9229 
    iprot.readStructEnd()
9230 
 
9231 
  def write(self, oprot):
9232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9234 
      return
9235 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 9236 
    if self.customerId is not None:
94 ashish 9237 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9238 
      oprot.writeI64(self.customerId)
9239 
      oprot.writeFieldEnd()
3431 rajveer 9240 
    if self.from_date is not None:
94 ashish 9241 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9242 
      oprot.writeI64(self.from_date)
9243 
      oprot.writeFieldEnd()
3431 rajveer 9244 
    if self.to_date is not None:
94 ashish 9245 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9246 
      oprot.writeI64(self.to_date)
9247 
      oprot.writeFieldEnd()
3431 rajveer 9248 
    if self.status is not None:
94 ashish 9249 
      oprot.writeFieldBegin('status', TType.I32, 4)
9250 
      oprot.writeI32(self.status)
9251 
      oprot.writeFieldEnd()
9252 
    oprot.writeFieldStop()
9253 
    oprot.writeStructEnd()
9254 
 
3431 rajveer 9255 
  def validate(self):
9256 
    return
9257 
 
9258 
 
94 ashish 9259 
  def __repr__(self):
9260 
    L = ['%s=%r' % (key, value)
9261 
      for key, value in self.__dict__.iteritems()]
9262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9263 
 
9264 
  def __eq__(self, other):
9265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9266 
 
9267 
  def __ne__(self, other):
9268 
    return not (self == other)
9269 
 
9270 
class getTransactionsForCustomer_result:
9271 
  """
9272 
  Attributes:
9273 
   - success
9274 
   - ex
9275 
  """
9276 
 
9277 
  thrift_spec = (
9278 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9279 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9280 
  )
9281 
 
9282 
  def __init__(self, success=None, ex=None,):
9283 
    self.success = success
9284 
    self.ex = ex
9285 
 
9286 
  def read(self, iprot):
9287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9289 
      return
9290 
    iprot.readStructBegin()
9291 
    while True:
9292 
      (fname, ftype, fid) = iprot.readFieldBegin()
9293 
      if ftype == TType.STOP:
9294 
        break
9295 
      if fid == 0:
9296 
        if ftype == TType.LIST:
9297 
          self.success = []
6188 rajveer 9298 
          (_etype109, _size106) = iprot.readListBegin()
9299 
          for _i110 in xrange(_size106):
9300 
            _elem111 = Transaction()
9301 
            _elem111.read(iprot)
9302 
            self.success.append(_elem111)
94 ashish 9303 
          iprot.readListEnd()
9304 
        else:
9305 
          iprot.skip(ftype)
9306 
      elif fid == 1:
9307 
        if ftype == TType.STRUCT:
9308 
          self.ex = TransactionServiceException()
9309 
          self.ex.read(iprot)
9310 
        else:
9311 
          iprot.skip(ftype)
9312 
      else:
9313 
        iprot.skip(ftype)
9314 
      iprot.readFieldEnd()
9315 
    iprot.readStructEnd()
9316 
 
9317 
  def write(self, oprot):
9318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9320 
      return
9321 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 9322 
    if self.success is not None:
94 ashish 9323 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9324 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9325 
      for iter112 in self.success:
9326 
        iter112.write(oprot)
94 ashish 9327 
      oprot.writeListEnd()
9328 
      oprot.writeFieldEnd()
3431 rajveer 9329 
    if self.ex is not None:
94 ashish 9330 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9331 
      self.ex.write(oprot)
9332 
      oprot.writeFieldEnd()
9333 
    oprot.writeFieldStop()
9334 
    oprot.writeStructEnd()
9335 
 
3431 rajveer 9336 
  def validate(self):
9337 
    return
9338 
 
9339 
 
94 ashish 9340 
  def __repr__(self):
9341 
    L = ['%s=%r' % (key, value)
9342 
      for key, value in self.__dict__.iteritems()]
9343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9344 
 
9345 
  def __eq__(self, other):
9346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9347 
 
9348 
  def __ne__(self, other):
9349 
    return not (self == other)
9350 
 
132 ashish 9351 
class getTransactionsForShoppingCartId_args:
9352 
  """
9353 
  Attributes:
9354 
   - shoppingCartId
9355 
  """
9356 
 
9357 
  thrift_spec = (
9358 
    None, # 0
9359 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
9360 
  )
9361 
 
9362 
  def __init__(self, shoppingCartId=None,):
9363 
    self.shoppingCartId = shoppingCartId
9364 
 
9365 
  def read(self, iprot):
9366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9368 
      return
9369 
    iprot.readStructBegin()
9370 
    while True:
9371 
      (fname, ftype, fid) = iprot.readFieldBegin()
9372 
      if ftype == TType.STOP:
9373 
        break
9374 
      if fid == 1:
9375 
        if ftype == TType.I64:
9376 
          self.shoppingCartId = iprot.readI64();
9377 
        else:
9378 
          iprot.skip(ftype)
9379 
      else:
9380 
        iprot.skip(ftype)
9381 
      iprot.readFieldEnd()
9382 
    iprot.readStructEnd()
9383 
 
9384 
  def write(self, oprot):
9385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9387 
      return
9388 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 9389 
    if self.shoppingCartId is not None:
132 ashish 9390 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
9391 
      oprot.writeI64(self.shoppingCartId)
9392 
      oprot.writeFieldEnd()
9393 
    oprot.writeFieldStop()
9394 
    oprot.writeStructEnd()
9395 
 
3431 rajveer 9396 
  def validate(self):
9397 
    return
9398 
 
9399 
 
132 ashish 9400 
  def __repr__(self):
9401 
    L = ['%s=%r' % (key, value)
9402 
      for key, value in self.__dict__.iteritems()]
9403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9404 
 
9405 
  def __eq__(self, other):
9406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9407 
 
9408 
  def __ne__(self, other):
9409 
    return not (self == other)
9410 
 
9411 
class getTransactionsForShoppingCartId_result:
9412 
  """
9413 
  Attributes:
9414 
   - success
9415 
   - ex
9416 
  """
9417 
 
9418 
  thrift_spec = (
9419 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9420 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9421 
  )
9422 
 
9423 
  def __init__(self, success=None, ex=None,):
9424 
    self.success = success
9425 
    self.ex = ex
9426 
 
9427 
  def read(self, iprot):
9428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9430 
      return
9431 
    iprot.readStructBegin()
9432 
    while True:
9433 
      (fname, ftype, fid) = iprot.readFieldBegin()
9434 
      if ftype == TType.STOP:
9435 
        break
9436 
      if fid == 0:
9437 
        if ftype == TType.LIST:
9438 
          self.success = []
6188 rajveer 9439 
          (_etype116, _size113) = iprot.readListBegin()
9440 
          for _i117 in xrange(_size113):
9441 
            _elem118 = Transaction()
9442 
            _elem118.read(iprot)
9443 
            self.success.append(_elem118)
132 ashish 9444 
          iprot.readListEnd()
9445 
        else:
9446 
          iprot.skip(ftype)
9447 
      elif fid == 1:
9448 
        if ftype == TType.STRUCT:
9449 
          self.ex = TransactionServiceException()
9450 
          self.ex.read(iprot)
9451 
        else:
9452 
          iprot.skip(ftype)
9453 
      else:
9454 
        iprot.skip(ftype)
9455 
      iprot.readFieldEnd()
9456 
    iprot.readStructEnd()
9457 
 
9458 
  def write(self, oprot):
9459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9461 
      return
9462 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 9463 
    if self.success is not None:
132 ashish 9464 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9465 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9466 
      for iter119 in self.success:
9467 
        iter119.write(oprot)
132 ashish 9468 
      oprot.writeListEnd()
9469 
      oprot.writeFieldEnd()
3431 rajveer 9470 
    if self.ex is not None:
132 ashish 9471 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9472 
      self.ex.write(oprot)
9473 
      oprot.writeFieldEnd()
9474 
    oprot.writeFieldStop()
9475 
    oprot.writeStructEnd()
9476 
 
3431 rajveer 9477 
  def validate(self):
9478 
    return
9479 
 
9480 
 
132 ashish 9481 
  def __repr__(self):
9482 
    L = ['%s=%r' % (key, value)
9483 
      for key, value in self.__dict__.iteritems()]
9484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9485 
 
9486 
  def __eq__(self, other):
9487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9488 
 
9489 
  def __ne__(self, other):
9490 
    return not (self == other)
9491 
 
94 ashish 9492 
class getTransactionStatus_args:
9493 
  """
9494 
  Attributes:
9495 
   - transactionId
9496 
  """
9497 
 
9498 
  thrift_spec = (
9499 
    None, # 0
9500 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9501 
  )
9502 
 
9503 
  def __init__(self, transactionId=None,):
9504 
    self.transactionId = transactionId
9505 
 
9506 
  def read(self, iprot):
9507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9509 
      return
9510 
    iprot.readStructBegin()
9511 
    while True:
9512 
      (fname, ftype, fid) = iprot.readFieldBegin()
9513 
      if ftype == TType.STOP:
9514 
        break
9515 
      if fid == 1:
9516 
        if ftype == TType.I64:
9517 
          self.transactionId = iprot.readI64();
9518 
        else:
9519 
          iprot.skip(ftype)
9520 
      else:
9521 
        iprot.skip(ftype)
9522 
      iprot.readFieldEnd()
9523 
    iprot.readStructEnd()
9524 
 
9525 
  def write(self, oprot):
9526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9528 
      return
9529 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 9530 
    if self.transactionId is not None:
94 ashish 9531 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9532 
      oprot.writeI64(self.transactionId)
9533 
      oprot.writeFieldEnd()
9534 
    oprot.writeFieldStop()
9535 
    oprot.writeStructEnd()
9536 
 
3431 rajveer 9537 
  def validate(self):
9538 
    return
9539 
 
9540 
 
94 ashish 9541 
  def __repr__(self):
9542 
    L = ['%s=%r' % (key, value)
9543 
      for key, value in self.__dict__.iteritems()]
9544 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9545 
 
9546 
  def __eq__(self, other):
9547 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9548 
 
9549 
  def __ne__(self, other):
9550 
    return not (self == other)
9551 
 
9552 
class getTransactionStatus_result:
9553 
  """
9554 
  Attributes:
9555 
   - success
9556 
   - ex
9557 
  """
9558 
 
9559 
  thrift_spec = (
9560 
    (0, TType.I32, 'success', None, None, ), # 0
9561 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9562 
  )
9563 
 
9564 
  def __init__(self, success=None, ex=None,):
9565 
    self.success = success
9566 
    self.ex = ex
9567 
 
9568 
  def read(self, iprot):
9569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9571 
      return
9572 
    iprot.readStructBegin()
9573 
    while True:
9574 
      (fname, ftype, fid) = iprot.readFieldBegin()
9575 
      if ftype == TType.STOP:
9576 
        break
9577 
      if fid == 0:
9578 
        if ftype == TType.I32:
9579 
          self.success = iprot.readI32();
9580 
        else:
9581 
          iprot.skip(ftype)
9582 
      elif fid == 1:
9583 
        if ftype == TType.STRUCT:
9584 
          self.ex = TransactionServiceException()
9585 
          self.ex.read(iprot)
9586 
        else:
9587 
          iprot.skip(ftype)
9588 
      else:
9589 
        iprot.skip(ftype)
9590 
      iprot.readFieldEnd()
9591 
    iprot.readStructEnd()
9592 
 
9593 
  def write(self, oprot):
9594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9596 
      return
9597 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 9598 
    if self.success is not None:
94 ashish 9599 
      oprot.writeFieldBegin('success', TType.I32, 0)
9600 
      oprot.writeI32(self.success)
9601 
      oprot.writeFieldEnd()
3431 rajveer 9602 
    if self.ex is not None:
94 ashish 9603 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9604 
      self.ex.write(oprot)
9605 
      oprot.writeFieldEnd()
9606 
    oprot.writeFieldStop()
9607 
    oprot.writeStructEnd()
9608 
 
3431 rajveer 9609 
  def validate(self):
9610 
    return
9611 
 
9612 
 
94 ashish 9613 
  def __repr__(self):
9614 
    L = ['%s=%r' % (key, value)
9615 
      for key, value in self.__dict__.iteritems()]
9616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9617 
 
9618 
  def __eq__(self, other):
9619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9620 
 
9621 
  def __ne__(self, other):
9622 
    return not (self == other)
9623 
 
9624 
class changeTransactionStatus_args:
9625 
  """
9626 
  Attributes:
9627 
   - transactionId
9628 
   - status
9629 
   - description
5527 anupam.sin 9630 
   - pickUp
9631 
   - orderType
94 ashish 9632 
  """
9633 
 
9634 
  thrift_spec = (
9635 
    None, # 0
9636 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9637 
    (2, TType.I32, 'status', None, None, ), # 2
9638 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 9639 
    (4, TType.I64, 'pickUp', None, None, ), # 4
9640 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 9641 
  )
9642 
 
5527 anupam.sin 9643 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 9644 
    self.transactionId = transactionId
9645 
    self.status = status
9646 
    self.description = description
5527 anupam.sin 9647 
    self.pickUp = pickUp
9648 
    self.orderType = orderType
94 ashish 9649 
 
9650 
  def read(self, iprot):
9651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9653 
      return
9654 
    iprot.readStructBegin()
9655 
    while True:
9656 
      (fname, ftype, fid) = iprot.readFieldBegin()
9657 
      if ftype == TType.STOP:
9658 
        break
9659 
      if fid == 1:
9660 
        if ftype == TType.I64:
9661 
          self.transactionId = iprot.readI64();
9662 
        else:
9663 
          iprot.skip(ftype)
9664 
      elif fid == 2:
9665 
        if ftype == TType.I32:
9666 
          self.status = iprot.readI32();
9667 
        else:
9668 
          iprot.skip(ftype)
9669 
      elif fid == 3:
9670 
        if ftype == TType.STRING:
9671 
          self.description = iprot.readString();
9672 
        else:
9673 
          iprot.skip(ftype)
5387 rajveer 9674 
      elif fid == 4:
5527 anupam.sin 9675 
        if ftype == TType.I64:
9676 
          self.pickUp = iprot.readI64();
5387 rajveer 9677 
        else:
9678 
          iprot.skip(ftype)
5527 anupam.sin 9679 
      elif fid == 5:
9680 
        if ftype == TType.I32:
9681 
          self.orderType = iprot.readI32();
9682 
        else:
9683 
          iprot.skip(ftype)
94 ashish 9684 
      else:
9685 
        iprot.skip(ftype)
9686 
      iprot.readFieldEnd()
9687 
    iprot.readStructEnd()
9688 
 
9689 
  def write(self, oprot):
9690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9692 
      return
9693 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 9694 
    if self.transactionId is not None:
94 ashish 9695 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9696 
      oprot.writeI64(self.transactionId)
9697 
      oprot.writeFieldEnd()
3431 rajveer 9698 
    if self.status is not None:
94 ashish 9699 
      oprot.writeFieldBegin('status', TType.I32, 2)
9700 
      oprot.writeI32(self.status)
9701 
      oprot.writeFieldEnd()
3431 rajveer 9702 
    if self.description is not None:
94 ashish 9703 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9704 
      oprot.writeString(self.description)
9705 
      oprot.writeFieldEnd()
5527 anupam.sin 9706 
    if self.pickUp is not None:
9707 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
9708 
      oprot.writeI64(self.pickUp)
5387 rajveer 9709 
      oprot.writeFieldEnd()
5527 anupam.sin 9710 
    if self.orderType is not None:
9711 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
9712 
      oprot.writeI32(self.orderType)
9713 
      oprot.writeFieldEnd()
94 ashish 9714 
    oprot.writeFieldStop()
9715 
    oprot.writeStructEnd()
9716 
 
3431 rajveer 9717 
  def validate(self):
9718 
    return
9719 
 
9720 
 
94 ashish 9721 
  def __repr__(self):
9722 
    L = ['%s=%r' % (key, value)
9723 
      for key, value in self.__dict__.iteritems()]
9724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9725 
 
9726 
  def __eq__(self, other):
9727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9728 
 
9729 
  def __ne__(self, other):
9730 
    return not (self == other)
9731 
 
9732 
class changeTransactionStatus_result:
9733 
  """
9734 
  Attributes:
9735 
   - success
9736 
   - ex
9737 
  """
9738 
 
9739 
  thrift_spec = (
9740 
    (0, TType.BOOL, 'success', None, None, ), # 0
9741 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9742 
  )
9743 
 
9744 
  def __init__(self, success=None, ex=None,):
9745 
    self.success = success
9746 
    self.ex = ex
9747 
 
9748 
  def read(self, iprot):
9749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9751 
      return
9752 
    iprot.readStructBegin()
9753 
    while True:
9754 
      (fname, ftype, fid) = iprot.readFieldBegin()
9755 
      if ftype == TType.STOP:
9756 
        break
9757 
      if fid == 0:
9758 
        if ftype == TType.BOOL:
9759 
          self.success = iprot.readBool();
9760 
        else:
9761 
          iprot.skip(ftype)
9762 
      elif fid == 1:
9763 
        if ftype == TType.STRUCT:
9764 
          self.ex = TransactionServiceException()
9765 
          self.ex.read(iprot)
9766 
        else:
9767 
          iprot.skip(ftype)
9768 
      else:
9769 
        iprot.skip(ftype)
9770 
      iprot.readFieldEnd()
9771 
    iprot.readStructEnd()
9772 
 
9773 
  def write(self, oprot):
9774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9776 
      return
9777 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9778 
    if self.success is not None:
94 ashish 9779 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9780 
      oprot.writeBool(self.success)
9781 
      oprot.writeFieldEnd()
3431 rajveer 9782 
    if self.ex is not None:
94 ashish 9783 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9784 
      self.ex.write(oprot)
9785 
      oprot.writeFieldEnd()
9786 
    oprot.writeFieldStop()
9787 
    oprot.writeStructEnd()
9788 
 
3431 rajveer 9789 
  def validate(self):
9790 
    return
9791 
 
9792 
 
94 ashish 9793 
  def __repr__(self):
9794 
    L = ['%s=%r' % (key, value)
9795 
      for key, value in self.__dict__.iteritems()]
9796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9797 
 
9798 
  def __eq__(self, other):
9799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9800 
 
9801 
  def __ne__(self, other):
9802 
    return not (self == other)
9803 
 
1398 varun.gupt 9804 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 9805 
  """
9806 
  Attributes:
9807 
   - transactionId
9808 
  """
9809 
 
9810 
  thrift_spec = (
9811 
    None, # 0
9812 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9813 
  )
9814 
 
9815 
  def __init__(self, transactionId=None,):
9816 
    self.transactionId = transactionId
9817 
 
9818 
  def read(self, iprot):
9819 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9820 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9821 
      return
9822 
    iprot.readStructBegin()
9823 
    while True:
9824 
      (fname, ftype, fid) = iprot.readFieldBegin()
9825 
      if ftype == TType.STOP:
9826 
        break
9827 
      if fid == 1:
9828 
        if ftype == TType.I64:
9829 
          self.transactionId = iprot.readI64();
9830 
        else:
9831 
          iprot.skip(ftype)
9832 
      else:
9833 
        iprot.skip(ftype)
9834 
      iprot.readFieldEnd()
9835 
    iprot.readStructEnd()
9836 
 
9837 
  def write(self, oprot):
9838 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9839 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9840 
      return
1398 varun.gupt 9841 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 9842 
    if self.transactionId is not None:
1382 varun.gupt 9843 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9844 
      oprot.writeI64(self.transactionId)
9845 
      oprot.writeFieldEnd()
9846 
    oprot.writeFieldStop()
9847 
    oprot.writeStructEnd()
9848 
 
3431 rajveer 9849 
  def validate(self):
9850 
    return
9851 
 
9852 
 
1382 varun.gupt 9853 
  def __repr__(self):
9854 
    L = ['%s=%r' % (key, value)
9855 
      for key, value in self.__dict__.iteritems()]
9856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9857 
 
9858 
  def __eq__(self, other):
9859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9860 
 
9861 
  def __ne__(self, other):
9862 
    return not (self == other)
9863 
 
1398 varun.gupt 9864 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 9865 
  """
9866 
  Attributes:
9867 
   - success
9868 
   - ex
9869 
  """
9870 
 
9871 
  thrift_spec = (
9872 
    (0, TType.BOOL, 'success', None, None, ), # 0
9873 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9874 
  )
9875 
 
9876 
  def __init__(self, success=None, ex=None,):
9877 
    self.success = success
9878 
    self.ex = ex
9879 
 
9880 
  def read(self, iprot):
9881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9883 
      return
9884 
    iprot.readStructBegin()
9885 
    while True:
9886 
      (fname, ftype, fid) = iprot.readFieldBegin()
9887 
      if ftype == TType.STOP:
9888 
        break
9889 
      if fid == 0:
9890 
        if ftype == TType.BOOL:
9891 
          self.success = iprot.readBool();
9892 
        else:
9893 
          iprot.skip(ftype)
9894 
      elif fid == 1:
9895 
        if ftype == TType.STRUCT:
9896 
          self.ex = TransactionServiceException()
9897 
          self.ex.read(iprot)
9898 
        else:
9899 
          iprot.skip(ftype)
9900 
      else:
9901 
        iprot.skip(ftype)
9902 
      iprot.readFieldEnd()
9903 
    iprot.readStructEnd()
9904 
 
9905 
  def write(self, oprot):
9906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9908 
      return
1398 varun.gupt 9909 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9910 
    if self.success is not None:
1382 varun.gupt 9911 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9912 
      oprot.writeBool(self.success)
9913 
      oprot.writeFieldEnd()
3431 rajveer 9914 
    if self.ex is not None:
1382 varun.gupt 9915 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9916 
      self.ex.write(oprot)
9917 
      oprot.writeFieldEnd()
9918 
    oprot.writeFieldStop()
9919 
    oprot.writeStructEnd()
9920 
 
3431 rajveer 9921 
  def validate(self):
9922 
    return
9923 
 
9924 
 
1382 varun.gupt 9925 
  def __repr__(self):
9926 
    L = ['%s=%r' % (key, value)
9927 
      for key, value in self.__dict__.iteritems()]
9928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9929 
 
9930 
  def __eq__(self, other):
9931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9932 
 
9933 
  def __ne__(self, other):
9934 
    return not (self == other)
9935 
 
483 rajveer 9936 
class getAllOrders_args:
94 ashish 9937 
  """
9938 
  Attributes:
4801 anupam.sin 9939 
   - statuses
483 rajveer 9940 
   - from_date
9941 
   - to_date
9942 
   - warehouse_id
94 ashish 9943 
  """
9944 
 
9945 
  thrift_spec = (
9946 
    None, # 0
4801 anupam.sin 9947 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 9948 
    (2, TType.I64, 'from_date', None, None, ), # 2
9949 
    (3, TType.I64, 'to_date', None, None, ), # 3
9950 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 9951 
  )
9952 
 
4801 anupam.sin 9953 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
9954 
    self.statuses = statuses
483 rajveer 9955 
    self.from_date = from_date
9956 
    self.to_date = to_date
9957 
    self.warehouse_id = warehouse_id
94 ashish 9958 
 
9959 
  def read(self, iprot):
9960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9962 
      return
9963 
    iprot.readStructBegin()
9964 
    while True:
9965 
      (fname, ftype, fid) = iprot.readFieldBegin()
9966 
      if ftype == TType.STOP:
9967 
        break
9968 
      if fid == 1:
4801 anupam.sin 9969 
        if ftype == TType.LIST:
9970 
          self.statuses = []
6188 rajveer 9971 
          (_etype123, _size120) = iprot.readListBegin()
9972 
          for _i124 in xrange(_size120):
9973 
            _elem125 = iprot.readI32();
9974 
            self.statuses.append(_elem125)
4801 anupam.sin 9975 
          iprot.readListEnd()
94 ashish 9976 
        else:
9977 
          iprot.skip(ftype)
483 rajveer 9978 
      elif fid == 2:
9979 
        if ftype == TType.I64:
9980 
          self.from_date = iprot.readI64();
94 ashish 9981 
        else:
9982 
          iprot.skip(ftype)
483 rajveer 9983 
      elif fid == 3:
9984 
        if ftype == TType.I64:
9985 
          self.to_date = iprot.readI64();
94 ashish 9986 
        else:
9987 
          iprot.skip(ftype)
483 rajveer 9988 
      elif fid == 4:
94 ashish 9989 
        if ftype == TType.I64:
483 rajveer 9990 
          self.warehouse_id = iprot.readI64();
94 ashish 9991 
        else:
9992 
          iprot.skip(ftype)
9993 
      else:
9994 
        iprot.skip(ftype)
9995 
      iprot.readFieldEnd()
9996 
    iprot.readStructEnd()
9997 
 
9998 
  def write(self, oprot):
9999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10001 
      return
483 rajveer 10002 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 10003 
    if self.statuses is not None:
10004 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10005 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10006 
      for iter126 in self.statuses:
10007 
        oprot.writeI32(iter126)
4801 anupam.sin 10008 
      oprot.writeListEnd()
94 ashish 10009 
      oprot.writeFieldEnd()
3431 rajveer 10010 
    if self.from_date is not None:
483 rajveer 10011 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
10012 
      oprot.writeI64(self.from_date)
94 ashish 10013 
      oprot.writeFieldEnd()
3431 rajveer 10014 
    if self.to_date is not None:
483 rajveer 10015 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
10016 
      oprot.writeI64(self.to_date)
94 ashish 10017 
      oprot.writeFieldEnd()
3431 rajveer 10018 
    if self.warehouse_id is not None:
483 rajveer 10019 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10020 
      oprot.writeI64(self.warehouse_id)
94 ashish 10021 
      oprot.writeFieldEnd()
10022 
    oprot.writeFieldStop()
10023 
    oprot.writeStructEnd()
10024 
 
3431 rajveer 10025 
  def validate(self):
10026 
    return
10027 
 
10028 
 
94 ashish 10029 
  def __repr__(self):
10030 
    L = ['%s=%r' % (key, value)
10031 
      for key, value in self.__dict__.iteritems()]
10032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10033 
 
10034 
  def __eq__(self, other):
10035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10036 
 
10037 
  def __ne__(self, other):
10038 
    return not (self == other)
10039 
 
483 rajveer 10040 
class getAllOrders_result:
94 ashish 10041 
  """
10042 
  Attributes:
10043 
   - success
10044 
   - ex
10045 
  """
10046 
 
10047 
  thrift_spec = (
483 rajveer 10048 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 10049 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10050 
  )
10051 
 
10052 
  def __init__(self, success=None, ex=None,):
10053 
    self.success = success
10054 
    self.ex = ex
10055 
 
10056 
  def read(self, iprot):
10057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10059 
      return
10060 
    iprot.readStructBegin()
10061 
    while True:
10062 
      (fname, ftype, fid) = iprot.readFieldBegin()
10063 
      if ftype == TType.STOP:
10064 
        break
10065 
      if fid == 0:
483 rajveer 10066 
        if ftype == TType.LIST:
10067 
          self.success = []
6188 rajveer 10068 
          (_etype130, _size127) = iprot.readListBegin()
10069 
          for _i131 in xrange(_size127):
10070 
            _elem132 = Order()
10071 
            _elem132.read(iprot)
10072 
            self.success.append(_elem132)
483 rajveer 10073 
          iprot.readListEnd()
94 ashish 10074 
        else:
10075 
          iprot.skip(ftype)
10076 
      elif fid == 1:
10077 
        if ftype == TType.STRUCT:
10078 
          self.ex = TransactionServiceException()
10079 
          self.ex.read(iprot)
10080 
        else:
10081 
          iprot.skip(ftype)
10082 
      else:
10083 
        iprot.skip(ftype)
10084 
      iprot.readFieldEnd()
10085 
    iprot.readStructEnd()
10086 
 
10087 
  def write(self, oprot):
10088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10090 
      return
483 rajveer 10091 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 10092 
    if self.success is not None:
483 rajveer 10093 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10094 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10095 
      for iter133 in self.success:
10096 
        iter133.write(oprot)
483 rajveer 10097 
      oprot.writeListEnd()
94 ashish 10098 
      oprot.writeFieldEnd()
3431 rajveer 10099 
    if self.ex is not None:
94 ashish 10100 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10101 
      self.ex.write(oprot)
10102 
      oprot.writeFieldEnd()
10103 
    oprot.writeFieldStop()
10104 
    oprot.writeStructEnd()
10105 
 
3431 rajveer 10106 
  def validate(self):
10107 
    return
10108 
 
10109 
 
94 ashish 10110 
  def __repr__(self):
10111 
    L = ['%s=%r' % (key, value)
10112 
      for key, value in self.__dict__.iteritems()]
10113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10114 
 
10115 
  def __eq__(self, other):
10116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10117 
 
10118 
  def __ne__(self, other):
10119 
    return not (self == other)
10120 
 
4133 chandransh 10121 
class getOrdersInBatch_args:
10122 
  """
10123 
  Attributes:
10124 
   - statuses
10125 
   - offset
10126 
   - limit
10127 
   - warehouse_id
10128 
  """
10129 
 
10130 
  thrift_spec = (
10131 
    None, # 0
10132 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10133 
    (2, TType.I64, 'offset', None, None, ), # 2
10134 
    (3, TType.I64, 'limit', None, None, ), # 3
10135 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10136 
  )
10137 
 
10138 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
10139 
    self.statuses = statuses
10140 
    self.offset = offset
10141 
    self.limit = limit
10142 
    self.warehouse_id = warehouse_id
10143 
 
10144 
  def read(self, iprot):
10145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10147 
      return
10148 
    iprot.readStructBegin()
10149 
    while True:
10150 
      (fname, ftype, fid) = iprot.readFieldBegin()
10151 
      if ftype == TType.STOP:
10152 
        break
10153 
      if fid == 1:
10154 
        if ftype == TType.LIST:
10155 
          self.statuses = []
6188 rajveer 10156 
          (_etype137, _size134) = iprot.readListBegin()
10157 
          for _i138 in xrange(_size134):
10158 
            _elem139 = iprot.readI32();
10159 
            self.statuses.append(_elem139)
4133 chandransh 10160 
          iprot.readListEnd()
10161 
        else:
10162 
          iprot.skip(ftype)
10163 
      elif fid == 2:
10164 
        if ftype == TType.I64:
10165 
          self.offset = iprot.readI64();
10166 
        else:
10167 
          iprot.skip(ftype)
10168 
      elif fid == 3:
10169 
        if ftype == TType.I64:
10170 
          self.limit = iprot.readI64();
10171 
        else:
10172 
          iprot.skip(ftype)
10173 
      elif fid == 4:
10174 
        if ftype == TType.I64:
10175 
          self.warehouse_id = iprot.readI64();
10176 
        else:
10177 
          iprot.skip(ftype)
10178 
      else:
10179 
        iprot.skip(ftype)
10180 
      iprot.readFieldEnd()
10181 
    iprot.readStructEnd()
10182 
 
10183 
  def write(self, oprot):
10184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10186 
      return
10187 
    oprot.writeStructBegin('getOrdersInBatch_args')
10188 
    if self.statuses is not None:
10189 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10190 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10191 
      for iter140 in self.statuses:
10192 
        oprot.writeI32(iter140)
4133 chandransh 10193 
      oprot.writeListEnd()
10194 
      oprot.writeFieldEnd()
10195 
    if self.offset is not None:
10196 
      oprot.writeFieldBegin('offset', TType.I64, 2)
10197 
      oprot.writeI64(self.offset)
10198 
      oprot.writeFieldEnd()
10199 
    if self.limit is not None:
10200 
      oprot.writeFieldBegin('limit', TType.I64, 3)
10201 
      oprot.writeI64(self.limit)
10202 
      oprot.writeFieldEnd()
10203 
    if self.warehouse_id is not None:
10204 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10205 
      oprot.writeI64(self.warehouse_id)
10206 
      oprot.writeFieldEnd()
10207 
    oprot.writeFieldStop()
10208 
    oprot.writeStructEnd()
10209 
 
10210 
  def validate(self):
10211 
    return
10212 
 
10213 
 
10214 
  def __repr__(self):
10215 
    L = ['%s=%r' % (key, value)
10216 
      for key, value in self.__dict__.iteritems()]
10217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10218 
 
10219 
  def __eq__(self, other):
10220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10221 
 
10222 
  def __ne__(self, other):
10223 
    return not (self == other)
10224 
 
10225 
class getOrdersInBatch_result:
10226 
  """
10227 
  Attributes:
10228 
   - success
10229 
   - ex
10230 
  """
10231 
 
10232 
  thrift_spec = (
10233 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10234 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10235 
  )
10236 
 
10237 
  def __init__(self, success=None, ex=None,):
10238 
    self.success = success
10239 
    self.ex = ex
10240 
 
10241 
  def read(self, iprot):
10242 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10243 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10244 
      return
10245 
    iprot.readStructBegin()
10246 
    while True:
10247 
      (fname, ftype, fid) = iprot.readFieldBegin()
10248 
      if ftype == TType.STOP:
10249 
        break
10250 
      if fid == 0:
10251 
        if ftype == TType.LIST:
10252 
          self.success = []
6188 rajveer 10253 
          (_etype144, _size141) = iprot.readListBegin()
10254 
          for _i145 in xrange(_size141):
10255 
            _elem146 = Order()
10256 
            _elem146.read(iprot)
10257 
            self.success.append(_elem146)
4133 chandransh 10258 
          iprot.readListEnd()
10259 
        else:
10260 
          iprot.skip(ftype)
10261 
      elif fid == 1:
10262 
        if ftype == TType.STRUCT:
10263 
          self.ex = TransactionServiceException()
10264 
          self.ex.read(iprot)
10265 
        else:
10266 
          iprot.skip(ftype)
10267 
      else:
10268 
        iprot.skip(ftype)
10269 
      iprot.readFieldEnd()
10270 
    iprot.readStructEnd()
10271 
 
10272 
  def write(self, oprot):
10273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10275 
      return
10276 
    oprot.writeStructBegin('getOrdersInBatch_result')
10277 
    if self.success is not None:
10278 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10279 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10280 
      for iter147 in self.success:
10281 
        iter147.write(oprot)
4133 chandransh 10282 
      oprot.writeListEnd()
10283 
      oprot.writeFieldEnd()
10284 
    if self.ex is not None:
10285 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10286 
      self.ex.write(oprot)
10287 
      oprot.writeFieldEnd()
10288 
    oprot.writeFieldStop()
10289 
    oprot.writeStructEnd()
10290 
 
10291 
  def validate(self):
10292 
    return
10293 
 
10294 
 
10295 
  def __repr__(self):
10296 
    L = ['%s=%r' % (key, value)
10297 
      for key, value in self.__dict__.iteritems()]
10298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10299 
 
10300 
  def __eq__(self, other):
10301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10302 
 
10303 
  def __ne__(self, other):
10304 
    return not (self == other)
10305 
 
10306 
class getOrderCount_args:
10307 
  """
10308 
  Attributes:
10309 
   - statuses
10310 
   - warehouseId
10311 
  """
10312 
 
10313 
  thrift_spec = (
10314 
    None, # 0
10315 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10316 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10317 
  )
10318 
 
10319 
  def __init__(self, statuses=None, warehouseId=None,):
10320 
    self.statuses = statuses
10321 
    self.warehouseId = warehouseId
10322 
 
10323 
  def read(self, iprot):
10324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10326 
      return
10327 
    iprot.readStructBegin()
10328 
    while True:
10329 
      (fname, ftype, fid) = iprot.readFieldBegin()
10330 
      if ftype == TType.STOP:
10331 
        break
10332 
      if fid == 1:
10333 
        if ftype == TType.LIST:
10334 
          self.statuses = []
6188 rajveer 10335 
          (_etype151, _size148) = iprot.readListBegin()
10336 
          for _i152 in xrange(_size148):
10337 
            _elem153 = iprot.readI32();
10338 
            self.statuses.append(_elem153)
4133 chandransh 10339 
          iprot.readListEnd()
10340 
        else:
10341 
          iprot.skip(ftype)
10342 
      elif fid == 2:
10343 
        if ftype == TType.I64:
10344 
          self.warehouseId = iprot.readI64();
10345 
        else:
10346 
          iprot.skip(ftype)
10347 
      else:
10348 
        iprot.skip(ftype)
10349 
      iprot.readFieldEnd()
10350 
    iprot.readStructEnd()
10351 
 
10352 
  def write(self, oprot):
10353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10355 
      return
10356 
    oprot.writeStructBegin('getOrderCount_args')
10357 
    if self.statuses is not None:
10358 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10359 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10360 
      for iter154 in self.statuses:
10361 
        oprot.writeI32(iter154)
4133 chandransh 10362 
      oprot.writeListEnd()
10363 
      oprot.writeFieldEnd()
10364 
    if self.warehouseId is not None:
10365 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10366 
      oprot.writeI64(self.warehouseId)
10367 
      oprot.writeFieldEnd()
10368 
    oprot.writeFieldStop()
10369 
    oprot.writeStructEnd()
10370 
 
10371 
  def validate(self):
10372 
    return
10373 
 
10374 
 
10375 
  def __repr__(self):
10376 
    L = ['%s=%r' % (key, value)
10377 
      for key, value in self.__dict__.iteritems()]
10378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10379 
 
10380 
  def __eq__(self, other):
10381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10382 
 
10383 
  def __ne__(self, other):
10384 
    return not (self == other)
10385 
 
10386 
class getOrderCount_result:
10387 
  """
10388 
  Attributes:
10389 
   - success
10390 
   - ex
10391 
  """
10392 
 
10393 
  thrift_spec = (
10394 
    (0, TType.I32, 'success', None, None, ), # 0
10395 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10396 
  )
10397 
 
10398 
  def __init__(self, success=None, ex=None,):
10399 
    self.success = success
10400 
    self.ex = ex
10401 
 
10402 
  def read(self, iprot):
10403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10405 
      return
10406 
    iprot.readStructBegin()
10407 
    while True:
10408 
      (fname, ftype, fid) = iprot.readFieldBegin()
10409 
      if ftype == TType.STOP:
10410 
        break
10411 
      if fid == 0:
10412 
        if ftype == TType.I32:
10413 
          self.success = iprot.readI32();
10414 
        else:
10415 
          iprot.skip(ftype)
10416 
      elif fid == 1:
10417 
        if ftype == TType.STRUCT:
10418 
          self.ex = TransactionServiceException()
10419 
          self.ex.read(iprot)
10420 
        else:
10421 
          iprot.skip(ftype)
10422 
      else:
10423 
        iprot.skip(ftype)
10424 
      iprot.readFieldEnd()
10425 
    iprot.readStructEnd()
10426 
 
10427 
  def write(self, oprot):
10428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10430 
      return
10431 
    oprot.writeStructBegin('getOrderCount_result')
10432 
    if self.success is not None:
10433 
      oprot.writeFieldBegin('success', TType.I32, 0)
10434 
      oprot.writeI32(self.success)
10435 
      oprot.writeFieldEnd()
10436 
    if self.ex is not None:
10437 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10438 
      self.ex.write(oprot)
10439 
      oprot.writeFieldEnd()
10440 
    oprot.writeFieldStop()
10441 
    oprot.writeStructEnd()
10442 
 
10443 
  def validate(self):
10444 
    return
10445 
 
10446 
 
10447 
  def __repr__(self):
10448 
    L = ['%s=%r' % (key, value)
10449 
      for key, value in self.__dict__.iteritems()]
10450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10451 
 
10452 
  def __eq__(self, other):
10453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10454 
 
10455 
  def __ne__(self, other):
10456 
    return not (self == other)
10457 
 
999 varun.gupt 10458 
class getOrdersByBillingDate_args:
10459 
  """
10460 
  Attributes:
10461 
   - status
10462 
   - start_billing_date
10463 
   - end_billing_date
10464 
   - warehouse_id
10465 
  """
10466 
 
10467 
  thrift_spec = (
10468 
    None, # 0
10469 
    (1, TType.I32, 'status', None, None, ), # 1
10470 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
10471 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
10472 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10473 
  )
10474 
 
10475 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
10476 
    self.status = status
10477 
    self.start_billing_date = start_billing_date
10478 
    self.end_billing_date = end_billing_date
10479 
    self.warehouse_id = warehouse_id
10480 
 
10481 
  def read(self, iprot):
10482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10484 
      return
10485 
    iprot.readStructBegin()
10486 
    while True:
10487 
      (fname, ftype, fid) = iprot.readFieldBegin()
10488 
      if ftype == TType.STOP:
10489 
        break
10490 
      if fid == 1:
10491 
        if ftype == TType.I32:
10492 
          self.status = iprot.readI32();
10493 
        else:
10494 
          iprot.skip(ftype)
10495 
      elif fid == 2:
10496 
        if ftype == TType.I64:
10497 
          self.start_billing_date = iprot.readI64();
10498 
        else:
10499 
          iprot.skip(ftype)
10500 
      elif fid == 3:
10501 
        if ftype == TType.I64:
10502 
          self.end_billing_date = iprot.readI64();
10503 
        else:
10504 
          iprot.skip(ftype)
10505 
      elif fid == 4:
10506 
        if ftype == TType.I64:
10507 
          self.warehouse_id = iprot.readI64();
10508 
        else:
10509 
          iprot.skip(ftype)
10510 
      else:
10511 
        iprot.skip(ftype)
10512 
      iprot.readFieldEnd()
10513 
    iprot.readStructEnd()
10514 
 
10515 
  def write(self, oprot):
10516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10518 
      return
10519 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 10520 
    if self.status is not None:
999 varun.gupt 10521 
      oprot.writeFieldBegin('status', TType.I32, 1)
10522 
      oprot.writeI32(self.status)
10523 
      oprot.writeFieldEnd()
3431 rajveer 10524 
    if self.start_billing_date is not None:
999 varun.gupt 10525 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
10526 
      oprot.writeI64(self.start_billing_date)
10527 
      oprot.writeFieldEnd()
3431 rajveer 10528 
    if self.end_billing_date is not None:
999 varun.gupt 10529 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
10530 
      oprot.writeI64(self.end_billing_date)
10531 
      oprot.writeFieldEnd()
3431 rajveer 10532 
    if self.warehouse_id is not None:
999 varun.gupt 10533 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10534 
      oprot.writeI64(self.warehouse_id)
10535 
      oprot.writeFieldEnd()
10536 
    oprot.writeFieldStop()
10537 
    oprot.writeStructEnd()
10538 
 
3431 rajveer 10539 
  def validate(self):
10540 
    return
10541 
 
10542 
 
999 varun.gupt 10543 
  def __repr__(self):
10544 
    L = ['%s=%r' % (key, value)
10545 
      for key, value in self.__dict__.iteritems()]
10546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10547 
 
10548 
  def __eq__(self, other):
10549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10550 
 
10551 
  def __ne__(self, other):
10552 
    return not (self == other)
10553 
 
10554 
class getOrdersByBillingDate_result:
10555 
  """
10556 
  Attributes:
10557 
   - success
10558 
   - ex
10559 
  """
10560 
 
10561 
  thrift_spec = (
10562 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10563 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10564 
  )
10565 
 
10566 
  def __init__(self, success=None, ex=None,):
10567 
    self.success = success
10568 
    self.ex = ex
10569 
 
10570 
  def read(self, iprot):
10571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10573 
      return
10574 
    iprot.readStructBegin()
10575 
    while True:
10576 
      (fname, ftype, fid) = iprot.readFieldBegin()
10577 
      if ftype == TType.STOP:
10578 
        break
10579 
      if fid == 0:
10580 
        if ftype == TType.LIST:
10581 
          self.success = []
6188 rajveer 10582 
          (_etype158, _size155) = iprot.readListBegin()
10583 
          for _i159 in xrange(_size155):
10584 
            _elem160 = Order()
10585 
            _elem160.read(iprot)
10586 
            self.success.append(_elem160)
999 varun.gupt 10587 
          iprot.readListEnd()
10588 
        else:
10589 
          iprot.skip(ftype)
10590 
      elif fid == 1:
10591 
        if ftype == TType.STRUCT:
10592 
          self.ex = TransactionServiceException()
10593 
          self.ex.read(iprot)
10594 
        else:
10595 
          iprot.skip(ftype)
10596 
      else:
10597 
        iprot.skip(ftype)
10598 
      iprot.readFieldEnd()
10599 
    iprot.readStructEnd()
10600 
 
10601 
  def write(self, oprot):
10602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10604 
      return
10605 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 10606 
    if self.success is not None:
999 varun.gupt 10607 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10608 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10609 
      for iter161 in self.success:
10610 
        iter161.write(oprot)
999 varun.gupt 10611 
      oprot.writeListEnd()
10612 
      oprot.writeFieldEnd()
3431 rajveer 10613 
    if self.ex is not None:
999 varun.gupt 10614 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10615 
      self.ex.write(oprot)
10616 
      oprot.writeFieldEnd()
10617 
    oprot.writeFieldStop()
10618 
    oprot.writeStructEnd()
10619 
 
3431 rajveer 10620 
  def validate(self):
10621 
    return
10622 
 
10623 
 
999 varun.gupt 10624 
  def __repr__(self):
10625 
    L = ['%s=%r' % (key, value)
10626 
      for key, value in self.__dict__.iteritems()]
10627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10628 
 
10629 
  def __eq__(self, other):
10630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10631 
 
10632 
  def __ne__(self, other):
10633 
    return not (self == other)
10634 
 
3427 chandransh 10635 
class getOrdersByShippingDate_args:
10636 
  """
10637 
  Attributes:
10638 
   - fromShippingDate
10639 
   - toShippingDate
10640 
   - providerId
10641 
   - warehouseId
3451 chandransh 10642 
   - cod
3427 chandransh 10643 
  """
10644 
 
10645 
  thrift_spec = (
10646 
    None, # 0
10647 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
10648 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
10649 
    (3, TType.I64, 'providerId', None, None, ), # 3
10650 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 10651 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 10652 
  )
10653 
 
3451 chandransh 10654 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 10655 
    self.fromShippingDate = fromShippingDate
10656 
    self.toShippingDate = toShippingDate
10657 
    self.providerId = providerId
10658 
    self.warehouseId = warehouseId
3451 chandransh 10659 
    self.cod = cod
3427 chandransh 10660 
 
10661 
  def read(self, iprot):
10662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10664 
      return
10665 
    iprot.readStructBegin()
10666 
    while True:
10667 
      (fname, ftype, fid) = iprot.readFieldBegin()
10668 
      if ftype == TType.STOP:
10669 
        break
10670 
      if fid == 1:
10671 
        if ftype == TType.I64:
10672 
          self.fromShippingDate = iprot.readI64();
10673 
        else:
10674 
          iprot.skip(ftype)
10675 
      elif fid == 2:
10676 
        if ftype == TType.I64:
10677 
          self.toShippingDate = iprot.readI64();
10678 
        else:
10679 
          iprot.skip(ftype)
10680 
      elif fid == 3:
10681 
        if ftype == TType.I64:
10682 
          self.providerId = iprot.readI64();
10683 
        else:
10684 
          iprot.skip(ftype)
10685 
      elif fid == 4:
10686 
        if ftype == TType.I64:
10687 
          self.warehouseId = iprot.readI64();
10688 
        else:
10689 
          iprot.skip(ftype)
3451 chandransh 10690 
      elif fid == 5:
10691 
        if ftype == TType.BOOL:
10692 
          self.cod = iprot.readBool();
10693 
        else:
10694 
          iprot.skip(ftype)
3427 chandransh 10695 
      else:
10696 
        iprot.skip(ftype)
10697 
      iprot.readFieldEnd()
10698 
    iprot.readStructEnd()
10699 
 
10700 
  def write(self, oprot):
10701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10703 
      return
10704 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 10705 
    if self.fromShippingDate is not None:
3427 chandransh 10706 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
10707 
      oprot.writeI64(self.fromShippingDate)
10708 
      oprot.writeFieldEnd()
3431 rajveer 10709 
    if self.toShippingDate is not None:
3427 chandransh 10710 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
10711 
      oprot.writeI64(self.toShippingDate)
10712 
      oprot.writeFieldEnd()
3431 rajveer 10713 
    if self.providerId is not None:
3427 chandransh 10714 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
10715 
      oprot.writeI64(self.providerId)
10716 
      oprot.writeFieldEnd()
3431 rajveer 10717 
    if self.warehouseId is not None:
3427 chandransh 10718 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
10719 
      oprot.writeI64(self.warehouseId)
10720 
      oprot.writeFieldEnd()
3451 chandransh 10721 
    if self.cod is not None:
10722 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
10723 
      oprot.writeBool(self.cod)
10724 
      oprot.writeFieldEnd()
3427 chandransh 10725 
    oprot.writeFieldStop()
10726 
    oprot.writeStructEnd()
10727 
 
3431 rajveer 10728 
  def validate(self):
10729 
    return
10730 
 
10731 
 
3427 chandransh 10732 
  def __repr__(self):
10733 
    L = ['%s=%r' % (key, value)
10734 
      for key, value in self.__dict__.iteritems()]
10735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10736 
 
10737 
  def __eq__(self, other):
10738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10739 
 
10740 
  def __ne__(self, other):
10741 
    return not (self == other)
10742 
 
10743 
class getOrdersByShippingDate_result:
10744 
  """
10745 
  Attributes:
10746 
   - success
10747 
   - ex
10748 
  """
10749 
 
10750 
  thrift_spec = (
10751 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10752 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10753 
  )
10754 
 
10755 
  def __init__(self, success=None, ex=None,):
10756 
    self.success = success
10757 
    self.ex = ex
10758 
 
10759 
  def read(self, iprot):
10760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10762 
      return
10763 
    iprot.readStructBegin()
10764 
    while True:
10765 
      (fname, ftype, fid) = iprot.readFieldBegin()
10766 
      if ftype == TType.STOP:
10767 
        break
10768 
      if fid == 0:
10769 
        if ftype == TType.LIST:
10770 
          self.success = []
6188 rajveer 10771 
          (_etype165, _size162) = iprot.readListBegin()
10772 
          for _i166 in xrange(_size162):
10773 
            _elem167 = Order()
10774 
            _elem167.read(iprot)
10775 
            self.success.append(_elem167)
3427 chandransh 10776 
          iprot.readListEnd()
10777 
        else:
10778 
          iprot.skip(ftype)
10779 
      elif fid == 1:
10780 
        if ftype == TType.STRUCT:
10781 
          self.ex = TransactionServiceException()
10782 
          self.ex.read(iprot)
10783 
        else:
10784 
          iprot.skip(ftype)
10785 
      else:
10786 
        iprot.skip(ftype)
10787 
      iprot.readFieldEnd()
10788 
    iprot.readStructEnd()
10789 
 
10790 
  def write(self, oprot):
10791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10793 
      return
10794 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10795 
    if self.success is not None:
3427 chandransh 10796 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10797 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10798 
      for iter168 in self.success:
10799 
        iter168.write(oprot)
3427 chandransh 10800 
      oprot.writeListEnd()
10801 
      oprot.writeFieldEnd()
3431 rajveer 10802 
    if self.ex is not None:
3427 chandransh 10803 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10804 
      self.ex.write(oprot)
10805 
      oprot.writeFieldEnd()
10806 
    oprot.writeFieldStop()
10807 
    oprot.writeStructEnd()
10808 
 
3431 rajveer 10809 
  def validate(self):
10810 
    return
10811 
 
10812 
 
3427 chandransh 10813 
  def __repr__(self):
10814 
    L = ['%s=%r' % (key, value)
10815 
      for key, value in self.__dict__.iteritems()]
10816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10817 
 
10818 
  def __eq__(self, other):
10819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10820 
 
10821 
  def __ne__(self, other):
10822 
    return not (self == other)
10823 
 
1382 varun.gupt 10824 
class getReturnableOrdersForCustomer_args:
10825 
  """
10826 
  Attributes:
10827 
   - customer_id
10828 
   - limit
10829 
  """
10830 
 
10831 
  thrift_spec = (
10832 
    None, # 0
10833 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10834 
    (2, TType.I64, 'limit', None, None, ), # 2
10835 
  )
10836 
 
10837 
  def __init__(self, customer_id=None, limit=None,):
10838 
    self.customer_id = customer_id
10839 
    self.limit = limit
10840 
 
10841 
  def read(self, iprot):
10842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10844 
      return
10845 
    iprot.readStructBegin()
10846 
    while True:
10847 
      (fname, ftype, fid) = iprot.readFieldBegin()
10848 
      if ftype == TType.STOP:
10849 
        break
10850 
      if fid == 1:
10851 
        if ftype == TType.I64:
10852 
          self.customer_id = iprot.readI64();
10853 
        else:
10854 
          iprot.skip(ftype)
10855 
      elif fid == 2:
10856 
        if ftype == TType.I64:
10857 
          self.limit = iprot.readI64();
10858 
        else:
10859 
          iprot.skip(ftype)
10860 
      else:
10861 
        iprot.skip(ftype)
10862 
      iprot.readFieldEnd()
10863 
    iprot.readStructEnd()
10864 
 
10865 
  def write(self, oprot):
10866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10868 
      return
10869 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 10870 
    if self.customer_id is not None:
1382 varun.gupt 10871 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10872 
      oprot.writeI64(self.customer_id)
10873 
      oprot.writeFieldEnd()
3431 rajveer 10874 
    if self.limit is not None:
1382 varun.gupt 10875 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10876 
      oprot.writeI64(self.limit)
10877 
      oprot.writeFieldEnd()
10878 
    oprot.writeFieldStop()
10879 
    oprot.writeStructEnd()
10880 
 
3431 rajveer 10881 
  def validate(self):
10882 
    return
10883 
 
10884 
 
1382 varun.gupt 10885 
  def __repr__(self):
10886 
    L = ['%s=%r' % (key, value)
10887 
      for key, value in self.__dict__.iteritems()]
10888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10889 
 
10890 
  def __eq__(self, other):
10891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10892 
 
10893 
  def __ne__(self, other):
10894 
    return not (self == other)
10895 
 
10896 
class getReturnableOrdersForCustomer_result:
10897 
  """
10898 
  Attributes:
10899 
   - success
10900 
   - ex
10901 
  """
10902 
 
10903 
  thrift_spec = (
10904 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10905 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10906 
  )
10907 
 
10908 
  def __init__(self, success=None, ex=None,):
10909 
    self.success = success
10910 
    self.ex = ex
10911 
 
10912 
  def read(self, iprot):
10913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10915 
      return
10916 
    iprot.readStructBegin()
10917 
    while True:
10918 
      (fname, ftype, fid) = iprot.readFieldBegin()
10919 
      if ftype == TType.STOP:
10920 
        break
10921 
      if fid == 0:
10922 
        if ftype == TType.LIST:
10923 
          self.success = []
6188 rajveer 10924 
          (_etype172, _size169) = iprot.readListBegin()
10925 
          for _i173 in xrange(_size169):
10926 
            _elem174 = iprot.readI64();
10927 
            self.success.append(_elem174)
1382 varun.gupt 10928 
          iprot.readListEnd()
10929 
        else:
10930 
          iprot.skip(ftype)
10931 
      elif fid == 1:
10932 
        if ftype == TType.STRUCT:
10933 
          self.ex = TransactionServiceException()
10934 
          self.ex.read(iprot)
10935 
        else:
10936 
          iprot.skip(ftype)
10937 
      else:
10938 
        iprot.skip(ftype)
10939 
      iprot.readFieldEnd()
10940 
    iprot.readStructEnd()
10941 
 
10942 
  def write(self, oprot):
10943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10945 
      return
10946 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10947 
    if self.success is not None:
1382 varun.gupt 10948 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10949 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10950 
      for iter175 in self.success:
10951 
        oprot.writeI64(iter175)
1382 varun.gupt 10952 
      oprot.writeListEnd()
10953 
      oprot.writeFieldEnd()
3431 rajveer 10954 
    if self.ex is not None:
1382 varun.gupt 10955 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10956 
      self.ex.write(oprot)
10957 
      oprot.writeFieldEnd()
10958 
    oprot.writeFieldStop()
10959 
    oprot.writeStructEnd()
10960 
 
3431 rajveer 10961 
  def validate(self):
10962 
    return
10963 
 
10964 
 
1382 varun.gupt 10965 
  def __repr__(self):
10966 
    L = ['%s=%r' % (key, value)
10967 
      for key, value in self.__dict__.iteritems()]
10968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10969 
 
10970 
  def __eq__(self, other):
10971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10972 
 
10973 
  def __ne__(self, other):
10974 
    return not (self == other)
10975 
 
10976 
class getCancellableOrdersForCustomer_args:
10977 
  """
10978 
  Attributes:
10979 
   - customer_id
10980 
   - limit
10981 
  """
10982 
 
10983 
  thrift_spec = (
10984 
    None, # 0
10985 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10986 
    (2, TType.I64, 'limit', None, None, ), # 2
10987 
  )
10988 
 
10989 
  def __init__(self, customer_id=None, limit=None,):
10990 
    self.customer_id = customer_id
10991 
    self.limit = limit
10992 
 
10993 
  def read(self, iprot):
10994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10996 
      return
10997 
    iprot.readStructBegin()
10998 
    while True:
10999 
      (fname, ftype, fid) = iprot.readFieldBegin()
11000 
      if ftype == TType.STOP:
11001 
        break
11002 
      if fid == 1:
11003 
        if ftype == TType.I64:
11004 
          self.customer_id = iprot.readI64();
11005 
        else:
11006 
          iprot.skip(ftype)
11007 
      elif fid == 2:
11008 
        if ftype == TType.I64:
11009 
          self.limit = iprot.readI64();
11010 
        else:
11011 
          iprot.skip(ftype)
11012 
      else:
11013 
        iprot.skip(ftype)
11014 
      iprot.readFieldEnd()
11015 
    iprot.readStructEnd()
11016 
 
11017 
  def write(self, oprot):
11018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11020 
      return
11021 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 11022 
    if self.customer_id is not None:
1382 varun.gupt 11023 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
11024 
      oprot.writeI64(self.customer_id)
11025 
      oprot.writeFieldEnd()
3431 rajveer 11026 
    if self.limit is not None:
1382 varun.gupt 11027 
      oprot.writeFieldBegin('limit', TType.I64, 2)
11028 
      oprot.writeI64(self.limit)
11029 
      oprot.writeFieldEnd()
11030 
    oprot.writeFieldStop()
11031 
    oprot.writeStructEnd()
11032 
 
3431 rajveer 11033 
  def validate(self):
11034 
    return
11035 
 
11036 
 
1382 varun.gupt 11037 
  def __repr__(self):
11038 
    L = ['%s=%r' % (key, value)
11039 
      for key, value in self.__dict__.iteritems()]
11040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11041 
 
11042 
  def __eq__(self, other):
11043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11044 
 
11045 
  def __ne__(self, other):
11046 
    return not (self == other)
11047 
 
11048 
class getCancellableOrdersForCustomer_result:
11049 
  """
11050 
  Attributes:
11051 
   - success
11052 
   - ex
11053 
  """
11054 
 
11055 
  thrift_spec = (
11056 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
11057 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11058 
  )
11059 
 
11060 
  def __init__(self, success=None, ex=None,):
11061 
    self.success = success
11062 
    self.ex = ex
11063 
 
11064 
  def read(self, iprot):
11065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11067 
      return
11068 
    iprot.readStructBegin()
11069 
    while True:
11070 
      (fname, ftype, fid) = iprot.readFieldBegin()
11071 
      if ftype == TType.STOP:
11072 
        break
11073 
      if fid == 0:
11074 
        if ftype == TType.LIST:
11075 
          self.success = []
6188 rajveer 11076 
          (_etype179, _size176) = iprot.readListBegin()
11077 
          for _i180 in xrange(_size176):
11078 
            _elem181 = iprot.readI64();
11079 
            self.success.append(_elem181)
1382 varun.gupt 11080 
          iprot.readListEnd()
11081 
        else:
11082 
          iprot.skip(ftype)
11083 
      elif fid == 1:
11084 
        if ftype == TType.STRUCT:
11085 
          self.ex = TransactionServiceException()
11086 
          self.ex.read(iprot)
11087 
        else:
11088 
          iprot.skip(ftype)
11089 
      else:
11090 
        iprot.skip(ftype)
11091 
      iprot.readFieldEnd()
11092 
    iprot.readStructEnd()
11093 
 
11094 
  def write(self, oprot):
11095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11097 
      return
11098 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 11099 
    if self.success is not None:
1382 varun.gupt 11100 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11101 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11102 
      for iter182 in self.success:
11103 
        oprot.writeI64(iter182)
1382 varun.gupt 11104 
      oprot.writeListEnd()
11105 
      oprot.writeFieldEnd()
3431 rajveer 11106 
    if self.ex is not None:
1382 varun.gupt 11107 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11108 
      self.ex.write(oprot)
11109 
      oprot.writeFieldEnd()
11110 
    oprot.writeFieldStop()
11111 
    oprot.writeStructEnd()
11112 
 
3431 rajveer 11113 
  def validate(self):
11114 
    return
11115 
 
11116 
 
1382 varun.gupt 11117 
  def __repr__(self):
11118 
    L = ['%s=%r' % (key, value)
11119 
      for key, value in self.__dict__.iteritems()]
11120 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11121 
 
11122 
  def __eq__(self, other):
11123 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11124 
 
11125 
  def __ne__(self, other):
11126 
    return not (self == other)
11127 
 
483 rajveer 11128 
class changeOrderStatus_args:
94 ashish 11129 
  """
11130 
  Attributes:
483 rajveer 11131 
   - orderId
11132 
   - status
11133 
   - description
94 ashish 11134 
  """
11135 
 
11136 
  thrift_spec = (
11137 
    None, # 0
483 rajveer 11138 
    (1, TType.I64, 'orderId', None, None, ), # 1
11139 
    (2, TType.I32, 'status', None, None, ), # 2
11140 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11141 
  )
11142 
 
483 rajveer 11143 
  def __init__(self, orderId=None, status=None, description=None,):
11144 
    self.orderId = orderId
11145 
    self.status = status
11146 
    self.description = description
94 ashish 11147 
 
11148 
  def read(self, iprot):
11149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11151 
      return
11152 
    iprot.readStructBegin()
11153 
    while True:
11154 
      (fname, ftype, fid) = iprot.readFieldBegin()
11155 
      if ftype == TType.STOP:
11156 
        break
11157 
      if fid == 1:
11158 
        if ftype == TType.I64:
483 rajveer 11159 
          self.orderId = iprot.readI64();
94 ashish 11160 
        else:
11161 
          iprot.skip(ftype)
11162 
      elif fid == 2:
483 rajveer 11163 
        if ftype == TType.I32:
11164 
          self.status = iprot.readI32();
94 ashish 11165 
        else:
11166 
          iprot.skip(ftype)
483 rajveer 11167 
      elif fid == 3:
11168 
        if ftype == TType.STRING:
11169 
          self.description = iprot.readString();
11170 
        else:
11171 
          iprot.skip(ftype)
94 ashish 11172 
      else:
11173 
        iprot.skip(ftype)
11174 
      iprot.readFieldEnd()
11175 
    iprot.readStructEnd()
11176 
 
11177 
  def write(self, oprot):
11178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11180 
      return
483 rajveer 11181 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 11182 
    if self.orderId is not None:
483 rajveer 11183 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11184 
      oprot.writeI64(self.orderId)
94 ashish 11185 
      oprot.writeFieldEnd()
3431 rajveer 11186 
    if self.status is not None:
483 rajveer 11187 
      oprot.writeFieldBegin('status', TType.I32, 2)
11188 
      oprot.writeI32(self.status)
94 ashish 11189 
      oprot.writeFieldEnd()
3431 rajveer 11190 
    if self.description is not None:
483 rajveer 11191 
      oprot.writeFieldBegin('description', TType.STRING, 3)
11192 
      oprot.writeString(self.description)
11193 
      oprot.writeFieldEnd()
94 ashish 11194 
    oprot.writeFieldStop()
11195 
    oprot.writeStructEnd()
11196 
 
3431 rajveer 11197 
  def validate(self):
11198 
    return
11199 
 
11200 
 
94 ashish 11201 
  def __repr__(self):
11202 
    L = ['%s=%r' % (key, value)
11203 
      for key, value in self.__dict__.iteritems()]
11204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11205 
 
11206 
  def __eq__(self, other):
11207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11208 
 
11209 
  def __ne__(self, other):
11210 
    return not (self == other)
11211 
 
483 rajveer 11212 
class changeOrderStatus_result:
94 ashish 11213 
  """
11214 
  Attributes:
11215 
   - success
11216 
   - ex
11217 
  """
11218 
 
11219 
  thrift_spec = (
11220 
    (0, TType.BOOL, 'success', None, None, ), # 0
11221 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11222 
  )
11223 
 
11224 
  def __init__(self, success=None, ex=None,):
11225 
    self.success = success
11226 
    self.ex = ex
11227 
 
11228 
  def read(self, iprot):
11229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11231 
      return
11232 
    iprot.readStructBegin()
11233 
    while True:
11234 
      (fname, ftype, fid) = iprot.readFieldBegin()
11235 
      if ftype == TType.STOP:
11236 
        break
11237 
      if fid == 0:
11238 
        if ftype == TType.BOOL:
11239 
          self.success = iprot.readBool();
11240 
        else:
11241 
          iprot.skip(ftype)
11242 
      elif fid == 1:
11243 
        if ftype == TType.STRUCT:
11244 
          self.ex = TransactionServiceException()
11245 
          self.ex.read(iprot)
11246 
        else:
11247 
          iprot.skip(ftype)
11248 
      else:
11249 
        iprot.skip(ftype)
11250 
      iprot.readFieldEnd()
11251 
    iprot.readStructEnd()
11252 
 
11253 
  def write(self, oprot):
11254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11256 
      return
483 rajveer 11257 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 11258 
    if self.success is not None:
94 ashish 11259 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11260 
      oprot.writeBool(self.success)
11261 
      oprot.writeFieldEnd()
3431 rajveer 11262 
    if self.ex is not None:
94 ashish 11263 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11264 
      self.ex.write(oprot)
11265 
      oprot.writeFieldEnd()
11266 
    oprot.writeFieldStop()
11267 
    oprot.writeStructEnd()
11268 
 
3431 rajveer 11269 
  def validate(self):
11270 
    return
11271 
 
11272 
 
94 ashish 11273 
  def __repr__(self):
11274 
    L = ['%s=%r' % (key, value)
11275 
      for key, value in self.__dict__.iteritems()]
11276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11277 
 
11278 
  def __eq__(self, other):
11279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11280 
 
11281 
  def __ne__(self, other):
11282 
    return not (self == other)
11283 
 
3064 chandransh 11284 
class getOrdersForTransaction_args:
494 rajveer 11285 
  """
11286 
  Attributes:
3064 chandransh 11287 
   - transactionId
11288 
   - customerId
494 rajveer 11289 
  """
11290 
 
11291 
  thrift_spec = (
11292 
    None, # 0
3064 chandransh 11293 
    (1, TType.I64, 'transactionId', None, None, ), # 1
11294 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 11295 
  )
11296 
 
3064 chandransh 11297 
  def __init__(self, transactionId=None, customerId=None,):
11298 
    self.transactionId = transactionId
11299 
    self.customerId = customerId
494 rajveer 11300 
 
11301 
  def read(self, iprot):
11302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11304 
      return
11305 
    iprot.readStructBegin()
11306 
    while True:
11307 
      (fname, ftype, fid) = iprot.readFieldBegin()
11308 
      if ftype == TType.STOP:
11309 
        break
11310 
      if fid == 1:
11311 
        if ftype == TType.I64:
3064 chandransh 11312 
          self.transactionId = iprot.readI64();
494 rajveer 11313 
        else:
11314 
          iprot.skip(ftype)
11315 
      elif fid == 2:
3064 chandransh 11316 
        if ftype == TType.I64:
11317 
          self.customerId = iprot.readI64();
494 rajveer 11318 
        else:
11319 
          iprot.skip(ftype)
11320 
      else:
11321 
        iprot.skip(ftype)
11322 
      iprot.readFieldEnd()
11323 
    iprot.readStructEnd()
11324 
 
11325 
  def write(self, oprot):
11326 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11327 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11328 
      return
3064 chandransh 11329 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 11330 
    if self.transactionId is not None:
3064 chandransh 11331 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
11332 
      oprot.writeI64(self.transactionId)
494 rajveer 11333 
      oprot.writeFieldEnd()
3431 rajveer 11334 
    if self.customerId is not None:
3064 chandransh 11335 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
11336 
      oprot.writeI64(self.customerId)
494 rajveer 11337 
      oprot.writeFieldEnd()
11338 
    oprot.writeFieldStop()
11339 
    oprot.writeStructEnd()
11340 
 
3431 rajveer 11341 
  def validate(self):
11342 
    return
11343 
 
11344 
 
494 rajveer 11345 
  def __repr__(self):
11346 
    L = ['%s=%r' % (key, value)
11347 
      for key, value in self.__dict__.iteritems()]
11348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11349 
 
11350 
  def __eq__(self, other):
11351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11352 
 
11353 
  def __ne__(self, other):
11354 
    return not (self == other)
11355 
 
3064 chandransh 11356 
class getOrdersForTransaction_result:
494 rajveer 11357 
  """
11358 
  Attributes:
11359 
   - success
11360 
   - ex
11361 
  """
11362 
 
11363 
  thrift_spec = (
3064 chandransh 11364 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 11365 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11366 
  )
11367 
 
11368 
  def __init__(self, success=None, ex=None,):
11369 
    self.success = success
11370 
    self.ex = ex
11371 
 
11372 
  def read(self, iprot):
11373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11375 
      return
11376 
    iprot.readStructBegin()
11377 
    while True:
11378 
      (fname, ftype, fid) = iprot.readFieldBegin()
11379 
      if ftype == TType.STOP:
11380 
        break
11381 
      if fid == 0:
3064 chandransh 11382 
        if ftype == TType.LIST:
11383 
          self.success = []
6188 rajveer 11384 
          (_etype186, _size183) = iprot.readListBegin()
11385 
          for _i187 in xrange(_size183):
11386 
            _elem188 = Order()
11387 
            _elem188.read(iprot)
11388 
            self.success.append(_elem188)
3064 chandransh 11389 
          iprot.readListEnd()
494 rajveer 11390 
        else:
11391 
          iprot.skip(ftype)
11392 
      elif fid == 1:
11393 
        if ftype == TType.STRUCT:
11394 
          self.ex = TransactionServiceException()
11395 
          self.ex.read(iprot)
11396 
        else:
11397 
          iprot.skip(ftype)
11398 
      else:
11399 
        iprot.skip(ftype)
11400 
      iprot.readFieldEnd()
11401 
    iprot.readStructEnd()
11402 
 
11403 
  def write(self, oprot):
11404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11406 
      return
3064 chandransh 11407 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 11408 
    if self.success is not None:
3064 chandransh 11409 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11410 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11411 
      for iter189 in self.success:
11412 
        iter189.write(oprot)
3064 chandransh 11413 
      oprot.writeListEnd()
494 rajveer 11414 
      oprot.writeFieldEnd()
3431 rajveer 11415 
    if self.ex is not None:
494 rajveer 11416 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11417 
      self.ex.write(oprot)
11418 
      oprot.writeFieldEnd()
11419 
    oprot.writeFieldStop()
11420 
    oprot.writeStructEnd()
11421 
 
3431 rajveer 11422 
  def validate(self):
11423 
    return
11424 
 
11425 
 
494 rajveer 11426 
  def __repr__(self):
11427 
    L = ['%s=%r' % (key, value)
11428 
      for key, value in self.__dict__.iteritems()]
11429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11430 
 
11431 
  def __eq__(self, other):
11432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11433 
 
11434 
  def __ne__(self, other):
11435 
    return not (self == other)
11436 
 
3064 chandransh 11437 
class getOrdersForCustomer_args:
1149 chandransh 11438 
  """
11439 
  Attributes:
3064 chandransh 11440 
   - customerId
11441 
   - from_date
11442 
   - to_date
11443 
   - statuses
1149 chandransh 11444 
  """
11445 
 
11446 
  thrift_spec = (
11447 
    None, # 0
3064 chandransh 11448 
    (1, TType.I64, 'customerId', None, None, ), # 1
11449 
    (2, TType.I64, 'from_date', None, None, ), # 2
11450 
    (3, TType.I64, 'to_date', None, None, ), # 3
11451 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 11452 
  )
11453 
 
3064 chandransh 11454 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
11455 
    self.customerId = customerId
11456 
    self.from_date = from_date
11457 
    self.to_date = to_date
11458 
    self.statuses = statuses
1149 chandransh 11459 
 
11460 
  def read(self, iprot):
11461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11463 
      return
11464 
    iprot.readStructBegin()
11465 
    while True:
11466 
      (fname, ftype, fid) = iprot.readFieldBegin()
11467 
      if ftype == TType.STOP:
11468 
        break
11469 
      if fid == 1:
11470 
        if ftype == TType.I64:
3064 chandransh 11471 
          self.customerId = iprot.readI64();
1149 chandransh 11472 
        else:
11473 
          iprot.skip(ftype)
11474 
      elif fid == 2:
11475 
        if ftype == TType.I64:
3064 chandransh 11476 
          self.from_date = iprot.readI64();
1149 chandransh 11477 
        else:
11478 
          iprot.skip(ftype)
2783 chandransh 11479 
      elif fid == 3:
11480 
        if ftype == TType.I64:
3064 chandransh 11481 
          self.to_date = iprot.readI64();
2783 chandransh 11482 
        else:
11483 
          iprot.skip(ftype)
11484 
      elif fid == 4:
3064 chandransh 11485 
        if ftype == TType.LIST:
11486 
          self.statuses = []
6188 rajveer 11487 
          (_etype193, _size190) = iprot.readListBegin()
11488 
          for _i194 in xrange(_size190):
11489 
            _elem195 = iprot.readI32();
11490 
            self.statuses.append(_elem195)
3064 chandransh 11491 
          iprot.readListEnd()
2783 chandransh 11492 
        else:
11493 
          iprot.skip(ftype)
1149 chandransh 11494 
      else:
11495 
        iprot.skip(ftype)
11496 
      iprot.readFieldEnd()
11497 
    iprot.readStructEnd()
11498 
 
11499 
  def write(self, oprot):
11500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11502 
      return
3064 chandransh 11503 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 11504 
    if self.customerId is not None:
3064 chandransh 11505 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
11506 
      oprot.writeI64(self.customerId)
1149 chandransh 11507 
      oprot.writeFieldEnd()
3431 rajveer 11508 
    if self.from_date is not None:
3064 chandransh 11509 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
11510 
      oprot.writeI64(self.from_date)
1149 chandransh 11511 
      oprot.writeFieldEnd()
3431 rajveer 11512 
    if self.to_date is not None:
3064 chandransh 11513 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
11514 
      oprot.writeI64(self.to_date)
2783 chandransh 11515 
      oprot.writeFieldEnd()
3431 rajveer 11516 
    if self.statuses is not None:
3064 chandransh 11517 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
11518 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11519 
      for iter196 in self.statuses:
11520 
        oprot.writeI32(iter196)
3064 chandransh 11521 
      oprot.writeListEnd()
2783 chandransh 11522 
      oprot.writeFieldEnd()
1149 chandransh 11523 
    oprot.writeFieldStop()
11524 
    oprot.writeStructEnd()
11525 
 
3431 rajveer 11526 
  def validate(self):
11527 
    return
11528 
 
11529 
 
1149 chandransh 11530 
  def __repr__(self):
11531 
    L = ['%s=%r' % (key, value)
11532 
      for key, value in self.__dict__.iteritems()]
11533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11534 
 
11535 
  def __eq__(self, other):
11536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11537 
 
11538 
  def __ne__(self, other):
11539 
    return not (self == other)
11540 
 
3064 chandransh 11541 
class getOrdersForCustomer_result:
1149 chandransh 11542 
  """
11543 
  Attributes:
11544 
   - success
11545 
   - ex
11546 
  """
11547 
 
11548 
  thrift_spec = (
3064 chandransh 11549 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 11550 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11551 
  )
11552 
 
11553 
  def __init__(self, success=None, ex=None,):
11554 
    self.success = success
11555 
    self.ex = ex
11556 
 
11557 
  def read(self, iprot):
11558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11560 
      return
11561 
    iprot.readStructBegin()
11562 
    while True:
11563 
      (fname, ftype, fid) = iprot.readFieldBegin()
11564 
      if ftype == TType.STOP:
11565 
        break
11566 
      if fid == 0:
3064 chandransh 11567 
        if ftype == TType.LIST:
11568 
          self.success = []
6188 rajveer 11569 
          (_etype200, _size197) = iprot.readListBegin()
11570 
          for _i201 in xrange(_size197):
11571 
            _elem202 = Order()
11572 
            _elem202.read(iprot)
11573 
            self.success.append(_elem202)
3064 chandransh 11574 
          iprot.readListEnd()
1149 chandransh 11575 
        else:
11576 
          iprot.skip(ftype)
11577 
      elif fid == 1:
11578 
        if ftype == TType.STRUCT:
11579 
          self.ex = TransactionServiceException()
11580 
          self.ex.read(iprot)
11581 
        else:
11582 
          iprot.skip(ftype)
11583 
      else:
11584 
        iprot.skip(ftype)
11585 
      iprot.readFieldEnd()
11586 
    iprot.readStructEnd()
11587 
 
11588 
  def write(self, oprot):
11589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11591 
      return
3064 chandransh 11592 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 11593 
    if self.success is not None:
3064 chandransh 11594 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11595 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11596 
      for iter203 in self.success:
11597 
        iter203.write(oprot)
3064 chandransh 11598 
      oprot.writeListEnd()
1149 chandransh 11599 
      oprot.writeFieldEnd()
3431 rajveer 11600 
    if self.ex is not None:
1149 chandransh 11601 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11602 
      self.ex.write(oprot)
11603 
      oprot.writeFieldEnd()
11604 
    oprot.writeFieldStop()
11605 
    oprot.writeStructEnd()
11606 
 
3431 rajveer 11607 
  def validate(self):
11608 
    return
11609 
 
11610 
 
1149 chandransh 11611 
  def __repr__(self):
11612 
    L = ['%s=%r' % (key, value)
11613 
      for key, value in self.__dict__.iteritems()]
11614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11615 
 
11616 
  def __eq__(self, other):
11617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11618 
 
11619 
  def __ne__(self, other):
11620 
    return not (self == other)
11621 
 
3064 chandransh 11622 
class createOrder_args:
921 rajveer 11623 
  """
11624 
  Attributes:
3064 chandransh 11625 
   - order
921 rajveer 11626 
  """
11627 
 
11628 
  thrift_spec = (
11629 
    None, # 0
3064 chandransh 11630 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 11631 
  )
11632 
 
3064 chandransh 11633 
  def __init__(self, order=None,):
11634 
    self.order = order
921 rajveer 11635 
 
11636 
  def read(self, iprot):
11637 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11638 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11639 
      return
11640 
    iprot.readStructBegin()
11641 
    while True:
11642 
      (fname, ftype, fid) = iprot.readFieldBegin()
11643 
      if ftype == TType.STOP:
11644 
        break
11645 
      if fid == 1:
3064 chandransh 11646 
        if ftype == TType.STRUCT:
11647 
          self.order = Order()
11648 
          self.order.read(iprot)
921 rajveer 11649 
        else:
11650 
          iprot.skip(ftype)
11651 
      else:
11652 
        iprot.skip(ftype)
11653 
      iprot.readFieldEnd()
11654 
    iprot.readStructEnd()
11655 
 
11656 
  def write(self, oprot):
11657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11659 
      return
3064 chandransh 11660 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 11661 
    if self.order is not None:
3064 chandransh 11662 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
11663 
      self.order.write(oprot)
921 rajveer 11664 
      oprot.writeFieldEnd()
11665 
    oprot.writeFieldStop()
11666 
    oprot.writeStructEnd()
11667 
 
3431 rajveer 11668 
  def validate(self):
11669 
    return
11670 
 
11671 
 
921 rajveer 11672 
  def __repr__(self):
11673 
    L = ['%s=%r' % (key, value)
11674 
      for key, value in self.__dict__.iteritems()]
11675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11676 
 
11677 
  def __eq__(self, other):
11678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11679 
 
11680 
  def __ne__(self, other):
11681 
    return not (self == other)
11682 
 
3064 chandransh 11683 
class createOrder_result:
921 rajveer 11684 
  """
11685 
  Attributes:
11686 
   - success
11687 
   - ex
11688 
  """
11689 
 
11690 
  thrift_spec = (
3064 chandransh 11691 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 11692 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11693 
  )
11694 
 
11695 
  def __init__(self, success=None, ex=None,):
11696 
    self.success = success
11697 
    self.ex = ex
11698 
 
11699 
  def read(self, iprot):
11700 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11701 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11702 
      return
11703 
    iprot.readStructBegin()
11704 
    while True:
11705 
      (fname, ftype, fid) = iprot.readFieldBegin()
11706 
      if ftype == TType.STOP:
11707 
        break
11708 
      if fid == 0:
3064 chandransh 11709 
        if ftype == TType.I64:
11710 
          self.success = iprot.readI64();
921 rajveer 11711 
        else:
11712 
          iprot.skip(ftype)
11713 
      elif fid == 1:
11714 
        if ftype == TType.STRUCT:
11715 
          self.ex = TransactionServiceException()
11716 
          self.ex.read(iprot)
11717 
        else:
11718 
          iprot.skip(ftype)
11719 
      else:
11720 
        iprot.skip(ftype)
11721 
      iprot.readFieldEnd()
11722 
    iprot.readStructEnd()
11723 
 
11724 
  def write(self, oprot):
11725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11727 
      return
3064 chandransh 11728 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 11729 
    if self.success is not None:
3064 chandransh 11730 
      oprot.writeFieldBegin('success', TType.I64, 0)
11731 
      oprot.writeI64(self.success)
921 rajveer 11732 
      oprot.writeFieldEnd()
3431 rajveer 11733 
    if self.ex is not None:
921 rajveer 11734 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11735 
      self.ex.write(oprot)
11736 
      oprot.writeFieldEnd()
11737 
    oprot.writeFieldStop()
11738 
    oprot.writeStructEnd()
11739 
 
3431 rajveer 11740 
  def validate(self):
11741 
    return
11742 
 
11743 
 
921 rajveer 11744 
  def __repr__(self):
11745 
    L = ['%s=%r' % (key, value)
11746 
      for key, value in self.__dict__.iteritems()]
11747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11748 
 
11749 
  def __eq__(self, other):
11750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11751 
 
11752 
  def __ne__(self, other):
11753 
    return not (self == other)
11754 
 
3064 chandransh 11755 
class getOrder_args:
921 rajveer 11756 
  """
11757 
  Attributes:
3064 chandransh 11758 
   - id
921 rajveer 11759 
  """
11760 
 
11761 
  thrift_spec = (
11762 
    None, # 0
3064 chandransh 11763 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11764 
  )
11765 
 
3064 chandransh 11766 
  def __init__(self, id=None,):
11767 
    self.id = id
921 rajveer 11768 
 
11769 
  def read(self, iprot):
11770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11772 
      return
11773 
    iprot.readStructBegin()
11774 
    while True:
11775 
      (fname, ftype, fid) = iprot.readFieldBegin()
11776 
      if ftype == TType.STOP:
11777 
        break
11778 
      if fid == 1:
11779 
        if ftype == TType.I64:
3064 chandransh 11780 
          self.id = iprot.readI64();
921 rajveer 11781 
        else:
11782 
          iprot.skip(ftype)
11783 
      else:
11784 
        iprot.skip(ftype)
11785 
      iprot.readFieldEnd()
11786 
    iprot.readStructEnd()
11787 
 
11788 
  def write(self, oprot):
11789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11791 
      return
3064 chandransh 11792 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 11793 
    if self.id is not None:
3064 chandransh 11794 
      oprot.writeFieldBegin('id', TType.I64, 1)
11795 
      oprot.writeI64(self.id)
921 rajveer 11796 
      oprot.writeFieldEnd()
11797 
    oprot.writeFieldStop()
11798 
    oprot.writeStructEnd()
11799 
 
3431 rajveer 11800 
  def validate(self):
11801 
    return
11802 
 
11803 
 
921 rajveer 11804 
  def __repr__(self):
11805 
    L = ['%s=%r' % (key, value)
11806 
      for key, value in self.__dict__.iteritems()]
11807 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11808 
 
11809 
  def __eq__(self, other):
11810 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11811 
 
11812 
  def __ne__(self, other):
11813 
    return not (self == other)
11814 
 
3064 chandransh 11815 
class getOrder_result:
921 rajveer 11816 
  """
11817 
  Attributes:
11818 
   - success
11819 
   - ex
11820 
  """
11821 
 
11822 
  thrift_spec = (
3064 chandransh 11823 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 11824 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11825 
  )
11826 
 
11827 
  def __init__(self, success=None, ex=None,):
11828 
    self.success = success
11829 
    self.ex = ex
11830 
 
11831 
  def read(self, iprot):
11832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11834 
      return
11835 
    iprot.readStructBegin()
11836 
    while True:
11837 
      (fname, ftype, fid) = iprot.readFieldBegin()
11838 
      if ftype == TType.STOP:
11839 
        break
11840 
      if fid == 0:
3064 chandransh 11841 
        if ftype == TType.STRUCT:
11842 
          self.success = Order()
11843 
          self.success.read(iprot)
921 rajveer 11844 
        else:
11845 
          iprot.skip(ftype)
11846 
      elif fid == 1:
11847 
        if ftype == TType.STRUCT:
11848 
          self.ex = TransactionServiceException()
11849 
          self.ex.read(iprot)
11850 
        else:
11851 
          iprot.skip(ftype)
11852 
      else:
11853 
        iprot.skip(ftype)
11854 
      iprot.readFieldEnd()
11855 
    iprot.readStructEnd()
11856 
 
11857 
  def write(self, oprot):
11858 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11859 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11860 
      return
3064 chandransh 11861 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 11862 
    if self.success is not None:
3064 chandransh 11863 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11864 
      self.success.write(oprot)
921 rajveer 11865 
      oprot.writeFieldEnd()
3431 rajveer 11866 
    if self.ex is not None:
921 rajveer 11867 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11868 
      self.ex.write(oprot)
11869 
      oprot.writeFieldEnd()
11870 
    oprot.writeFieldStop()
11871 
    oprot.writeStructEnd()
11872 
 
3431 rajveer 11873 
  def validate(self):
11874 
    return
11875 
 
11876 
 
921 rajveer 11877 
  def __repr__(self):
11878 
    L = ['%s=%r' % (key, value)
11879 
      for key, value in self.__dict__.iteritems()]
11880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11881 
 
11882 
  def __eq__(self, other):
11883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11884 
 
11885 
  def __ne__(self, other):
11886 
    return not (self == other)
11887 
 
3064 chandransh 11888 
class getLineItemsForOrder_args:
94 ashish 11889 
  """
11890 
  Attributes:
3064 chandransh 11891 
   - orderId
94 ashish 11892 
  """
11893 
 
11894 
  thrift_spec = (
11895 
    None, # 0
3064 chandransh 11896 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11897 
  )
11898 
 
3064 chandransh 11899 
  def __init__(self, orderId=None,):
11900 
    self.orderId = orderId
94 ashish 11901 
 
11902 
  def read(self, iprot):
11903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11905 
      return
11906 
    iprot.readStructBegin()
11907 
    while True:
11908 
      (fname, ftype, fid) = iprot.readFieldBegin()
11909 
      if ftype == TType.STOP:
11910 
        break
11911 
      if fid == 1:
11912 
        if ftype == TType.I64:
3064 chandransh 11913 
          self.orderId = iprot.readI64();
94 ashish 11914 
        else:
11915 
          iprot.skip(ftype)
11916 
      else:
11917 
        iprot.skip(ftype)
11918 
      iprot.readFieldEnd()
11919 
    iprot.readStructEnd()
11920 
 
11921 
  def write(self, oprot):
11922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11924 
      return
3064 chandransh 11925 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 11926 
    if self.orderId is not None:
3064 chandransh 11927 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11928 
      oprot.writeI64(self.orderId)
94 ashish 11929 
      oprot.writeFieldEnd()
11930 
    oprot.writeFieldStop()
11931 
    oprot.writeStructEnd()
11932 
 
3431 rajveer 11933 
  def validate(self):
11934 
    return
11935 
 
11936 
 
94 ashish 11937 
  def __repr__(self):
11938 
    L = ['%s=%r' % (key, value)
11939 
      for key, value in self.__dict__.iteritems()]
11940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11941 
 
11942 
  def __eq__(self, other):
11943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11944 
 
11945 
  def __ne__(self, other):
11946 
    return not (self == other)
11947 
 
3064 chandransh 11948 
class getLineItemsForOrder_result:
94 ashish 11949 
  """
11950 
  Attributes:
11951 
   - success
11952 
   - ex
11953 
  """
11954 
 
11955 
  thrift_spec = (
3064 chandransh 11956 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 11957 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11958 
  )
11959 
 
11960 
  def __init__(self, success=None, ex=None,):
11961 
    self.success = success
11962 
    self.ex = ex
11963 
 
11964 
  def read(self, iprot):
11965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11967 
      return
11968 
    iprot.readStructBegin()
11969 
    while True:
11970 
      (fname, ftype, fid) = iprot.readFieldBegin()
11971 
      if ftype == TType.STOP:
11972 
        break
11973 
      if fid == 0:
483 rajveer 11974 
        if ftype == TType.LIST:
11975 
          self.success = []
6188 rajveer 11976 
          (_etype207, _size204) = iprot.readListBegin()
11977 
          for _i208 in xrange(_size204):
11978 
            _elem209 = LineItem()
11979 
            _elem209.read(iprot)
11980 
            self.success.append(_elem209)
483 rajveer 11981 
          iprot.readListEnd()
94 ashish 11982 
        else:
11983 
          iprot.skip(ftype)
11984 
      elif fid == 1:
11985 
        if ftype == TType.STRUCT:
11986 
          self.ex = TransactionServiceException()
11987 
          self.ex.read(iprot)
11988 
        else:
11989 
          iprot.skip(ftype)
11990 
      else:
11991 
        iprot.skip(ftype)
11992 
      iprot.readFieldEnd()
11993 
    iprot.readStructEnd()
11994 
 
11995 
  def write(self, oprot):
11996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11998 
      return
3064 chandransh 11999 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 12000 
    if self.success is not None:
483 rajveer 12001 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12002 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12003 
      for iter210 in self.success:
12004 
        iter210.write(oprot)
483 rajveer 12005 
      oprot.writeListEnd()
94 ashish 12006 
      oprot.writeFieldEnd()
3431 rajveer 12007 
    if self.ex is not None:
94 ashish 12008 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12009 
      self.ex.write(oprot)
12010 
      oprot.writeFieldEnd()
12011 
    oprot.writeFieldStop()
12012 
    oprot.writeStructEnd()
12013 
 
3431 rajveer 12014 
  def validate(self):
12015 
    return
12016 
 
12017 
 
94 ashish 12018 
  def __repr__(self):
12019 
    L = ['%s=%r' % (key, value)
12020 
      for key, value in self.__dict__.iteritems()]
12021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12022 
 
12023 
  def __eq__(self, other):
12024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12025 
 
12026 
  def __ne__(self, other):
12027 
    return not (self == other)
12028 
 
4999 phani.kuma 12029 
class getOrderList_args:
12030 
  """
12031 
  Attributes:
12032 
   - order_ids
12033 
  """
12034 
 
12035 
  thrift_spec = (
12036 
    None, # 0
12037 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12038 
  )
12039 
 
12040 
  def __init__(self, order_ids=None,):
12041 
    self.order_ids = order_ids
12042 
 
12043 
  def read(self, iprot):
12044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12046 
      return
12047 
    iprot.readStructBegin()
12048 
    while True:
12049 
      (fname, ftype, fid) = iprot.readFieldBegin()
12050 
      if ftype == TType.STOP:
12051 
        break
12052 
      if fid == 1:
12053 
        if ftype == TType.LIST:
12054 
          self.order_ids = []
6188 rajveer 12055 
          (_etype214, _size211) = iprot.readListBegin()
12056 
          for _i215 in xrange(_size211):
12057 
            _elem216 = iprot.readI64();
12058 
            self.order_ids.append(_elem216)
4999 phani.kuma 12059 
          iprot.readListEnd()
12060 
        else:
12061 
          iprot.skip(ftype)
12062 
      else:
12063 
        iprot.skip(ftype)
12064 
      iprot.readFieldEnd()
12065 
    iprot.readStructEnd()
12066 
 
12067 
  def write(self, oprot):
12068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12070 
      return
12071 
    oprot.writeStructBegin('getOrderList_args')
12072 
    if self.order_ids is not None:
12073 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12074 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12075 
      for iter217 in self.order_ids:
12076 
        oprot.writeI64(iter217)
4999 phani.kuma 12077 
      oprot.writeListEnd()
12078 
      oprot.writeFieldEnd()
12079 
    oprot.writeFieldStop()
12080 
    oprot.writeStructEnd()
12081 
 
12082 
  def validate(self):
12083 
    return
12084 
 
12085 
 
12086 
  def __repr__(self):
12087 
    L = ['%s=%r' % (key, value)
12088 
      for key, value in self.__dict__.iteritems()]
12089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12090 
 
12091 
  def __eq__(self, other):
12092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12093 
 
12094 
  def __ne__(self, other):
12095 
    return not (self == other)
12096 
 
12097 
class getOrderList_result:
12098 
  """
12099 
  Attributes:
12100 
   - success
12101 
  """
12102 
 
12103 
  thrift_spec = (
12104 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12105 
  )
12106 
 
12107 
  def __init__(self, success=None,):
12108 
    self.success = success
12109 
 
12110 
  def read(self, iprot):
12111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12113 
      return
12114 
    iprot.readStructBegin()
12115 
    while True:
12116 
      (fname, ftype, fid) = iprot.readFieldBegin()
12117 
      if ftype == TType.STOP:
12118 
        break
12119 
      if fid == 0:
12120 
        if ftype == TType.LIST:
12121 
          self.success = []
6188 rajveer 12122 
          (_etype221, _size218) = iprot.readListBegin()
12123 
          for _i222 in xrange(_size218):
12124 
            _elem223 = Order()
12125 
            _elem223.read(iprot)
12126 
            self.success.append(_elem223)
4999 phani.kuma 12127 
          iprot.readListEnd()
12128 
        else:
12129 
          iprot.skip(ftype)
12130 
      else:
12131 
        iprot.skip(ftype)
12132 
      iprot.readFieldEnd()
12133 
    iprot.readStructEnd()
12134 
 
12135 
  def write(self, oprot):
12136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12138 
      return
12139 
    oprot.writeStructBegin('getOrderList_result')
12140 
    if self.success is not None:
12141 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12142 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12143 
      for iter224 in self.success:
12144 
        iter224.write(oprot)
4999 phani.kuma 12145 
      oprot.writeListEnd()
12146 
      oprot.writeFieldEnd()
12147 
    oprot.writeFieldStop()
12148 
    oprot.writeStructEnd()
12149 
 
12150 
  def validate(self):
12151 
    return
12152 
 
12153 
 
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 
 
5386 phani.kuma 12165 
class getOrderListForVendor_args:
12166 
  """
12167 
  Attributes:
12168 
   - order_ids
12169 
   - vendorId
12170 
  """
12171 
 
12172 
  thrift_spec = (
12173 
    None, # 0
12174 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12175 
    (2, TType.I64, 'vendorId', None, None, ), # 2
12176 
  )
12177 
 
12178 
  def __init__(self, order_ids=None, vendorId=None,):
12179 
    self.order_ids = order_ids
12180 
    self.vendorId = vendorId
12181 
 
12182 
  def read(self, iprot):
12183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12185 
      return
12186 
    iprot.readStructBegin()
12187 
    while True:
12188 
      (fname, ftype, fid) = iprot.readFieldBegin()
12189 
      if ftype == TType.STOP:
12190 
        break
12191 
      if fid == 1:
12192 
        if ftype == TType.LIST:
12193 
          self.order_ids = []
6188 rajveer 12194 
          (_etype228, _size225) = iprot.readListBegin()
12195 
          for _i229 in xrange(_size225):
12196 
            _elem230 = iprot.readI64();
12197 
            self.order_ids.append(_elem230)
5386 phani.kuma 12198 
          iprot.readListEnd()
12199 
        else:
12200 
          iprot.skip(ftype)
12201 
      elif fid == 2:
12202 
        if ftype == TType.I64:
12203 
          self.vendorId = iprot.readI64();
12204 
        else:
12205 
          iprot.skip(ftype)
12206 
      else:
12207 
        iprot.skip(ftype)
12208 
      iprot.readFieldEnd()
12209 
    iprot.readStructEnd()
12210 
 
12211 
  def write(self, oprot):
12212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12214 
      return
12215 
    oprot.writeStructBegin('getOrderListForVendor_args')
12216 
    if self.order_ids is not None:
12217 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12218 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12219 
      for iter231 in self.order_ids:
12220 
        oprot.writeI64(iter231)
5386 phani.kuma 12221 
      oprot.writeListEnd()
12222 
      oprot.writeFieldEnd()
12223 
    if self.vendorId is not None:
12224 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
12225 
      oprot.writeI64(self.vendorId)
12226 
      oprot.writeFieldEnd()
12227 
    oprot.writeFieldStop()
12228 
    oprot.writeStructEnd()
12229 
 
12230 
  def validate(self):
12231 
    return
12232 
 
12233 
 
12234 
  def __repr__(self):
12235 
    L = ['%s=%r' % (key, value)
12236 
      for key, value in self.__dict__.iteritems()]
12237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12238 
 
12239 
  def __eq__(self, other):
12240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12241 
 
12242 
  def __ne__(self, other):
12243 
    return not (self == other)
12244 
 
12245 
class getOrderListForVendor_result:
12246 
  """
12247 
  Attributes:
12248 
   - success
12249 
  """
12250 
 
12251 
  thrift_spec = (
12252 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12253 
  )
12254 
 
12255 
  def __init__(self, success=None,):
12256 
    self.success = success
12257 
 
12258 
  def read(self, iprot):
12259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12261 
      return
12262 
    iprot.readStructBegin()
12263 
    while True:
12264 
      (fname, ftype, fid) = iprot.readFieldBegin()
12265 
      if ftype == TType.STOP:
12266 
        break
12267 
      if fid == 0:
12268 
        if ftype == TType.LIST:
12269 
          self.success = []
6188 rajveer 12270 
          (_etype235, _size232) = iprot.readListBegin()
12271 
          for _i236 in xrange(_size232):
12272 
            _elem237 = Order()
12273 
            _elem237.read(iprot)
12274 
            self.success.append(_elem237)
5386 phani.kuma 12275 
          iprot.readListEnd()
12276 
        else:
12277 
          iprot.skip(ftype)
12278 
      else:
12279 
        iprot.skip(ftype)
12280 
      iprot.readFieldEnd()
12281 
    iprot.readStructEnd()
12282 
 
12283 
  def write(self, oprot):
12284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12286 
      return
12287 
    oprot.writeStructBegin('getOrderListForVendor_result')
12288 
    if self.success is not None:
12289 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12290 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12291 
      for iter238 in self.success:
12292 
        iter238.write(oprot)
5386 phani.kuma 12293 
      oprot.writeListEnd()
12294 
      oprot.writeFieldEnd()
12295 
    oprot.writeFieldStop()
12296 
    oprot.writeStructEnd()
12297 
 
12298 
  def validate(self):
12299 
    return
12300 
 
12301 
 
12302 
  def __repr__(self):
12303 
    L = ['%s=%r' % (key, value)
12304 
      for key, value in self.__dict__.iteritems()]
12305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12306 
 
12307 
  def __eq__(self, other):
12308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12309 
 
12310 
  def __ne__(self, other):
12311 
    return not (self == other)
12312 
 
3064 chandransh 12313 
class getOrderForCustomer_args:
94 ashish 12314 
  """
12315 
  Attributes:
3064 chandransh 12316 
   - orderId
483 rajveer 12317 
   - customerId
94 ashish 12318 
  """
12319 
 
12320 
  thrift_spec = (
12321 
    None, # 0
3064 chandransh 12322 
    (1, TType.I64, 'orderId', None, None, ), # 1
12323 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 12324 
  )
12325 
 
3064 chandransh 12326 
  def __init__(self, orderId=None, customerId=None,):
12327 
    self.orderId = orderId
483 rajveer 12328 
    self.customerId = customerId
94 ashish 12329 
 
12330 
  def read(self, iprot):
12331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12333 
      return
12334 
    iprot.readStructBegin()
12335 
    while True:
12336 
      (fname, ftype, fid) = iprot.readFieldBegin()
12337 
      if ftype == TType.STOP:
12338 
        break
12339 
      if fid == 1:
12340 
        if ftype == TType.I64:
3064 chandransh 12341 
          self.orderId = iprot.readI64();
94 ashish 12342 
        else:
12343 
          iprot.skip(ftype)
12344 
      elif fid == 2:
12345 
        if ftype == TType.I64:
3064 chandransh 12346 
          self.customerId = iprot.readI64();
94 ashish 12347 
        else:
12348 
          iprot.skip(ftype)
12349 
      else:
12350 
        iprot.skip(ftype)
12351 
      iprot.readFieldEnd()
12352 
    iprot.readStructEnd()
12353 
 
12354 
  def write(self, oprot):
12355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12357 
      return
3064 chandransh 12358 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 12359 
    if self.orderId is not None:
3064 chandransh 12360 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12361 
      oprot.writeI64(self.orderId)
12362 
      oprot.writeFieldEnd()
3431 rajveer 12363 
    if self.customerId is not None:
3064 chandransh 12364 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 12365 
      oprot.writeI64(self.customerId)
94 ashish 12366 
      oprot.writeFieldEnd()
12367 
    oprot.writeFieldStop()
12368 
    oprot.writeStructEnd()
12369 
 
3431 rajveer 12370 
  def validate(self):
12371 
    return
12372 
 
12373 
 
94 ashish 12374 
  def __repr__(self):
12375 
    L = ['%s=%r' % (key, value)
12376 
      for key, value in self.__dict__.iteritems()]
12377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12378 
 
12379 
  def __eq__(self, other):
12380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12381 
 
12382 
  def __ne__(self, other):
12383 
    return not (self == other)
12384 
 
3064 chandransh 12385 
class getOrderForCustomer_result:
94 ashish 12386 
  """
12387 
  Attributes:
12388 
   - success
12389 
   - ex
12390 
  """
12391 
 
12392 
  thrift_spec = (
3064 chandransh 12393 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 12394 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12395 
  )
12396 
 
12397 
  def __init__(self, success=None, ex=None,):
12398 
    self.success = success
12399 
    self.ex = ex
12400 
 
12401 
  def read(self, iprot):
12402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12404 
      return
12405 
    iprot.readStructBegin()
12406 
    while True:
12407 
      (fname, ftype, fid) = iprot.readFieldBegin()
12408 
      if ftype == TType.STOP:
12409 
        break
12410 
      if fid == 0:
3064 chandransh 12411 
        if ftype == TType.STRUCT:
12412 
          self.success = Order()
12413 
          self.success.read(iprot)
94 ashish 12414 
        else:
12415 
          iprot.skip(ftype)
12416 
      elif fid == 1:
12417 
        if ftype == TType.STRUCT:
12418 
          self.ex = TransactionServiceException()
12419 
          self.ex.read(iprot)
12420 
        else:
12421 
          iprot.skip(ftype)
12422 
      else:
12423 
        iprot.skip(ftype)
12424 
      iprot.readFieldEnd()
12425 
    iprot.readStructEnd()
12426 
 
12427 
  def write(self, oprot):
12428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12430 
      return
3064 chandransh 12431 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 12432 
    if self.success is not None:
3064 chandransh 12433 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12434 
      self.success.write(oprot)
94 ashish 12435 
      oprot.writeFieldEnd()
3431 rajveer 12436 
    if self.ex is not None:
94 ashish 12437 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12438 
      self.ex.write(oprot)
12439 
      oprot.writeFieldEnd()
12440 
    oprot.writeFieldStop()
12441 
    oprot.writeStructEnd()
12442 
 
3431 rajveer 12443 
  def validate(self):
12444 
    return
12445 
 
12446 
 
94 ashish 12447 
  def __repr__(self):
12448 
    L = ['%s=%r' % (key, value)
12449 
      for key, value in self.__dict__.iteritems()]
12450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12451 
 
12452 
  def __eq__(self, other):
12453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12454 
 
12455 
  def __ne__(self, other):
12456 
    return not (self == other)
12457 
 
3064 chandransh 12458 
class getAlerts_args:
94 ashish 12459 
  """
12460 
  Attributes:
4394 rajveer 12461 
   - type
4444 rajveer 12462 
   - warehouseId
4394 rajveer 12463 
   - status
12464 
   - timestamp
94 ashish 12465 
  """
12466 
 
12467 
  thrift_spec = (
12468 
    None, # 0
4394 rajveer 12469 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12470 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12471 
    (3, TType.I64, 'status', None, None, ), # 3
12472 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 12473 
  )
12474 
 
4444 rajveer 12475 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 12476 
    self.type = type
4444 rajveer 12477 
    self.warehouseId = warehouseId
4394 rajveer 12478 
    self.status = status
12479 
    self.timestamp = timestamp
94 ashish 12480 
 
12481 
  def read(self, iprot):
12482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12484 
      return
12485 
    iprot.readStructBegin()
12486 
    while True:
12487 
      (fname, ftype, fid) = iprot.readFieldBegin()
12488 
      if ftype == TType.STOP:
12489 
        break
12490 
      if fid == 1:
3064 chandransh 12491 
        if ftype == TType.I64:
4394 rajveer 12492 
          self.type = iprot.readI64();
94 ashish 12493 
        else:
12494 
          iprot.skip(ftype)
3064 chandransh 12495 
      elif fid == 2:
4394 rajveer 12496 
        if ftype == TType.I64:
4444 rajveer 12497 
          self.warehouseId = iprot.readI64();
3064 chandransh 12498 
        else:
12499 
          iprot.skip(ftype)
4394 rajveer 12500 
      elif fid == 3:
12501 
        if ftype == TType.I64:
4444 rajveer 12502 
          self.status = iprot.readI64();
12503 
        else:
12504 
          iprot.skip(ftype)
12505 
      elif fid == 4:
12506 
        if ftype == TType.I64:
4394 rajveer 12507 
          self.timestamp = iprot.readI64();
12508 
        else:
12509 
          iprot.skip(ftype)
94 ashish 12510 
      else:
12511 
        iprot.skip(ftype)
12512 
      iprot.readFieldEnd()
12513 
    iprot.readStructEnd()
12514 
 
12515 
  def write(self, oprot):
12516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12518 
      return
3064 chandransh 12519 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 12520 
    if self.type is not None:
12521 
      oprot.writeFieldBegin('type', TType.I64, 1)
12522 
      oprot.writeI64(self.type)
94 ashish 12523 
      oprot.writeFieldEnd()
4444 rajveer 12524 
    if self.warehouseId is not None:
12525 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12526 
      oprot.writeI64(self.warehouseId)
12527 
      oprot.writeFieldEnd()
4394 rajveer 12528 
    if self.status is not None:
4444 rajveer 12529 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 12530 
      oprot.writeI64(self.status)
3064 chandransh 12531 
      oprot.writeFieldEnd()
4394 rajveer 12532 
    if self.timestamp is not None:
4444 rajveer 12533 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 12534 
      oprot.writeI64(self.timestamp)
12535 
      oprot.writeFieldEnd()
94 ashish 12536 
    oprot.writeFieldStop()
12537 
    oprot.writeStructEnd()
12538 
 
3431 rajveer 12539 
  def validate(self):
12540 
    return
12541 
 
12542 
 
94 ashish 12543 
  def __repr__(self):
12544 
    L = ['%s=%r' % (key, value)
12545 
      for key, value in self.__dict__.iteritems()]
12546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12547 
 
12548 
  def __eq__(self, other):
12549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12550 
 
12551 
  def __ne__(self, other):
12552 
    return not (self == other)
12553 
 
3064 chandransh 12554 
class getAlerts_result:
94 ashish 12555 
  """
12556 
  Attributes:
12557 
   - success
12558 
  """
12559 
 
12560 
  thrift_spec = (
3064 chandransh 12561 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 12562 
  )
12563 
 
3064 chandransh 12564 
  def __init__(self, success=None,):
94 ashish 12565 
    self.success = success
12566 
 
12567 
  def read(self, iprot):
12568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12570 
      return
12571 
    iprot.readStructBegin()
12572 
    while True:
12573 
      (fname, ftype, fid) = iprot.readFieldBegin()
12574 
      if ftype == TType.STOP:
12575 
        break
12576 
      if fid == 0:
3064 chandransh 12577 
        if ftype == TType.LIST:
12578 
          self.success = []
6188 rajveer 12579 
          (_etype242, _size239) = iprot.readListBegin()
12580 
          for _i243 in xrange(_size239):
12581 
            _elem244 = Alert()
12582 
            _elem244.read(iprot)
12583 
            self.success.append(_elem244)
3064 chandransh 12584 
          iprot.readListEnd()
94 ashish 12585 
        else:
12586 
          iprot.skip(ftype)
12587 
      else:
12588 
        iprot.skip(ftype)
12589 
      iprot.readFieldEnd()
12590 
    iprot.readStructEnd()
12591 
 
12592 
  def write(self, oprot):
12593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12595 
      return
3064 chandransh 12596 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 12597 
    if self.success is not None:
3064 chandransh 12598 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12599 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12600 
      for iter245 in self.success:
12601 
        iter245.write(oprot)
3064 chandransh 12602 
      oprot.writeListEnd()
94 ashish 12603 
      oprot.writeFieldEnd()
12604 
    oprot.writeFieldStop()
12605 
    oprot.writeStructEnd()
12606 
 
3431 rajveer 12607 
  def validate(self):
12608 
    return
12609 
 
12610 
 
94 ashish 12611 
  def __repr__(self):
12612 
    L = ['%s=%r' % (key, value)
12613 
      for key, value in self.__dict__.iteritems()]
12614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12615 
 
12616 
  def __eq__(self, other):
12617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12618 
 
12619 
  def __ne__(self, other):
12620 
    return not (self == other)
12621 
 
4394 rajveer 12622 
class addAlert_args:
94 ashish 12623 
  """
12624 
  Attributes:
3064 chandransh 12625 
   - type
4444 rajveer 12626 
   - warehouseId
4394 rajveer 12627 
   - description
94 ashish 12628 
  """
12629 
 
12630 
  thrift_spec = (
12631 
    None, # 0
4394 rajveer 12632 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12633 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12634 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12635 
  )
12636 
 
4444 rajveer 12637 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 12638 
    self.type = type
4444 rajveer 12639 
    self.warehouseId = warehouseId
4394 rajveer 12640 
    self.description = description
94 ashish 12641 
 
12642 
  def read(self, iprot):
12643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12645 
      return
12646 
    iprot.readStructBegin()
12647 
    while True:
12648 
      (fname, ftype, fid) = iprot.readFieldBegin()
12649 
      if ftype == TType.STOP:
12650 
        break
12651 
      if fid == 1:
12652 
        if ftype == TType.I64:
4394 rajveer 12653 
          self.type = iprot.readI64();
94 ashish 12654 
        else:
12655 
          iprot.skip(ftype)
3064 chandransh 12656 
      elif fid == 2:
4444 rajveer 12657 
        if ftype == TType.I64:
12658 
          self.warehouseId = iprot.readI64();
12659 
        else:
12660 
          iprot.skip(ftype)
12661 
      elif fid == 3:
3064 chandransh 12662 
        if ftype == TType.STRING:
4394 rajveer 12663 
          self.description = iprot.readString();
3064 chandransh 12664 
        else:
12665 
          iprot.skip(ftype)
94 ashish 12666 
      else:
12667 
        iprot.skip(ftype)
12668 
      iprot.readFieldEnd()
12669 
    iprot.readStructEnd()
12670 
 
12671 
  def write(self, oprot):
12672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12674 
      return
4394 rajveer 12675 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 12676 
    if self.type is not None:
4394 rajveer 12677 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 12678 
      oprot.writeI64(self.type)
12679 
      oprot.writeFieldEnd()
4444 rajveer 12680 
    if self.warehouseId is not None:
12681 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12682 
      oprot.writeI64(self.warehouseId)
12683 
      oprot.writeFieldEnd()
4394 rajveer 12684 
    if self.description is not None:
4444 rajveer 12685 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 12686 
      oprot.writeString(self.description)
3064 chandransh 12687 
      oprot.writeFieldEnd()
94 ashish 12688 
    oprot.writeFieldStop()
12689 
    oprot.writeStructEnd()
12690 
 
3431 rajveer 12691 
  def validate(self):
12692 
    return
12693 
 
12694 
 
94 ashish 12695 
  def __repr__(self):
12696 
    L = ['%s=%r' % (key, value)
12697 
      for key, value in self.__dict__.iteritems()]
12698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12699 
 
12700 
  def __eq__(self, other):
12701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12702 
 
12703 
  def __ne__(self, other):
12704 
    return not (self == other)
12705 
 
4394 rajveer 12706 
class addAlert_result:
3064 chandransh 12707 
 
12708 
  thrift_spec = (
12709 
  )
12710 
 
12711 
  def read(self, iprot):
12712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12714 
      return
12715 
    iprot.readStructBegin()
12716 
    while True:
12717 
      (fname, ftype, fid) = iprot.readFieldBegin()
12718 
      if ftype == TType.STOP:
12719 
        break
12720 
      else:
12721 
        iprot.skip(ftype)
12722 
      iprot.readFieldEnd()
12723 
    iprot.readStructEnd()
12724 
 
12725 
  def write(self, oprot):
12726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12728 
      return
4394 rajveer 12729 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 12730 
    oprot.writeFieldStop()
12731 
    oprot.writeStructEnd()
12732 
 
3431 rajveer 12733 
  def validate(self):
12734 
    return
12735 
 
12736 
 
3064 chandransh 12737 
  def __repr__(self):
12738 
    L = ['%s=%r' % (key, value)
12739 
      for key, value in self.__dict__.iteritems()]
12740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12741 
 
12742 
  def __eq__(self, other):
12743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12744 
 
12745 
  def __ne__(self, other):
12746 
    return not (self == other)
12747 
 
4444 rajveer 12748 
class markAlertsAsSeen_args:
12749 
  """
12750 
  Attributes:
12751 
   - warehouseId
12752 
  """
12753 
 
12754 
  thrift_spec = (
12755 
    None, # 0
12756 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12757 
  )
12758 
 
12759 
  def __init__(self, warehouseId=None,):
12760 
    self.warehouseId = warehouseId
12761 
 
12762 
  def read(self, iprot):
12763 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12764 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12765 
      return
12766 
    iprot.readStructBegin()
12767 
    while True:
12768 
      (fname, ftype, fid) = iprot.readFieldBegin()
12769 
      if ftype == TType.STOP:
12770 
        break
12771 
      if fid == 1:
12772 
        if ftype == TType.I64:
12773 
          self.warehouseId = iprot.readI64();
12774 
        else:
12775 
          iprot.skip(ftype)
12776 
      else:
12777 
        iprot.skip(ftype)
12778 
      iprot.readFieldEnd()
12779 
    iprot.readStructEnd()
12780 
 
12781 
  def write(self, oprot):
12782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12784 
      return
12785 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12786 
    if self.warehouseId is not None:
12787 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12788 
      oprot.writeI64(self.warehouseId)
12789 
      oprot.writeFieldEnd()
12790 
    oprot.writeFieldStop()
12791 
    oprot.writeStructEnd()
12792 
 
12793 
  def validate(self):
12794 
    return
12795 
 
12796 
 
12797 
  def __repr__(self):
12798 
    L = ['%s=%r' % (key, value)
12799 
      for key, value in self.__dict__.iteritems()]
12800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12801 
 
12802 
  def __eq__(self, other):
12803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12804 
 
12805 
  def __ne__(self, other):
12806 
    return not (self == other)
12807 
 
12808 
class markAlertsAsSeen_result:
12809 
 
12810 
  thrift_spec = (
12811 
  )
12812 
 
12813 
  def read(self, iprot):
12814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12816 
      return
12817 
    iprot.readStructBegin()
12818 
    while True:
12819 
      (fname, ftype, fid) = iprot.readFieldBegin()
12820 
      if ftype == TType.STOP:
12821 
        break
12822 
      else:
12823 
        iprot.skip(ftype)
12824 
      iprot.readFieldEnd()
12825 
    iprot.readStructEnd()
12826 
 
12827 
  def write(self, oprot):
12828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12830 
      return
12831 
    oprot.writeStructBegin('markAlertsAsSeen_result')
12832 
    oprot.writeFieldStop()
12833 
    oprot.writeStructEnd()
12834 
 
12835 
  def validate(self):
12836 
    return
12837 
 
12838 
 
12839 
  def __repr__(self):
12840 
    L = ['%s=%r' % (key, value)
12841 
      for key, value in self.__dict__.iteritems()]
12842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12843 
 
12844 
  def __eq__(self, other):
12845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12846 
 
12847 
  def __ne__(self, other):
12848 
    return not (self == other)
12849 
 
3064 chandransh 12850 
class getValidOrderCount_args:
12851 
 
12852 
  thrift_spec = (
12853 
  )
12854 
 
12855 
  def read(self, iprot):
12856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12858 
      return
12859 
    iprot.readStructBegin()
12860 
    while True:
12861 
      (fname, ftype, fid) = iprot.readFieldBegin()
12862 
      if ftype == TType.STOP:
12863 
        break
12864 
      else:
12865 
        iprot.skip(ftype)
12866 
      iprot.readFieldEnd()
12867 
    iprot.readStructEnd()
12868 
 
12869 
  def write(self, oprot):
12870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12872 
      return
12873 
    oprot.writeStructBegin('getValidOrderCount_args')
12874 
    oprot.writeFieldStop()
12875 
    oprot.writeStructEnd()
12876 
 
3431 rajveer 12877 
  def validate(self):
12878 
    return
12879 
 
12880 
 
3064 chandransh 12881 
  def __repr__(self):
12882 
    L = ['%s=%r' % (key, value)
12883 
      for key, value in self.__dict__.iteritems()]
12884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12885 
 
12886 
  def __eq__(self, other):
12887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12888 
 
12889 
  def __ne__(self, other):
12890 
    return not (self == other)
12891 
 
12892 
class getValidOrderCount_result:
94 ashish 12893 
  """
12894 
  Attributes:
12895 
   - success
12896 
  """
12897 
 
12898 
  thrift_spec = (
3064 chandransh 12899 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12900 
  )
12901 
 
3064 chandransh 12902 
  def __init__(self, success=None,):
94 ashish 12903 
    self.success = success
12904 
 
12905 
  def read(self, iprot):
12906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12908 
      return
12909 
    iprot.readStructBegin()
12910 
    while True:
12911 
      (fname, ftype, fid) = iprot.readFieldBegin()
12912 
      if ftype == TType.STOP:
12913 
        break
12914 
      if fid == 0:
3064 chandransh 12915 
        if ftype == TType.I64:
12916 
          self.success = iprot.readI64();
94 ashish 12917 
        else:
12918 
          iprot.skip(ftype)
12919 
      else:
12920 
        iprot.skip(ftype)
12921 
      iprot.readFieldEnd()
12922 
    iprot.readStructEnd()
12923 
 
12924 
  def write(self, oprot):
12925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12927 
      return
3064 chandransh 12928 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12929 
    if self.success is not None:
3064 chandransh 12930 
      oprot.writeFieldBegin('success', TType.I64, 0)
12931 
      oprot.writeI64(self.success)
94 ashish 12932 
      oprot.writeFieldEnd()
12933 
    oprot.writeFieldStop()
12934 
    oprot.writeStructEnd()
12935 
 
3431 rajveer 12936 
  def validate(self):
12937 
    return
12938 
 
12939 
 
94 ashish 12940 
  def __repr__(self):
12941 
    L = ['%s=%r' % (key, value)
12942 
      for key, value in self.__dict__.iteritems()]
12943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12944 
 
12945 
  def __eq__(self, other):
12946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12947 
 
12948 
  def __ne__(self, other):
12949 
    return not (self == other)
12950 
 
3064 chandransh 12951 
class getNoOfCustomersWithSuccessfulTransaction_args:
12952 
 
12953 
  thrift_spec = (
12954 
  )
12955 
 
12956 
  def read(self, iprot):
12957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12959 
      return
12960 
    iprot.readStructBegin()
12961 
    while True:
12962 
      (fname, ftype, fid) = iprot.readFieldBegin()
12963 
      if ftype == TType.STOP:
12964 
        break
12965 
      else:
12966 
        iprot.skip(ftype)
12967 
      iprot.readFieldEnd()
12968 
    iprot.readStructEnd()
12969 
 
12970 
  def write(self, oprot):
12971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12973 
      return
12974 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
12975 
    oprot.writeFieldStop()
12976 
    oprot.writeStructEnd()
12977 
 
3431 rajveer 12978 
  def validate(self):
12979 
    return
12980 
 
12981 
 
3064 chandransh 12982 
  def __repr__(self):
12983 
    L = ['%s=%r' % (key, value)
12984 
      for key, value in self.__dict__.iteritems()]
12985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12986 
 
12987 
  def __eq__(self, other):
12988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12989 
 
12990 
  def __ne__(self, other):
12991 
    return not (self == other)
12992 
 
12993 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 12994 
  """
12995 
  Attributes:
3064 chandransh 12996 
   - success
94 ashish 12997 
  """
12998 
 
12999 
  thrift_spec = (
3064 chandransh 13000 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 13001 
  )
13002 
 
3064 chandransh 13003 
  def __init__(self, success=None,):
13004 
    self.success = success
94 ashish 13005 
 
13006 
  def read(self, iprot):
13007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13009 
      return
13010 
    iprot.readStructBegin()
13011 
    while True:
13012 
      (fname, ftype, fid) = iprot.readFieldBegin()
13013 
      if ftype == TType.STOP:
13014 
        break
3064 chandransh 13015 
      if fid == 0:
94 ashish 13016 
        if ftype == TType.I64:
3064 chandransh 13017 
          self.success = iprot.readI64();
94 ashish 13018 
        else:
13019 
          iprot.skip(ftype)
13020 
      else:
13021 
        iprot.skip(ftype)
13022 
      iprot.readFieldEnd()
13023 
    iprot.readStructEnd()
13024 
 
13025 
  def write(self, oprot):
13026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13028 
      return
3064 chandransh 13029 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 13030 
    if self.success is not None:
3064 chandransh 13031 
      oprot.writeFieldBegin('success', TType.I64, 0)
13032 
      oprot.writeI64(self.success)
94 ashish 13033 
      oprot.writeFieldEnd()
13034 
    oprot.writeFieldStop()
13035 
    oprot.writeStructEnd()
13036 
 
3431 rajveer 13037 
  def validate(self):
13038 
    return
13039 
 
13040 
 
94 ashish 13041 
  def __repr__(self):
13042 
    L = ['%s=%r' % (key, value)
13043 
      for key, value in self.__dict__.iteritems()]
13044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13045 
 
13046 
  def __eq__(self, other):
13047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13048 
 
13049 
  def __ne__(self, other):
13050 
    return not (self == other)
13051 
 
3064 chandransh 13052 
class getValidOrdersAmountRange_args:
13053 
 
13054 
  thrift_spec = (
13055 
  )
13056 
 
13057 
  def read(self, iprot):
13058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13060 
      return
13061 
    iprot.readStructBegin()
13062 
    while True:
13063 
      (fname, ftype, fid) = iprot.readFieldBegin()
13064 
      if ftype == TType.STOP:
13065 
        break
13066 
      else:
13067 
        iprot.skip(ftype)
13068 
      iprot.readFieldEnd()
13069 
    iprot.readStructEnd()
13070 
 
13071 
  def write(self, oprot):
13072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13074 
      return
13075 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
13076 
    oprot.writeFieldStop()
13077 
    oprot.writeStructEnd()
13078 
 
3431 rajveer 13079 
  def validate(self):
13080 
    return
13081 
 
13082 
 
3064 chandransh 13083 
  def __repr__(self):
13084 
    L = ['%s=%r' % (key, value)
13085 
      for key, value in self.__dict__.iteritems()]
13086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13087 
 
13088 
  def __eq__(self, other):
13089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13090 
 
13091 
  def __ne__(self, other):
13092 
    return not (self == other)
13093 
 
13094 
class getValidOrdersAmountRange_result:
94 ashish 13095 
  """
13096 
  Attributes:
13097 
   - success
13098 
  """
13099 
 
13100 
  thrift_spec = (
3064 chandransh 13101 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 13102 
  )
13103 
 
3064 chandransh 13104 
  def __init__(self, success=None,):
94 ashish 13105 
    self.success = success
13106 
 
13107 
  def read(self, iprot):
13108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13110 
      return
13111 
    iprot.readStructBegin()
13112 
    while True:
13113 
      (fname, ftype, fid) = iprot.readFieldBegin()
13114 
      if ftype == TType.STOP:
13115 
        break
13116 
      if fid == 0:
483 rajveer 13117 
        if ftype == TType.LIST:
13118 
          self.success = []
6188 rajveer 13119 
          (_etype249, _size246) = iprot.readListBegin()
13120 
          for _i250 in xrange(_size246):
13121 
            _elem251 = iprot.readDouble();
13122 
            self.success.append(_elem251)
483 rajveer 13123 
          iprot.readListEnd()
94 ashish 13124 
        else:
13125 
          iprot.skip(ftype)
13126 
      else:
13127 
        iprot.skip(ftype)
13128 
      iprot.readFieldEnd()
13129 
    iprot.readStructEnd()
13130 
 
13131 
  def write(self, oprot):
13132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13134 
      return
3064 chandransh 13135 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 13136 
    if self.success is not None:
483 rajveer 13137 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 13138 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 13139 
      for iter252 in self.success:
13140 
        oprot.writeDouble(iter252)
483 rajveer 13141 
      oprot.writeListEnd()
94 ashish 13142 
      oprot.writeFieldEnd()
13143 
    oprot.writeFieldStop()
13144 
    oprot.writeStructEnd()
13145 
 
3431 rajveer 13146 
  def validate(self):
13147 
    return
13148 
 
13149 
 
94 ashish 13150 
  def __repr__(self):
13151 
    L = ['%s=%r' % (key, value)
13152 
      for key, value in self.__dict__.iteritems()]
13153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13154 
 
13155 
  def __eq__(self, other):
13156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13157 
 
13158 
  def __ne__(self, other):
13159 
    return not (self == other)
13160 
 
3064 chandransh 13161 
class getValidOrders_args:
1528 ankur.sing 13162 
  """
13163 
  Attributes:
3064 chandransh 13164 
   - limit
5874 rajveer 13165 
   - onlyStore
1528 ankur.sing 13166 
  """
13167 
 
13168 
  thrift_spec = (
13169 
    None, # 0
3064 chandransh 13170 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 13171 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 13172 
  )
13173 
 
5874 rajveer 13174 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 13175 
    self.limit = limit
5874 rajveer 13176 
    self.onlyStore = onlyStore
1528 ankur.sing 13177 
 
13178 
  def read(self, iprot):
13179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13181 
      return
13182 
    iprot.readStructBegin()
13183 
    while True:
13184 
      (fname, ftype, fid) = iprot.readFieldBegin()
13185 
      if ftype == TType.STOP:
13186 
        break
13187 
      if fid == 1:
13188 
        if ftype == TType.I64:
3064 chandransh 13189 
          self.limit = iprot.readI64();
1528 ankur.sing 13190 
        else:
13191 
          iprot.skip(ftype)
5874 rajveer 13192 
      elif fid == 2:
13193 
        if ftype == TType.BOOL:
13194 
          self.onlyStore = iprot.readBool();
13195 
        else:
13196 
          iprot.skip(ftype)
1528 ankur.sing 13197 
      else:
13198 
        iprot.skip(ftype)
13199 
      iprot.readFieldEnd()
13200 
    iprot.readStructEnd()
13201 
 
13202 
  def write(self, oprot):
13203 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13204 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13205 
      return
3064 chandransh 13206 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 13207 
    if self.limit is not None:
3064 chandransh 13208 
      oprot.writeFieldBegin('limit', TType.I64, 1)
13209 
      oprot.writeI64(self.limit)
1528 ankur.sing 13210 
      oprot.writeFieldEnd()
5874 rajveer 13211 
    if self.onlyStore is not None:
13212 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
13213 
      oprot.writeBool(self.onlyStore)
13214 
      oprot.writeFieldEnd()
1528 ankur.sing 13215 
    oprot.writeFieldStop()
13216 
    oprot.writeStructEnd()
13217 
 
3431 rajveer 13218 
  def validate(self):
13219 
    return
13220 
 
13221 
 
1528 ankur.sing 13222 
  def __repr__(self):
13223 
    L = ['%s=%r' % (key, value)
13224 
      for key, value in self.__dict__.iteritems()]
13225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13226 
 
13227 
  def __eq__(self, other):
13228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13229 
 
13230 
  def __ne__(self, other):
13231 
    return not (self == other)
13232 
 
3064 chandransh 13233 
class getValidOrders_result:
1528 ankur.sing 13234 
  """
13235 
  Attributes:
13236 
   - success
13237 
  """
13238 
 
13239 
  thrift_spec = (
3064 chandransh 13240 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 13241 
  )
13242 
 
3064 chandransh 13243 
  def __init__(self, success=None,):
1528 ankur.sing 13244 
    self.success = success
13245 
 
13246 
  def read(self, iprot):
13247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13249 
      return
13250 
    iprot.readStructBegin()
13251 
    while True:
13252 
      (fname, ftype, fid) = iprot.readFieldBegin()
13253 
      if ftype == TType.STOP:
13254 
        break
13255 
      if fid == 0:
3064 chandransh 13256 
        if ftype == TType.LIST:
13257 
          self.success = []
6188 rajveer 13258 
          (_etype256, _size253) = iprot.readListBegin()
13259 
          for _i257 in xrange(_size253):
13260 
            _elem258 = Order()
13261 
            _elem258.read(iprot)
13262 
            self.success.append(_elem258)
3064 chandransh 13263 
          iprot.readListEnd()
1528 ankur.sing 13264 
        else:
13265 
          iprot.skip(ftype)
13266 
      else:
13267 
        iprot.skip(ftype)
13268 
      iprot.readFieldEnd()
13269 
    iprot.readStructEnd()
13270 
 
13271 
  def write(self, oprot):
13272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13274 
      return
3064 chandransh 13275 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 13276 
    if self.success is not None:
3064 chandransh 13277 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13278 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13279 
      for iter259 in self.success:
13280 
        iter259.write(oprot)
3064 chandransh 13281 
      oprot.writeListEnd()
1528 ankur.sing 13282 
      oprot.writeFieldEnd()
13283 
    oprot.writeFieldStop()
13284 
    oprot.writeStructEnd()
13285 
 
3431 rajveer 13286 
  def validate(self):
13287 
    return
13288 
 
13289 
 
1528 ankur.sing 13290 
  def __repr__(self):
13291 
    L = ['%s=%r' % (key, value)
13292 
      for key, value in self.__dict__.iteritems()]
13293 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13294 
 
13295 
  def __eq__(self, other):
13296 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13297 
 
13298 
  def __ne__(self, other):
13299 
    return not (self == other)
13300 
 
1220 chandransh 13301 
class batchOrders_args:
13302 
  """
13303 
  Attributes:
13304 
   - warehouseId
13305 
  """
13306 
 
13307 
  thrift_spec = (
13308 
    None, # 0
13309 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13310 
  )
13311 
 
13312 
  def __init__(self, warehouseId=None,):
13313 
    self.warehouseId = warehouseId
13314 
 
13315 
  def read(self, iprot):
13316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13318 
      return
13319 
    iprot.readStructBegin()
13320 
    while True:
13321 
      (fname, ftype, fid) = iprot.readFieldBegin()
13322 
      if ftype == TType.STOP:
13323 
        break
13324 
      if fid == 1:
13325 
        if ftype == TType.I64:
13326 
          self.warehouseId = iprot.readI64();
13327 
        else:
13328 
          iprot.skip(ftype)
13329 
      else:
13330 
        iprot.skip(ftype)
13331 
      iprot.readFieldEnd()
13332 
    iprot.readStructEnd()
13333 
 
13334 
  def write(self, oprot):
13335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13337 
      return
13338 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 13339 
    if self.warehouseId is not None:
1220 chandransh 13340 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13341 
      oprot.writeI64(self.warehouseId)
13342 
      oprot.writeFieldEnd()
13343 
    oprot.writeFieldStop()
13344 
    oprot.writeStructEnd()
13345 
 
3431 rajveer 13346 
  def validate(self):
13347 
    return
13348 
 
13349 
 
1220 chandransh 13350 
  def __repr__(self):
13351 
    L = ['%s=%r' % (key, value)
13352 
      for key, value in self.__dict__.iteritems()]
13353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13354 
 
13355 
  def __eq__(self, other):
13356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13357 
 
13358 
  def __ne__(self, other):
13359 
    return not (self == other)
13360 
 
13361 
class batchOrders_result:
13362 
  """
13363 
  Attributes:
13364 
   - success
13365 
   - ex
13366 
  """
13367 
 
13368 
  thrift_spec = (
13369 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13370 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13371 
  )
13372 
 
13373 
  def __init__(self, success=None, ex=None,):
13374 
    self.success = success
13375 
    self.ex = ex
13376 
 
13377 
  def read(self, iprot):
13378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13380 
      return
13381 
    iprot.readStructBegin()
13382 
    while True:
13383 
      (fname, ftype, fid) = iprot.readFieldBegin()
13384 
      if ftype == TType.STOP:
13385 
        break
13386 
      if fid == 0:
13387 
        if ftype == TType.LIST:
13388 
          self.success = []
6188 rajveer 13389 
          (_etype263, _size260) = iprot.readListBegin()
13390 
          for _i264 in xrange(_size260):
13391 
            _elem265 = Order()
13392 
            _elem265.read(iprot)
13393 
            self.success.append(_elem265)
1220 chandransh 13394 
          iprot.readListEnd()
13395 
        else:
13396 
          iprot.skip(ftype)
13397 
      elif fid == 1:
13398 
        if ftype == TType.STRUCT:
13399 
          self.ex = TransactionServiceException()
13400 
          self.ex.read(iprot)
13401 
        else:
13402 
          iprot.skip(ftype)
13403 
      else:
13404 
        iprot.skip(ftype)
13405 
      iprot.readFieldEnd()
13406 
    iprot.readStructEnd()
13407 
 
13408 
  def write(self, oprot):
13409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13411 
      return
13412 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 13413 
    if self.success is not None:
1220 chandransh 13414 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13415 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13416 
      for iter266 in self.success:
13417 
        iter266.write(oprot)
1220 chandransh 13418 
      oprot.writeListEnd()
13419 
      oprot.writeFieldEnd()
3431 rajveer 13420 
    if self.ex is not None:
1220 chandransh 13421 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13422 
      self.ex.write(oprot)
13423 
      oprot.writeFieldEnd()
13424 
    oprot.writeFieldStop()
13425 
    oprot.writeStructEnd()
13426 
 
3431 rajveer 13427 
  def validate(self):
13428 
    return
13429 
 
13430 
 
1220 chandransh 13431 
  def __repr__(self):
13432 
    L = ['%s=%r' % (key, value)
13433 
      for key, value in self.__dict__.iteritems()]
13434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13435 
 
13436 
  def __eq__(self, other):
13437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13438 
 
13439 
  def __ne__(self, other):
13440 
    return not (self == other)
13441 
 
1208 chandransh 13442 
class markOrderAsOutOfStock_args:
13443 
  """
13444 
  Attributes:
13445 
   - orderId
13446 
  """
13447 
 
13448 
  thrift_spec = (
13449 
    None, # 0
13450 
    (1, TType.I64, 'orderId', None, None, ), # 1
13451 
  )
13452 
 
13453 
  def __init__(self, orderId=None,):
13454 
    self.orderId = orderId
13455 
 
13456 
  def read(self, iprot):
13457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13459 
      return
13460 
    iprot.readStructBegin()
13461 
    while True:
13462 
      (fname, ftype, fid) = iprot.readFieldBegin()
13463 
      if ftype == TType.STOP:
13464 
        break
13465 
      if fid == 1:
13466 
        if ftype == TType.I64:
13467 
          self.orderId = iprot.readI64();
13468 
        else:
13469 
          iprot.skip(ftype)
13470 
      else:
13471 
        iprot.skip(ftype)
13472 
      iprot.readFieldEnd()
13473 
    iprot.readStructEnd()
13474 
 
13475 
  def write(self, oprot):
13476 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13477 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13478 
      return
13479 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 13480 
    if self.orderId is not None:
1208 chandransh 13481 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13482 
      oprot.writeI64(self.orderId)
13483 
      oprot.writeFieldEnd()
13484 
    oprot.writeFieldStop()
13485 
    oprot.writeStructEnd()
13486 
 
3431 rajveer 13487 
  def validate(self):
13488 
    return
13489 
 
13490 
 
1208 chandransh 13491 
  def __repr__(self):
13492 
    L = ['%s=%r' % (key, value)
13493 
      for key, value in self.__dict__.iteritems()]
13494 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13495 
 
13496 
  def __eq__(self, other):
13497 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13498 
 
13499 
  def __ne__(self, other):
13500 
    return not (self == other)
13501 
 
13502 
class markOrderAsOutOfStock_result:
13503 
  """
13504 
  Attributes:
13505 
   - success
13506 
   - ex
13507 
  """
13508 
 
13509 
  thrift_spec = (
13510 
    (0, TType.BOOL, 'success', None, None, ), # 0
13511 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13512 
  )
13513 
 
13514 
  def __init__(self, success=None, ex=None,):
13515 
    self.success = success
13516 
    self.ex = ex
13517 
 
13518 
  def read(self, iprot):
13519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13521 
      return
13522 
    iprot.readStructBegin()
13523 
    while True:
13524 
      (fname, ftype, fid) = iprot.readFieldBegin()
13525 
      if ftype == TType.STOP:
13526 
        break
13527 
      if fid == 0:
13528 
        if ftype == TType.BOOL:
13529 
          self.success = iprot.readBool();
13530 
        else:
13531 
          iprot.skip(ftype)
13532 
      elif fid == 1:
13533 
        if ftype == TType.STRUCT:
13534 
          self.ex = TransactionServiceException()
13535 
          self.ex.read(iprot)
13536 
        else:
13537 
          iprot.skip(ftype)
13538 
      else:
13539 
        iprot.skip(ftype)
13540 
      iprot.readFieldEnd()
13541 
    iprot.readStructEnd()
13542 
 
13543 
  def write(self, oprot):
13544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13546 
      return
13547 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 13548 
    if self.success is not None:
1208 chandransh 13549 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13550 
      oprot.writeBool(self.success)
13551 
      oprot.writeFieldEnd()
3431 rajveer 13552 
    if self.ex is not None:
1208 chandransh 13553 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13554 
      self.ex.write(oprot)
13555 
      oprot.writeFieldEnd()
13556 
    oprot.writeFieldStop()
13557 
    oprot.writeStructEnd()
13558 
 
3431 rajveer 13559 
  def validate(self):
13560 
    return
13561 
 
13562 
 
1208 chandransh 13563 
  def __repr__(self):
13564 
    L = ['%s=%r' % (key, value)
13565 
      for key, value in self.__dict__.iteritems()]
13566 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13567 
 
13568 
  def __eq__(self, other):
13569 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13570 
 
13571 
  def __ne__(self, other):
13572 
    return not (self == other)
13573 
 
3064 chandransh 13574 
class verifyOrder_args:
759 chandransh 13575 
  """
13576 
  Attributes:
3064 chandransh 13577 
   - orderId
759 chandransh 13578 
  """
13579 
 
13580 
  thrift_spec = (
13581 
    None, # 0
3064 chandransh 13582 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 13583 
  )
13584 
 
3064 chandransh 13585 
  def __init__(self, orderId=None,):
13586 
    self.orderId = orderId
759 chandransh 13587 
 
13588 
  def read(self, iprot):
13589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13591 
      return
13592 
    iprot.readStructBegin()
13593 
    while True:
13594 
      (fname, ftype, fid) = iprot.readFieldBegin()
13595 
      if ftype == TType.STOP:
13596 
        break
13597 
      if fid == 1:
13598 
        if ftype == TType.I64:
3064 chandransh 13599 
          self.orderId = iprot.readI64();
759 chandransh 13600 
        else:
13601 
          iprot.skip(ftype)
13602 
      else:
13603 
        iprot.skip(ftype)
13604 
      iprot.readFieldEnd()
13605 
    iprot.readStructEnd()
13606 
 
13607 
  def write(self, oprot):
13608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13610 
      return
3064 chandransh 13611 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 13612 
    if self.orderId is not None:
3064 chandransh 13613 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13614 
      oprot.writeI64(self.orderId)
759 chandransh 13615 
      oprot.writeFieldEnd()
13616 
    oprot.writeFieldStop()
13617 
    oprot.writeStructEnd()
13618 
 
3431 rajveer 13619 
  def validate(self):
13620 
    return
13621 
 
13622 
 
759 chandransh 13623 
  def __repr__(self):
13624 
    L = ['%s=%r' % (key, value)
13625 
      for key, value in self.__dict__.iteritems()]
13626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13627 
 
13628 
  def __eq__(self, other):
13629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13630 
 
13631 
  def __ne__(self, other):
13632 
    return not (self == other)
13633 
 
3064 chandransh 13634 
class verifyOrder_result:
759 chandransh 13635 
  """
13636 
  Attributes:
13637 
   - success
13638 
   - ex
13639 
  """
13640 
 
13641 
  thrift_spec = (
13642 
    (0, TType.BOOL, 'success', None, None, ), # 0
13643 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13644 
  )
13645 
 
13646 
  def __init__(self, success=None, ex=None,):
13647 
    self.success = success
13648 
    self.ex = ex
13649 
 
13650 
  def read(self, iprot):
13651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13653 
      return
13654 
    iprot.readStructBegin()
13655 
    while True:
13656 
      (fname, ftype, fid) = iprot.readFieldBegin()
13657 
      if ftype == TType.STOP:
13658 
        break
13659 
      if fid == 0:
13660 
        if ftype == TType.BOOL:
13661 
          self.success = iprot.readBool();
13662 
        else:
13663 
          iprot.skip(ftype)
13664 
      elif fid == 1:
13665 
        if ftype == TType.STRUCT:
13666 
          self.ex = TransactionServiceException()
13667 
          self.ex.read(iprot)
13668 
        else:
13669 
          iprot.skip(ftype)
13670 
      else:
13671 
        iprot.skip(ftype)
13672 
      iprot.readFieldEnd()
13673 
    iprot.readStructEnd()
13674 
 
13675 
  def write(self, oprot):
13676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13678 
      return
3064 chandransh 13679 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 13680 
    if self.success is not None:
759 chandransh 13681 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13682 
      oprot.writeBool(self.success)
13683 
      oprot.writeFieldEnd()
3431 rajveer 13684 
    if self.ex is not None:
759 chandransh 13685 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13686 
      self.ex.write(oprot)
13687 
      oprot.writeFieldEnd()
13688 
    oprot.writeFieldStop()
13689 
    oprot.writeStructEnd()
13690 
 
3431 rajveer 13691 
  def validate(self):
13692 
    return
13693 
 
13694 
 
759 chandransh 13695 
  def __repr__(self):
13696 
    L = ['%s=%r' % (key, value)
13697 
      for key, value in self.__dict__.iteritems()]
13698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13699 
 
13700 
  def __eq__(self, other):
13701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13702 
 
13703 
  def __ne__(self, other):
13704 
    return not (self == other)
13705 
 
3064 chandransh 13706 
class acceptOrder_args:
1113 chandransh 13707 
  """
13708 
  Attributes:
3064 chandransh 13709 
   - orderId
1113 chandransh 13710 
  """
13711 
 
13712 
  thrift_spec = (
13713 
    None, # 0
3064 chandransh 13714 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 13715 
  )
13716 
 
3064 chandransh 13717 
  def __init__(self, orderId=None,):
13718 
    self.orderId = orderId
1113 chandransh 13719 
 
13720 
  def read(self, iprot):
13721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13723 
      return
13724 
    iprot.readStructBegin()
13725 
    while True:
13726 
      (fname, ftype, fid) = iprot.readFieldBegin()
13727 
      if ftype == TType.STOP:
13728 
        break
13729 
      if fid == 1:
13730 
        if ftype == TType.I64:
3064 chandransh 13731 
          self.orderId = iprot.readI64();
1113 chandransh 13732 
        else:
13733 
          iprot.skip(ftype)
13734 
      else:
13735 
        iprot.skip(ftype)
13736 
      iprot.readFieldEnd()
13737 
    iprot.readStructEnd()
13738 
 
13739 
  def write(self, oprot):
13740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13742 
      return
3064 chandransh 13743 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 13744 
    if self.orderId is not None:
3064 chandransh 13745 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13746 
      oprot.writeI64(self.orderId)
1113 chandransh 13747 
      oprot.writeFieldEnd()
13748 
    oprot.writeFieldStop()
13749 
    oprot.writeStructEnd()
13750 
 
3431 rajveer 13751 
  def validate(self):
13752 
    return
13753 
 
13754 
 
1113 chandransh 13755 
  def __repr__(self):
13756 
    L = ['%s=%r' % (key, value)
13757 
      for key, value in self.__dict__.iteritems()]
13758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13759 
 
13760 
  def __eq__(self, other):
13761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13762 
 
13763 
  def __ne__(self, other):
13764 
    return not (self == other)
13765 
 
3064 chandransh 13766 
class acceptOrder_result:
1113 chandransh 13767 
  """
13768 
  Attributes:
13769 
   - success
13770 
   - ex
13771 
  """
13772 
 
13773 
  thrift_spec = (
3064 chandransh 13774 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13775 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13776 
  )
13777 
 
13778 
  def __init__(self, success=None, ex=None,):
13779 
    self.success = success
13780 
    self.ex = ex
13781 
 
13782 
  def read(self, iprot):
13783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13785 
      return
13786 
    iprot.readStructBegin()
13787 
    while True:
13788 
      (fname, ftype, fid) = iprot.readFieldBegin()
13789 
      if ftype == TType.STOP:
13790 
        break
13791 
      if fid == 0:
3064 chandransh 13792 
        if ftype == TType.BOOL:
13793 
          self.success = iprot.readBool();
1113 chandransh 13794 
        else:
13795 
          iprot.skip(ftype)
13796 
      elif fid == 1:
13797 
        if ftype == TType.STRUCT:
13798 
          self.ex = TransactionServiceException()
13799 
          self.ex.read(iprot)
13800 
        else:
13801 
          iprot.skip(ftype)
13802 
      else:
13803 
        iprot.skip(ftype)
13804 
      iprot.readFieldEnd()
13805 
    iprot.readStructEnd()
13806 
 
13807 
  def write(self, oprot):
13808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13810 
      return
3064 chandransh 13811 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 13812 
    if self.success is not None:
3064 chandransh 13813 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13814 
      oprot.writeBool(self.success)
1113 chandransh 13815 
      oprot.writeFieldEnd()
3431 rajveer 13816 
    if self.ex is not None:
1113 chandransh 13817 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13818 
      self.ex.write(oprot)
13819 
      oprot.writeFieldEnd()
13820 
    oprot.writeFieldStop()
13821 
    oprot.writeStructEnd()
13822 
 
3431 rajveer 13823 
  def validate(self):
13824 
    return
13825 
 
13826 
 
1113 chandransh 13827 
  def __repr__(self):
13828 
    L = ['%s=%r' % (key, value)
13829 
      for key, value in self.__dict__.iteritems()]
13830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13831 
 
13832 
  def __eq__(self, other):
13833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13834 
 
13835 
  def __ne__(self, other):
13836 
    return not (self == other)
13837 
 
3064 chandransh 13838 
class addBillingDetails_args:
1135 chandransh 13839 
  """
13840 
  Attributes:
3064 chandransh 13841 
   - orderId
13842 
   - invoice_number
4658 mandeep.dh 13843 
   - serialNumber
4283 anupam.sin 13844 
   - itemNumber
3064 chandransh 13845 
   - billed_by
4264 rajveer 13846 
   - jacketNumber
4283 anupam.sin 13847 
   - billingType
5110 mandeep.dh 13848 
   - fulfilmentWarehouseId
4763 rajveer 13849 
   - authorize
1135 chandransh 13850 
  """
13851 
 
13852 
  thrift_spec = (
13853 
    None, # 0
3064 chandransh 13854 
    (1, TType.I64, 'orderId', None, None, ), # 1
13855 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 13856 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
13857 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 13858 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
13859 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
13860 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 13861 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 13862 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 13863 
  )
13864 
 
5110 mandeep.dh 13865 
  def __init__(self, orderId=None, invoice_number=None, serialNumber=None, itemNumber=None, billed_by=None, jacketNumber=None, billingType=None, fulfilmentWarehouseId=None, authorize=None,):
3064 chandransh 13866 
    self.orderId = orderId
13867 
    self.invoice_number = invoice_number
4658 mandeep.dh 13868 
    self.serialNumber = serialNumber
4283 anupam.sin 13869 
    self.itemNumber = itemNumber
3064 chandransh 13870 
    self.billed_by = billed_by
4264 rajveer 13871 
    self.jacketNumber = jacketNumber
4283 anupam.sin 13872 
    self.billingType = billingType
5110 mandeep.dh 13873 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 13874 
    self.authorize = authorize
1135 chandransh 13875 
 
13876 
  def read(self, iprot):
13877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13879 
      return
13880 
    iprot.readStructBegin()
13881 
    while True:
13882 
      (fname, ftype, fid) = iprot.readFieldBegin()
13883 
      if ftype == TType.STOP:
13884 
        break
13885 
      if fid == 1:
13886 
        if ftype == TType.I64:
3064 chandransh 13887 
          self.orderId = iprot.readI64();
1135 chandransh 13888 
        else:
13889 
          iprot.skip(ftype)
13890 
      elif fid == 2:
3064 chandransh 13891 
        if ftype == TType.STRING:
13892 
          self.invoice_number = iprot.readString();
1135 chandransh 13893 
        else:
13894 
          iprot.skip(ftype)
3064 chandransh 13895 
      elif fid == 3:
5411 rajveer 13896 
        if ftype == TType.LIST:
13897 
          self.serialNumber = []
6188 rajveer 13898 
          (_etype270, _size267) = iprot.readListBegin()
13899 
          for _i271 in xrange(_size267):
13900 
            _elem272 = iprot.readString();
13901 
            self.serialNumber.append(_elem272)
5411 rajveer 13902 
          iprot.readListEnd()
3064 chandransh 13903 
        else:
13904 
          iprot.skip(ftype)
13905 
      elif fid == 4:
5411 rajveer 13906 
        if ftype == TType.LIST:
13907 
          self.itemNumber = []
6188 rajveer 13908 
          (_etype276, _size273) = iprot.readListBegin()
13909 
          for _i277 in xrange(_size273):
13910 
            _elem278 = iprot.readString();
13911 
            self.itemNumber.append(_elem278)
5411 rajveer 13912 
          iprot.readListEnd()
3064 chandransh 13913 
        else:
13914 
          iprot.skip(ftype)
13915 
      elif fid == 5:
13916 
        if ftype == TType.STRING:
4283 anupam.sin 13917 
          self.billed_by = iprot.readString();
3064 chandransh 13918 
        else:
13919 
          iprot.skip(ftype)
13920 
      elif fid == 6:
13921 
        if ftype == TType.I64:
4283 anupam.sin 13922 
          self.jacketNumber = iprot.readI64();
13923 
        else:
13924 
          iprot.skip(ftype)
13925 
      elif fid == 7:
13926 
        if ftype == TType.I64:
3064 chandransh 13927 
          self.billingType = iprot.readI64();
13928 
        else:
13929 
          iprot.skip(ftype)
4283 anupam.sin 13930 
      elif fid == 8:
13931 
        if ftype == TType.I64:
5110 mandeep.dh 13932 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13933 
        else:
13934 
          iprot.skip(ftype)
4763 rajveer 13935 
      elif fid == 9:
13936 
        if ftype == TType.BOOL:
13937 
          self.authorize = iprot.readBool();
13938 
        else:
13939 
          iprot.skip(ftype)
1246 chandransh 13940 
      else:
13941 
        iprot.skip(ftype)
13942 
      iprot.readFieldEnd()
13943 
    iprot.readStructEnd()
13944 
 
13945 
  def write(self, oprot):
13946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13948 
      return
4283 anupam.sin 13949 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 13950 
    if self.orderId is not None:
3064 chandransh 13951 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13952 
      oprot.writeI64(self.orderId)
1246 chandransh 13953 
      oprot.writeFieldEnd()
4283 anupam.sin 13954 
    if self.invoice_number is not None:
13955 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
13956 
      oprot.writeString(self.invoice_number)
1246 chandransh 13957 
      oprot.writeFieldEnd()
4658 mandeep.dh 13958 
    if self.serialNumber is not None:
5411 rajveer 13959 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
13960 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 13961 
      for iter279 in self.serialNumber:
13962 
        oprot.writeString(iter279)
5411 rajveer 13963 
      oprot.writeListEnd()
3064 chandransh 13964 
      oprot.writeFieldEnd()
3431 rajveer 13965 
    if self.itemNumber is not None:
5411 rajveer 13966 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
13967 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 13968 
      for iter280 in self.itemNumber:
13969 
        oprot.writeString(iter280)
5411 rajveer 13970 
      oprot.writeListEnd()
3064 chandransh 13971 
      oprot.writeFieldEnd()
4283 anupam.sin 13972 
    if self.billed_by is not None:
13973 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
13974 
      oprot.writeString(self.billed_by)
3064 chandransh 13975 
      oprot.writeFieldEnd()
4283 anupam.sin 13976 
    if self.jacketNumber is not None:
13977 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
13978 
      oprot.writeI64(self.jacketNumber)
13979 
      oprot.writeFieldEnd()
3431 rajveer 13980 
    if self.billingType is not None:
4283 anupam.sin 13981 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 13982 
      oprot.writeI64(self.billingType)
13983 
      oprot.writeFieldEnd()
5110 mandeep.dh 13984 
    if self.fulfilmentWarehouseId is not None:
13985 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
13986 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 13987 
      oprot.writeFieldEnd()
4763 rajveer 13988 
    if self.authorize is not None:
13989 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
13990 
      oprot.writeBool(self.authorize)
13991 
      oprot.writeFieldEnd()
1246 chandransh 13992 
    oprot.writeFieldStop()
13993 
    oprot.writeStructEnd()
13994 
 
3431 rajveer 13995 
  def validate(self):
13996 
    return
13997 
 
13998 
 
1246 chandransh 13999 
  def __repr__(self):
14000 
    L = ['%s=%r' % (key, value)
14001 
      for key, value in self.__dict__.iteritems()]
14002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14003 
 
14004 
  def __eq__(self, other):
14005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14006 
 
14007 
  def __ne__(self, other):
14008 
    return not (self == other)
14009 
 
4283 anupam.sin 14010 
class addBillingDetails_result:
1246 chandransh 14011 
  """
14012 
  Attributes:
3064 chandransh 14013 
   - success
1246 chandransh 14014 
   - ex
14015 
  """
14016 
 
14017 
  thrift_spec = (
3064 chandransh 14018 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 14019 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14020 
  )
14021 
 
3064 chandransh 14022 
  def __init__(self, success=None, ex=None,):
14023 
    self.success = success
1246 chandransh 14024 
    self.ex = ex
14025 
 
14026 
  def read(self, iprot):
14027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14029 
      return
14030 
    iprot.readStructBegin()
14031 
    while True:
14032 
      (fname, ftype, fid) = iprot.readFieldBegin()
14033 
      if ftype == TType.STOP:
14034 
        break
3064 chandransh 14035 
      if fid == 0:
14036 
        if ftype == TType.BOOL:
14037 
          self.success = iprot.readBool();
14038 
        else:
14039 
          iprot.skip(ftype)
14040 
      elif fid == 1:
1246 chandransh 14041 
        if ftype == TType.STRUCT:
14042 
          self.ex = TransactionServiceException()
14043 
          self.ex.read(iprot)
14044 
        else:
14045 
          iprot.skip(ftype)
14046 
      else:
14047 
        iprot.skip(ftype)
14048 
      iprot.readFieldEnd()
14049 
    iprot.readStructEnd()
14050 
 
14051 
  def write(self, oprot):
14052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14054 
      return
4283 anupam.sin 14055 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 14056 
    if self.success is not None:
3064 chandransh 14057 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14058 
      oprot.writeBool(self.success)
14059 
      oprot.writeFieldEnd()
3431 rajveer 14060 
    if self.ex is not None:
1246 chandransh 14061 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14062 
      self.ex.write(oprot)
14063 
      oprot.writeFieldEnd()
14064 
    oprot.writeFieldStop()
14065 
    oprot.writeStructEnd()
14066 
 
3431 rajveer 14067 
  def validate(self):
14068 
    return
14069 
 
14070 
 
1246 chandransh 14071 
  def __repr__(self):
14072 
    L = ['%s=%r' % (key, value)
14073 
      for key, value in self.__dict__.iteritems()]
14074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14075 
 
14076 
  def __eq__(self, other):
14077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14078 
 
14079 
  def __ne__(self, other):
14080 
    return not (self == other)
14081 
 
4579 rajveer 14082 
class addInvoiceNumber_args:
14083 
  """
14084 
  Attributes:
14085 
   - orderId
14086 
   - invoiceNumber
4763 rajveer 14087 
   - color
6756 amar.kumar 14088 
   - serialNumber
14089 
   - itemNumber
4579 rajveer 14090 
  """
14091 
 
14092 
  thrift_spec = (
14093 
    None, # 0
14094 
    (1, TType.I64, 'orderId', None, None, ), # 1
14095 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 14096 
    (3, TType.STRING, 'color', None, None, ), # 3
6756 amar.kumar 14097 
    (4, TType.STRING, 'serialNumber', None, None, ), # 4
14098 
    (5, TType.STRING, 'itemNumber', None, None, ), # 5
4579 rajveer 14099 
  )
14100 
 
6756 amar.kumar 14101 
  def __init__(self, orderId=None, invoiceNumber=None, color=None, serialNumber=None, itemNumber=None,):
4579 rajveer 14102 
    self.orderId = orderId
14103 
    self.invoiceNumber = invoiceNumber
4763 rajveer 14104 
    self.color = color
6756 amar.kumar 14105 
    self.serialNumber = serialNumber
14106 
    self.itemNumber = itemNumber
4579 rajveer 14107 
 
14108 
  def read(self, iprot):
14109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14111 
      return
14112 
    iprot.readStructBegin()
14113 
    while True:
14114 
      (fname, ftype, fid) = iprot.readFieldBegin()
14115 
      if ftype == TType.STOP:
14116 
        break
14117 
      if fid == 1:
14118 
        if ftype == TType.I64:
14119 
          self.orderId = iprot.readI64();
14120 
        else:
14121 
          iprot.skip(ftype)
14122 
      elif fid == 2:
14123 
        if ftype == TType.STRING:
14124 
          self.invoiceNumber = iprot.readString();
14125 
        else:
14126 
          iprot.skip(ftype)
4763 rajveer 14127 
      elif fid == 3:
14128 
        if ftype == TType.STRING:
14129 
          self.color = iprot.readString();
14130 
        else:
14131 
          iprot.skip(ftype)
6756 amar.kumar 14132 
      elif fid == 4:
14133 
        if ftype == TType.STRING:
14134 
          self.serialNumber = iprot.readString();
14135 
        else:
14136 
          iprot.skip(ftype)
14137 
      elif fid == 5:
14138 
        if ftype == TType.STRING:
14139 
          self.itemNumber = iprot.readString();
14140 
        else:
14141 
          iprot.skip(ftype)
4579 rajveer 14142 
      else:
14143 
        iprot.skip(ftype)
14144 
      iprot.readFieldEnd()
14145 
    iprot.readStructEnd()
14146 
 
14147 
  def write(self, oprot):
14148 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14149 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14150 
      return
14151 
    oprot.writeStructBegin('addInvoiceNumber_args')
14152 
    if self.orderId is not None:
14153 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14154 
      oprot.writeI64(self.orderId)
14155 
      oprot.writeFieldEnd()
14156 
    if self.invoiceNumber is not None:
14157 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
14158 
      oprot.writeString(self.invoiceNumber)
14159 
      oprot.writeFieldEnd()
4763 rajveer 14160 
    if self.color is not None:
14161 
      oprot.writeFieldBegin('color', TType.STRING, 3)
14162 
      oprot.writeString(self.color)
14163 
      oprot.writeFieldEnd()
6756 amar.kumar 14164 
    if self.serialNumber is not None:
14165 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 4)
14166 
      oprot.writeString(self.serialNumber)
14167 
      oprot.writeFieldEnd()
14168 
    if self.itemNumber is not None:
14169 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 5)
14170 
      oprot.writeString(self.itemNumber)
14171 
      oprot.writeFieldEnd()
4579 rajveer 14172 
    oprot.writeFieldStop()
14173 
    oprot.writeStructEnd()
14174 
 
14175 
  def validate(self):
14176 
    return
14177 
 
14178 
 
14179 
  def __repr__(self):
14180 
    L = ['%s=%r' % (key, value)
14181 
      for key, value in self.__dict__.iteritems()]
14182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14183 
 
14184 
  def __eq__(self, other):
14185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14186 
 
14187 
  def __ne__(self, other):
14188 
    return not (self == other)
14189 
 
14190 
class addInvoiceNumber_result:
14191 
  """
14192 
  Attributes:
14193 
   - ex
14194 
  """
14195 
 
14196 
  thrift_spec = (
14197 
    None, # 0
14198 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14199 
  )
14200 
 
14201 
  def __init__(self, ex=None,):
14202 
    self.ex = ex
14203 
 
14204 
  def read(self, iprot):
14205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14207 
      return
14208 
    iprot.readStructBegin()
14209 
    while True:
14210 
      (fname, ftype, fid) = iprot.readFieldBegin()
14211 
      if ftype == TType.STOP:
14212 
        break
14213 
      if fid == 1:
14214 
        if ftype == TType.STRUCT:
14215 
          self.ex = TransactionServiceException()
14216 
          self.ex.read(iprot)
14217 
        else:
14218 
          iprot.skip(ftype)
14219 
      else:
14220 
        iprot.skip(ftype)
14221 
      iprot.readFieldEnd()
14222 
    iprot.readStructEnd()
14223 
 
14224 
  def write(self, oprot):
14225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14227 
      return
14228 
    oprot.writeStructBegin('addInvoiceNumber_result')
14229 
    if self.ex is not None:
14230 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14231 
      self.ex.write(oprot)
14232 
      oprot.writeFieldEnd()
14233 
    oprot.writeFieldStop()
14234 
    oprot.writeStructEnd()
14235 
 
14236 
  def validate(self):
14237 
    return
14238 
 
14239 
 
14240 
  def __repr__(self):
14241 
    L = ['%s=%r' % (key, value)
14242 
      for key, value in self.__dict__.iteritems()]
14243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14244 
 
14245 
  def __eq__(self, other):
14246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14247 
 
14248 
  def __ne__(self, other):
14249 
    return not (self == other)
14250 
 
4910 phani.kuma 14251 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 14252 
  """
14253 
  Attributes:
3064 chandransh 14254 
   - warehouseId
1408 ankur.sing 14255 
   - providerId
3064 chandransh 14256 
   - cod
4910 phani.kuma 14257 
   - orderIds
1408 ankur.sing 14258 
  """
14259 
 
14260 
  thrift_spec = (
14261 
    None, # 0
3064 chandransh 14262 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14263 
    (2, TType.I64, 'providerId', None, None, ), # 2
14264 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 14265 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 14266 
  )
14267 
 
4910 phani.kuma 14268 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 14269 
    self.warehouseId = warehouseId
1408 ankur.sing 14270 
    self.providerId = providerId
3064 chandransh 14271 
    self.cod = cod
4910 phani.kuma 14272 
    self.orderIds = orderIds
1408 ankur.sing 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 == 1:
14284 
        if ftype == TType.I64:
3064 chandransh 14285 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 14286 
        else:
14287 
          iprot.skip(ftype)
14288 
      elif fid == 2:
14289 
        if ftype == TType.I64:
3064 chandransh 14290 
          self.providerId = iprot.readI64();
1408 ankur.sing 14291 
        else:
14292 
          iprot.skip(ftype)
3064 chandransh 14293 
      elif fid == 3:
14294 
        if ftype == TType.BOOL:
14295 
          self.cod = iprot.readBool();
14296 
        else:
14297 
          iprot.skip(ftype)
4910 phani.kuma 14298 
      elif fid == 4:
14299 
        if ftype == TType.LIST:
14300 
          self.orderIds = []
6188 rajveer 14301 
          (_etype284, _size281) = iprot.readListBegin()
14302 
          for _i285 in xrange(_size281):
14303 
            _elem286 = iprot.readI64();
14304 
            self.orderIds.append(_elem286)
4910 phani.kuma 14305 
          iprot.readListEnd()
14306 
        else:
14307 
          iprot.skip(ftype)
1408 ankur.sing 14308 
      else:
14309 
        iprot.skip(ftype)
14310 
      iprot.readFieldEnd()
14311 
    iprot.readStructEnd()
14312 
 
14313 
  def write(self, oprot):
14314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14316 
      return
4910 phani.kuma 14317 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 14318 
    if self.warehouseId is not None:
3064 chandransh 14319 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14320 
      oprot.writeI64(self.warehouseId)
14321 
      oprot.writeFieldEnd()
3431 rajveer 14322 
    if self.providerId is not None:
3064 chandransh 14323 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 14324 
      oprot.writeI64(self.providerId)
14325 
      oprot.writeFieldEnd()
3431 rajveer 14326 
    if self.cod is not None:
3064 chandransh 14327 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
14328 
      oprot.writeBool(self.cod)
1408 ankur.sing 14329 
      oprot.writeFieldEnd()
4910 phani.kuma 14330 
    if self.orderIds is not None:
14331 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
14332 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14333 
      for iter287 in self.orderIds:
14334 
        oprot.writeI64(iter287)
4910 phani.kuma 14335 
      oprot.writeListEnd()
14336 
      oprot.writeFieldEnd()
1408 ankur.sing 14337 
    oprot.writeFieldStop()
14338 
    oprot.writeStructEnd()
14339 
 
3431 rajveer 14340 
  def validate(self):
14341 
    return
14342 
 
14343 
 
1408 ankur.sing 14344 
  def __repr__(self):
14345 
    L = ['%s=%r' % (key, value)
14346 
      for key, value in self.__dict__.iteritems()]
14347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14348 
 
14349 
  def __eq__(self, other):
14350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14351 
 
14352 
  def __ne__(self, other):
14353 
    return not (self == other)
14354 
 
4910 phani.kuma 14355 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 14356 
  """
14357 
  Attributes:
14358 
   - success
3064 chandransh 14359 
   - ex
1408 ankur.sing 14360 
  """
14361 
 
14362 
  thrift_spec = (
3064 chandransh 14363 
    (0, TType.BOOL, 'success', None, None, ), # 0
14364 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 14365 
  )
14366 
 
3064 chandransh 14367 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 14368 
    self.success = success
3064 chandransh 14369 
    self.ex = ex
1408 ankur.sing 14370 
 
14371 
  def read(self, iprot):
14372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14374 
      return
14375 
    iprot.readStructBegin()
14376 
    while True:
14377 
      (fname, ftype, fid) = iprot.readFieldBegin()
14378 
      if ftype == TType.STOP:
14379 
        break
14380 
      if fid == 0:
3064 chandransh 14381 
        if ftype == TType.BOOL:
14382 
          self.success = iprot.readBool();
1408 ankur.sing 14383 
        else:
14384 
          iprot.skip(ftype)
3064 chandransh 14385 
      elif fid == 1:
14386 
        if ftype == TType.STRUCT:
14387 
          self.ex = TransactionServiceException()
14388 
          self.ex.read(iprot)
14389 
        else:
14390 
          iprot.skip(ftype)
1408 ankur.sing 14391 
      else:
14392 
        iprot.skip(ftype)
14393 
      iprot.readFieldEnd()
14394 
    iprot.readStructEnd()
14395 
 
14396 
  def write(self, oprot):
14397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14399 
      return
4910 phani.kuma 14400 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 14401 
    if self.success is not None:
3064 chandransh 14402 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14403 
      oprot.writeBool(self.success)
1408 ankur.sing 14404 
      oprot.writeFieldEnd()
3431 rajveer 14405 
    if self.ex is not None:
3064 chandransh 14406 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14407 
      self.ex.write(oprot)
14408 
      oprot.writeFieldEnd()
1408 ankur.sing 14409 
    oprot.writeFieldStop()
14410 
    oprot.writeStructEnd()
14411 
 
3431 rajveer 14412 
  def validate(self):
14413 
    return
14414 
 
14415 
 
1408 ankur.sing 14416 
  def __repr__(self):
14417 
    L = ['%s=%r' % (key, value)
14418 
      for key, value in self.__dict__.iteritems()]
14419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14420 
 
14421 
  def __eq__(self, other):
14422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14423 
 
14424 
  def __ne__(self, other):
14425 
    return not (self == other)
14426 
 
5676 rajveer 14427 
class markOrdersAsReturnedFromStore_args:
14428 
  """
14429 
  Attributes:
14430 
   - providerId
14431 
   - orderIds
5713 rajveer 14432 
   - awbs
5676 rajveer 14433 
  """
14434 
 
14435 
  thrift_spec = (
14436 
    None, # 0
14437 
    (1, TType.I64, 'providerId', None, None, ), # 1
14438 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 14439 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 14440 
  )
14441 
 
5713 rajveer 14442 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 14443 
    self.providerId = providerId
14444 
    self.orderIds = orderIds
5713 rajveer 14445 
    self.awbs = awbs
5676 rajveer 14446 
 
14447 
  def read(self, iprot):
14448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14450 
      return
14451 
    iprot.readStructBegin()
14452 
    while True:
14453 
      (fname, ftype, fid) = iprot.readFieldBegin()
14454 
      if ftype == TType.STOP:
14455 
        break
14456 
      if fid == 1:
14457 
        if ftype == TType.I64:
14458 
          self.providerId = iprot.readI64();
14459 
        else:
14460 
          iprot.skip(ftype)
14461 
      elif fid == 2:
14462 
        if ftype == TType.LIST:
14463 
          self.orderIds = []
6188 rajveer 14464 
          (_etype291, _size288) = iprot.readListBegin()
14465 
          for _i292 in xrange(_size288):
14466 
            _elem293 = iprot.readI64();
14467 
            self.orderIds.append(_elem293)
5676 rajveer 14468 
          iprot.readListEnd()
14469 
        else:
14470 
          iprot.skip(ftype)
5713 rajveer 14471 
      elif fid == 3:
14472 
        if ftype == TType.LIST:
14473 
          self.awbs = []
6188 rajveer 14474 
          (_etype297, _size294) = iprot.readListBegin()
14475 
          for _i298 in xrange(_size294):
14476 
            _elem299 = iprot.readString();
14477 
            self.awbs.append(_elem299)
5713 rajveer 14478 
          iprot.readListEnd()
14479 
        else:
14480 
          iprot.skip(ftype)
5676 rajveer 14481 
      else:
14482 
        iprot.skip(ftype)
14483 
      iprot.readFieldEnd()
14484 
    iprot.readStructEnd()
14485 
 
14486 
  def write(self, oprot):
14487 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14488 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14489 
      return
14490 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
14491 
    if self.providerId is not None:
14492 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14493 
      oprot.writeI64(self.providerId)
14494 
      oprot.writeFieldEnd()
14495 
    if self.orderIds is not None:
14496 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
14497 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14498 
      for iter300 in self.orderIds:
14499 
        oprot.writeI64(iter300)
5676 rajveer 14500 
      oprot.writeListEnd()
14501 
      oprot.writeFieldEnd()
5713 rajveer 14502 
    if self.awbs is not None:
14503 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
14504 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 14505 
      for iter301 in self.awbs:
14506 
        oprot.writeString(iter301)
5713 rajveer 14507 
      oprot.writeListEnd()
14508 
      oprot.writeFieldEnd()
5676 rajveer 14509 
    oprot.writeFieldStop()
14510 
    oprot.writeStructEnd()
14511 
 
14512 
  def validate(self):
14513 
    return
14514 
 
14515 
 
14516 
  def __repr__(self):
14517 
    L = ['%s=%r' % (key, value)
14518 
      for key, value in self.__dict__.iteritems()]
14519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14520 
 
14521 
  def __eq__(self, other):
14522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14523 
 
14524 
  def __ne__(self, other):
14525 
    return not (self == other)
14526 
 
14527 
class markOrdersAsReturnedFromStore_result:
14528 
  """
14529 
  Attributes:
14530 
   - success
14531 
   - ex
14532 
  """
14533 
 
14534 
  thrift_spec = (
14535 
    (0, TType.BOOL, 'success', None, None, ), # 0
14536 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14537 
  )
14538 
 
14539 
  def __init__(self, success=None, ex=None,):
14540 
    self.success = success
14541 
    self.ex = ex
14542 
 
14543 
  def read(self, iprot):
14544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14546 
      return
14547 
    iprot.readStructBegin()
14548 
    while True:
14549 
      (fname, ftype, fid) = iprot.readFieldBegin()
14550 
      if ftype == TType.STOP:
14551 
        break
14552 
      if fid == 0:
14553 
        if ftype == TType.BOOL:
14554 
          self.success = iprot.readBool();
14555 
        else:
14556 
          iprot.skip(ftype)
14557 
      elif fid == 1:
14558 
        if ftype == TType.STRUCT:
14559 
          self.ex = TransactionServiceException()
14560 
          self.ex.read(iprot)
14561 
        else:
14562 
          iprot.skip(ftype)
14563 
      else:
14564 
        iprot.skip(ftype)
14565 
      iprot.readFieldEnd()
14566 
    iprot.readStructEnd()
14567 
 
14568 
  def write(self, oprot):
14569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14571 
      return
14572 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
14573 
    if self.success is not None:
14574 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14575 
      oprot.writeBool(self.success)
14576 
      oprot.writeFieldEnd()
14577 
    if self.ex is not None:
14578 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14579 
      self.ex.write(oprot)
14580 
      oprot.writeFieldEnd()
14581 
    oprot.writeFieldStop()
14582 
    oprot.writeStructEnd()
14583 
 
14584 
  def validate(self):
14585 
    return
14586 
 
14587 
 
14588 
  def __repr__(self):
14589 
    L = ['%s=%r' % (key, value)
14590 
      for key, value in self.__dict__.iteritems()]
14591 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14592 
 
14593 
  def __eq__(self, other):
14594 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14595 
 
14596 
  def __ne__(self, other):
14597 
    return not (self == other)
14598 
 
4910 phani.kuma 14599 
class markOrdersAsPickedUp_args:
4410 rajveer 14600 
  """
14601 
  Attributes:
14602 
   - providerId
4910 phani.kuma 14603 
   - pickupDetails
4410 rajveer 14604 
  """
14605 
 
14606 
  thrift_spec = (
14607 
    None, # 0
4910 phani.kuma 14608 
    (1, TType.I64, 'providerId', None, None, ), # 1
14609 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 14610 
  )
14611 
 
4910 phani.kuma 14612 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 14613 
    self.providerId = providerId
4910 phani.kuma 14614 
    self.pickupDetails = pickupDetails
4410 rajveer 14615 
 
14616 
  def read(self, iprot):
14617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14619 
      return
14620 
    iprot.readStructBegin()
14621 
    while True:
14622 
      (fname, ftype, fid) = iprot.readFieldBegin()
14623 
      if ftype == TType.STOP:
14624 
        break
14625 
      if fid == 1:
14626 
        if ftype == TType.I64:
4910 phani.kuma 14627 
          self.providerId = iprot.readI64();
4410 rajveer 14628 
        else:
14629 
          iprot.skip(ftype)
14630 
      elif fid == 2:
4910 phani.kuma 14631 
        if ftype == TType.MAP:
14632 
          self.pickupDetails = {}
6188 rajveer 14633 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
14634 
          for _i306 in xrange(_size302):
14635 
            _key307 = iprot.readString();
14636 
            _val308 = iprot.readString();
14637 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 14638 
          iprot.readMapEnd()
4410 rajveer 14639 
        else:
14640 
          iprot.skip(ftype)
14641 
      else:
14642 
        iprot.skip(ftype)
14643 
      iprot.readFieldEnd()
14644 
    iprot.readStructEnd()
14645 
 
14646 
  def write(self, oprot):
14647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14649 
      return
4910 phani.kuma 14650 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 14651 
    if self.providerId is not None:
4910 phani.kuma 14652 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 14653 
      oprot.writeI64(self.providerId)
14654 
      oprot.writeFieldEnd()
4910 phani.kuma 14655 
    if self.pickupDetails is not None:
14656 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14657 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 14658 
      for kiter309,viter310 in self.pickupDetails.items():
14659 
        oprot.writeString(kiter309)
14660 
        oprot.writeString(viter310)
4910 phani.kuma 14661 
      oprot.writeMapEnd()
4410 rajveer 14662 
      oprot.writeFieldEnd()
14663 
    oprot.writeFieldStop()
14664 
    oprot.writeStructEnd()
14665 
 
14666 
  def validate(self):
14667 
    return
14668 
 
14669 
 
14670 
  def __repr__(self):
14671 
    L = ['%s=%r' % (key, value)
14672 
      for key, value in self.__dict__.iteritems()]
14673 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14674 
 
14675 
  def __eq__(self, other):
14676 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14677 
 
14678 
  def __ne__(self, other):
14679 
    return not (self == other)
14680 
 
4910 phani.kuma 14681 
class markOrdersAsPickedUp_result:
4410 rajveer 14682 
  """
14683 
  Attributes:
14684 
   - ex
14685 
  """
14686 
 
14687 
  thrift_spec = (
4910 phani.kuma 14688 
    None, # 0
4410 rajveer 14689 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14690 
  )
14691 
 
4910 phani.kuma 14692 
  def __init__(self, ex=None,):
4410 rajveer 14693 
    self.ex = ex
14694 
 
14695 
  def read(self, iprot):
14696 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14697 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14698 
      return
14699 
    iprot.readStructBegin()
14700 
    while True:
14701 
      (fname, ftype, fid) = iprot.readFieldBegin()
14702 
      if ftype == TType.STOP:
14703 
        break
4910 phani.kuma 14704 
      if fid == 1:
4410 rajveer 14705 
        if ftype == TType.STRUCT:
14706 
          self.ex = TransactionServiceException()
14707 
          self.ex.read(iprot)
14708 
        else:
14709 
          iprot.skip(ftype)
14710 
      else:
14711 
        iprot.skip(ftype)
14712 
      iprot.readFieldEnd()
14713 
    iprot.readStructEnd()
14714 
 
14715 
  def write(self, oprot):
14716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14718 
      return
4910 phani.kuma 14719 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 14720 
    if self.ex is not None:
14721 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14722 
      self.ex.write(oprot)
14723 
      oprot.writeFieldEnd()
14724 
    oprot.writeFieldStop()
14725 
    oprot.writeStructEnd()
14726 
 
14727 
  def validate(self):
14728 
    return
14729 
 
14730 
 
14731 
  def __repr__(self):
14732 
    L = ['%s=%r' % (key, value)
14733 
      for key, value in self.__dict__.iteritems()]
14734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14735 
 
14736 
  def __eq__(self, other):
14737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14738 
 
14739 
  def __ne__(self, other):
14740 
    return not (self == other)
14741 
 
4910 phani.kuma 14742 
class getOrdersNotPickedUp_args:
304 ashish 14743 
  """
14744 
  Attributes:
3064 chandransh 14745 
   - providerId
304 ashish 14746 
  """
94 ashish 14747 
 
304 ashish 14748 
  thrift_spec = (
14749 
    None, # 0
3064 chandransh 14750 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 14751 
  )
14752 
 
4910 phani.kuma 14753 
  def __init__(self, providerId=None,):
3064 chandransh 14754 
    self.providerId = providerId
304 ashish 14755 
 
14756 
  def read(self, iprot):
14757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14759 
      return
14760 
    iprot.readStructBegin()
14761 
    while True:
14762 
      (fname, ftype, fid) = iprot.readFieldBegin()
14763 
      if ftype == TType.STOP:
14764 
        break
14765 
      if fid == 1:
14766 
        if ftype == TType.I64:
3064 chandransh 14767 
          self.providerId = iprot.readI64();
304 ashish 14768 
        else:
14769 
          iprot.skip(ftype)
14770 
      else:
14771 
        iprot.skip(ftype)
14772 
      iprot.readFieldEnd()
14773 
    iprot.readStructEnd()
14774 
 
14775 
  def write(self, oprot):
14776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14778 
      return
4910 phani.kuma 14779 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14780 
    if self.providerId is not None:
3064 chandransh 14781 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14782 
      oprot.writeI64(self.providerId)
304 ashish 14783 
      oprot.writeFieldEnd()
14784 
    oprot.writeFieldStop()
14785 
    oprot.writeStructEnd()
14786 
 
3431 rajveer 14787 
  def validate(self):
14788 
    return
14789 
 
14790 
 
304 ashish 14791 
  def __repr__(self):
14792 
    L = ['%s=%r' % (key, value)
14793 
      for key, value in self.__dict__.iteritems()]
14794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14795 
 
14796 
  def __eq__(self, other):
14797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14798 
 
14799 
  def __ne__(self, other):
14800 
    return not (self == other)
14801 
 
4910 phani.kuma 14802 
class getOrdersNotPickedUp_result:
304 ashish 14803 
  """
14804 
  Attributes:
14805 
   - success
14806 
  """
14807 
 
14808 
  thrift_spec = (
3064 chandransh 14809 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 14810 
  )
14811 
 
4910 phani.kuma 14812 
  def __init__(self, success=None,):
304 ashish 14813 
    self.success = success
14814 
 
14815 
  def read(self, iprot):
14816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14818 
      return
14819 
    iprot.readStructBegin()
14820 
    while True:
14821 
      (fname, ftype, fid) = iprot.readFieldBegin()
14822 
      if ftype == TType.STOP:
14823 
        break
14824 
      if fid == 0:
14825 
        if ftype == TType.LIST:
14826 
          self.success = []
6188 rajveer 14827 
          (_etype314, _size311) = iprot.readListBegin()
14828 
          for _i315 in xrange(_size311):
14829 
            _elem316 = Order()
14830 
            _elem316.read(iprot)
14831 
            self.success.append(_elem316)
304 ashish 14832 
          iprot.readListEnd()
14833 
        else:
14834 
          iprot.skip(ftype)
14835 
      else:
14836 
        iprot.skip(ftype)
14837 
      iprot.readFieldEnd()
14838 
    iprot.readStructEnd()
14839 
 
14840 
  def write(self, oprot):
14841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14843 
      return
4910 phani.kuma 14844 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 14845 
    if self.success is not None:
304 ashish 14846 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14847 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14848 
      for iter317 in self.success:
14849 
        iter317.write(oprot)
304 ashish 14850 
      oprot.writeListEnd()
14851 
      oprot.writeFieldEnd()
14852 
    oprot.writeFieldStop()
14853 
    oprot.writeStructEnd()
14854 
 
3431 rajveer 14855 
  def validate(self):
14856 
    return
14857 
 
14858 
 
304 ashish 14859 
  def __repr__(self):
14860 
    L = ['%s=%r' % (key, value)
14861 
      for key, value in self.__dict__.iteritems()]
14862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14863 
 
14864 
  def __eq__(self, other):
14865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14866 
 
14867 
  def __ne__(self, other):
14868 
    return not (self == other)
14869 
 
3064 chandransh 14870 
class markOrdersAsDelivered_args:
304 ashish 14871 
  """
14872 
  Attributes:
3064 chandransh 14873 
   - providerId
14874 
   - deliveredOrders
304 ashish 14875 
  """
14876 
 
14877 
  thrift_spec = (
14878 
    None, # 0
3064 chandransh 14879 
    (1, TType.I64, 'providerId', None, None, ), # 1
14880 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 14881 
  )
14882 
 
3064 chandransh 14883 
  def __init__(self, providerId=None, deliveredOrders=None,):
14884 
    self.providerId = providerId
14885 
    self.deliveredOrders = deliveredOrders
304 ashish 14886 
 
14887 
  def read(self, iprot):
14888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14890 
      return
14891 
    iprot.readStructBegin()
14892 
    while True:
14893 
      (fname, ftype, fid) = iprot.readFieldBegin()
14894 
      if ftype == TType.STOP:
14895 
        break
14896 
      if fid == 1:
14897 
        if ftype == TType.I64:
3064 chandransh 14898 
          self.providerId = iprot.readI64();
304 ashish 14899 
        else:
14900 
          iprot.skip(ftype)
14901 
      elif fid == 2:
3064 chandransh 14902 
        if ftype == TType.MAP:
14903 
          self.deliveredOrders = {}
6188 rajveer 14904 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
14905 
          for _i322 in xrange(_size318):
14906 
            _key323 = iprot.readString();
14907 
            _val324 = iprot.readString();
14908 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 14909 
          iprot.readMapEnd()
304 ashish 14910 
        else:
14911 
          iprot.skip(ftype)
14912 
      else:
14913 
        iprot.skip(ftype)
14914 
      iprot.readFieldEnd()
14915 
    iprot.readStructEnd()
14916 
 
14917 
  def write(self, oprot):
14918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14920 
      return
3064 chandransh 14921 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14922 
    if self.providerId is not None:
3064 chandransh 14923 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14924 
      oprot.writeI64(self.providerId)
304 ashish 14925 
      oprot.writeFieldEnd()
3431 rajveer 14926 
    if self.deliveredOrders is not None:
3064 chandransh 14927 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14928 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 14929 
      for kiter325,viter326 in self.deliveredOrders.items():
14930 
        oprot.writeString(kiter325)
14931 
        oprot.writeString(viter326)
3064 chandransh 14932 
      oprot.writeMapEnd()
304 ashish 14933 
      oprot.writeFieldEnd()
14934 
    oprot.writeFieldStop()
14935 
    oprot.writeStructEnd()
14936 
 
3431 rajveer 14937 
  def validate(self):
14938 
    return
14939 
 
14940 
 
304 ashish 14941 
  def __repr__(self):
14942 
    L = ['%s=%r' % (key, value)
14943 
      for key, value in self.__dict__.iteritems()]
14944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14945 
 
14946 
  def __eq__(self, other):
14947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14948 
 
14949 
  def __ne__(self, other):
14950 
    return not (self == other)
14951 
 
3064 chandransh 14952 
class markOrdersAsDelivered_result:
14953 
  """
14954 
  Attributes:
14955 
   - ex
14956 
  """
304 ashish 14957 
 
14958 
  thrift_spec = (
3064 chandransh 14959 
    None, # 0
14960 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 14961 
  )
14962 
 
3064 chandransh 14963 
  def __init__(self, ex=None,):
14964 
    self.ex = ex
304 ashish 14965 
 
1596 ankur.sing 14966 
  def read(self, iprot):
14967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14969 
      return
14970 
    iprot.readStructBegin()
14971 
    while True:
14972 
      (fname, ftype, fid) = iprot.readFieldBegin()
14973 
      if ftype == TType.STOP:
14974 
        break
3064 chandransh 14975 
      if fid == 1:
14976 
        if ftype == TType.STRUCT:
14977 
          self.ex = TransactionServiceException()
14978 
          self.ex.read(iprot)
14979 
        else:
14980 
          iprot.skip(ftype)
1596 ankur.sing 14981 
      else:
14982 
        iprot.skip(ftype)
14983 
      iprot.readFieldEnd()
14984 
    iprot.readStructEnd()
14985 
 
14986 
  def write(self, oprot):
14987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14989 
      return
3064 chandransh 14990 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 14991 
    if self.ex is not None:
3064 chandransh 14992 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14993 
      self.ex.write(oprot)
14994 
      oprot.writeFieldEnd()
1596 ankur.sing 14995 
    oprot.writeFieldStop()
14996 
    oprot.writeStructEnd()
14997 
 
3431 rajveer 14998 
  def validate(self):
14999 
    return
15000 
 
15001 
 
1596 ankur.sing 15002 
  def __repr__(self):
15003 
    L = ['%s=%r' % (key, value)
15004 
      for key, value in self.__dict__.iteritems()]
15005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15006 
 
15007 
  def __eq__(self, other):
15008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15009 
 
15010 
  def __ne__(self, other):
15011 
    return not (self == other)
15012 
 
4910 phani.kuma 15013 
class markAsRTOrders_args:
1596 ankur.sing 15014 
  """
15015 
  Attributes:
3064 chandransh 15016 
   - providerId
15017 
   - returnedOrders
1596 ankur.sing 15018 
  """
15019 
 
15020 
  thrift_spec = (
3064 chandransh 15021 
    None, # 0
15022 
    (1, TType.I64, 'providerId', None, None, ), # 1
15023 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 15024 
  )
15025 
 
3064 chandransh 15026 
  def __init__(self, providerId=None, returnedOrders=None,):
15027 
    self.providerId = providerId
15028 
    self.returnedOrders = returnedOrders
1596 ankur.sing 15029 
 
15030 
  def read(self, iprot):
15031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15033 
      return
15034 
    iprot.readStructBegin()
15035 
    while True:
15036 
      (fname, ftype, fid) = iprot.readFieldBegin()
15037 
      if ftype == TType.STOP:
15038 
        break
3064 chandransh 15039 
      if fid == 1:
1596 ankur.sing 15040 
        if ftype == TType.I64:
3064 chandransh 15041 
          self.providerId = iprot.readI64();
1596 ankur.sing 15042 
        else:
15043 
          iprot.skip(ftype)
3064 chandransh 15044 
      elif fid == 2:
15045 
        if ftype == TType.MAP:
15046 
          self.returnedOrders = {}
6188 rajveer 15047 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
15048 
          for _i331 in xrange(_size327):
15049 
            _key332 = iprot.readString();
15050 
            _val333 = iprot.readString();
15051 
            self.returnedOrders[_key332] = _val333
3064 chandransh 15052 
          iprot.readMapEnd()
15053 
        else:
15054 
          iprot.skip(ftype)
1596 ankur.sing 15055 
      else:
15056 
        iprot.skip(ftype)
15057 
      iprot.readFieldEnd()
15058 
    iprot.readStructEnd()
15059 
 
15060 
  def write(self, oprot):
15061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15063 
      return
4910 phani.kuma 15064 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 15065 
    if self.providerId is not None:
3064 chandransh 15066 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15067 
      oprot.writeI64(self.providerId)
1596 ankur.sing 15068 
      oprot.writeFieldEnd()
3431 rajveer 15069 
    if self.returnedOrders is not None:
3064 chandransh 15070 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
15071 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 15072 
      for kiter334,viter335 in self.returnedOrders.items():
15073 
        oprot.writeString(kiter334)
15074 
        oprot.writeString(viter335)
3064 chandransh 15075 
      oprot.writeMapEnd()
15076 
      oprot.writeFieldEnd()
1596 ankur.sing 15077 
    oprot.writeFieldStop()
15078 
    oprot.writeStructEnd()
15079 
 
3431 rajveer 15080 
  def validate(self):
15081 
    return
15082 
 
15083 
 
1596 ankur.sing 15084 
  def __repr__(self):
15085 
    L = ['%s=%r' % (key, value)
15086 
      for key, value in self.__dict__.iteritems()]
15087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15088 
 
15089 
  def __eq__(self, other):
15090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15091 
 
15092 
  def __ne__(self, other):
15093 
    return not (self == other)
15094 
 
4910 phani.kuma 15095 
class markAsRTOrders_result:
3064 chandransh 15096 
  """
15097 
  Attributes:
15098 
   - ex
15099 
  """
1596 ankur.sing 15100 
 
1627 ankur.sing 15101 
  thrift_spec = (
3064 chandransh 15102 
    None, # 0
15103 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15104 
  )
15105 
 
3064 chandransh 15106 
  def __init__(self, ex=None,):
15107 
    self.ex = ex
15108 
 
1627 ankur.sing 15109 
  def read(self, iprot):
15110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15112 
      return
15113 
    iprot.readStructBegin()
15114 
    while True:
15115 
      (fname, ftype, fid) = iprot.readFieldBegin()
15116 
      if ftype == TType.STOP:
15117 
        break
3064 chandransh 15118 
      if fid == 1:
15119 
        if ftype == TType.STRUCT:
15120 
          self.ex = TransactionServiceException()
15121 
          self.ex.read(iprot)
15122 
        else:
15123 
          iprot.skip(ftype)
1627 ankur.sing 15124 
      else:
15125 
        iprot.skip(ftype)
15126 
      iprot.readFieldEnd()
15127 
    iprot.readStructEnd()
15128 
 
15129 
  def write(self, oprot):
15130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15132 
      return
4910 phani.kuma 15133 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 15134 
    if self.ex is not None:
3064 chandransh 15135 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15136 
      self.ex.write(oprot)
15137 
      oprot.writeFieldEnd()
1627 ankur.sing 15138 
    oprot.writeFieldStop()
15139 
    oprot.writeStructEnd()
15140 
 
3431 rajveer 15141 
  def validate(self):
15142 
    return
15143 
 
15144 
 
1627 ankur.sing 15145 
  def __repr__(self):
15146 
    L = ['%s=%r' % (key, value)
15147 
      for key, value in self.__dict__.iteritems()]
15148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15149 
 
15150 
  def __eq__(self, other):
15151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15152 
 
15153 
  def __ne__(self, other):
15154 
    return not (self == other)
15155 
 
4910 phani.kuma 15156 
class getRTOrders_args:
15157 
  """
15158 
  Attributes:
15159 
   - providerId
15160 
  """
15161 
 
15162 
  thrift_spec = (
15163 
    None, # 0
15164 
    (1, TType.I64, 'providerId', None, None, ), # 1
15165 
  )
15166 
 
15167 
  def __init__(self, providerId=None,):
15168 
    self.providerId = providerId
15169 
 
15170 
  def read(self, iprot):
15171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15173 
      return
15174 
    iprot.readStructBegin()
15175 
    while True:
15176 
      (fname, ftype, fid) = iprot.readFieldBegin()
15177 
      if ftype == TType.STOP:
15178 
        break
15179 
      if fid == 1:
15180 
        if ftype == TType.I64:
15181 
          self.providerId = iprot.readI64();
15182 
        else:
15183 
          iprot.skip(ftype)
15184 
      else:
15185 
        iprot.skip(ftype)
15186 
      iprot.readFieldEnd()
15187 
    iprot.readStructEnd()
15188 
 
15189 
  def write(self, oprot):
15190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15192 
      return
15193 
    oprot.writeStructBegin('getRTOrders_args')
15194 
    if self.providerId is not None:
15195 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15196 
      oprot.writeI64(self.providerId)
15197 
      oprot.writeFieldEnd()
15198 
    oprot.writeFieldStop()
15199 
    oprot.writeStructEnd()
15200 
 
15201 
  def validate(self):
15202 
    return
15203 
 
15204 
 
15205 
  def __repr__(self):
15206 
    L = ['%s=%r' % (key, value)
15207 
      for key, value in self.__dict__.iteritems()]
15208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15209 
 
15210 
  def __eq__(self, other):
15211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15212 
 
15213 
  def __ne__(self, other):
15214 
    return not (self == other)
15215 
 
15216 
class getRTOrders_result:
15217 
  """
15218 
  Attributes:
15219 
   - success
15220 
  """
15221 
 
15222 
  thrift_spec = (
15223 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15224 
  )
15225 
 
15226 
  def __init__(self, success=None,):
15227 
    self.success = success
15228 
 
15229 
  def read(self, iprot):
15230 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15231 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15232 
      return
15233 
    iprot.readStructBegin()
15234 
    while True:
15235 
      (fname, ftype, fid) = iprot.readFieldBegin()
15236 
      if ftype == TType.STOP:
15237 
        break
15238 
      if fid == 0:
15239 
        if ftype == TType.LIST:
15240 
          self.success = []
6188 rajveer 15241 
          (_etype339, _size336) = iprot.readListBegin()
15242 
          for _i340 in xrange(_size336):
15243 
            _elem341 = Order()
15244 
            _elem341.read(iprot)
15245 
            self.success.append(_elem341)
4910 phani.kuma 15246 
          iprot.readListEnd()
15247 
        else:
15248 
          iprot.skip(ftype)
15249 
      else:
15250 
        iprot.skip(ftype)
15251 
      iprot.readFieldEnd()
15252 
    iprot.readStructEnd()
15253 
 
15254 
  def write(self, oprot):
15255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15257 
      return
15258 
    oprot.writeStructBegin('getRTOrders_result')
15259 
    if self.success is not None:
15260 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15261 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15262 
      for iter342 in self.success:
15263 
        iter342.write(oprot)
4910 phani.kuma 15264 
      oprot.writeListEnd()
15265 
      oprot.writeFieldEnd()
15266 
    oprot.writeFieldStop()
15267 
    oprot.writeStructEnd()
15268 
 
15269 
  def validate(self):
15270 
    return
15271 
 
15272 
 
15273 
  def __repr__(self):
15274 
    L = ['%s=%r' % (key, value)
15275 
      for key, value in self.__dict__.iteritems()]
15276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15277 
 
15278 
  def __eq__(self, other):
15279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15280 
 
15281 
  def __ne__(self, other):
15282 
    return not (self == other)
15283 
 
3064 chandransh 15284 
class updateNonDeliveryReason_args:
1627 ankur.sing 15285 
  """
15286 
  Attributes:
3064 chandransh 15287 
   - providerId
15288 
   - undeliveredOrders
1627 ankur.sing 15289 
  """
15290 
 
15291 
  thrift_spec = (
3064 chandransh 15292 
    None, # 0
15293 
    (1, TType.I64, 'providerId', None, None, ), # 1
15294 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 15295 
  )
15296 
 
3064 chandransh 15297 
  def __init__(self, providerId=None, undeliveredOrders=None,):
15298 
    self.providerId = providerId
15299 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 15300 
 
15301 
  def read(self, iprot):
15302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15304 
      return
15305 
    iprot.readStructBegin()
15306 
    while True:
15307 
      (fname, ftype, fid) = iprot.readFieldBegin()
15308 
      if ftype == TType.STOP:
15309 
        break
3064 chandransh 15310 
      if fid == 1:
1627 ankur.sing 15311 
        if ftype == TType.I64:
3064 chandransh 15312 
          self.providerId = iprot.readI64();
1627 ankur.sing 15313 
        else:
15314 
          iprot.skip(ftype)
3064 chandransh 15315 
      elif fid == 2:
15316 
        if ftype == TType.MAP:
15317 
          self.undeliveredOrders = {}
6188 rajveer 15318 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
15319 
          for _i347 in xrange(_size343):
15320 
            _key348 = iprot.readString();
15321 
            _val349 = iprot.readString();
15322 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 15323 
          iprot.readMapEnd()
15324 
        else:
15325 
          iprot.skip(ftype)
1627 ankur.sing 15326 
      else:
15327 
        iprot.skip(ftype)
15328 
      iprot.readFieldEnd()
15329 
    iprot.readStructEnd()
15330 
 
15331 
  def write(self, oprot):
15332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15334 
      return
3064 chandransh 15335 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 15336 
    if self.providerId is not None:
3064 chandransh 15337 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15338 
      oprot.writeI64(self.providerId)
1627 ankur.sing 15339 
      oprot.writeFieldEnd()
3431 rajveer 15340 
    if self.undeliveredOrders is not None:
3064 chandransh 15341 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
15342 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 15343 
      for kiter350,viter351 in self.undeliveredOrders.items():
15344 
        oprot.writeString(kiter350)
15345 
        oprot.writeString(viter351)
3064 chandransh 15346 
      oprot.writeMapEnd()
15347 
      oprot.writeFieldEnd()
1627 ankur.sing 15348 
    oprot.writeFieldStop()
15349 
    oprot.writeStructEnd()
15350 
 
3431 rajveer 15351 
  def validate(self):
15352 
    return
15353 
 
15354 
 
1627 ankur.sing 15355 
  def __repr__(self):
15356 
    L = ['%s=%r' % (key, value)
15357 
      for key, value in self.__dict__.iteritems()]
15358 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15359 
 
15360 
  def __eq__(self, other):
15361 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15362 
 
15363 
  def __ne__(self, other):
15364 
    return not (self == other)
15365 
 
3064 chandransh 15366 
class updateNonDeliveryReason_result:
1627 ankur.sing 15367 
  """
15368 
  Attributes:
3064 chandransh 15369 
   - ex
1627 ankur.sing 15370 
  """
15371 
 
15372 
  thrift_spec = (
4910 phani.kuma 15373 
    None, # 0
3064 chandransh 15374 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15375 
  )
15376 
 
4910 phani.kuma 15377 
  def __init__(self, ex=None,):
3064 chandransh 15378 
    self.ex = ex
1627 ankur.sing 15379 
 
15380 
  def read(self, iprot):
15381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15383 
      return
15384 
    iprot.readStructBegin()
15385 
    while True:
15386 
      (fname, ftype, fid) = iprot.readFieldBegin()
15387 
      if ftype == TType.STOP:
15388 
        break
4910 phani.kuma 15389 
      if fid == 1:
15390 
        if ftype == TType.STRUCT:
15391 
          self.ex = TransactionServiceException()
15392 
          self.ex.read(iprot)
15393 
        else:
15394 
          iprot.skip(ftype)
15395 
      else:
15396 
        iprot.skip(ftype)
15397 
      iprot.readFieldEnd()
15398 
    iprot.readStructEnd()
15399 
 
15400 
  def write(self, oprot):
15401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15403 
      return
15404 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
15405 
    if self.ex is not None:
15406 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15407 
      self.ex.write(oprot)
15408 
      oprot.writeFieldEnd()
15409 
    oprot.writeFieldStop()
15410 
    oprot.writeStructEnd()
15411 
 
15412 
  def validate(self):
15413 
    return
15414 
 
15415 
 
15416 
  def __repr__(self):
15417 
    L = ['%s=%r' % (key, value)
15418 
      for key, value in self.__dict__.iteritems()]
15419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15420 
 
15421 
  def __eq__(self, other):
15422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15423 
 
15424 
  def __ne__(self, other):
15425 
    return not (self == other)
15426 
 
15427 
class getNonDeliveredOrdersbyCourier_args:
15428 
  """
15429 
  Attributes:
15430 
   - providerId
15431 
  """
15432 
 
15433 
  thrift_spec = (
15434 
    None, # 0
15435 
    (1, TType.I64, 'providerId', None, None, ), # 1
15436 
  )
15437 
 
15438 
  def __init__(self, providerId=None,):
15439 
    self.providerId = providerId
15440 
 
15441 
  def read(self, iprot):
15442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15444 
      return
15445 
    iprot.readStructBegin()
15446 
    while True:
15447 
      (fname, ftype, fid) = iprot.readFieldBegin()
15448 
      if ftype == TType.STOP:
15449 
        break
15450 
      if fid == 1:
15451 
        if ftype == TType.I64:
15452 
          self.providerId = iprot.readI64();
15453 
        else:
15454 
          iprot.skip(ftype)
15455 
      else:
15456 
        iprot.skip(ftype)
15457 
      iprot.readFieldEnd()
15458 
    iprot.readStructEnd()
15459 
 
15460 
  def write(self, oprot):
15461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15463 
      return
15464 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
15465 
    if self.providerId is not None:
15466 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15467 
      oprot.writeI64(self.providerId)
15468 
      oprot.writeFieldEnd()
15469 
    oprot.writeFieldStop()
15470 
    oprot.writeStructEnd()
15471 
 
15472 
  def validate(self):
15473 
    return
15474 
 
15475 
 
15476 
  def __repr__(self):
15477 
    L = ['%s=%r' % (key, value)
15478 
      for key, value in self.__dict__.iteritems()]
15479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15480 
 
15481 
  def __eq__(self, other):
15482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15483 
 
15484 
  def __ne__(self, other):
15485 
    return not (self == other)
15486 
 
15487 
class getNonDeliveredOrdersbyCourier_result:
15488 
  """
15489 
  Attributes:
15490 
   - success
15491 
  """
15492 
 
15493 
  thrift_spec = (
15494 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15495 
  )
15496 
 
15497 
  def __init__(self, success=None,):
15498 
    self.success = success
15499 
 
15500 
  def read(self, iprot):
15501 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15502 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15503 
      return
15504 
    iprot.readStructBegin()
15505 
    while True:
15506 
      (fname, ftype, fid) = iprot.readFieldBegin()
15507 
      if ftype == TType.STOP:
15508 
        break
4581 phani.kuma 15509 
      if fid == 0:
15510 
        if ftype == TType.LIST:
15511 
          self.success = []
6188 rajveer 15512 
          (_etype355, _size352) = iprot.readListBegin()
15513 
          for _i356 in xrange(_size352):
15514 
            _elem357 = Order()
15515 
            _elem357.read(iprot)
15516 
            self.success.append(_elem357)
4581 phani.kuma 15517 
          iprot.readListEnd()
15518 
        else:
15519 
          iprot.skip(ftype)
4910 phani.kuma 15520 
      else:
15521 
        iprot.skip(ftype)
15522 
      iprot.readFieldEnd()
15523 
    iprot.readStructEnd()
15524 
 
15525 
  def write(self, oprot):
15526 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15527 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15528 
      return
15529 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
15530 
    if self.success is not None:
15531 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15532 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15533 
      for iter358 in self.success:
15534 
        iter358.write(oprot)
4910 phani.kuma 15535 
      oprot.writeListEnd()
15536 
      oprot.writeFieldEnd()
15537 
    oprot.writeFieldStop()
15538 
    oprot.writeStructEnd()
15539 
 
15540 
  def validate(self):
15541 
    return
15542 
 
15543 
 
15544 
  def __repr__(self):
15545 
    L = ['%s=%r' % (key, value)
15546 
      for key, value in self.__dict__.iteritems()]
15547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15548 
 
15549 
  def __eq__(self, other):
15550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15551 
 
15552 
  def __ne__(self, other):
15553 
    return not (self == other)
15554 
 
15555 
class markOrdersAsLocalConnected_args:
15556 
  """
15557 
  Attributes:
15558 
   - providerId
15559 
   - local_connected_orders
15560 
  """
15561 
 
15562 
  thrift_spec = (
15563 
    None, # 0
15564 
    (1, TType.I64, 'providerId', None, None, ), # 1
15565 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15566 
  )
15567 
 
15568 
  def __init__(self, providerId=None, local_connected_orders=None,):
15569 
    self.providerId = providerId
15570 
    self.local_connected_orders = local_connected_orders
15571 
 
15572 
  def read(self, iprot):
15573 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15574 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15575 
      return
15576 
    iprot.readStructBegin()
15577 
    while True:
15578 
      (fname, ftype, fid) = iprot.readFieldBegin()
15579 
      if ftype == TType.STOP:
15580 
        break
15581 
      if fid == 1:
15582 
        if ftype == TType.I64:
15583 
          self.providerId = iprot.readI64();
15584 
        else:
15585 
          iprot.skip(ftype)
15586 
      elif fid == 2:
15587 
        if ftype == TType.MAP:
15588 
          self.local_connected_orders = {}
6188 rajveer 15589 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
15590 
          for _i363 in xrange(_size359):
15591 
            _key364 = iprot.readString();
15592 
            _val365 = iprot.readString();
15593 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 15594 
          iprot.readMapEnd()
15595 
        else:
15596 
          iprot.skip(ftype)
15597 
      else:
15598 
        iprot.skip(ftype)
15599 
      iprot.readFieldEnd()
15600 
    iprot.readStructEnd()
15601 
 
15602 
  def write(self, oprot):
15603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15605 
      return
15606 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
15607 
    if self.providerId is not None:
15608 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15609 
      oprot.writeI64(self.providerId)
15610 
      oprot.writeFieldEnd()
15611 
    if self.local_connected_orders is not None:
15612 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
15613 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 15614 
      for kiter366,viter367 in self.local_connected_orders.items():
15615 
        oprot.writeString(kiter366)
15616 
        oprot.writeString(viter367)
4910 phani.kuma 15617 
      oprot.writeMapEnd()
15618 
      oprot.writeFieldEnd()
15619 
    oprot.writeFieldStop()
15620 
    oprot.writeStructEnd()
15621 
 
15622 
  def validate(self):
15623 
    return
15624 
 
15625 
 
15626 
  def __repr__(self):
15627 
    L = ['%s=%r' % (key, value)
15628 
      for key, value in self.__dict__.iteritems()]
15629 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15630 
 
15631 
  def __eq__(self, other):
15632 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15633 
 
15634 
  def __ne__(self, other):
15635 
    return not (self == other)
15636 
 
15637 
class markOrdersAsLocalConnected_result:
15638 
  """
15639 
  Attributes:
15640 
   - ex
15641 
  """
15642 
 
15643 
  thrift_spec = (
15644 
    None, # 0
15645 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15646 
  )
15647 
 
15648 
  def __init__(self, ex=None,):
15649 
    self.ex = ex
15650 
 
15651 
  def read(self, iprot):
15652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15654 
      return
15655 
    iprot.readStructBegin()
15656 
    while True:
15657 
      (fname, ftype, fid) = iprot.readFieldBegin()
15658 
      if ftype == TType.STOP:
15659 
        break
15660 
      if fid == 1:
3064 chandransh 15661 
        if ftype == TType.STRUCT:
15662 
          self.ex = TransactionServiceException()
15663 
          self.ex.read(iprot)
1627 ankur.sing 15664 
        else:
15665 
          iprot.skip(ftype)
15666 
      else:
15667 
        iprot.skip(ftype)
15668 
      iprot.readFieldEnd()
15669 
    iprot.readStructEnd()
15670 
 
15671 
  def write(self, oprot):
15672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15674 
      return
4910 phani.kuma 15675 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
15676 
    if self.ex is not None:
15677 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15678 
      self.ex.write(oprot)
15679 
      oprot.writeFieldEnd()
15680 
    oprot.writeFieldStop()
15681 
    oprot.writeStructEnd()
15682 
 
15683 
  def validate(self):
15684 
    return
15685 
 
15686 
 
15687 
  def __repr__(self):
15688 
    L = ['%s=%r' % (key, value)
15689 
      for key, value in self.__dict__.iteritems()]
15690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15691 
 
15692 
  def __eq__(self, other):
15693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15694 
 
15695 
  def __ne__(self, other):
15696 
    return not (self == other)
15697 
 
15698 
class getOrdersNotLocalConnected_args:
15699 
  """
15700 
  Attributes:
15701 
   - providerId
15702 
  """
15703 
 
15704 
  thrift_spec = (
15705 
    None, # 0
15706 
    (1, TType.I64, 'providerId', None, None, ), # 1
15707 
  )
15708 
 
15709 
  def __init__(self, providerId=None,):
15710 
    self.providerId = providerId
15711 
 
15712 
  def read(self, iprot):
15713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15715 
      return
15716 
    iprot.readStructBegin()
15717 
    while True:
15718 
      (fname, ftype, fid) = iprot.readFieldBegin()
15719 
      if ftype == TType.STOP:
15720 
        break
15721 
      if fid == 1:
15722 
        if ftype == TType.I64:
15723 
          self.providerId = iprot.readI64();
15724 
        else:
15725 
          iprot.skip(ftype)
15726 
      else:
15727 
        iprot.skip(ftype)
15728 
      iprot.readFieldEnd()
15729 
    iprot.readStructEnd()
15730 
 
15731 
  def write(self, oprot):
15732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15734 
      return
15735 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
15736 
    if self.providerId is not None:
15737 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15738 
      oprot.writeI64(self.providerId)
15739 
      oprot.writeFieldEnd()
15740 
    oprot.writeFieldStop()
15741 
    oprot.writeStructEnd()
15742 
 
15743 
  def validate(self):
15744 
    return
15745 
 
15746 
 
15747 
  def __repr__(self):
15748 
    L = ['%s=%r' % (key, value)
15749 
      for key, value in self.__dict__.iteritems()]
15750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15751 
 
15752 
  def __eq__(self, other):
15753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15754 
 
15755 
  def __ne__(self, other):
15756 
    return not (self == other)
15757 
 
15758 
class getOrdersNotLocalConnected_result:
15759 
  """
15760 
  Attributes:
15761 
   - success
15762 
  """
15763 
 
15764 
  thrift_spec = (
15765 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15766 
  )
15767 
 
15768 
  def __init__(self, success=None,):
15769 
    self.success = success
15770 
 
15771 
  def read(self, iprot):
15772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15774 
      return
15775 
    iprot.readStructBegin()
15776 
    while True:
15777 
      (fname, ftype, fid) = iprot.readFieldBegin()
15778 
      if ftype == TType.STOP:
15779 
        break
15780 
      if fid == 0:
15781 
        if ftype == TType.LIST:
15782 
          self.success = []
6188 rajveer 15783 
          (_etype371, _size368) = iprot.readListBegin()
15784 
          for _i372 in xrange(_size368):
15785 
            _elem373 = Order()
15786 
            _elem373.read(iprot)
15787 
            self.success.append(_elem373)
4910 phani.kuma 15788 
          iprot.readListEnd()
15789 
        else:
15790 
          iprot.skip(ftype)
15791 
      else:
15792 
        iprot.skip(ftype)
15793 
      iprot.readFieldEnd()
15794 
    iprot.readStructEnd()
15795 
 
15796 
  def write(self, oprot):
15797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15799 
      return
15800 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 15801 
    if self.success is not None:
15802 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15803 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15804 
      for iter374 in self.success:
15805 
        iter374.write(oprot)
4581 phani.kuma 15806 
      oprot.writeListEnd()
15807 
      oprot.writeFieldEnd()
4910 phani.kuma 15808 
    oprot.writeFieldStop()
15809 
    oprot.writeStructEnd()
15810 
 
15811 
  def validate(self):
15812 
    return
15813 
 
15814 
 
15815 
  def __repr__(self):
15816 
    L = ['%s=%r' % (key, value)
15817 
      for key, value in self.__dict__.iteritems()]
15818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15819 
 
15820 
  def __eq__(self, other):
15821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15822 
 
15823 
  def __ne__(self, other):
15824 
    return not (self == other)
15825 
 
15826 
class markOrdersAsDestinationCityReached_args:
15827 
  """
15828 
  Attributes:
15829 
   - providerId
15830 
   - destination_city_reached_orders
15831 
  """
15832 
 
15833 
  thrift_spec = (
15834 
    None, # 0
15835 
    (1, TType.I64, 'providerId', None, None, ), # 1
15836 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15837 
  )
15838 
 
15839 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
15840 
    self.providerId = providerId
15841 
    self.destination_city_reached_orders = destination_city_reached_orders
15842 
 
15843 
  def read(self, iprot):
15844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15846 
      return
15847 
    iprot.readStructBegin()
15848 
    while True:
15849 
      (fname, ftype, fid) = iprot.readFieldBegin()
15850 
      if ftype == TType.STOP:
15851 
        break
15852 
      if fid == 1:
15853 
        if ftype == TType.I64:
15854 
          self.providerId = iprot.readI64();
15855 
        else:
15856 
          iprot.skip(ftype)
15857 
      elif fid == 2:
15858 
        if ftype == TType.MAP:
15859 
          self.destination_city_reached_orders = {}
6188 rajveer 15860 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
15861 
          for _i379 in xrange(_size375):
15862 
            _key380 = iprot.readString();
15863 
            _val381 = iprot.readString();
15864 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 15865 
          iprot.readMapEnd()
15866 
        else:
15867 
          iprot.skip(ftype)
15868 
      else:
15869 
        iprot.skip(ftype)
15870 
      iprot.readFieldEnd()
15871 
    iprot.readStructEnd()
15872 
 
15873 
  def write(self, oprot):
15874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15876 
      return
15877 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
15878 
    if self.providerId is not None:
15879 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15880 
      oprot.writeI64(self.providerId)
15881 
      oprot.writeFieldEnd()
15882 
    if self.destination_city_reached_orders is not None:
15883 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
15884 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 15885 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
15886 
        oprot.writeString(kiter382)
15887 
        oprot.writeString(viter383)
4910 phani.kuma 15888 
      oprot.writeMapEnd()
15889 
      oprot.writeFieldEnd()
15890 
    oprot.writeFieldStop()
15891 
    oprot.writeStructEnd()
15892 
 
15893 
  def validate(self):
15894 
    return
15895 
 
15896 
 
15897 
  def __repr__(self):
15898 
    L = ['%s=%r' % (key, value)
15899 
      for key, value in self.__dict__.iteritems()]
15900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15901 
 
15902 
  def __eq__(self, other):
15903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15904 
 
15905 
  def __ne__(self, other):
15906 
    return not (self == other)
15907 
 
15908 
class markOrdersAsDestinationCityReached_result:
15909 
  """
15910 
  Attributes:
15911 
   - ex
15912 
  """
15913 
 
15914 
  thrift_spec = (
15915 
    None, # 0
15916 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15917 
  )
15918 
 
15919 
  def __init__(self, ex=None,):
15920 
    self.ex = ex
15921 
 
15922 
  def read(self, iprot):
15923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15925 
      return
15926 
    iprot.readStructBegin()
15927 
    while True:
15928 
      (fname, ftype, fid) = iprot.readFieldBegin()
15929 
      if ftype == TType.STOP:
15930 
        break
15931 
      if fid == 1:
15932 
        if ftype == TType.STRUCT:
15933 
          self.ex = TransactionServiceException()
15934 
          self.ex.read(iprot)
15935 
        else:
15936 
          iprot.skip(ftype)
15937 
      else:
15938 
        iprot.skip(ftype)
15939 
      iprot.readFieldEnd()
15940 
    iprot.readStructEnd()
15941 
 
15942 
  def write(self, oprot):
15943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15945 
      return
15946 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15947 
    if self.ex is not None:
3064 chandransh 15948 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15949 
      self.ex.write(oprot)
1627 ankur.sing 15950 
      oprot.writeFieldEnd()
15951 
    oprot.writeFieldStop()
15952 
    oprot.writeStructEnd()
15953 
 
3431 rajveer 15954 
  def validate(self):
15955 
    return
15956 
 
15957 
 
1627 ankur.sing 15958 
  def __repr__(self):
15959 
    L = ['%s=%r' % (key, value)
15960 
      for key, value in self.__dict__.iteritems()]
15961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15962 
 
15963 
  def __eq__(self, other):
15964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15965 
 
15966 
  def __ne__(self, other):
15967 
    return not (self == other)
15968 
 
4910 phani.kuma 15969 
class markOrdersAsFirstDeliveryAttempted_args:
15970 
  """
15971 
  Attributes:
15972 
   - providerId
15973 
   - first_atdl_orders
15974 
  """
15975 
 
15976 
  thrift_spec = (
15977 
    None, # 0
15978 
    (1, TType.I64, 'providerId', None, None, ), # 1
15979 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15980 
  )
15981 
 
15982 
  def __init__(self, providerId=None, first_atdl_orders=None,):
15983 
    self.providerId = providerId
15984 
    self.first_atdl_orders = first_atdl_orders
15985 
 
15986 
  def read(self, iprot):
15987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15989 
      return
15990 
    iprot.readStructBegin()
15991 
    while True:
15992 
      (fname, ftype, fid) = iprot.readFieldBegin()
15993 
      if ftype == TType.STOP:
15994 
        break
15995 
      if fid == 1:
15996 
        if ftype == TType.I64:
15997 
          self.providerId = iprot.readI64();
15998 
        else:
15999 
          iprot.skip(ftype)
16000 
      elif fid == 2:
16001 
        if ftype == TType.MAP:
16002 
          self.first_atdl_orders = {}
6188 rajveer 16003 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
16004 
          for _i388 in xrange(_size384):
16005 
            _key389 = iprot.readString();
16006 
            _val390 = iprot.readString();
16007 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 16008 
          iprot.readMapEnd()
16009 
        else:
16010 
          iprot.skip(ftype)
16011 
      else:
16012 
        iprot.skip(ftype)
16013 
      iprot.readFieldEnd()
16014 
    iprot.readStructEnd()
16015 
 
16016 
  def write(self, oprot):
16017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16019 
      return
16020 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
16021 
    if self.providerId is not None:
16022 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16023 
      oprot.writeI64(self.providerId)
16024 
      oprot.writeFieldEnd()
16025 
    if self.first_atdl_orders is not None:
16026 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
16027 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 16028 
      for kiter391,viter392 in self.first_atdl_orders.items():
16029 
        oprot.writeString(kiter391)
16030 
        oprot.writeString(viter392)
4910 phani.kuma 16031 
      oprot.writeMapEnd()
16032 
      oprot.writeFieldEnd()
16033 
    oprot.writeFieldStop()
16034 
    oprot.writeStructEnd()
16035 
 
16036 
  def validate(self):
16037 
    return
16038 
 
16039 
 
16040 
  def __repr__(self):
16041 
    L = ['%s=%r' % (key, value)
16042 
      for key, value in self.__dict__.iteritems()]
16043 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16044 
 
16045 
  def __eq__(self, other):
16046 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16047 
 
16048 
  def __ne__(self, other):
16049 
    return not (self == other)
16050 
 
16051 
class markOrdersAsFirstDeliveryAttempted_result:
16052 
  """
16053 
  Attributes:
16054 
   - ex
16055 
  """
16056 
 
16057 
  thrift_spec = (
16058 
    None, # 0
16059 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16060 
  )
16061 
 
16062 
  def __init__(self, ex=None,):
16063 
    self.ex = ex
16064 
 
16065 
  def read(self, iprot):
16066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16068 
      return
16069 
    iprot.readStructBegin()
16070 
    while True:
16071 
      (fname, ftype, fid) = iprot.readFieldBegin()
16072 
      if ftype == TType.STOP:
16073 
        break
16074 
      if fid == 1:
16075 
        if ftype == TType.STRUCT:
16076 
          self.ex = TransactionServiceException()
16077 
          self.ex.read(iprot)
16078 
        else:
16079 
          iprot.skip(ftype)
16080 
      else:
16081 
        iprot.skip(ftype)
16082 
      iprot.readFieldEnd()
16083 
    iprot.readStructEnd()
16084 
 
16085 
  def write(self, oprot):
16086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16088 
      return
16089 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
16090 
    if self.ex is not None:
16091 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16092 
      self.ex.write(oprot)
16093 
      oprot.writeFieldEnd()
16094 
    oprot.writeFieldStop()
16095 
    oprot.writeStructEnd()
16096 
 
16097 
  def validate(self):
16098 
    return
16099 
 
16100 
 
16101 
  def __repr__(self):
16102 
    L = ['%s=%r' % (key, value)
16103 
      for key, value in self.__dict__.iteritems()]
16104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16105 
 
16106 
  def __eq__(self, other):
16107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16108 
 
16109 
  def __ne__(self, other):
16110 
    return not (self == other)
16111 
 
3064 chandransh 16112 
class getUndeliveredOrders_args:
1886 ankur.sing 16113 
  """
16114 
  Attributes:
3064 chandransh 16115 
   - providerId
16116 
   - warehouseId
1886 ankur.sing 16117 
  """
1627 ankur.sing 16118 
 
1886 ankur.sing 16119 
  thrift_spec = (
16120 
    None, # 0
3064 chandransh 16121 
    (1, TType.I64, 'providerId', None, None, ), # 1
16122 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 16123 
  )
16124 
 
3064 chandransh 16125 
  def __init__(self, providerId=None, warehouseId=None,):
16126 
    self.providerId = providerId
16127 
    self.warehouseId = warehouseId
1886 ankur.sing 16128 
 
16129 
  def read(self, iprot):
16130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16132 
      return
16133 
    iprot.readStructBegin()
16134 
    while True:
16135 
      (fname, ftype, fid) = iprot.readFieldBegin()
16136 
      if ftype == TType.STOP:
16137 
        break
16138 
      if fid == 1:
16139 
        if ftype == TType.I64:
3064 chandransh 16140 
          self.providerId = iprot.readI64();
1886 ankur.sing 16141 
        else:
16142 
          iprot.skip(ftype)
3064 chandransh 16143 
      elif fid == 2:
16144 
        if ftype == TType.I64:
16145 
          self.warehouseId = iprot.readI64();
16146 
        else:
16147 
          iprot.skip(ftype)
1886 ankur.sing 16148 
      else:
16149 
        iprot.skip(ftype)
16150 
      iprot.readFieldEnd()
16151 
    iprot.readStructEnd()
16152 
 
16153 
  def write(self, oprot):
16154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16156 
      return
3064 chandransh 16157 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 16158 
    if self.providerId is not None:
3064 chandransh 16159 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16160 
      oprot.writeI64(self.providerId)
1886 ankur.sing 16161 
      oprot.writeFieldEnd()
3431 rajveer 16162 
    if self.warehouseId is not None:
3064 chandransh 16163 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16164 
      oprot.writeI64(self.warehouseId)
16165 
      oprot.writeFieldEnd()
1886 ankur.sing 16166 
    oprot.writeFieldStop()
16167 
    oprot.writeStructEnd()
16168 
 
3431 rajveer 16169 
  def validate(self):
16170 
    return
16171 
 
16172 
 
1886 ankur.sing 16173 
  def __repr__(self):
16174 
    L = ['%s=%r' % (key, value)
16175 
      for key, value in self.__dict__.iteritems()]
16176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16177 
 
16178 
  def __eq__(self, other):
16179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16180 
 
16181 
  def __ne__(self, other):
16182 
    return not (self == other)
16183 
 
3064 chandransh 16184 
class getUndeliveredOrders_result:
1886 ankur.sing 16185 
  """
16186 
  Attributes:
16187 
   - success
16188 
  """
16189 
 
16190 
  thrift_spec = (
16191 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16192 
  )
16193 
 
16194 
  def __init__(self, success=None,):
16195 
    self.success = success
16196 
 
16197 
  def read(self, iprot):
16198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16200 
      return
16201 
    iprot.readStructBegin()
16202 
    while True:
16203 
      (fname, ftype, fid) = iprot.readFieldBegin()
16204 
      if ftype == TType.STOP:
16205 
        break
16206 
      if fid == 0:
16207 
        if ftype == TType.LIST:
16208 
          self.success = []
6188 rajveer 16209 
          (_etype396, _size393) = iprot.readListBegin()
16210 
          for _i397 in xrange(_size393):
16211 
            _elem398 = Order()
16212 
            _elem398.read(iprot)
16213 
            self.success.append(_elem398)
1886 ankur.sing 16214 
          iprot.readListEnd()
16215 
        else:
16216 
          iprot.skip(ftype)
16217 
      else:
16218 
        iprot.skip(ftype)
16219 
      iprot.readFieldEnd()
16220 
    iprot.readStructEnd()
16221 
 
16222 
  def write(self, oprot):
16223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16225 
      return
3064 chandransh 16226 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 16227 
    if self.success is not None:
1886 ankur.sing 16228 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16229 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16230 
      for iter399 in self.success:
16231 
        iter399.write(oprot)
1886 ankur.sing 16232 
      oprot.writeListEnd()
16233 
      oprot.writeFieldEnd()
16234 
    oprot.writeFieldStop()
16235 
    oprot.writeStructEnd()
16236 
 
3431 rajveer 16237 
  def validate(self):
16238 
    return
16239 
 
16240 
 
1886 ankur.sing 16241 
  def __repr__(self):
16242 
    L = ['%s=%r' % (key, value)
16243 
      for key, value in self.__dict__.iteritems()]
16244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16245 
 
16246 
  def __eq__(self, other):
16247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16248 
 
16249 
  def __ne__(self, other):
16250 
    return not (self == other)
16251 
 
4783 phani.kuma 16252 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
16253 
 
16254 
  thrift_spec = (
16255 
  )
16256 
 
16257 
  def read(self, iprot):
16258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16260 
      return
16261 
    iprot.readStructBegin()
16262 
    while True:
16263 
      (fname, ftype, fid) = iprot.readFieldBegin()
16264 
      if ftype == TType.STOP:
16265 
        break
16266 
      else:
16267 
        iprot.skip(ftype)
16268 
      iprot.readFieldEnd()
16269 
    iprot.readStructEnd()
16270 
 
16271 
  def write(self, oprot):
16272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16274 
      return
16275 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
16276 
    oprot.writeFieldStop()
16277 
    oprot.writeStructEnd()
16278 
 
16279 
  def validate(self):
16280 
    return
16281 
 
16282 
 
16283 
  def __repr__(self):
16284 
    L = ['%s=%r' % (key, value)
16285 
      for key, value in self.__dict__.iteritems()]
16286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16287 
 
16288 
  def __eq__(self, other):
16289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16290 
 
16291 
  def __ne__(self, other):
16292 
    return not (self == other)
16293 
 
16294 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
16295 
  """
16296 
  Attributes:
16297 
   - success
16298 
  """
16299 
 
16300 
  thrift_spec = (
16301 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16302 
  )
16303 
 
16304 
  def __init__(self, success=None,):
16305 
    self.success = success
16306 
 
16307 
  def read(self, iprot):
16308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16310 
      return
16311 
    iprot.readStructBegin()
16312 
    while True:
16313 
      (fname, ftype, fid) = iprot.readFieldBegin()
16314 
      if ftype == TType.STOP:
16315 
        break
16316 
      if fid == 0:
16317 
        if ftype == TType.LIST:
16318 
          self.success = []
6188 rajveer 16319 
          (_etype403, _size400) = iprot.readListBegin()
16320 
          for _i404 in xrange(_size400):
16321 
            _elem405 = Order()
16322 
            _elem405.read(iprot)
16323 
            self.success.append(_elem405)
4783 phani.kuma 16324 
          iprot.readListEnd()
16325 
        else:
16326 
          iprot.skip(ftype)
16327 
      else:
16328 
        iprot.skip(ftype)
16329 
      iprot.readFieldEnd()
16330 
    iprot.readStructEnd()
16331 
 
16332 
  def write(self, oprot):
16333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16335 
      return
16336 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
16337 
    if self.success is not None:
16338 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16339 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16340 
      for iter406 in self.success:
16341 
        iter406.write(oprot)
4783 phani.kuma 16342 
      oprot.writeListEnd()
16343 
      oprot.writeFieldEnd()
16344 
    oprot.writeFieldStop()
16345 
    oprot.writeStructEnd()
16346 
 
16347 
  def validate(self):
16348 
    return
16349 
 
16350 
 
16351 
  def __repr__(self):
16352 
    L = ['%s=%r' % (key, value)
16353 
      for key, value in self.__dict__.iteritems()]
16354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16355 
 
16356 
  def __eq__(self, other):
16357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16358 
 
16359 
  def __ne__(self, other):
16360 
    return not (self == other)
16361 
 
2536 chandransh 16362 
class toggleDOAFlag_args:
16363 
  """
16364 
  Attributes:
16365 
   - orderId
16366 
  """
1886 ankur.sing 16367 
 
2536 chandransh 16368 
  thrift_spec = (
16369 
    None, # 0
16370 
    (1, TType.I64, 'orderId', None, None, ), # 1
16371 
  )
16372 
 
16373 
  def __init__(self, orderId=None,):
16374 
    self.orderId = orderId
16375 
 
16376 
  def read(self, iprot):
16377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16379 
      return
16380 
    iprot.readStructBegin()
16381 
    while True:
16382 
      (fname, ftype, fid) = iprot.readFieldBegin()
16383 
      if ftype == TType.STOP:
16384 
        break
16385 
      if fid == 1:
16386 
        if ftype == TType.I64:
16387 
          self.orderId = iprot.readI64();
16388 
        else:
16389 
          iprot.skip(ftype)
16390 
      else:
16391 
        iprot.skip(ftype)
16392 
      iprot.readFieldEnd()
16393 
    iprot.readStructEnd()
16394 
 
16395 
  def write(self, oprot):
16396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16398 
      return
16399 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 16400 
    if self.orderId is not None:
2536 chandransh 16401 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16402 
      oprot.writeI64(self.orderId)
16403 
      oprot.writeFieldEnd()
16404 
    oprot.writeFieldStop()
16405 
    oprot.writeStructEnd()
16406 
 
3431 rajveer 16407 
  def validate(self):
16408 
    return
16409 
 
16410 
 
2536 chandransh 16411 
  def __repr__(self):
16412 
    L = ['%s=%r' % (key, value)
16413 
      for key, value in self.__dict__.iteritems()]
16414 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16415 
 
16416 
  def __eq__(self, other):
16417 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16418 
 
16419 
  def __ne__(self, other):
16420 
    return not (self == other)
16421 
 
16422 
class toggleDOAFlag_result:
16423 
  """
16424 
  Attributes:
16425 
   - success
16426 
   - ex
16427 
  """
16428 
 
16429 
  thrift_spec = (
16430 
    (0, TType.BOOL, 'success', None, None, ), # 0
16431 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16432 
  )
16433 
 
16434 
  def __init__(self, success=None, ex=None,):
16435 
    self.success = success
16436 
    self.ex = ex
16437 
 
16438 
  def read(self, iprot):
16439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16441 
      return
16442 
    iprot.readStructBegin()
16443 
    while True:
16444 
      (fname, ftype, fid) = iprot.readFieldBegin()
16445 
      if ftype == TType.STOP:
16446 
        break
16447 
      if fid == 0:
16448 
        if ftype == TType.BOOL:
16449 
          self.success = iprot.readBool();
16450 
        else:
16451 
          iprot.skip(ftype)
16452 
      elif fid == 1:
16453 
        if ftype == TType.STRUCT:
16454 
          self.ex = TransactionServiceException()
16455 
          self.ex.read(iprot)
16456 
        else:
16457 
          iprot.skip(ftype)
16458 
      else:
16459 
        iprot.skip(ftype)
16460 
      iprot.readFieldEnd()
16461 
    iprot.readStructEnd()
16462 
 
16463 
  def write(self, oprot):
16464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16466 
      return
16467 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 16468 
    if self.success is not None:
2536 chandransh 16469 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16470 
      oprot.writeBool(self.success)
16471 
      oprot.writeFieldEnd()
3431 rajveer 16472 
    if self.ex is not None:
2536 chandransh 16473 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16474 
      self.ex.write(oprot)
16475 
      oprot.writeFieldEnd()
16476 
    oprot.writeFieldStop()
16477 
    oprot.writeStructEnd()
16478 
 
3431 rajveer 16479 
  def validate(self):
16480 
    return
16481 
 
16482 
 
2536 chandransh 16483 
  def __repr__(self):
16484 
    L = ['%s=%r' % (key, value)
16485 
      for key, value in self.__dict__.iteritems()]
16486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16487 
 
16488 
  def __eq__(self, other):
16489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16490 
 
16491 
  def __ne__(self, other):
16492 
    return not (self == other)
16493 
 
4712 rajveer 16494 
class markOrderAsDelivered_args:
16495 
  """
16496 
  Attributes:
16497 
   - orderId
16498 
   - deliveryTimestamp
16499 
   - receiver
16500 
  """
16501 
 
16502 
  thrift_spec = None
16503 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
16504 
    self.orderId = orderId
16505 
    self.deliveryTimestamp = deliveryTimestamp
16506 
    self.receiver = receiver
16507 
 
16508 
  def read(self, iprot):
16509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16511 
      return
16512 
    iprot.readStructBegin()
16513 
    while True:
16514 
      (fname, ftype, fid) = iprot.readFieldBegin()
16515 
      if ftype == TType.STOP:
16516 
        break
16517 
      if fid == 1:
16518 
        if ftype == TType.I64:
16519 
          self.orderId = iprot.readI64();
16520 
        else:
16521 
          iprot.skip(ftype)
16522 
      elif fid == 2:
16523 
        if ftype == TType.I64:
16524 
          self.deliveryTimestamp = iprot.readI64();
16525 
        else:
16526 
          iprot.skip(ftype)
16527 
      elif fid == -1:
16528 
        if ftype == TType.STRING:
16529 
          self.receiver = iprot.readString();
16530 
        else:
16531 
          iprot.skip(ftype)
16532 
      else:
16533 
        iprot.skip(ftype)
16534 
      iprot.readFieldEnd()
16535 
    iprot.readStructEnd()
16536 
 
16537 
  def write(self, oprot):
16538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16540 
      return
16541 
    oprot.writeStructBegin('markOrderAsDelivered_args')
16542 
    if self.receiver is not None:
16543 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
16544 
      oprot.writeString(self.receiver)
16545 
      oprot.writeFieldEnd()
16546 
    if self.orderId is not None:
16547 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16548 
      oprot.writeI64(self.orderId)
16549 
      oprot.writeFieldEnd()
16550 
    if self.deliveryTimestamp is not None:
16551 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16552 
      oprot.writeI64(self.deliveryTimestamp)
16553 
      oprot.writeFieldEnd()
16554 
    oprot.writeFieldStop()
16555 
    oprot.writeStructEnd()
16556 
 
16557 
  def validate(self):
16558 
    return
16559 
 
16560 
 
16561 
  def __repr__(self):
16562 
    L = ['%s=%r' % (key, value)
16563 
      for key, value in self.__dict__.iteritems()]
16564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16565 
 
16566 
  def __eq__(self, other):
16567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16568 
 
16569 
  def __ne__(self, other):
16570 
    return not (self == other)
16571 
 
16572 
class markOrderAsDelivered_result:
16573 
  """
16574 
  Attributes:
16575 
   - ex
16576 
  """
16577 
 
16578 
  thrift_spec = (
16579 
    None, # 0
16580 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16581 
  )
16582 
 
16583 
  def __init__(self, ex=None,):
16584 
    self.ex = ex
16585 
 
16586 
  def read(self, iprot):
16587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16589 
      return
16590 
    iprot.readStructBegin()
16591 
    while True:
16592 
      (fname, ftype, fid) = iprot.readFieldBegin()
16593 
      if ftype == TType.STOP:
16594 
        break
16595 
      if fid == 1:
16596 
        if ftype == TType.STRUCT:
16597 
          self.ex = TransactionServiceException()
16598 
          self.ex.read(iprot)
16599 
        else:
16600 
          iprot.skip(ftype)
16601 
      else:
16602 
        iprot.skip(ftype)
16603 
      iprot.readFieldEnd()
16604 
    iprot.readStructEnd()
16605 
 
16606 
  def write(self, oprot):
16607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16609 
      return
16610 
    oprot.writeStructBegin('markOrderAsDelivered_result')
16611 
    if self.ex is not None:
16612 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16613 
      self.ex.write(oprot)
16614 
      oprot.writeFieldEnd()
16615 
    oprot.writeFieldStop()
16616 
    oprot.writeStructEnd()
16617 
 
16618 
  def validate(self):
16619 
    return
16620 
 
16621 
 
16622 
  def __repr__(self):
16623 
    L = ['%s=%r' % (key, value)
16624 
      for key, value in self.__dict__.iteritems()]
16625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16626 
 
16627 
  def __eq__(self, other):
16628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16629 
 
16630 
  def __ne__(self, other):
16631 
    return not (self == other)
16632 
 
5553 rajveer 16633 
class markOrderAsReceivedAtStore_args:
16634 
  """
16635 
  Attributes:
16636 
   - orderId
16637 
   - deliveryTimestamp
16638 
  """
16639 
 
16640 
  thrift_spec = (
16641 
    None, # 0
16642 
    (1, TType.I64, 'orderId', None, None, ), # 1
16643 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
16644 
  )
16645 
 
16646 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
16647 
    self.orderId = orderId
16648 
    self.deliveryTimestamp = deliveryTimestamp
16649 
 
16650 
  def read(self, iprot):
16651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16653 
      return
16654 
    iprot.readStructBegin()
16655 
    while True:
16656 
      (fname, ftype, fid) = iprot.readFieldBegin()
16657 
      if ftype == TType.STOP:
16658 
        break
16659 
      if fid == 1:
16660 
        if ftype == TType.I64:
16661 
          self.orderId = iprot.readI64();
16662 
        else:
16663 
          iprot.skip(ftype)
16664 
      elif fid == 2:
16665 
        if ftype == TType.I64:
16666 
          self.deliveryTimestamp = iprot.readI64();
16667 
        else:
16668 
          iprot.skip(ftype)
16669 
      else:
16670 
        iprot.skip(ftype)
16671 
      iprot.readFieldEnd()
16672 
    iprot.readStructEnd()
16673 
 
16674 
  def write(self, oprot):
16675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16677 
      return
16678 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
16679 
    if self.orderId is not None:
16680 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16681 
      oprot.writeI64(self.orderId)
16682 
      oprot.writeFieldEnd()
16683 
    if self.deliveryTimestamp is not None:
16684 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16685 
      oprot.writeI64(self.deliveryTimestamp)
16686 
      oprot.writeFieldEnd()
16687 
    oprot.writeFieldStop()
16688 
    oprot.writeStructEnd()
16689 
 
16690 
  def validate(self):
16691 
    return
16692 
 
16693 
 
16694 
  def __repr__(self):
16695 
    L = ['%s=%r' % (key, value)
16696 
      for key, value in self.__dict__.iteritems()]
16697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16698 
 
16699 
  def __eq__(self, other):
16700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16701 
 
16702 
  def __ne__(self, other):
16703 
    return not (self == other)
16704 
 
16705 
class markOrderAsReceivedAtStore_result:
16706 
  """
16707 
  Attributes:
16708 
   - ex
16709 
  """
16710 
 
16711 
  thrift_spec = (
16712 
    None, # 0
16713 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16714 
  )
16715 
 
16716 
  def __init__(self, ex=None,):
16717 
    self.ex = ex
16718 
 
16719 
  def read(self, iprot):
16720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16722 
      return
16723 
    iprot.readStructBegin()
16724 
    while True:
16725 
      (fname, ftype, fid) = iprot.readFieldBegin()
16726 
      if ftype == TType.STOP:
16727 
        break
16728 
      if fid == 1:
16729 
        if ftype == TType.STRUCT:
16730 
          self.ex = TransactionServiceException()
16731 
          self.ex.read(iprot)
16732 
        else:
16733 
          iprot.skip(ftype)
16734 
      else:
16735 
        iprot.skip(ftype)
16736 
      iprot.readFieldEnd()
16737 
    iprot.readStructEnd()
16738 
 
16739 
  def write(self, oprot):
16740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16742 
      return
16743 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
16744 
    if self.ex is not None:
16745 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16746 
      self.ex.write(oprot)
16747 
      oprot.writeFieldEnd()
16748 
    oprot.writeFieldStop()
16749 
    oprot.writeStructEnd()
16750 
 
16751 
  def validate(self):
16752 
    return
16753 
 
16754 
 
16755 
  def __repr__(self):
16756 
    L = ['%s=%r' % (key, value)
16757 
      for key, value in self.__dict__.iteritems()]
16758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16759 
 
16760 
  def __eq__(self, other):
16761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16762 
 
16763 
  def __ne__(self, other):
16764 
    return not (self == other)
16765 
 
4454 rajveer 16766 
class markOrderDoaRequestReceived_args:
16767 
  """
16768 
  Attributes:
16769 
   - orderId
16770 
  """
16771 
 
16772 
  thrift_spec = (
16773 
    None, # 0
16774 
    (1, TType.I64, 'orderId', None, None, ), # 1
16775 
  )
16776 
 
16777 
  def __init__(self, orderId=None,):
16778 
    self.orderId = orderId
16779 
 
16780 
  def read(self, iprot):
16781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16783 
      return
16784 
    iprot.readStructBegin()
16785 
    while True:
16786 
      (fname, ftype, fid) = iprot.readFieldBegin()
16787 
      if ftype == TType.STOP:
16788 
        break
16789 
      if fid == 1:
16790 
        if ftype == TType.I64:
16791 
          self.orderId = iprot.readI64();
16792 
        else:
16793 
          iprot.skip(ftype)
16794 
      else:
16795 
        iprot.skip(ftype)
16796 
      iprot.readFieldEnd()
16797 
    iprot.readStructEnd()
16798 
 
16799 
  def write(self, oprot):
16800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16802 
      return
16803 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
16804 
    if self.orderId is not None:
16805 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16806 
      oprot.writeI64(self.orderId)
16807 
      oprot.writeFieldEnd()
16808 
    oprot.writeFieldStop()
16809 
    oprot.writeStructEnd()
16810 
 
16811 
  def validate(self):
16812 
    return
16813 
 
16814 
 
16815 
  def __repr__(self):
16816 
    L = ['%s=%r' % (key, value)
16817 
      for key, value in self.__dict__.iteritems()]
16818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16819 
 
16820 
  def __eq__(self, other):
16821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16822 
 
16823 
  def __ne__(self, other):
16824 
    return not (self == other)
16825 
 
16826 
class markOrderDoaRequestReceived_result:
16827 
  """
16828 
  Attributes:
16829 
   - success
16830 
   - ex
16831 
  """
16832 
 
16833 
  thrift_spec = (
16834 
    (0, TType.BOOL, 'success', None, None, ), # 0
16835 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16836 
  )
16837 
 
16838 
  def __init__(self, success=None, ex=None,):
16839 
    self.success = success
16840 
    self.ex = ex
16841 
 
16842 
  def read(self, iprot):
16843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16845 
      return
16846 
    iprot.readStructBegin()
16847 
    while True:
16848 
      (fname, ftype, fid) = iprot.readFieldBegin()
16849 
      if ftype == TType.STOP:
16850 
        break
16851 
      if fid == 0:
16852 
        if ftype == TType.BOOL:
16853 
          self.success = iprot.readBool();
16854 
        else:
16855 
          iprot.skip(ftype)
16856 
      elif fid == 1:
16857 
        if ftype == TType.STRUCT:
16858 
          self.ex = TransactionServiceException()
16859 
          self.ex.read(iprot)
16860 
        else:
16861 
          iprot.skip(ftype)
16862 
      else:
16863 
        iprot.skip(ftype)
16864 
      iprot.readFieldEnd()
16865 
    iprot.readStructEnd()
16866 
 
16867 
  def write(self, oprot):
16868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16870 
      return
16871 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
16872 
    if self.success is not None:
16873 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16874 
      oprot.writeBool(self.success)
16875 
      oprot.writeFieldEnd()
16876 
    if self.ex is not None:
16877 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16878 
      self.ex.write(oprot)
16879 
      oprot.writeFieldEnd()
16880 
    oprot.writeFieldStop()
16881 
    oprot.writeStructEnd()
16882 
 
16883 
  def validate(self):
16884 
    return
16885 
 
16886 
 
16887 
  def __repr__(self):
16888 
    L = ['%s=%r' % (key, value)
16889 
      for key, value in self.__dict__.iteritems()]
16890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16891 
 
16892 
  def __eq__(self, other):
16893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16894 
 
16895 
  def __ne__(self, other):
16896 
    return not (self == other)
16897 
 
16898 
class markOrderDoaRequestAuthorized_args:
16899 
  """
16900 
  Attributes:
16901 
   - orderId
16902 
   - isAuthorized
16903 
  """
16904 
 
16905 
  thrift_spec = (
16906 
    None, # 0
16907 
    (1, TType.I64, 'orderId', None, None, ), # 1
16908 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16909 
  )
16910 
 
16911 
  def __init__(self, orderId=None, isAuthorized=None,):
16912 
    self.orderId = orderId
16913 
    self.isAuthorized = isAuthorized
16914 
 
16915 
  def read(self, iprot):
16916 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16917 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16918 
      return
16919 
    iprot.readStructBegin()
16920 
    while True:
16921 
      (fname, ftype, fid) = iprot.readFieldBegin()
16922 
      if ftype == TType.STOP:
16923 
        break
16924 
      if fid == 1:
16925 
        if ftype == TType.I64:
16926 
          self.orderId = iprot.readI64();
16927 
        else:
16928 
          iprot.skip(ftype)
16929 
      elif fid == 2:
16930 
        if ftype == TType.BOOL:
16931 
          self.isAuthorized = iprot.readBool();
16932 
        else:
16933 
          iprot.skip(ftype)
16934 
      else:
16935 
        iprot.skip(ftype)
16936 
      iprot.readFieldEnd()
16937 
    iprot.readStructEnd()
16938 
 
16939 
  def write(self, oprot):
16940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16942 
      return
16943 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16944 
    if self.orderId is not None:
16945 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16946 
      oprot.writeI64(self.orderId)
16947 
      oprot.writeFieldEnd()
16948 
    if self.isAuthorized is not None:
16949 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16950 
      oprot.writeBool(self.isAuthorized)
16951 
      oprot.writeFieldEnd()
16952 
    oprot.writeFieldStop()
16953 
    oprot.writeStructEnd()
16954 
 
16955 
  def validate(self):
16956 
    return
16957 
 
16958 
 
16959 
  def __repr__(self):
16960 
    L = ['%s=%r' % (key, value)
16961 
      for key, value in self.__dict__.iteritems()]
16962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16963 
 
16964 
  def __eq__(self, other):
16965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16966 
 
16967 
  def __ne__(self, other):
16968 
    return not (self == other)
16969 
 
16970 
class markOrderDoaRequestAuthorized_result:
16971 
  """
16972 
  Attributes:
16973 
   - success
16974 
   - ex
16975 
  """
16976 
 
16977 
  thrift_spec = (
16978 
    (0, TType.BOOL, 'success', None, None, ), # 0
16979 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16980 
  )
16981 
 
16982 
  def __init__(self, success=None, ex=None,):
16983 
    self.success = success
16984 
    self.ex = ex
16985 
 
16986 
  def read(self, iprot):
16987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16989 
      return
16990 
    iprot.readStructBegin()
16991 
    while True:
16992 
      (fname, ftype, fid) = iprot.readFieldBegin()
16993 
      if ftype == TType.STOP:
16994 
        break
16995 
      if fid == 0:
16996 
        if ftype == TType.BOOL:
16997 
          self.success = iprot.readBool();
16998 
        else:
16999 
          iprot.skip(ftype)
17000 
      elif fid == 1:
17001 
        if ftype == TType.STRUCT:
17002 
          self.ex = TransactionServiceException()
17003 
          self.ex.read(iprot)
17004 
        else:
17005 
          iprot.skip(ftype)
17006 
      else:
17007 
        iprot.skip(ftype)
17008 
      iprot.readFieldEnd()
17009 
    iprot.readStructEnd()
17010 
 
17011 
  def write(self, oprot):
17012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17014 
      return
17015 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
17016 
    if self.success is not None:
17017 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17018 
      oprot.writeBool(self.success)
17019 
      oprot.writeFieldEnd()
17020 
    if self.ex is not None:
17021 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17022 
      self.ex.write(oprot)
17023 
      oprot.writeFieldEnd()
17024 
    oprot.writeFieldStop()
17025 
    oprot.writeStructEnd()
17026 
 
17027 
  def validate(self):
17028 
    return
17029 
 
17030 
 
17031 
  def __repr__(self):
17032 
    L = ['%s=%r' % (key, value)
17033 
      for key, value in self.__dict__.iteritems()]
17034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17035 
 
17036 
  def __eq__(self, other):
17037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17038 
 
17039 
  def __ne__(self, other):
17040 
    return not (self == other)
17041 
 
4488 rajveer 17042 
class markOrderReturnRequestReceived_args:
17043 
  """
17044 
  Attributes:
17045 
   - orderId
17046 
  """
17047 
 
17048 
  thrift_spec = (
17049 
    None, # 0
17050 
    (1, TType.I64, 'orderId', None, None, ), # 1
17051 
  )
17052 
 
17053 
  def __init__(self, orderId=None,):
17054 
    self.orderId = orderId
17055 
 
17056 
  def read(self, iprot):
17057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17059 
      return
17060 
    iprot.readStructBegin()
17061 
    while True:
17062 
      (fname, ftype, fid) = iprot.readFieldBegin()
17063 
      if ftype == TType.STOP:
17064 
        break
17065 
      if fid == 1:
17066 
        if ftype == TType.I64:
17067 
          self.orderId = iprot.readI64();
17068 
        else:
17069 
          iprot.skip(ftype)
17070 
      else:
17071 
        iprot.skip(ftype)
17072 
      iprot.readFieldEnd()
17073 
    iprot.readStructEnd()
17074 
 
17075 
  def write(self, oprot):
17076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17078 
      return
17079 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
17080 
    if self.orderId is not None:
17081 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17082 
      oprot.writeI64(self.orderId)
17083 
      oprot.writeFieldEnd()
17084 
    oprot.writeFieldStop()
17085 
    oprot.writeStructEnd()
17086 
 
17087 
  def validate(self):
17088 
    return
17089 
 
17090 
 
17091 
  def __repr__(self):
17092 
    L = ['%s=%r' % (key, value)
17093 
      for key, value in self.__dict__.iteritems()]
17094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17095 
 
17096 
  def __eq__(self, other):
17097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17098 
 
17099 
  def __ne__(self, other):
17100 
    return not (self == other)
17101 
 
17102 
class markOrderReturnRequestReceived_result:
17103 
  """
17104 
  Attributes:
17105 
   - success
17106 
   - ex
17107 
  """
17108 
 
17109 
  thrift_spec = (
17110 
    (0, TType.BOOL, 'success', None, None, ), # 0
17111 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17112 
  )
17113 
 
17114 
  def __init__(self, success=None, ex=None,):
17115 
    self.success = success
17116 
    self.ex = ex
17117 
 
17118 
  def read(self, iprot):
17119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17121 
      return
17122 
    iprot.readStructBegin()
17123 
    while True:
17124 
      (fname, ftype, fid) = iprot.readFieldBegin()
17125 
      if ftype == TType.STOP:
17126 
        break
17127 
      if fid == 0:
17128 
        if ftype == TType.BOOL:
17129 
          self.success = iprot.readBool();
17130 
        else:
17131 
          iprot.skip(ftype)
17132 
      elif fid == 1:
17133 
        if ftype == TType.STRUCT:
17134 
          self.ex = TransactionServiceException()
17135 
          self.ex.read(iprot)
17136 
        else:
17137 
          iprot.skip(ftype)
17138 
      else:
17139 
        iprot.skip(ftype)
17140 
      iprot.readFieldEnd()
17141 
    iprot.readStructEnd()
17142 
 
17143 
  def write(self, oprot):
17144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17146 
      return
17147 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
17148 
    if self.success is not None:
17149 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17150 
      oprot.writeBool(self.success)
17151 
      oprot.writeFieldEnd()
17152 
    if self.ex is not None:
17153 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17154 
      self.ex.write(oprot)
17155 
      oprot.writeFieldEnd()
17156 
    oprot.writeFieldStop()
17157 
    oprot.writeStructEnd()
17158 
 
17159 
  def validate(self):
17160 
    return
17161 
 
17162 
 
17163 
  def __repr__(self):
17164 
    L = ['%s=%r' % (key, value)
17165 
      for key, value in self.__dict__.iteritems()]
17166 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17167 
 
17168 
  def __eq__(self, other):
17169 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17170 
 
17171 
  def __ne__(self, other):
17172 
    return not (self == other)
17173 
 
17174 
class markOrderReturnRequestAuthorized_args:
17175 
  """
17176 
  Attributes:
17177 
   - orderId
17178 
   - isAuthorized
17179 
  """
17180 
 
17181 
  thrift_spec = (
17182 
    None, # 0
17183 
    (1, TType.I64, 'orderId', None, None, ), # 1
17184 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17185 
  )
17186 
 
17187 
  def __init__(self, orderId=None, isAuthorized=None,):
17188 
    self.orderId = orderId
17189 
    self.isAuthorized = isAuthorized
17190 
 
17191 
  def read(self, iprot):
17192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17194 
      return
17195 
    iprot.readStructBegin()
17196 
    while True:
17197 
      (fname, ftype, fid) = iprot.readFieldBegin()
17198 
      if ftype == TType.STOP:
17199 
        break
17200 
      if fid == 1:
17201 
        if ftype == TType.I64:
17202 
          self.orderId = iprot.readI64();
17203 
        else:
17204 
          iprot.skip(ftype)
17205 
      elif fid == 2:
17206 
        if ftype == TType.BOOL:
17207 
          self.isAuthorized = iprot.readBool();
17208 
        else:
17209 
          iprot.skip(ftype)
17210 
      else:
17211 
        iprot.skip(ftype)
17212 
      iprot.readFieldEnd()
17213 
    iprot.readStructEnd()
17214 
 
17215 
  def write(self, oprot):
17216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17218 
      return
17219 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
17220 
    if self.orderId is not None:
17221 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17222 
      oprot.writeI64(self.orderId)
17223 
      oprot.writeFieldEnd()
17224 
    if self.isAuthorized is not None:
17225 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17226 
      oprot.writeBool(self.isAuthorized)
17227 
      oprot.writeFieldEnd()
17228 
    oprot.writeFieldStop()
17229 
    oprot.writeStructEnd()
17230 
 
17231 
  def validate(self):
17232 
    return
17233 
 
17234 
 
17235 
  def __repr__(self):
17236 
    L = ['%s=%r' % (key, value)
17237 
      for key, value in self.__dict__.iteritems()]
17238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17239 
 
17240 
  def __eq__(self, other):
17241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17242 
 
17243 
  def __ne__(self, other):
17244 
    return not (self == other)
17245 
 
17246 
class markOrderReturnRequestAuthorized_result:
17247 
  """
17248 
  Attributes:
17249 
   - success
17250 
   - ex
17251 
  """
17252 
 
17253 
  thrift_spec = (
17254 
    (0, TType.BOOL, 'success', None, None, ), # 0
17255 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17256 
  )
17257 
 
17258 
  def __init__(self, success=None, ex=None,):
17259 
    self.success = success
17260 
    self.ex = ex
17261 
 
17262 
  def read(self, iprot):
17263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17265 
      return
17266 
    iprot.readStructBegin()
17267 
    while True:
17268 
      (fname, ftype, fid) = iprot.readFieldBegin()
17269 
      if ftype == TType.STOP:
17270 
        break
17271 
      if fid == 0:
17272 
        if ftype == TType.BOOL:
17273 
          self.success = iprot.readBool();
17274 
        else:
17275 
          iprot.skip(ftype)
17276 
      elif fid == 1:
17277 
        if ftype == TType.STRUCT:
17278 
          self.ex = TransactionServiceException()
17279 
          self.ex.read(iprot)
17280 
        else:
17281 
          iprot.skip(ftype)
17282 
      else:
17283 
        iprot.skip(ftype)
17284 
      iprot.readFieldEnd()
17285 
    iprot.readStructEnd()
17286 
 
17287 
  def write(self, oprot):
17288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17290 
      return
17291 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
17292 
    if self.success is not None:
17293 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17294 
      oprot.writeBool(self.success)
17295 
      oprot.writeFieldEnd()
17296 
    if self.ex is not None:
17297 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17298 
      self.ex.write(oprot)
17299 
      oprot.writeFieldEnd()
17300 
    oprot.writeFieldStop()
17301 
    oprot.writeStructEnd()
17302 
 
17303 
  def validate(self):
17304 
    return
17305 
 
17306 
 
17307 
  def __repr__(self):
17308 
    L = ['%s=%r' % (key, value)
17309 
      for key, value in self.__dict__.iteritems()]
17310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17311 
 
17312 
  def __eq__(self, other):
17313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17314 
 
17315 
  def __ne__(self, other):
17316 
    return not (self == other)
17317 
 
2536 chandransh 17318 
class requestPickupNumber_args:
17319 
  """
17320 
  Attributes:
17321 
   - orderId
4579 rajveer 17322 
   - providerId
2536 chandransh 17323 
  """
17324 
 
17325 
  thrift_spec = (
17326 
    None, # 0
17327 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 17328 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 17329 
  )
17330 
 
4579 rajveer 17331 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 17332 
    self.orderId = orderId
4579 rajveer 17333 
    self.providerId = providerId
2536 chandransh 17334 
 
17335 
  def read(self, iprot):
17336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17338 
      return
17339 
    iprot.readStructBegin()
17340 
    while True:
17341 
      (fname, ftype, fid) = iprot.readFieldBegin()
17342 
      if ftype == TType.STOP:
17343 
        break
17344 
      if fid == 1:
17345 
        if ftype == TType.I64:
17346 
          self.orderId = iprot.readI64();
17347 
        else:
17348 
          iprot.skip(ftype)
4579 rajveer 17349 
      elif fid == 2:
17350 
        if ftype == TType.I64:
17351 
          self.providerId = iprot.readI64();
17352 
        else:
17353 
          iprot.skip(ftype)
2536 chandransh 17354 
      else:
17355 
        iprot.skip(ftype)
17356 
      iprot.readFieldEnd()
17357 
    iprot.readStructEnd()
17358 
 
17359 
  def write(self, oprot):
17360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17362 
      return
17363 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 17364 
    if self.orderId is not None:
2536 chandransh 17365 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17366 
      oprot.writeI64(self.orderId)
17367 
      oprot.writeFieldEnd()
4579 rajveer 17368 
    if self.providerId is not None:
17369 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
17370 
      oprot.writeI64(self.providerId)
17371 
      oprot.writeFieldEnd()
2536 chandransh 17372 
    oprot.writeFieldStop()
17373 
    oprot.writeStructEnd()
17374 
 
3431 rajveer 17375 
  def validate(self):
17376 
    return
17377 
 
17378 
 
2536 chandransh 17379 
  def __repr__(self):
17380 
    L = ['%s=%r' % (key, value)
17381 
      for key, value in self.__dict__.iteritems()]
17382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17383 
 
17384 
  def __eq__(self, other):
17385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17386 
 
17387 
  def __ne__(self, other):
17388 
    return not (self == other)
17389 
 
17390 
class requestPickupNumber_result:
17391 
  """
17392 
  Attributes:
17393 
   - success
17394 
   - ex
17395 
  """
17396 
 
17397 
  thrift_spec = (
17398 
    (0, TType.BOOL, 'success', None, None, ), # 0
17399 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17400 
  )
17401 
 
17402 
  def __init__(self, success=None, ex=None,):
17403 
    self.success = success
17404 
    self.ex = ex
17405 
 
17406 
  def read(self, iprot):
17407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17409 
      return
17410 
    iprot.readStructBegin()
17411 
    while True:
17412 
      (fname, ftype, fid) = iprot.readFieldBegin()
17413 
      if ftype == TType.STOP:
17414 
        break
17415 
      if fid == 0:
17416 
        if ftype == TType.BOOL:
17417 
          self.success = iprot.readBool();
17418 
        else:
17419 
          iprot.skip(ftype)
17420 
      elif fid == 1:
17421 
        if ftype == TType.STRUCT:
17422 
          self.ex = TransactionServiceException()
17423 
          self.ex.read(iprot)
17424 
        else:
17425 
          iprot.skip(ftype)
17426 
      else:
17427 
        iprot.skip(ftype)
17428 
      iprot.readFieldEnd()
17429 
    iprot.readStructEnd()
17430 
 
17431 
  def write(self, oprot):
17432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17434 
      return
17435 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 17436 
    if self.success is not None:
2536 chandransh 17437 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17438 
      oprot.writeBool(self.success)
17439 
      oprot.writeFieldEnd()
3431 rajveer 17440 
    if self.ex is not None:
2536 chandransh 17441 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17442 
      self.ex.write(oprot)
17443 
      oprot.writeFieldEnd()
17444 
    oprot.writeFieldStop()
17445 
    oprot.writeStructEnd()
17446 
 
3431 rajveer 17447 
  def validate(self):
17448 
    return
17449 
 
17450 
 
2536 chandransh 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 authorizePickup_args:
17463 
  """
17464 
  Attributes:
17465 
   - orderId
17466 
   - pickupNumber
4602 rajveer 17467 
   - providerId
2536 chandransh 17468 
  """
17469 
 
17470 
  thrift_spec = (
17471 
    None, # 0
17472 
    (1, TType.I64, 'orderId', None, None, ), # 1
17473 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 17474 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 17475 
  )
17476 
 
4602 rajveer 17477 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 17478 
    self.orderId = orderId
17479 
    self.pickupNumber = pickupNumber
4602 rajveer 17480 
    self.providerId = providerId
2536 chandransh 17481 
 
17482 
  def read(self, iprot):
17483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17485 
      return
17486 
    iprot.readStructBegin()
17487 
    while True:
17488 
      (fname, ftype, fid) = iprot.readFieldBegin()
17489 
      if ftype == TType.STOP:
17490 
        break
17491 
      if fid == 1:
17492 
        if ftype == TType.I64:
17493 
          self.orderId = iprot.readI64();
17494 
        else:
17495 
          iprot.skip(ftype)
17496 
      elif fid == 2:
17497 
        if ftype == TType.STRING:
17498 
          self.pickupNumber = iprot.readString();
17499 
        else:
17500 
          iprot.skip(ftype)
4602 rajveer 17501 
      elif fid == 3:
17502 
        if ftype == TType.I64:
17503 
          self.providerId = iprot.readI64();
17504 
        else:
17505 
          iprot.skip(ftype)
2536 chandransh 17506 
      else:
17507 
        iprot.skip(ftype)
17508 
      iprot.readFieldEnd()
17509 
    iprot.readStructEnd()
17510 
 
17511 
  def write(self, oprot):
17512 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17513 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17514 
      return
17515 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 17516 
    if self.orderId is not None:
2536 chandransh 17517 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17518 
      oprot.writeI64(self.orderId)
17519 
      oprot.writeFieldEnd()
3431 rajveer 17520 
    if self.pickupNumber is not None:
2536 chandransh 17521 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
17522 
      oprot.writeString(self.pickupNumber)
17523 
      oprot.writeFieldEnd()
4602 rajveer 17524 
    if self.providerId is not None:
17525 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
17526 
      oprot.writeI64(self.providerId)
17527 
      oprot.writeFieldEnd()
2536 chandransh 17528 
    oprot.writeFieldStop()
17529 
    oprot.writeStructEnd()
17530 
 
3431 rajveer 17531 
  def validate(self):
17532 
    return
17533 
 
17534 
 
2536 chandransh 17535 
  def __repr__(self):
17536 
    L = ['%s=%r' % (key, value)
17537 
      for key, value in self.__dict__.iteritems()]
17538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17539 
 
17540 
  def __eq__(self, other):
17541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17542 
 
17543 
  def __ne__(self, other):
17544 
    return not (self == other)
17545 
 
17546 
class authorizePickup_result:
17547 
  """
17548 
  Attributes:
17549 
   - success
17550 
   - ex
17551 
  """
17552 
 
17553 
  thrift_spec = (
17554 
    (0, TType.BOOL, 'success', None, None, ), # 0
17555 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17556 
  )
17557 
 
17558 
  def __init__(self, success=None, ex=None,):
17559 
    self.success = success
17560 
    self.ex = ex
17561 
 
17562 
  def read(self, iprot):
17563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17565 
      return
17566 
    iprot.readStructBegin()
17567 
    while True:
17568 
      (fname, ftype, fid) = iprot.readFieldBegin()
17569 
      if ftype == TType.STOP:
17570 
        break
17571 
      if fid == 0:
17572 
        if ftype == TType.BOOL:
17573 
          self.success = iprot.readBool();
17574 
        else:
17575 
          iprot.skip(ftype)
17576 
      elif fid == 1:
17577 
        if ftype == TType.STRUCT:
17578 
          self.ex = TransactionServiceException()
17579 
          self.ex.read(iprot)
17580 
        else:
17581 
          iprot.skip(ftype)
17582 
      else:
17583 
        iprot.skip(ftype)
17584 
      iprot.readFieldEnd()
17585 
    iprot.readStructEnd()
17586 
 
17587 
  def write(self, oprot):
17588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17590 
      return
17591 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 17592 
    if self.success is not None:
2536 chandransh 17593 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17594 
      oprot.writeBool(self.success)
17595 
      oprot.writeFieldEnd()
3431 rajveer 17596 
    if self.ex is not None:
2536 chandransh 17597 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17598 
      self.ex.write(oprot)
17599 
      oprot.writeFieldEnd()
17600 
    oprot.writeFieldStop()
17601 
    oprot.writeStructEnd()
17602 
 
3431 rajveer 17603 
  def validate(self):
17604 
    return
17605 
 
17606 
 
2536 chandransh 17607 
  def __repr__(self):
17608 
    L = ['%s=%r' % (key, value)
17609 
      for key, value in self.__dict__.iteritems()]
17610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17611 
 
17612 
  def __eq__(self, other):
17613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17614 
 
17615 
  def __ne__(self, other):
17616 
    return not (self == other)
17617 
 
2764 chandransh 17618 
class markDoasAsPickedUp_args:
17619 
  """
17620 
  Attributes:
17621 
   - providerId
17622 
   - pickupDetails
17623 
  """
17624 
 
17625 
  thrift_spec = (
17626 
    None, # 0
17627 
    (1, TType.I64, 'providerId', None, None, ), # 1
17628 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17629 
  )
17630 
 
17631 
  def __init__(self, providerId=None, pickupDetails=None,):
17632 
    self.providerId = providerId
17633 
    self.pickupDetails = pickupDetails
17634 
 
17635 
  def read(self, iprot):
17636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17638 
      return
17639 
    iprot.readStructBegin()
17640 
    while True:
17641 
      (fname, ftype, fid) = iprot.readFieldBegin()
17642 
      if ftype == TType.STOP:
17643 
        break
17644 
      if fid == 1:
17645 
        if ftype == TType.I64:
17646 
          self.providerId = iprot.readI64();
17647 
        else:
17648 
          iprot.skip(ftype)
17649 
      elif fid == 2:
17650 
        if ftype == TType.MAP:
17651 
          self.pickupDetails = {}
6188 rajveer 17652 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
17653 
          for _i411 in xrange(_size407):
17654 
            _key412 = iprot.readString();
17655 
            _val413 = iprot.readString();
17656 
            self.pickupDetails[_key412] = _val413
2764 chandransh 17657 
          iprot.readMapEnd()
17658 
        else:
17659 
          iprot.skip(ftype)
17660 
      else:
17661 
        iprot.skip(ftype)
17662 
      iprot.readFieldEnd()
17663 
    iprot.readStructEnd()
17664 
 
17665 
  def write(self, oprot):
17666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17668 
      return
17669 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 17670 
    if self.providerId is not None:
2764 chandransh 17671 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17672 
      oprot.writeI64(self.providerId)
17673 
      oprot.writeFieldEnd()
3431 rajveer 17674 
    if self.pickupDetails is not None:
2764 chandransh 17675 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17676 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17677 
      for kiter414,viter415 in self.pickupDetails.items():
17678 
        oprot.writeString(kiter414)
17679 
        oprot.writeString(viter415)
2764 chandransh 17680 
      oprot.writeMapEnd()
17681 
      oprot.writeFieldEnd()
17682 
    oprot.writeFieldStop()
17683 
    oprot.writeStructEnd()
17684 
 
3431 rajveer 17685 
  def validate(self):
17686 
    return
17687 
 
17688 
 
2764 chandransh 17689 
  def __repr__(self):
17690 
    L = ['%s=%r' % (key, value)
17691 
      for key, value in self.__dict__.iteritems()]
17692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17693 
 
17694 
  def __eq__(self, other):
17695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17696 
 
17697 
  def __ne__(self, other):
17698 
    return not (self == other)
17699 
 
17700 
class markDoasAsPickedUp_result:
4910 phani.kuma 17701 
 
17702 
  thrift_spec = (
17703 
  )
17704 
 
17705 
  def read(self, iprot):
17706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17708 
      return
17709 
    iprot.readStructBegin()
17710 
    while True:
17711 
      (fname, ftype, fid) = iprot.readFieldBegin()
17712 
      if ftype == TType.STOP:
17713 
        break
17714 
      else:
17715 
        iprot.skip(ftype)
17716 
      iprot.readFieldEnd()
17717 
    iprot.readStructEnd()
17718 
 
17719 
  def write(self, oprot):
17720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17722 
      return
17723 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
17724 
    oprot.writeFieldStop()
17725 
    oprot.writeStructEnd()
17726 
 
17727 
  def validate(self):
17728 
    return
17729 
 
17730 
 
17731 
  def __repr__(self):
17732 
    L = ['%s=%r' % (key, value)
17733 
      for key, value in self.__dict__.iteritems()]
17734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17735 
 
17736 
  def __eq__(self, other):
17737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17738 
 
17739 
  def __ne__(self, other):
17740 
    return not (self == other)
17741 
 
17742 
class getDoasNotPickedUp_args:
2764 chandransh 17743 
  """
17744 
  Attributes:
4910 phani.kuma 17745 
   - providerId
17746 
  """
17747 
 
17748 
  thrift_spec = (
17749 
    None, # 0
17750 
    (1, TType.I64, 'providerId', None, None, ), # 1
17751 
  )
17752 
 
17753 
  def __init__(self, providerId=None,):
17754 
    self.providerId = providerId
17755 
 
17756 
  def read(self, iprot):
17757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17759 
      return
17760 
    iprot.readStructBegin()
17761 
    while True:
17762 
      (fname, ftype, fid) = iprot.readFieldBegin()
17763 
      if ftype == TType.STOP:
17764 
        break
17765 
      if fid == 1:
17766 
        if ftype == TType.I64:
17767 
          self.providerId = iprot.readI64();
17768 
        else:
17769 
          iprot.skip(ftype)
17770 
      else:
17771 
        iprot.skip(ftype)
17772 
      iprot.readFieldEnd()
17773 
    iprot.readStructEnd()
17774 
 
17775 
  def write(self, oprot):
17776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17778 
      return
17779 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17780 
    if self.providerId is not None:
17781 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17782 
      oprot.writeI64(self.providerId)
17783 
      oprot.writeFieldEnd()
17784 
    oprot.writeFieldStop()
17785 
    oprot.writeStructEnd()
17786 
 
17787 
  def validate(self):
17788 
    return
17789 
 
17790 
 
17791 
  def __repr__(self):
17792 
    L = ['%s=%r' % (key, value)
17793 
      for key, value in self.__dict__.iteritems()]
17794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17795 
 
17796 
  def __eq__(self, other):
17797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17798 
 
17799 
  def __ne__(self, other):
17800 
    return not (self == other)
17801 
 
17802 
class getDoasNotPickedUp_result:
17803 
  """
17804 
  Attributes:
2764 chandransh 17805 
   - success
17806 
  """
17807 
 
17808 
  thrift_spec = (
17809 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17810 
  )
17811 
 
17812 
  def __init__(self, success=None,):
17813 
    self.success = success
17814 
 
17815 
  def read(self, iprot):
17816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17818 
      return
17819 
    iprot.readStructBegin()
17820 
    while True:
17821 
      (fname, ftype, fid) = iprot.readFieldBegin()
17822 
      if ftype == TType.STOP:
17823 
        break
17824 
      if fid == 0:
17825 
        if ftype == TType.LIST:
17826 
          self.success = []
6188 rajveer 17827 
          (_etype419, _size416) = iprot.readListBegin()
17828 
          for _i420 in xrange(_size416):
17829 
            _elem421 = Order()
17830 
            _elem421.read(iprot)
17831 
            self.success.append(_elem421)
2764 chandransh 17832 
          iprot.readListEnd()
17833 
        else:
17834 
          iprot.skip(ftype)
17835 
      else:
17836 
        iprot.skip(ftype)
17837 
      iprot.readFieldEnd()
17838 
    iprot.readStructEnd()
17839 
 
17840 
  def write(self, oprot):
17841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17843 
      return
4910 phani.kuma 17844 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 17845 
    if self.success is not None:
2764 chandransh 17846 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17847 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17848 
      for iter422 in self.success:
17849 
        iter422.write(oprot)
2764 chandransh 17850 
      oprot.writeListEnd()
17851 
      oprot.writeFieldEnd()
17852 
    oprot.writeFieldStop()
17853 
    oprot.writeStructEnd()
17854 
 
3431 rajveer 17855 
  def validate(self):
17856 
    return
17857 
 
17858 
 
2764 chandransh 17859 
  def __repr__(self):
17860 
    L = ['%s=%r' % (key, value)
17861 
      for key, value in self.__dict__.iteritems()]
17862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17863 
 
17864 
  def __eq__(self, other):
17865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17866 
 
17867 
  def __ne__(self, other):
17868 
    return not (self == other)
17869 
 
4741 phani.kuma 17870 
class markReturnOrdersAsPickedUp_args:
17871 
  """
17872 
  Attributes:
17873 
   - providerId
17874 
   - pickupDetails
17875 
  """
17876 
 
17877 
  thrift_spec = (
17878 
    None, # 0
17879 
    (1, TType.I64, 'providerId', None, None, ), # 1
17880 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17881 
  )
17882 
 
17883 
  def __init__(self, providerId=None, pickupDetails=None,):
17884 
    self.providerId = providerId
17885 
    self.pickupDetails = pickupDetails
17886 
 
17887 
  def read(self, iprot):
17888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17890 
      return
17891 
    iprot.readStructBegin()
17892 
    while True:
17893 
      (fname, ftype, fid) = iprot.readFieldBegin()
17894 
      if ftype == TType.STOP:
17895 
        break
17896 
      if fid == 1:
17897 
        if ftype == TType.I64:
17898 
          self.providerId = iprot.readI64();
17899 
        else:
17900 
          iprot.skip(ftype)
17901 
      elif fid == 2:
17902 
        if ftype == TType.MAP:
17903 
          self.pickupDetails = {}
6188 rajveer 17904 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
17905 
          for _i427 in xrange(_size423):
17906 
            _key428 = iprot.readString();
17907 
            _val429 = iprot.readString();
17908 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 17909 
          iprot.readMapEnd()
17910 
        else:
17911 
          iprot.skip(ftype)
17912 
      else:
17913 
        iprot.skip(ftype)
17914 
      iprot.readFieldEnd()
17915 
    iprot.readStructEnd()
17916 
 
17917 
  def write(self, oprot):
17918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17920 
      return
17921 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
17922 
    if self.providerId is not None:
17923 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17924 
      oprot.writeI64(self.providerId)
17925 
      oprot.writeFieldEnd()
17926 
    if self.pickupDetails is not None:
17927 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17928 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17929 
      for kiter430,viter431 in self.pickupDetails.items():
17930 
        oprot.writeString(kiter430)
17931 
        oprot.writeString(viter431)
4741 phani.kuma 17932 
      oprot.writeMapEnd()
17933 
      oprot.writeFieldEnd()
17934 
    oprot.writeFieldStop()
17935 
    oprot.writeStructEnd()
17936 
 
17937 
  def validate(self):
17938 
    return
17939 
 
17940 
 
17941 
  def __repr__(self):
17942 
    L = ['%s=%r' % (key, value)
17943 
      for key, value in self.__dict__.iteritems()]
17944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17945 
 
17946 
  def __eq__(self, other):
17947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17948 
 
17949 
  def __ne__(self, other):
17950 
    return not (self == other)
17951 
 
17952 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 17953 
 
17954 
  thrift_spec = (
17955 
  )
17956 
 
17957 
  def read(self, iprot):
17958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17960 
      return
17961 
    iprot.readStructBegin()
17962 
    while True:
17963 
      (fname, ftype, fid) = iprot.readFieldBegin()
17964 
      if ftype == TType.STOP:
17965 
        break
17966 
      else:
17967 
        iprot.skip(ftype)
17968 
      iprot.readFieldEnd()
17969 
    iprot.readStructEnd()
17970 
 
17971 
  def write(self, oprot):
17972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17974 
      return
17975 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
17976 
    oprot.writeFieldStop()
17977 
    oprot.writeStructEnd()
17978 
 
17979 
  def validate(self):
17980 
    return
17981 
 
17982 
 
17983 
  def __repr__(self):
17984 
    L = ['%s=%r' % (key, value)
17985 
      for key, value in self.__dict__.iteritems()]
17986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17987 
 
17988 
  def __eq__(self, other):
17989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17990 
 
17991 
  def __ne__(self, other):
17992 
    return not (self == other)
17993 
 
17994 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 17995 
  """
17996 
  Attributes:
4910 phani.kuma 17997 
   - providerId
17998 
  """
17999 
 
18000 
  thrift_spec = (
18001 
    None, # 0
18002 
    (1, TType.I64, 'providerId', None, None, ), # 1
18003 
  )
18004 
 
18005 
  def __init__(self, providerId=None,):
18006 
    self.providerId = providerId
18007 
 
18008 
  def read(self, iprot):
18009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18011 
      return
18012 
    iprot.readStructBegin()
18013 
    while True:
18014 
      (fname, ftype, fid) = iprot.readFieldBegin()
18015 
      if ftype == TType.STOP:
18016 
        break
18017 
      if fid == 1:
18018 
        if ftype == TType.I64:
18019 
          self.providerId = iprot.readI64();
18020 
        else:
18021 
          iprot.skip(ftype)
18022 
      else:
18023 
        iprot.skip(ftype)
18024 
      iprot.readFieldEnd()
18025 
    iprot.readStructEnd()
18026 
 
18027 
  def write(self, oprot):
18028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18030 
      return
18031 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
18032 
    if self.providerId is not None:
18033 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
18034 
      oprot.writeI64(self.providerId)
18035 
      oprot.writeFieldEnd()
18036 
    oprot.writeFieldStop()
18037 
    oprot.writeStructEnd()
18038 
 
18039 
  def validate(self):
18040 
    return
18041 
 
18042 
 
18043 
  def __repr__(self):
18044 
    L = ['%s=%r' % (key, value)
18045 
      for key, value in self.__dict__.iteritems()]
18046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18047 
 
18048 
  def __eq__(self, other):
18049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18050 
 
18051 
  def __ne__(self, other):
18052 
    return not (self == other)
18053 
 
18054 
class getReturnOrdersNotPickedUp_result:
18055 
  """
18056 
  Attributes:
4741 phani.kuma 18057 
   - success
18058 
  """
18059 
 
18060 
  thrift_spec = (
18061 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
18062 
  )
18063 
 
18064 
  def __init__(self, success=None,):
18065 
    self.success = success
18066 
 
18067 
  def read(self, iprot):
18068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18070 
      return
18071 
    iprot.readStructBegin()
18072 
    while True:
18073 
      (fname, ftype, fid) = iprot.readFieldBegin()
18074 
      if ftype == TType.STOP:
18075 
        break
18076 
      if fid == 0:
18077 
        if ftype == TType.LIST:
18078 
          self.success = []
6188 rajveer 18079 
          (_etype435, _size432) = iprot.readListBegin()
18080 
          for _i436 in xrange(_size432):
18081 
            _elem437 = Order()
18082 
            _elem437.read(iprot)
18083 
            self.success.append(_elem437)
4741 phani.kuma 18084 
          iprot.readListEnd()
18085 
        else:
18086 
          iprot.skip(ftype)
18087 
      else:
18088 
        iprot.skip(ftype)
18089 
      iprot.readFieldEnd()
18090 
    iprot.readStructEnd()
18091 
 
18092 
  def write(self, oprot):
18093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18095 
      return
4910 phani.kuma 18096 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 18097 
    if self.success is not None:
18098 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18099 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18100 
      for iter438 in self.success:
18101 
        iter438.write(oprot)
4741 phani.kuma 18102 
      oprot.writeListEnd()
18103 
      oprot.writeFieldEnd()
18104 
    oprot.writeFieldStop()
18105 
    oprot.writeStructEnd()
18106 
 
18107 
  def validate(self):
18108 
    return
18109 
 
18110 
 
18111 
  def __repr__(self):
18112 
    L = ['%s=%r' % (key, value)
18113 
      for key, value in self.__dict__.iteritems()]
18114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18115 
 
18116 
  def __eq__(self, other):
18117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18118 
 
18119 
  def __ne__(self, other):
18120 
    return not (self == other)
18121 
 
2616 chandransh 18122 
class receiveReturn_args:
2591 chandransh 18123 
  """
18124 
  Attributes:
18125 
   - orderId
4479 rajveer 18126 
   - receiveCondition
2591 chandransh 18127 
  """
2536 chandransh 18128 
 
2591 chandransh 18129 
  thrift_spec = (
18130 
    None, # 0
18131 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 18132 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 18133 
  )
18134 
 
4479 rajveer 18135 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 18136 
    self.orderId = orderId
4479 rajveer 18137 
    self.receiveCondition = receiveCondition
2591 chandransh 18138 
 
18139 
  def read(self, iprot):
18140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18142 
      return
18143 
    iprot.readStructBegin()
18144 
    while True:
18145 
      (fname, ftype, fid) = iprot.readFieldBegin()
18146 
      if ftype == TType.STOP:
18147 
        break
18148 
      if fid == 1:
18149 
        if ftype == TType.I64:
18150 
          self.orderId = iprot.readI64();
18151 
        else:
18152 
          iprot.skip(ftype)
4479 rajveer 18153 
      elif fid == 2:
18154 
        if ftype == TType.I64:
18155 
          self.receiveCondition = iprot.readI64();
18156 
        else:
18157 
          iprot.skip(ftype)
2591 chandransh 18158 
      else:
18159 
        iprot.skip(ftype)
18160 
      iprot.readFieldEnd()
18161 
    iprot.readStructEnd()
18162 
 
18163 
  def write(self, oprot):
18164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18166 
      return
2616 chandransh 18167 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 18168 
    if self.orderId is not None:
2591 chandransh 18169 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18170 
      oprot.writeI64(self.orderId)
18171 
      oprot.writeFieldEnd()
4479 rajveer 18172 
    if self.receiveCondition is not None:
18173 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
18174 
      oprot.writeI64(self.receiveCondition)
18175 
      oprot.writeFieldEnd()
2591 chandransh 18176 
    oprot.writeFieldStop()
18177 
    oprot.writeStructEnd()
18178 
 
3431 rajveer 18179 
  def validate(self):
18180 
    return
18181 
 
18182 
 
2591 chandransh 18183 
  def __repr__(self):
18184 
    L = ['%s=%r' % (key, value)
18185 
      for key, value in self.__dict__.iteritems()]
18186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18187 
 
18188 
  def __eq__(self, other):
18189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18190 
 
18191 
  def __ne__(self, other):
18192 
    return not (self == other)
18193 
 
2616 chandransh 18194 
class receiveReturn_result:
2591 chandransh 18195 
  """
18196 
  Attributes:
18197 
   - success
18198 
   - ex
18199 
  """
18200 
 
18201 
  thrift_spec = (
18202 
    (0, TType.BOOL, 'success', None, None, ), # 0
18203 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18204 
  )
18205 
 
18206 
  def __init__(self, success=None, ex=None,):
18207 
    self.success = success
18208 
    self.ex = ex
18209 
 
18210 
  def read(self, iprot):
18211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18213 
      return
18214 
    iprot.readStructBegin()
18215 
    while True:
18216 
      (fname, ftype, fid) = iprot.readFieldBegin()
18217 
      if ftype == TType.STOP:
18218 
        break
18219 
      if fid == 0:
18220 
        if ftype == TType.BOOL:
18221 
          self.success = iprot.readBool();
18222 
        else:
18223 
          iprot.skip(ftype)
18224 
      elif fid == 1:
18225 
        if ftype == TType.STRUCT:
18226 
          self.ex = TransactionServiceException()
18227 
          self.ex.read(iprot)
18228 
        else:
18229 
          iprot.skip(ftype)
18230 
      else:
18231 
        iprot.skip(ftype)
18232 
      iprot.readFieldEnd()
18233 
    iprot.readStructEnd()
18234 
 
18235 
  def write(self, oprot):
18236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18238 
      return
2616 chandransh 18239 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 18240 
    if self.success is not None:
2591 chandransh 18241 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18242 
      oprot.writeBool(self.success)
18243 
      oprot.writeFieldEnd()
3431 rajveer 18244 
    if self.ex is not None:
2591 chandransh 18245 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18246 
      self.ex.write(oprot)
18247 
      oprot.writeFieldEnd()
18248 
    oprot.writeFieldStop()
18249 
    oprot.writeStructEnd()
18250 
 
3431 rajveer 18251 
  def validate(self):
18252 
    return
18253 
 
18254 
 
2591 chandransh 18255 
  def __repr__(self):
18256 
    L = ['%s=%r' % (key, value)
18257 
      for key, value in self.__dict__.iteritems()]
18258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18259 
 
18260 
  def __eq__(self, other):
18261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18262 
 
18263 
  def __ne__(self, other):
18264 
    return not (self == other)
18265 
 
18266 
class validateDoa_args:
18267 
  """
18268 
  Attributes:
18269 
   - orderId
18270 
   - isValid
18271 
  """
18272 
 
18273 
  thrift_spec = (
18274 
    None, # 0
18275 
    (1, TType.I64, 'orderId', None, None, ), # 1
18276 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
18277 
  )
18278 
 
18279 
  def __init__(self, orderId=None, isValid=None,):
18280 
    self.orderId = orderId
18281 
    self.isValid = isValid
18282 
 
18283 
  def read(self, iprot):
18284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18286 
      return
18287 
    iprot.readStructBegin()
18288 
    while True:
18289 
      (fname, ftype, fid) = iprot.readFieldBegin()
18290 
      if ftype == TType.STOP:
18291 
        break
18292 
      if fid == 1:
18293 
        if ftype == TType.I64:
18294 
          self.orderId = iprot.readI64();
18295 
        else:
18296 
          iprot.skip(ftype)
18297 
      elif fid == 2:
18298 
        if ftype == TType.BOOL:
18299 
          self.isValid = iprot.readBool();
18300 
        else:
18301 
          iprot.skip(ftype)
18302 
      else:
18303 
        iprot.skip(ftype)
18304 
      iprot.readFieldEnd()
18305 
    iprot.readStructEnd()
18306 
 
18307 
  def write(self, oprot):
18308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18310 
      return
18311 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 18312 
    if self.orderId is not None:
2591 chandransh 18313 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18314 
      oprot.writeI64(self.orderId)
18315 
      oprot.writeFieldEnd()
3431 rajveer 18316 
    if self.isValid is not None:
2591 chandransh 18317 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
18318 
      oprot.writeBool(self.isValid)
18319 
      oprot.writeFieldEnd()
18320 
    oprot.writeFieldStop()
18321 
    oprot.writeStructEnd()
18322 
 
3431 rajveer 18323 
  def validate(self):
18324 
    return
18325 
 
18326 
 
2591 chandransh 18327 
  def __repr__(self):
18328 
    L = ['%s=%r' % (key, value)
18329 
      for key, value in self.__dict__.iteritems()]
18330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18331 
 
18332 
  def __eq__(self, other):
18333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18334 
 
18335 
  def __ne__(self, other):
18336 
    return not (self == other)
18337 
 
18338 
class validateDoa_result:
18339 
  """
18340 
  Attributes:
18341 
   - success
18342 
   - ex
18343 
  """
18344 
 
18345 
  thrift_spec = (
18346 
    (0, TType.BOOL, 'success', None, None, ), # 0
18347 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18348 
  )
18349 
 
18350 
  def __init__(self, success=None, ex=None,):
18351 
    self.success = success
18352 
    self.ex = ex
18353 
 
18354 
  def read(self, iprot):
18355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18357 
      return
18358 
    iprot.readStructBegin()
18359 
    while True:
18360 
      (fname, ftype, fid) = iprot.readFieldBegin()
18361 
      if ftype == TType.STOP:
18362 
        break
18363 
      if fid == 0:
18364 
        if ftype == TType.BOOL:
18365 
          self.success = iprot.readBool();
18366 
        else:
18367 
          iprot.skip(ftype)
18368 
      elif fid == 1:
18369 
        if ftype == TType.STRUCT:
18370 
          self.ex = TransactionServiceException()
18371 
          self.ex.read(iprot)
18372 
        else:
18373 
          iprot.skip(ftype)
18374 
      else:
18375 
        iprot.skip(ftype)
18376 
      iprot.readFieldEnd()
18377 
    iprot.readStructEnd()
18378 
 
18379 
  def write(self, oprot):
18380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18382 
      return
18383 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 18384 
    if self.success is not None:
2591 chandransh 18385 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18386 
      oprot.writeBool(self.success)
18387 
      oprot.writeFieldEnd()
3431 rajveer 18388 
    if self.ex is not None:
2591 chandransh 18389 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18390 
      self.ex.write(oprot)
18391 
      oprot.writeFieldEnd()
18392 
    oprot.writeFieldStop()
18393 
    oprot.writeStructEnd()
18394 
 
3431 rajveer 18395 
  def validate(self):
18396 
    return
18397 
 
18398 
 
2591 chandransh 18399 
  def __repr__(self):
18400 
    L = ['%s=%r' % (key, value)
18401 
      for key, value in self.__dict__.iteritems()]
18402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18403 
 
18404 
  def __eq__(self, other):
18405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18406 
 
18407 
  def __ne__(self, other):
18408 
    return not (self == other)
18409 
 
4495 rajveer 18410 
class validateReturnProduct_args:
18411 
  """
18412 
  Attributes:
18413 
   - orderId
18414 
   - isUsable
18415 
  """
18416 
 
18417 
  thrift_spec = (
18418 
    None, # 0
18419 
    (1, TType.I64, 'orderId', None, None, ), # 1
18420 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
18421 
  )
18422 
 
18423 
  def __init__(self, orderId=None, isUsable=None,):
18424 
    self.orderId = orderId
18425 
    self.isUsable = isUsable
18426 
 
18427 
  def read(self, iprot):
18428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18430 
      return
18431 
    iprot.readStructBegin()
18432 
    while True:
18433 
      (fname, ftype, fid) = iprot.readFieldBegin()
18434 
      if ftype == TType.STOP:
18435 
        break
18436 
      if fid == 1:
18437 
        if ftype == TType.I64:
18438 
          self.orderId = iprot.readI64();
18439 
        else:
18440 
          iprot.skip(ftype)
18441 
      elif fid == 2:
18442 
        if ftype == TType.BOOL:
18443 
          self.isUsable = iprot.readBool();
18444 
        else:
18445 
          iprot.skip(ftype)
18446 
      else:
18447 
        iprot.skip(ftype)
18448 
      iprot.readFieldEnd()
18449 
    iprot.readStructEnd()
18450 
 
18451 
  def write(self, oprot):
18452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18454 
      return
18455 
    oprot.writeStructBegin('validateReturnProduct_args')
18456 
    if self.orderId is not None:
18457 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18458 
      oprot.writeI64(self.orderId)
18459 
      oprot.writeFieldEnd()
18460 
    if self.isUsable is not None:
18461 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
18462 
      oprot.writeBool(self.isUsable)
18463 
      oprot.writeFieldEnd()
18464 
    oprot.writeFieldStop()
18465 
    oprot.writeStructEnd()
18466 
 
18467 
  def validate(self):
18468 
    return
18469 
 
18470 
 
18471 
  def __repr__(self):
18472 
    L = ['%s=%r' % (key, value)
18473 
      for key, value in self.__dict__.iteritems()]
18474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18475 
 
18476 
  def __eq__(self, other):
18477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18478 
 
18479 
  def __ne__(self, other):
18480 
    return not (self == other)
18481 
 
18482 
class validateReturnProduct_result:
18483 
  """
18484 
  Attributes:
18485 
   - success
18486 
   - ex
18487 
  """
18488 
 
18489 
  thrift_spec = (
18490 
    (0, TType.BOOL, 'success', None, None, ), # 0
18491 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18492 
  )
18493 
 
18494 
  def __init__(self, success=None, ex=None,):
18495 
    self.success = success
18496 
    self.ex = ex
18497 
 
18498 
  def read(self, iprot):
18499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18501 
      return
18502 
    iprot.readStructBegin()
18503 
    while True:
18504 
      (fname, ftype, fid) = iprot.readFieldBegin()
18505 
      if ftype == TType.STOP:
18506 
        break
18507 
      if fid == 0:
18508 
        if ftype == TType.BOOL:
18509 
          self.success = iprot.readBool();
18510 
        else:
18511 
          iprot.skip(ftype)
18512 
      elif fid == 1:
18513 
        if ftype == TType.STRUCT:
18514 
          self.ex = TransactionServiceException()
18515 
          self.ex.read(iprot)
18516 
        else:
18517 
          iprot.skip(ftype)
18518 
      else:
18519 
        iprot.skip(ftype)
18520 
      iprot.readFieldEnd()
18521 
    iprot.readStructEnd()
18522 
 
18523 
  def write(self, oprot):
18524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18526 
      return
18527 
    oprot.writeStructBegin('validateReturnProduct_result')
18528 
    if self.success is not None:
18529 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18530 
      oprot.writeBool(self.success)
18531 
      oprot.writeFieldEnd()
18532 
    if self.ex is not None:
18533 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18534 
      self.ex.write(oprot)
18535 
      oprot.writeFieldEnd()
18536 
    oprot.writeFieldStop()
18537 
    oprot.writeStructEnd()
18538 
 
18539 
  def validate(self):
18540 
    return
18541 
 
18542 
 
18543 
  def __repr__(self):
18544 
    L = ['%s=%r' % (key, value)
18545 
      for key, value in self.__dict__.iteritems()]
18546 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18547 
 
18548 
  def __eq__(self, other):
18549 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18550 
 
18551 
  def __ne__(self, other):
18552 
    return not (self == other)
18553 
 
2616 chandransh 18554 
class reshipOrder_args:
18555 
  """
18556 
  Attributes:
18557 
   - orderId
18558 
  """
2591 chandransh 18559 
 
2616 chandransh 18560 
  thrift_spec = (
18561 
    None, # 0
18562 
    (1, TType.I64, 'orderId', None, None, ), # 1
18563 
  )
18564 
 
18565 
  def __init__(self, orderId=None,):
18566 
    self.orderId = orderId
18567 
 
18568 
  def read(self, iprot):
18569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18571 
      return
18572 
    iprot.readStructBegin()
18573 
    while True:
18574 
      (fname, ftype, fid) = iprot.readFieldBegin()
18575 
      if ftype == TType.STOP:
18576 
        break
18577 
      if fid == 1:
18578 
        if ftype == TType.I64:
18579 
          self.orderId = iprot.readI64();
18580 
        else:
18581 
          iprot.skip(ftype)
18582 
      else:
18583 
        iprot.skip(ftype)
18584 
      iprot.readFieldEnd()
18585 
    iprot.readStructEnd()
18586 
 
18587 
  def write(self, oprot):
18588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18590 
      return
18591 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 18592 
    if self.orderId is not None:
2616 chandransh 18593 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18594 
      oprot.writeI64(self.orderId)
18595 
      oprot.writeFieldEnd()
18596 
    oprot.writeFieldStop()
18597 
    oprot.writeStructEnd()
18598 
 
3431 rajveer 18599 
  def validate(self):
18600 
    return
18601 
 
18602 
 
2616 chandransh 18603 
  def __repr__(self):
18604 
    L = ['%s=%r' % (key, value)
18605 
      for key, value in self.__dict__.iteritems()]
18606 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18607 
 
18608 
  def __eq__(self, other):
18609 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18610 
 
18611 
  def __ne__(self, other):
18612 
    return not (self == other)
18613 
 
18614 
class reshipOrder_result:
18615 
  """
18616 
  Attributes:
18617 
   - success
18618 
   - ex
18619 
  """
18620 
 
18621 
  thrift_spec = (
18622 
    (0, TType.I64, 'success', None, None, ), # 0
18623 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18624 
  )
18625 
 
18626 
  def __init__(self, success=None, ex=None,):
18627 
    self.success = success
18628 
    self.ex = ex
18629 
 
18630 
  def read(self, iprot):
18631 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18632 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18633 
      return
18634 
    iprot.readStructBegin()
18635 
    while True:
18636 
      (fname, ftype, fid) = iprot.readFieldBegin()
18637 
      if ftype == TType.STOP:
18638 
        break
18639 
      if fid == 0:
18640 
        if ftype == TType.I64:
18641 
          self.success = iprot.readI64();
18642 
        else:
18643 
          iprot.skip(ftype)
18644 
      elif fid == 1:
18645 
        if ftype == TType.STRUCT:
18646 
          self.ex = TransactionServiceException()
18647 
          self.ex.read(iprot)
18648 
        else:
18649 
          iprot.skip(ftype)
18650 
      else:
18651 
        iprot.skip(ftype)
18652 
      iprot.readFieldEnd()
18653 
    iprot.readStructEnd()
18654 
 
18655 
  def write(self, oprot):
18656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18658 
      return
18659 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 18660 
    if self.success is not None:
2616 chandransh 18661 
      oprot.writeFieldBegin('success', TType.I64, 0)
18662 
      oprot.writeI64(self.success)
18663 
      oprot.writeFieldEnd()
3431 rajveer 18664 
    if self.ex is not None:
2616 chandransh 18665 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18666 
      self.ex.write(oprot)
18667 
      oprot.writeFieldEnd()
18668 
    oprot.writeFieldStop()
18669 
    oprot.writeStructEnd()
18670 
 
3431 rajveer 18671 
  def validate(self):
18672 
    return
18673 
 
18674 
 
2616 chandransh 18675 
  def __repr__(self):
18676 
    L = ['%s=%r' % (key, value)
18677 
      for key, value in self.__dict__.iteritems()]
18678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18679 
 
18680 
  def __eq__(self, other):
18681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18682 
 
18683 
  def __ne__(self, other):
18684 
    return not (self == other)
18685 
 
18686 
class refundOrder_args:
18687 
  """
18688 
  Attributes:
18689 
   - orderId
3226 chandransh 18690 
   - refundedBy
18691 
   - reason
2616 chandransh 18692 
  """
18693 
 
18694 
  thrift_spec = (
18695 
    None, # 0
18696 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 18697 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18698 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 18699 
  )
18700 
 
3226 chandransh 18701 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 18702 
    self.orderId = orderId
3226 chandransh 18703 
    self.refundedBy = refundedBy
18704 
    self.reason = reason
2616 chandransh 18705 
 
18706 
  def read(self, iprot):
18707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18709 
      return
18710 
    iprot.readStructBegin()
18711 
    while True:
18712 
      (fname, ftype, fid) = iprot.readFieldBegin()
18713 
      if ftype == TType.STOP:
18714 
        break
18715 
      if fid == 1:
18716 
        if ftype == TType.I64:
18717 
          self.orderId = iprot.readI64();
18718 
        else:
18719 
          iprot.skip(ftype)
3226 chandransh 18720 
      elif fid == 2:
18721 
        if ftype == TType.STRING:
18722 
          self.refundedBy = iprot.readString();
18723 
        else:
18724 
          iprot.skip(ftype)
18725 
      elif fid == 3:
18726 
        if ftype == TType.STRING:
18727 
          self.reason = iprot.readString();
18728 
        else:
18729 
          iprot.skip(ftype)
2616 chandransh 18730 
      else:
18731 
        iprot.skip(ftype)
18732 
      iprot.readFieldEnd()
18733 
    iprot.readStructEnd()
18734 
 
18735 
  def write(self, oprot):
18736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18738 
      return
18739 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 18740 
    if self.orderId is not None:
2616 chandransh 18741 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18742 
      oprot.writeI64(self.orderId)
18743 
      oprot.writeFieldEnd()
3431 rajveer 18744 
    if self.refundedBy is not None:
3226 chandransh 18745 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18746 
      oprot.writeString(self.refundedBy)
18747 
      oprot.writeFieldEnd()
3431 rajveer 18748 
    if self.reason is not None:
3226 chandransh 18749 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18750 
      oprot.writeString(self.reason)
18751 
      oprot.writeFieldEnd()
2616 chandransh 18752 
    oprot.writeFieldStop()
18753 
    oprot.writeStructEnd()
18754 
 
3431 rajveer 18755 
  def validate(self):
18756 
    return
18757 
 
18758 
 
2616 chandransh 18759 
  def __repr__(self):
18760 
    L = ['%s=%r' % (key, value)
18761 
      for key, value in self.__dict__.iteritems()]
18762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18763 
 
18764 
  def __eq__(self, other):
18765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18766 
 
18767 
  def __ne__(self, other):
18768 
    return not (self == other)
18769 
 
18770 
class refundOrder_result:
18771 
  """
18772 
  Attributes:
18773 
   - success
18774 
   - ex
18775 
  """
18776 
 
18777 
  thrift_spec = (
18778 
    (0, TType.BOOL, 'success', None, None, ), # 0
18779 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18780 
  )
18781 
 
18782 
  def __init__(self, success=None, ex=None,):
18783 
    self.success = success
18784 
    self.ex = ex
18785 
 
18786 
  def read(self, iprot):
18787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18789 
      return
18790 
    iprot.readStructBegin()
18791 
    while True:
18792 
      (fname, ftype, fid) = iprot.readFieldBegin()
18793 
      if ftype == TType.STOP:
18794 
        break
18795 
      if fid == 0:
18796 
        if ftype == TType.BOOL:
18797 
          self.success = iprot.readBool();
18798 
        else:
18799 
          iprot.skip(ftype)
18800 
      elif fid == 1:
18801 
        if ftype == TType.STRUCT:
18802 
          self.ex = TransactionServiceException()
18803 
          self.ex.read(iprot)
18804 
        else:
18805 
          iprot.skip(ftype)
18806 
      else:
18807 
        iprot.skip(ftype)
18808 
      iprot.readFieldEnd()
18809 
    iprot.readStructEnd()
18810 
 
18811 
  def write(self, oprot):
18812 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18813 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18814 
      return
18815 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 18816 
    if self.success is not None:
2616 chandransh 18817 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18818 
      oprot.writeBool(self.success)
18819 
      oprot.writeFieldEnd()
3431 rajveer 18820 
    if self.ex is not None:
2616 chandransh 18821 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18822 
      self.ex.write(oprot)
18823 
      oprot.writeFieldEnd()
18824 
    oprot.writeFieldStop()
18825 
    oprot.writeStructEnd()
18826 
 
3431 rajveer 18827 
  def validate(self):
18828 
    return
18829 
 
18830 
 
2616 chandransh 18831 
  def __repr__(self):
18832 
    L = ['%s=%r' % (key, value)
18833 
      for key, value in self.__dict__.iteritems()]
18834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18835 
 
18836 
  def __eq__(self, other):
18837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18838 
 
18839 
  def __ne__(self, other):
18840 
    return not (self == other)
18841 
 
2690 chandransh 18842 
class getReturnOrders_args:
18843 
  """
18844 
  Attributes:
18845 
   - warehouseId
18846 
   - fromDate
18847 
   - toDate
18848 
  """
2616 chandransh 18849 
 
2690 chandransh 18850 
  thrift_spec = (
18851 
    None, # 0
18852 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
18853 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18854 
    (3, TType.I64, 'toDate', None, None, ), # 3
18855 
  )
18856 
 
18857 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
18858 
    self.warehouseId = warehouseId
18859 
    self.fromDate = fromDate
18860 
    self.toDate = toDate
18861 
 
18862 
  def read(self, iprot):
18863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18865 
      return
18866 
    iprot.readStructBegin()
18867 
    while True:
18868 
      (fname, ftype, fid) = iprot.readFieldBegin()
18869 
      if ftype == TType.STOP:
18870 
        break
18871 
      if fid == 1:
18872 
        if ftype == TType.I64:
18873 
          self.warehouseId = iprot.readI64();
18874 
        else:
18875 
          iprot.skip(ftype)
18876 
      elif fid == 2:
18877 
        if ftype == TType.I64:
18878 
          self.fromDate = iprot.readI64();
18879 
        else:
18880 
          iprot.skip(ftype)
18881 
      elif fid == 3:
18882 
        if ftype == TType.I64:
18883 
          self.toDate = iprot.readI64();
18884 
        else:
18885 
          iprot.skip(ftype)
18886 
      else:
18887 
        iprot.skip(ftype)
18888 
      iprot.readFieldEnd()
18889 
    iprot.readStructEnd()
18890 
 
18891 
  def write(self, oprot):
18892 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18893 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18894 
      return
18895 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 18896 
    if self.warehouseId is not None:
2690 chandransh 18897 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
18898 
      oprot.writeI64(self.warehouseId)
18899 
      oprot.writeFieldEnd()
3431 rajveer 18900 
    if self.fromDate is not None:
2690 chandransh 18901 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18902 
      oprot.writeI64(self.fromDate)
18903 
      oprot.writeFieldEnd()
3431 rajveer 18904 
    if self.toDate is not None:
2690 chandransh 18905 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18906 
      oprot.writeI64(self.toDate)
18907 
      oprot.writeFieldEnd()
18908 
    oprot.writeFieldStop()
18909 
    oprot.writeStructEnd()
18910 
 
3431 rajveer 18911 
  def validate(self):
18912 
    return
18913 
 
18914 
 
2690 chandransh 18915 
  def __repr__(self):
18916 
    L = ['%s=%r' % (key, value)
18917 
      for key, value in self.__dict__.iteritems()]
18918 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18919 
 
18920 
  def __eq__(self, other):
18921 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18922 
 
18923 
  def __ne__(self, other):
18924 
    return not (self == other)
18925 
 
18926 
class getReturnOrders_result:
18927 
  """
18928 
  Attributes:
18929 
   - success
18930 
  """
18931 
 
18932 
  thrift_spec = (
18933 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18934 
  )
18935 
 
18936 
  def __init__(self, success=None,):
18937 
    self.success = success
18938 
 
18939 
  def read(self, iprot):
18940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18942 
      return
18943 
    iprot.readStructBegin()
18944 
    while True:
18945 
      (fname, ftype, fid) = iprot.readFieldBegin()
18946 
      if ftype == TType.STOP:
18947 
        break
18948 
      if fid == 0:
18949 
        if ftype == TType.LIST:
18950 
          self.success = []
6188 rajveer 18951 
          (_etype442, _size439) = iprot.readListBegin()
18952 
          for _i443 in xrange(_size439):
18953 
            _elem444 = ReturnOrder()
18954 
            _elem444.read(iprot)
18955 
            self.success.append(_elem444)
2690 chandransh 18956 
          iprot.readListEnd()
18957 
        else:
18958 
          iprot.skip(ftype)
18959 
      else:
18960 
        iprot.skip(ftype)
18961 
      iprot.readFieldEnd()
18962 
    iprot.readStructEnd()
18963 
 
18964 
  def write(self, oprot):
18965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18967 
      return
18968 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 18969 
    if self.success is not None:
2690 chandransh 18970 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18971 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18972 
      for iter445 in self.success:
18973 
        iter445.write(oprot)
2690 chandransh 18974 
      oprot.writeListEnd()
18975 
      oprot.writeFieldEnd()
18976 
    oprot.writeFieldStop()
18977 
    oprot.writeStructEnd()
18978 
 
3431 rajveer 18979 
  def validate(self):
18980 
    return
18981 
 
18982 
 
2690 chandransh 18983 
  def __repr__(self):
18984 
    L = ['%s=%r' % (key, value)
18985 
      for key, value in self.__dict__.iteritems()]
18986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18987 
 
18988 
  def __eq__(self, other):
18989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18990 
 
18991 
  def __ne__(self, other):
18992 
    return not (self == other)
18993 
 
5481 phani.kuma 18994 
class getAllReturnOrders_args:
18995 
  """
18996 
  Attributes:
18997 
   - onlyNotProcessed
18998 
   - fromDate
18999 
   - toDate
19000 
  """
19001 
 
19002 
  thrift_spec = (
19003 
    None, # 0
19004 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
19005 
    (2, TType.I64, 'fromDate', None, None, ), # 2
19006 
    (3, TType.I64, 'toDate', None, None, ), # 3
19007 
  )
19008 
 
19009 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
19010 
    self.onlyNotProcessed = onlyNotProcessed
19011 
    self.fromDate = fromDate
19012 
    self.toDate = toDate
19013 
 
19014 
  def read(self, iprot):
19015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19017 
      return
19018 
    iprot.readStructBegin()
19019 
    while True:
19020 
      (fname, ftype, fid) = iprot.readFieldBegin()
19021 
      if ftype == TType.STOP:
19022 
        break
19023 
      if fid == 1:
19024 
        if ftype == TType.BOOL:
19025 
          self.onlyNotProcessed = iprot.readBool();
19026 
        else:
19027 
          iprot.skip(ftype)
19028 
      elif fid == 2:
19029 
        if ftype == TType.I64:
19030 
          self.fromDate = iprot.readI64();
19031 
        else:
19032 
          iprot.skip(ftype)
19033 
      elif fid == 3:
19034 
        if ftype == TType.I64:
19035 
          self.toDate = iprot.readI64();
19036 
        else:
19037 
          iprot.skip(ftype)
19038 
      else:
19039 
        iprot.skip(ftype)
19040 
      iprot.readFieldEnd()
19041 
    iprot.readStructEnd()
19042 
 
19043 
  def write(self, oprot):
19044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19046 
      return
19047 
    oprot.writeStructBegin('getAllReturnOrders_args')
19048 
    if self.onlyNotProcessed is not None:
19049 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
19050 
      oprot.writeBool(self.onlyNotProcessed)
19051 
      oprot.writeFieldEnd()
19052 
    if self.fromDate is not None:
19053 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
19054 
      oprot.writeI64(self.fromDate)
19055 
      oprot.writeFieldEnd()
19056 
    if self.toDate is not None:
19057 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
19058 
      oprot.writeI64(self.toDate)
19059 
      oprot.writeFieldEnd()
19060 
    oprot.writeFieldStop()
19061 
    oprot.writeStructEnd()
19062 
 
19063 
  def validate(self):
19064 
    return
19065 
 
19066 
 
19067 
  def __repr__(self):
19068 
    L = ['%s=%r' % (key, value)
19069 
      for key, value in self.__dict__.iteritems()]
19070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19071 
 
19072 
  def __eq__(self, other):
19073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19074 
 
19075 
  def __ne__(self, other):
19076 
    return not (self == other)
19077 
 
19078 
class getAllReturnOrders_result:
19079 
  """
19080 
  Attributes:
19081 
   - success
19082 
  """
19083 
 
19084 
  thrift_spec = (
19085 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
19086 
  )
19087 
 
19088 
  def __init__(self, success=None,):
19089 
    self.success = success
19090 
 
19091 
  def read(self, iprot):
19092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19094 
      return
19095 
    iprot.readStructBegin()
19096 
    while True:
19097 
      (fname, ftype, fid) = iprot.readFieldBegin()
19098 
      if ftype == TType.STOP:
19099 
        break
19100 
      if fid == 0:
19101 
        if ftype == TType.LIST:
19102 
          self.success = []
6188 rajveer 19103 
          (_etype449, _size446) = iprot.readListBegin()
19104 
          for _i450 in xrange(_size446):
19105 
            _elem451 = ReturnOrder()
19106 
            _elem451.read(iprot)
19107 
            self.success.append(_elem451)
5481 phani.kuma 19108 
          iprot.readListEnd()
19109 
        else:
19110 
          iprot.skip(ftype)
19111 
      else:
19112 
        iprot.skip(ftype)
19113 
      iprot.readFieldEnd()
19114 
    iprot.readStructEnd()
19115 
 
19116 
  def write(self, oprot):
19117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19119 
      return
19120 
    oprot.writeStructBegin('getAllReturnOrders_result')
19121 
    if self.success is not None:
19122 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19123 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19124 
      for iter452 in self.success:
19125 
        iter452.write(oprot)
5481 phani.kuma 19126 
      oprot.writeListEnd()
19127 
      oprot.writeFieldEnd()
19128 
    oprot.writeFieldStop()
19129 
    oprot.writeStructEnd()
19130 
 
19131 
  def validate(self):
19132 
    return
19133 
 
19134 
 
19135 
  def __repr__(self):
19136 
    L = ['%s=%r' % (key, value)
19137 
      for key, value in self.__dict__.iteritems()]
19138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19139 
 
19140 
  def __eq__(self, other):
19141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19142 
 
19143 
  def __ne__(self, other):
19144 
    return not (self == other)
19145 
 
2700 chandransh 19146 
class getReturnOrder_args:
19147 
  """
19148 
  Attributes:
19149 
   - id
19150 
  """
19151 
 
19152 
  thrift_spec = (
19153 
    None, # 0
19154 
    (1, TType.I64, 'id', None, None, ), # 1
19155 
  )
19156 
 
19157 
  def __init__(self, id=None,):
19158 
    self.id = id
19159 
 
19160 
  def read(self, iprot):
19161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19163 
      return
19164 
    iprot.readStructBegin()
19165 
    while True:
19166 
      (fname, ftype, fid) = iprot.readFieldBegin()
19167 
      if ftype == TType.STOP:
19168 
        break
19169 
      if fid == 1:
19170 
        if ftype == TType.I64:
19171 
          self.id = iprot.readI64();
19172 
        else:
19173 
          iprot.skip(ftype)
19174 
      else:
19175 
        iprot.skip(ftype)
19176 
      iprot.readFieldEnd()
19177 
    iprot.readStructEnd()
19178 
 
19179 
  def write(self, oprot):
19180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19182 
      return
19183 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 19184 
    if self.id is not None:
2700 chandransh 19185 
      oprot.writeFieldBegin('id', TType.I64, 1)
19186 
      oprot.writeI64(self.id)
19187 
      oprot.writeFieldEnd()
19188 
    oprot.writeFieldStop()
19189 
    oprot.writeStructEnd()
19190 
 
3431 rajveer 19191 
  def validate(self):
19192 
    return
19193 
 
19194 
 
2700 chandransh 19195 
  def __repr__(self):
19196 
    L = ['%s=%r' % (key, value)
19197 
      for key, value in self.__dict__.iteritems()]
19198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19199 
 
19200 
  def __eq__(self, other):
19201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19202 
 
19203 
  def __ne__(self, other):
19204 
    return not (self == other)
19205 
 
19206 
class getReturnOrder_result:
19207 
  """
19208 
  Attributes:
19209 
   - success
19210 
   - ex
19211 
  """
19212 
 
19213 
  thrift_spec = (
19214 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
19215 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19216 
  )
19217 
 
19218 
  def __init__(self, success=None, ex=None,):
19219 
    self.success = success
19220 
    self.ex = ex
19221 
 
19222 
  def read(self, iprot):
19223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19225 
      return
19226 
    iprot.readStructBegin()
19227 
    while True:
19228 
      (fname, ftype, fid) = iprot.readFieldBegin()
19229 
      if ftype == TType.STOP:
19230 
        break
19231 
      if fid == 0:
19232 
        if ftype == TType.STRUCT:
19233 
          self.success = ReturnOrder()
19234 
          self.success.read(iprot)
19235 
        else:
19236 
          iprot.skip(ftype)
19237 
      elif fid == 1:
19238 
        if ftype == TType.STRUCT:
19239 
          self.ex = TransactionServiceException()
19240 
          self.ex.read(iprot)
19241 
        else:
19242 
          iprot.skip(ftype)
19243 
      else:
19244 
        iprot.skip(ftype)
19245 
      iprot.readFieldEnd()
19246 
    iprot.readStructEnd()
19247 
 
19248 
  def write(self, oprot):
19249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19251 
      return
19252 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 19253 
    if self.success is not None:
2700 chandransh 19254 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19255 
      self.success.write(oprot)
19256 
      oprot.writeFieldEnd()
3431 rajveer 19257 
    if self.ex is not None:
2700 chandransh 19258 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19259 
      self.ex.write(oprot)
19260 
      oprot.writeFieldEnd()
19261 
    oprot.writeFieldStop()
19262 
    oprot.writeStructEnd()
19263 
 
3431 rajveer 19264 
  def validate(self):
19265 
    return
19266 
 
19267 
 
2700 chandransh 19268 
  def __repr__(self):
19269 
    L = ['%s=%r' % (key, value)
19270 
      for key, value in self.__dict__.iteritems()]
19271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19272 
 
19273 
  def __eq__(self, other):
19274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19275 
 
19276 
  def __ne__(self, other):
19277 
    return not (self == other)
19278 
 
2690 chandransh 19279 
class processReturn_args:
19280 
  """
19281 
  Attributes:
19282 
   - returnOrderId
19283 
  """
19284 
 
19285 
  thrift_spec = (
19286 
    None, # 0
19287 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
19288 
  )
19289 
 
19290 
  def __init__(self, returnOrderId=None,):
19291 
    self.returnOrderId = returnOrderId
19292 
 
19293 
  def read(self, iprot):
19294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19296 
      return
19297 
    iprot.readStructBegin()
19298 
    while True:
19299 
      (fname, ftype, fid) = iprot.readFieldBegin()
19300 
      if ftype == TType.STOP:
19301 
        break
19302 
      if fid == 1:
19303 
        if ftype == TType.I64:
19304 
          self.returnOrderId = iprot.readI64();
19305 
        else:
19306 
          iprot.skip(ftype)
19307 
      else:
19308 
        iprot.skip(ftype)
19309 
      iprot.readFieldEnd()
19310 
    iprot.readStructEnd()
19311 
 
19312 
  def write(self, oprot):
19313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19315 
      return
19316 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 19317 
    if self.returnOrderId is not None:
2690 chandransh 19318 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
19319 
      oprot.writeI64(self.returnOrderId)
19320 
      oprot.writeFieldEnd()
19321 
    oprot.writeFieldStop()
19322 
    oprot.writeStructEnd()
19323 
 
3431 rajveer 19324 
  def validate(self):
19325 
    return
19326 
 
19327 
 
2690 chandransh 19328 
  def __repr__(self):
19329 
    L = ['%s=%r' % (key, value)
19330 
      for key, value in self.__dict__.iteritems()]
19331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19332 
 
19333 
  def __eq__(self, other):
19334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19335 
 
19336 
  def __ne__(self, other):
19337 
    return not (self == other)
19338 
 
19339 
class processReturn_result:
19340 
  """
19341 
  Attributes:
19342 
   - ex
19343 
  """
19344 
 
19345 
  thrift_spec = (
19346 
    None, # 0
19347 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19348 
  )
19349 
 
19350 
  def __init__(self, ex=None,):
19351 
    self.ex = ex
19352 
 
19353 
  def read(self, iprot):
19354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19356 
      return
19357 
    iprot.readStructBegin()
19358 
    while True:
19359 
      (fname, ftype, fid) = iprot.readFieldBegin()
19360 
      if ftype == TType.STOP:
19361 
        break
19362 
      if fid == 1:
19363 
        if ftype == TType.STRUCT:
19364 
          self.ex = TransactionServiceException()
19365 
          self.ex.read(iprot)
19366 
        else:
19367 
          iprot.skip(ftype)
19368 
      else:
19369 
        iprot.skip(ftype)
19370 
      iprot.readFieldEnd()
19371 
    iprot.readStructEnd()
19372 
 
19373 
  def write(self, oprot):
19374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19376 
      return
19377 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 19378 
    if self.ex is not None:
2690 chandransh 19379 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19380 
      self.ex.write(oprot)
19381 
      oprot.writeFieldEnd()
19382 
    oprot.writeFieldStop()
19383 
    oprot.writeStructEnd()
19384 
 
3431 rajveer 19385 
  def validate(self):
19386 
    return
19387 
 
19388 
 
2690 chandransh 19389 
  def __repr__(self):
19390 
    L = ['%s=%r' % (key, value)
19391 
      for key, value in self.__dict__.iteritems()]
19392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19393 
 
19394 
  def __eq__(self, other):
19395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19396 
 
19397 
  def __ne__(self, other):
19398 
    return not (self == other)
19399 
 
3451 chandransh 19400 
class updateWeight_args:
19401 
  """
19402 
  Attributes:
19403 
   - orderId
19404 
   - weight
19405 
  """
19406 
 
19407 
  thrift_spec = (
19408 
    None, # 0
19409 
    (1, TType.I64, 'orderId', None, None, ), # 1
19410 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
19411 
  )
19412 
 
19413 
  def __init__(self, orderId=None, weight=None,):
19414 
    self.orderId = orderId
19415 
    self.weight = weight
19416 
 
19417 
  def read(self, iprot):
19418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19420 
      return
19421 
    iprot.readStructBegin()
19422 
    while True:
19423 
      (fname, ftype, fid) = iprot.readFieldBegin()
19424 
      if ftype == TType.STOP:
19425 
        break
19426 
      if fid == 1:
19427 
        if ftype == TType.I64:
19428 
          self.orderId = iprot.readI64();
19429 
        else:
19430 
          iprot.skip(ftype)
19431 
      elif fid == 2:
19432 
        if ftype == TType.DOUBLE:
19433 
          self.weight = iprot.readDouble();
19434 
        else:
19435 
          iprot.skip(ftype)
19436 
      else:
19437 
        iprot.skip(ftype)
19438 
      iprot.readFieldEnd()
19439 
    iprot.readStructEnd()
19440 
 
19441 
  def write(self, oprot):
19442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19444 
      return
19445 
    oprot.writeStructBegin('updateWeight_args')
19446 
    if self.orderId is not None:
19447 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19448 
      oprot.writeI64(self.orderId)
19449 
      oprot.writeFieldEnd()
19450 
    if self.weight is not None:
19451 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
19452 
      oprot.writeDouble(self.weight)
19453 
      oprot.writeFieldEnd()
19454 
    oprot.writeFieldStop()
19455 
    oprot.writeStructEnd()
19456 
 
19457 
  def validate(self):
19458 
    return
19459 
 
19460 
 
19461 
  def __repr__(self):
19462 
    L = ['%s=%r' % (key, value)
19463 
      for key, value in self.__dict__.iteritems()]
19464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19465 
 
19466 
  def __eq__(self, other):
19467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19468 
 
19469 
  def __ne__(self, other):
19470 
    return not (self == other)
19471 
 
19472 
class updateWeight_result:
19473 
  """
19474 
  Attributes:
19475 
   - success
19476 
   - ex
19477 
  """
19478 
 
19479 
  thrift_spec = (
19480 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19481 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19482 
  )
19483 
 
19484 
  def __init__(self, success=None, ex=None,):
19485 
    self.success = success
19486 
    self.ex = ex
19487 
 
19488 
  def read(self, iprot):
19489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19491 
      return
19492 
    iprot.readStructBegin()
19493 
    while True:
19494 
      (fname, ftype, fid) = iprot.readFieldBegin()
19495 
      if ftype == TType.STOP:
19496 
        break
19497 
      if fid == 0:
19498 
        if ftype == TType.STRUCT:
19499 
          self.success = Order()
19500 
          self.success.read(iprot)
19501 
        else:
19502 
          iprot.skip(ftype)
19503 
      elif fid == 1:
19504 
        if ftype == TType.STRUCT:
19505 
          self.ex = TransactionServiceException()
19506 
          self.ex.read(iprot)
19507 
        else:
19508 
          iprot.skip(ftype)
19509 
      else:
19510 
        iprot.skip(ftype)
19511 
      iprot.readFieldEnd()
19512 
    iprot.readStructEnd()
19513 
 
19514 
  def write(self, oprot):
19515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19517 
      return
19518 
    oprot.writeStructBegin('updateWeight_result')
19519 
    if self.success is not None:
19520 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19521 
      self.success.write(oprot)
19522 
      oprot.writeFieldEnd()
19523 
    if self.ex is not None:
19524 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19525 
      self.ex.write(oprot)
19526 
      oprot.writeFieldEnd()
19527 
    oprot.writeFieldStop()
19528 
    oprot.writeStructEnd()
19529 
 
19530 
  def validate(self):
19531 
    return
19532 
 
19533 
 
19534 
  def __repr__(self):
19535 
    L = ['%s=%r' % (key, value)
19536 
      for key, value in self.__dict__.iteritems()]
19537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19538 
 
19539 
  def __eq__(self, other):
19540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19541 
 
19542 
  def __ne__(self, other):
19543 
    return not (self == other)
3469 chandransh 19544 
 
19545 
class changeItem_args:
19546 
  """
19547 
  Attributes:
19548 
   - orderId
19549 
   - itemId
19550 
  """
19551 
 
19552 
  thrift_spec = (
19553 
    None, # 0
19554 
    (1, TType.I64, 'orderId', None, None, ), # 1
19555 
    (2, TType.I64, 'itemId', None, None, ), # 2
19556 
  )
19557 
 
19558 
  def __init__(self, orderId=None, itemId=None,):
19559 
    self.orderId = orderId
19560 
    self.itemId = itemId
19561 
 
19562 
  def read(self, iprot):
19563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19565 
      return
19566 
    iprot.readStructBegin()
19567 
    while True:
19568 
      (fname, ftype, fid) = iprot.readFieldBegin()
19569 
      if ftype == TType.STOP:
19570 
        break
19571 
      if fid == 1:
19572 
        if ftype == TType.I64:
19573 
          self.orderId = iprot.readI64();
19574 
        else:
19575 
          iprot.skip(ftype)
19576 
      elif fid == 2:
19577 
        if ftype == TType.I64:
19578 
          self.itemId = iprot.readI64();
19579 
        else:
19580 
          iprot.skip(ftype)
19581 
      else:
19582 
        iprot.skip(ftype)
19583 
      iprot.readFieldEnd()
19584 
    iprot.readStructEnd()
19585 
 
19586 
  def write(self, oprot):
19587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19589 
      return
19590 
    oprot.writeStructBegin('changeItem_args')
19591 
    if self.orderId is not None:
19592 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19593 
      oprot.writeI64(self.orderId)
19594 
      oprot.writeFieldEnd()
19595 
    if self.itemId is not None:
19596 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19597 
      oprot.writeI64(self.itemId)
19598 
      oprot.writeFieldEnd()
19599 
    oprot.writeFieldStop()
19600 
    oprot.writeStructEnd()
19601 
 
19602 
  def validate(self):
19603 
    return
19604 
 
19605 
 
19606 
  def __repr__(self):
19607 
    L = ['%s=%r' % (key, value)
19608 
      for key, value in self.__dict__.iteritems()]
19609 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19610 
 
19611 
  def __eq__(self, other):
19612 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19613 
 
19614 
  def __ne__(self, other):
19615 
    return not (self == other)
19616 
 
19617 
class changeItem_result:
19618 
  """
19619 
  Attributes:
19620 
   - success
19621 
   - ex
19622 
  """
19623 
 
19624 
  thrift_spec = (
19625 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19626 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19627 
  )
19628 
 
19629 
  def __init__(self, success=None, ex=None,):
19630 
    self.success = success
19631 
    self.ex = ex
19632 
 
19633 
  def read(self, iprot):
19634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19636 
      return
19637 
    iprot.readStructBegin()
19638 
    while True:
19639 
      (fname, ftype, fid) = iprot.readFieldBegin()
19640 
      if ftype == TType.STOP:
19641 
        break
19642 
      if fid == 0:
19643 
        if ftype == TType.STRUCT:
19644 
          self.success = Order()
19645 
          self.success.read(iprot)
19646 
        else:
19647 
          iprot.skip(ftype)
19648 
      elif fid == 1:
19649 
        if ftype == TType.STRUCT:
19650 
          self.ex = TransactionServiceException()
19651 
          self.ex.read(iprot)
19652 
        else:
19653 
          iprot.skip(ftype)
19654 
      else:
19655 
        iprot.skip(ftype)
19656 
      iprot.readFieldEnd()
19657 
    iprot.readStructEnd()
19658 
 
19659 
  def write(self, oprot):
19660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19662 
      return
19663 
    oprot.writeStructBegin('changeItem_result')
19664 
    if self.success is not None:
19665 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19666 
      self.success.write(oprot)
19667 
      oprot.writeFieldEnd()
19668 
    if self.ex is not None:
19669 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19670 
      self.ex.write(oprot)
19671 
      oprot.writeFieldEnd()
19672 
    oprot.writeFieldStop()
19673 
    oprot.writeStructEnd()
19674 
 
19675 
  def validate(self):
19676 
    return
19677 
 
19678 
 
19679 
  def __repr__(self):
19680 
    L = ['%s=%r' % (key, value)
19681 
      for key, value in self.__dict__.iteritems()]
19682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19683 
 
19684 
  def __eq__(self, other):
19685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19686 
 
19687 
  def __ne__(self, other):
19688 
    return not (self == other)
19689 
 
19690 
class shiftToWarehouse_args:
19691 
  """
19692 
  Attributes:
19693 
   - orderId
19694 
   - warehouseId
19695 
  """
19696 
 
19697 
  thrift_spec = (
19698 
    None, # 0
19699 
    (1, TType.I64, 'orderId', None, None, ), # 1
19700 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
19701 
  )
19702 
 
19703 
  def __init__(self, orderId=None, warehouseId=None,):
19704 
    self.orderId = orderId
19705 
    self.warehouseId = warehouseId
19706 
 
19707 
  def read(self, iprot):
19708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19710 
      return
19711 
    iprot.readStructBegin()
19712 
    while True:
19713 
      (fname, ftype, fid) = iprot.readFieldBegin()
19714 
      if ftype == TType.STOP:
19715 
        break
19716 
      if fid == 1:
19717 
        if ftype == TType.I64:
19718 
          self.orderId = iprot.readI64();
19719 
        else:
19720 
          iprot.skip(ftype)
19721 
      elif fid == 2:
19722 
        if ftype == TType.I64:
19723 
          self.warehouseId = iprot.readI64();
19724 
        else:
19725 
          iprot.skip(ftype)
19726 
      else:
19727 
        iprot.skip(ftype)
19728 
      iprot.readFieldEnd()
19729 
    iprot.readStructEnd()
19730 
 
19731 
  def write(self, oprot):
19732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19734 
      return
19735 
    oprot.writeStructBegin('shiftToWarehouse_args')
19736 
    if self.orderId is not None:
19737 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19738 
      oprot.writeI64(self.orderId)
19739 
      oprot.writeFieldEnd()
19740 
    if self.warehouseId is not None:
19741 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
19742 
      oprot.writeI64(self.warehouseId)
19743 
      oprot.writeFieldEnd()
19744 
    oprot.writeFieldStop()
19745 
    oprot.writeStructEnd()
19746 
 
19747 
  def validate(self):
19748 
    return
19749 
 
19750 
 
19751 
  def __repr__(self):
19752 
    L = ['%s=%r' % (key, value)
19753 
      for key, value in self.__dict__.iteritems()]
19754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19755 
 
19756 
  def __eq__(self, other):
19757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19758 
 
19759 
  def __ne__(self, other):
19760 
    return not (self == other)
19761 
 
19762 
class shiftToWarehouse_result:
19763 
  """
19764 
  Attributes:
19765 
   - success
19766 
   - ex
19767 
  """
19768 
 
19769 
  thrift_spec = (
19770 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19771 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19772 
  )
19773 
 
19774 
  def __init__(self, success=None, ex=None,):
19775 
    self.success = success
19776 
    self.ex = ex
19777 
 
19778 
  def read(self, iprot):
19779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19781 
      return
19782 
    iprot.readStructBegin()
19783 
    while True:
19784 
      (fname, ftype, fid) = iprot.readFieldBegin()
19785 
      if ftype == TType.STOP:
19786 
        break
19787 
      if fid == 0:
19788 
        if ftype == TType.STRUCT:
19789 
          self.success = Order()
19790 
          self.success.read(iprot)
19791 
        else:
19792 
          iprot.skip(ftype)
19793 
      elif fid == 1:
19794 
        if ftype == TType.STRUCT:
19795 
          self.ex = TransactionServiceException()
19796 
          self.ex.read(iprot)
19797 
        else:
19798 
          iprot.skip(ftype)
19799 
      else:
19800 
        iprot.skip(ftype)
19801 
      iprot.readFieldEnd()
19802 
    iprot.readStructEnd()
19803 
 
19804 
  def write(self, oprot):
19805 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19806 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19807 
      return
19808 
    oprot.writeStructBegin('shiftToWarehouse_result')
19809 
    if self.success is not None:
19810 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19811 
      self.success.write(oprot)
19812 
      oprot.writeFieldEnd()
19813 
    if self.ex is not None:
19814 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19815 
      self.ex.write(oprot)
19816 
      oprot.writeFieldEnd()
19817 
    oprot.writeFieldStop()
19818 
    oprot.writeStructEnd()
19819 
 
19820 
  def validate(self):
19821 
    return
19822 
 
19823 
 
19824 
  def __repr__(self):
19825 
    L = ['%s=%r' % (key, value)
19826 
      for key, value in self.__dict__.iteritems()]
19827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19828 
 
19829 
  def __eq__(self, other):
19830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19831 
 
19832 
  def __ne__(self, other):
19833 
    return not (self == other)
3553 chandransh 19834 
 
19835 
class addDelayReason_args:
19836 
  """
19837 
  Attributes:
19838 
   - orderId
19839 
   - delayReason
3986 chandransh 19840 
   - furtherDelay
4647 rajveer 19841 
   - delayReasonText
3553 chandransh 19842 
  """
19843 
 
19844 
  thrift_spec = (
19845 
    None, # 0
19846 
    (1, TType.I64, 'orderId', None, None, ), # 1
19847 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 19848 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 19849 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 19850 
  )
19851 
 
4647 rajveer 19852 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 19853 
    self.orderId = orderId
19854 
    self.delayReason = delayReason
3986 chandransh 19855 
    self.furtherDelay = furtherDelay
4647 rajveer 19856 
    self.delayReasonText = delayReasonText
3553 chandransh 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 == 1:
19868 
        if ftype == TType.I64:
19869 
          self.orderId = iprot.readI64();
19870 
        else:
19871 
          iprot.skip(ftype)
19872 
      elif fid == 2:
19873 
        if ftype == TType.I32:
19874 
          self.delayReason = iprot.readI32();
19875 
        else:
19876 
          iprot.skip(ftype)
3986 chandransh 19877 
      elif fid == 3:
19878 
        if ftype == TType.I64:
19879 
          self.furtherDelay = iprot.readI64();
19880 
        else:
19881 
          iprot.skip(ftype)
4647 rajveer 19882 
      elif fid == 4:
19883 
        if ftype == TType.STRING:
19884 
          self.delayReasonText = iprot.readString();
19885 
        else:
19886 
          iprot.skip(ftype)
3553 chandransh 19887 
      else:
19888 
        iprot.skip(ftype)
19889 
      iprot.readFieldEnd()
19890 
    iprot.readStructEnd()
19891 
 
19892 
  def write(self, oprot):
19893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19895 
      return
19896 
    oprot.writeStructBegin('addDelayReason_args')
19897 
    if self.orderId is not None:
19898 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19899 
      oprot.writeI64(self.orderId)
19900 
      oprot.writeFieldEnd()
19901 
    if self.delayReason is not None:
19902 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
19903 
      oprot.writeI32(self.delayReason)
19904 
      oprot.writeFieldEnd()
3986 chandransh 19905 
    if self.furtherDelay is not None:
19906 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
19907 
      oprot.writeI64(self.furtherDelay)
19908 
      oprot.writeFieldEnd()
4647 rajveer 19909 
    if self.delayReasonText is not None:
19910 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
19911 
      oprot.writeString(self.delayReasonText)
19912 
      oprot.writeFieldEnd()
3553 chandransh 19913 
    oprot.writeFieldStop()
19914 
    oprot.writeStructEnd()
19915 
 
19916 
  def validate(self):
19917 
    return
19918 
 
19919 
 
19920 
  def __repr__(self):
19921 
    L = ['%s=%r' % (key, value)
19922 
      for key, value in self.__dict__.iteritems()]
19923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19924 
 
19925 
  def __eq__(self, other):
19926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19927 
 
19928 
  def __ne__(self, other):
19929 
    return not (self == other)
19930 
 
19931 
class addDelayReason_result:
19932 
  """
19933 
  Attributes:
19934 
   - success
19935 
   - ex
19936 
  """
19937 
 
19938 
  thrift_spec = (
19939 
    (0, TType.BOOL, 'success', None, None, ), # 0
19940 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19941 
  )
19942 
 
19943 
  def __init__(self, success=None, ex=None,):
19944 
    self.success = success
19945 
    self.ex = ex
19946 
 
19947 
  def read(self, iprot):
19948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19950 
      return
19951 
    iprot.readStructBegin()
19952 
    while True:
19953 
      (fname, ftype, fid) = iprot.readFieldBegin()
19954 
      if ftype == TType.STOP:
19955 
        break
19956 
      if fid == 0:
19957 
        if ftype == TType.BOOL:
19958 
          self.success = iprot.readBool();
19959 
        else:
19960 
          iprot.skip(ftype)
19961 
      elif fid == 1:
19962 
        if ftype == TType.STRUCT:
19963 
          self.ex = TransactionServiceException()
19964 
          self.ex.read(iprot)
19965 
        else:
19966 
          iprot.skip(ftype)
19967 
      else:
19968 
        iprot.skip(ftype)
19969 
      iprot.readFieldEnd()
19970 
    iprot.readStructEnd()
19971 
 
19972 
  def write(self, oprot):
19973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19975 
      return
19976 
    oprot.writeStructBegin('addDelayReason_result')
19977 
    if self.success is not None:
19978 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19979 
      oprot.writeBool(self.success)
19980 
      oprot.writeFieldEnd()
19981 
    if self.ex is not None:
19982 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19983 
      self.ex.write(oprot)
19984 
      oprot.writeFieldEnd()
19985 
    oprot.writeFieldStop()
19986 
    oprot.writeStructEnd()
19987 
 
19988 
  def validate(self):
19989 
    return
19990 
 
19991 
 
19992 
  def __repr__(self):
19993 
    L = ['%s=%r' % (key, value)
19994 
      for key, value in self.__dict__.iteritems()]
19995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19996 
 
19997 
  def __eq__(self, other):
19998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19999 
 
20000 
  def __ne__(self, other):
20001 
    return not (self == other)
3956 chandransh 20002 
 
20003 
class reconcileCodCollection_args:
20004 
  """
20005 
  Attributes:
20006 
   - collectedAmountMap
20007 
   - xferBy
20008 
   - xferTxnId
20009 
   - xferDate
20010 
  """
20011 
 
20012 
  thrift_spec = (
20013 
    None, # 0
20014 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
20015 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
20016 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
20017 
    (4, TType.I64, 'xferDate', None, None, ), # 4
20018 
  )
20019 
 
20020 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
20021 
    self.collectedAmountMap = collectedAmountMap
20022 
    self.xferBy = xferBy
20023 
    self.xferTxnId = xferTxnId
20024 
    self.xferDate = xferDate
20025 
 
20026 
  def read(self, iprot):
20027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20029 
      return
20030 
    iprot.readStructBegin()
20031 
    while True:
20032 
      (fname, ftype, fid) = iprot.readFieldBegin()
20033 
      if ftype == TType.STOP:
20034 
        break
20035 
      if fid == 1:
20036 
        if ftype == TType.MAP:
20037 
          self.collectedAmountMap = {}
6188 rajveer 20038 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
20039 
          for _i457 in xrange(_size453):
20040 
            _key458 = iprot.readString();
20041 
            _val459 = iprot.readDouble();
20042 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 20043 
          iprot.readMapEnd()
20044 
        else:
20045 
          iprot.skip(ftype)
20046 
      elif fid == 2:
20047 
        if ftype == TType.STRING:
20048 
          self.xferBy = iprot.readString();
20049 
        else:
20050 
          iprot.skip(ftype)
20051 
      elif fid == 3:
20052 
        if ftype == TType.STRING:
20053 
          self.xferTxnId = iprot.readString();
20054 
        else:
20055 
          iprot.skip(ftype)
20056 
      elif fid == 4:
20057 
        if ftype == TType.I64:
20058 
          self.xferDate = iprot.readI64();
20059 
        else:
20060 
          iprot.skip(ftype)
20061 
      else:
20062 
        iprot.skip(ftype)
20063 
      iprot.readFieldEnd()
20064 
    iprot.readStructEnd()
20065 
 
20066 
  def write(self, oprot):
20067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20069 
      return
20070 
    oprot.writeStructBegin('reconcileCodCollection_args')
20071 
    if self.collectedAmountMap is not None:
20072 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
20073 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 20074 
      for kiter460,viter461 in self.collectedAmountMap.items():
20075 
        oprot.writeString(kiter460)
20076 
        oprot.writeDouble(viter461)
3956 chandransh 20077 
      oprot.writeMapEnd()
20078 
      oprot.writeFieldEnd()
20079 
    if self.xferBy is not None:
20080 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
20081 
      oprot.writeString(self.xferBy)
20082 
      oprot.writeFieldEnd()
20083 
    if self.xferTxnId is not None:
20084 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
20085 
      oprot.writeString(self.xferTxnId)
20086 
      oprot.writeFieldEnd()
20087 
    if self.xferDate is not None:
20088 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
20089 
      oprot.writeI64(self.xferDate)
20090 
      oprot.writeFieldEnd()
20091 
    oprot.writeFieldStop()
20092 
    oprot.writeStructEnd()
20093 
 
20094 
  def validate(self):
20095 
    return
20096 
 
20097 
 
20098 
  def __repr__(self):
20099 
    L = ['%s=%r' % (key, value)
20100 
      for key, value in self.__dict__.iteritems()]
20101 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20102 
 
20103 
  def __eq__(self, other):
20104 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20105 
 
20106 
  def __ne__(self, other):
20107 
    return not (self == other)
20108 
 
20109 
class reconcileCodCollection_result:
20110 
  """
20111 
  Attributes:
20112 
   - success
20113 
   - ex
20114 
  """
20115 
 
20116 
  thrift_spec = (
20117 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
20118 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20119 
  )
20120 
 
20121 
  def __init__(self, success=None, ex=None,):
20122 
    self.success = success
20123 
    self.ex = ex
20124 
 
20125 
  def read(self, iprot):
20126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20128 
      return
20129 
    iprot.readStructBegin()
20130 
    while True:
20131 
      (fname, ftype, fid) = iprot.readFieldBegin()
20132 
      if ftype == TType.STOP:
20133 
        break
20134 
      if fid == 0:
20135 
        if ftype == TType.MAP:
20136 
          self.success = {}
6188 rajveer 20137 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20138 
          for _i466 in xrange(_size462):
20139 
            _key467 = iprot.readString();
20140 
            _val468 = iprot.readString();
20141 
            self.success[_key467] = _val468
3956 chandransh 20142 
          iprot.readMapEnd()
20143 
        else:
20144 
          iprot.skip(ftype)
20145 
      elif fid == 1:
20146 
        if ftype == TType.STRUCT:
20147 
          self.ex = TransactionServiceException()
20148 
          self.ex.read(iprot)
20149 
        else:
20150 
          iprot.skip(ftype)
20151 
      else:
20152 
        iprot.skip(ftype)
20153 
      iprot.readFieldEnd()
20154 
    iprot.readStructEnd()
20155 
 
20156 
  def write(self, oprot):
20157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20159 
      return
20160 
    oprot.writeStructBegin('reconcileCodCollection_result')
20161 
    if self.success is not None:
20162 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20163 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 20164 
      for kiter469,viter470 in self.success.items():
20165 
        oprot.writeString(kiter469)
20166 
        oprot.writeString(viter470)
3956 chandransh 20167 
      oprot.writeMapEnd()
20168 
      oprot.writeFieldEnd()
20169 
    if self.ex is not None:
20170 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20171 
      self.ex.write(oprot)
20172 
      oprot.writeFieldEnd()
20173 
    oprot.writeFieldStop()
20174 
    oprot.writeStructEnd()
20175 
 
20176 
  def validate(self):
20177 
    return
20178 
 
20179 
 
20180 
  def __repr__(self):
20181 
    L = ['%s=%r' % (key, value)
20182 
      for key, value in self.__dict__.iteritems()]
20183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20184 
 
20185 
  def __eq__(self, other):
20186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20187 
 
20188 
  def __ne__(self, other):
20189 
    return not (self == other)
4008 mandeep.dh 20190 
 
20191 
class getTransactionsRequiringExtraProcessing_args:
20192 
  """
20193 
  Attributes:
20194 
   - category
20195 
  """
20196 
 
20197 
  thrift_spec = (
20198 
    None, # 0
20199 
    (1, TType.I32, 'category', None, None, ), # 1
20200 
  )
20201 
 
20202 
  def __init__(self, category=None,):
20203 
    self.category = category
20204 
 
20205 
  def read(self, iprot):
20206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20208 
      return
20209 
    iprot.readStructBegin()
20210 
    while True:
20211 
      (fname, ftype, fid) = iprot.readFieldBegin()
20212 
      if ftype == TType.STOP:
20213 
        break
20214 
      if fid == 1:
20215 
        if ftype == TType.I32:
20216 
          self.category = iprot.readI32();
20217 
        else:
20218 
          iprot.skip(ftype)
20219 
      else:
20220 
        iprot.skip(ftype)
20221 
      iprot.readFieldEnd()
20222 
    iprot.readStructEnd()
20223 
 
20224 
  def write(self, oprot):
20225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20227 
      return
20228 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
20229 
    if self.category is not None:
20230 
      oprot.writeFieldBegin('category', TType.I32, 1)
20231 
      oprot.writeI32(self.category)
20232 
      oprot.writeFieldEnd()
20233 
    oprot.writeFieldStop()
20234 
    oprot.writeStructEnd()
20235 
 
20236 
  def validate(self):
20237 
    return
20238 
 
20239 
 
20240 
  def __repr__(self):
20241 
    L = ['%s=%r' % (key, value)
20242 
      for key, value in self.__dict__.iteritems()]
20243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20244 
 
20245 
  def __eq__(self, other):
20246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20247 
 
20248 
  def __ne__(self, other):
20249 
    return not (self == other)
20250 
 
20251 
class getTransactionsRequiringExtraProcessing_result:
20252 
  """
20253 
  Attributes:
20254 
   - success
20255 
  """
20256 
 
20257 
  thrift_spec = (
20258 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
20259 
  )
20260 
 
20261 
  def __init__(self, success=None,):
20262 
    self.success = success
20263 
 
20264 
  def read(self, iprot):
20265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20267 
      return
20268 
    iprot.readStructBegin()
20269 
    while True:
20270 
      (fname, ftype, fid) = iprot.readFieldBegin()
20271 
      if ftype == TType.STOP:
20272 
        break
20273 
      if fid == 0:
20274 
        if ftype == TType.LIST:
20275 
          self.success = []
6188 rajveer 20276 
          (_etype474, _size471) = iprot.readListBegin()
20277 
          for _i475 in xrange(_size471):
20278 
            _elem476 = iprot.readI64();
20279 
            self.success.append(_elem476)
4008 mandeep.dh 20280 
          iprot.readListEnd()
20281 
        else:
20282 
          iprot.skip(ftype)
20283 
      else:
20284 
        iprot.skip(ftype)
20285 
      iprot.readFieldEnd()
20286 
    iprot.readStructEnd()
20287 
 
20288 
  def write(self, oprot):
20289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20291 
      return
20292 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
20293 
    if self.success is not None:
20294 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20295 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 20296 
      for iter477 in self.success:
20297 
        oprot.writeI64(iter477)
4008 mandeep.dh 20298 
      oprot.writeListEnd()
20299 
      oprot.writeFieldEnd()
20300 
    oprot.writeFieldStop()
20301 
    oprot.writeStructEnd()
20302 
 
20303 
  def validate(self):
20304 
    return
20305 
 
20306 
 
20307 
  def __repr__(self):
20308 
    L = ['%s=%r' % (key, value)
20309 
      for key, value in self.__dict__.iteritems()]
20310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20311 
 
20312 
  def __eq__(self, other):
20313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20314 
 
20315 
  def __ne__(self, other):
20316 
    return not (self == other)
20317 
 
20318 
class markTransactionAsProcessed_args:
20319 
  """
20320 
  Attributes:
20321 
   - transactionId
20322 
   - category
20323 
  """
20324 
 
20325 
  thrift_spec = (
20326 
    None, # 0
20327 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20328 
    (2, TType.I32, 'category', None, None, ), # 2
20329 
  )
20330 
 
20331 
  def __init__(self, transactionId=None, category=None,):
20332 
    self.transactionId = transactionId
20333 
    self.category = category
20334 
 
20335 
  def read(self, iprot):
20336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20338 
      return
20339 
    iprot.readStructBegin()
20340 
    while True:
20341 
      (fname, ftype, fid) = iprot.readFieldBegin()
20342 
      if ftype == TType.STOP:
20343 
        break
20344 
      if fid == 1:
20345 
        if ftype == TType.I64:
20346 
          self.transactionId = iprot.readI64();
20347 
        else:
20348 
          iprot.skip(ftype)
20349 
      elif fid == 2:
20350 
        if ftype == TType.I32:
20351 
          self.category = iprot.readI32();
20352 
        else:
20353 
          iprot.skip(ftype)
20354 
      else:
20355 
        iprot.skip(ftype)
20356 
      iprot.readFieldEnd()
20357 
    iprot.readStructEnd()
20358 
 
20359 
  def write(self, oprot):
20360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20362 
      return
20363 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
20364 
    if self.transactionId is not None:
20365 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20366 
      oprot.writeI64(self.transactionId)
20367 
      oprot.writeFieldEnd()
20368 
    if self.category is not None:
20369 
      oprot.writeFieldBegin('category', TType.I32, 2)
20370 
      oprot.writeI32(self.category)
20371 
      oprot.writeFieldEnd()
20372 
    oprot.writeFieldStop()
20373 
    oprot.writeStructEnd()
20374 
 
20375 
  def validate(self):
20376 
    return
20377 
 
20378 
 
20379 
  def __repr__(self):
20380 
    L = ['%s=%r' % (key, value)
20381 
      for key, value in self.__dict__.iteritems()]
20382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20383 
 
20384 
  def __eq__(self, other):
20385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20386 
 
20387 
  def __ne__(self, other):
20388 
    return not (self == other)
20389 
 
20390 
class markTransactionAsProcessed_result:
20391 
 
20392 
  thrift_spec = (
20393 
  )
20394 
 
20395 
  def read(self, iprot):
20396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20398 
      return
20399 
    iprot.readStructBegin()
20400 
    while True:
20401 
      (fname, ftype, fid) = iprot.readFieldBegin()
20402 
      if ftype == TType.STOP:
20403 
        break
20404 
      else:
20405 
        iprot.skip(ftype)
20406 
      iprot.readFieldEnd()
20407 
    iprot.readStructEnd()
20408 
 
20409 
  def write(self, oprot):
20410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20412 
      return
20413 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
20414 
    oprot.writeFieldStop()
20415 
    oprot.writeStructEnd()
20416 
 
20417 
  def validate(self):
20418 
    return
20419 
 
20420 
 
20421 
  def __repr__(self):
20422 
    L = ['%s=%r' % (key, value)
20423 
      for key, value in self.__dict__.iteritems()]
20424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20425 
 
20426 
  def __eq__(self, other):
20427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20428 
 
20429 
  def __ne__(self, other):
20430 
    return not (self == other)
4018 chandransh 20431 
 
20432 
class getItemWiseRiskyOrdersCount_args:
20433 
 
20434 
  thrift_spec = (
20435 
  )
20436 
 
20437 
  def read(self, iprot):
20438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20440 
      return
20441 
    iprot.readStructBegin()
20442 
    while True:
20443 
      (fname, ftype, fid) = iprot.readFieldBegin()
20444 
      if ftype == TType.STOP:
20445 
        break
20446 
      else:
20447 
        iprot.skip(ftype)
20448 
      iprot.readFieldEnd()
20449 
    iprot.readStructEnd()
20450 
 
20451 
  def write(self, oprot):
20452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20454 
      return
20455 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
20456 
    oprot.writeFieldStop()
20457 
    oprot.writeStructEnd()
20458 
 
20459 
  def validate(self):
20460 
    return
20461 
 
20462 
 
20463 
  def __repr__(self):
20464 
    L = ['%s=%r' % (key, value)
20465 
      for key, value in self.__dict__.iteritems()]
20466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20467 
 
20468 
  def __eq__(self, other):
20469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20470 
 
20471 
  def __ne__(self, other):
20472 
    return not (self == other)
20473 
 
20474 
class getItemWiseRiskyOrdersCount_result:
20475 
  """
20476 
  Attributes:
20477 
   - success
20478 
  """
20479 
 
20480 
  thrift_spec = (
20481 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
20482 
  )
20483 
 
20484 
  def __init__(self, success=None,):
20485 
    self.success = success
20486 
 
20487 
  def read(self, iprot):
20488 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20489 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20490 
      return
20491 
    iprot.readStructBegin()
20492 
    while True:
20493 
      (fname, ftype, fid) = iprot.readFieldBegin()
20494 
      if ftype == TType.STOP:
20495 
        break
20496 
      if fid == 0:
20497 
        if ftype == TType.MAP:
20498 
          self.success = {}
6188 rajveer 20499 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
20500 
          for _i482 in xrange(_size478):
20501 
            _key483 = iprot.readI64();
20502 
            _val484 = iprot.readI64();
20503 
            self.success[_key483] = _val484
4018 chandransh 20504 
          iprot.readMapEnd()
20505 
        else:
20506 
          iprot.skip(ftype)
20507 
      else:
20508 
        iprot.skip(ftype)
20509 
      iprot.readFieldEnd()
20510 
    iprot.readStructEnd()
20511 
 
20512 
  def write(self, oprot):
20513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20515 
      return
20516 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
20517 
    if self.success is not None:
20518 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20519 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 20520 
      for kiter485,viter486 in self.success.items():
20521 
        oprot.writeI64(kiter485)
20522 
        oprot.writeI64(viter486)
4018 chandransh 20523 
      oprot.writeMapEnd()
20524 
      oprot.writeFieldEnd()
20525 
    oprot.writeFieldStop()
20526 
    oprot.writeStructEnd()
20527 
 
20528 
  def validate(self):
20529 
    return
20530 
 
20531 
 
20532 
  def __repr__(self):
20533 
    L = ['%s=%r' % (key, value)
20534 
      for key, value in self.__dict__.iteritems()]
20535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20536 
 
20537 
  def __eq__(self, other):
20538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20539 
 
20540 
  def __ne__(self, other):
20541 
    return not (self == other)
4247 rajveer 20542 
 
4295 varun.gupt 20543 
class getOrdersForItemIds_args:
20544 
  """
20545 
  Attributes:
20546 
   - itemIds
20547 
  """
20548 
 
20549 
  thrift_spec = (
20550 
    None, # 0
20551 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20552 
  )
20553 
 
20554 
  def __init__(self, itemIds=None,):
20555 
    self.itemIds = itemIds
20556 
 
20557 
  def read(self, iprot):
20558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20560 
      return
20561 
    iprot.readStructBegin()
20562 
    while True:
20563 
      (fname, ftype, fid) = iprot.readFieldBegin()
20564 
      if ftype == TType.STOP:
20565 
        break
20566 
      if fid == 1:
20567 
        if ftype == TType.LIST:
20568 
          self.itemIds = []
6188 rajveer 20569 
          (_etype490, _size487) = iprot.readListBegin()
20570 
          for _i491 in xrange(_size487):
20571 
            _elem492 = iprot.readI64();
20572 
            self.itemIds.append(_elem492)
4295 varun.gupt 20573 
          iprot.readListEnd()
20574 
        else:
20575 
          iprot.skip(ftype)
20576 
      else:
20577 
        iprot.skip(ftype)
20578 
      iprot.readFieldEnd()
20579 
    iprot.readStructEnd()
20580 
 
20581 
  def write(self, oprot):
20582 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20583 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20584 
      return
20585 
    oprot.writeStructBegin('getOrdersForItemIds_args')
20586 
    if self.itemIds is not None:
20587 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20588 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 20589 
      for iter493 in self.itemIds:
20590 
        oprot.writeI64(iter493)
4295 varun.gupt 20591 
      oprot.writeListEnd()
20592 
      oprot.writeFieldEnd()
20593 
    oprot.writeFieldStop()
20594 
    oprot.writeStructEnd()
20595 
 
20596 
  def validate(self):
20597 
    return
20598 
 
20599 
 
20600 
  def __repr__(self):
20601 
    L = ['%s=%r' % (key, value)
20602 
      for key, value in self.__dict__.iteritems()]
20603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20604 
 
20605 
  def __eq__(self, other):
20606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20607 
 
20608 
  def __ne__(self, other):
20609 
    return not (self == other)
20610 
 
20611 
class getOrdersForItemIds_result:
20612 
  """
20613 
  Attributes:
20614 
   - success
20615 
  """
20616 
 
20617 
  thrift_spec = (
20618 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20619 
  )
20620 
 
20621 
  def __init__(self, success=None,):
20622 
    self.success = success
20623 
 
20624 
  def read(self, iprot):
20625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20627 
      return
20628 
    iprot.readStructBegin()
20629 
    while True:
20630 
      (fname, ftype, fid) = iprot.readFieldBegin()
20631 
      if ftype == TType.STOP:
20632 
        break
20633 
      if fid == 0:
20634 
        if ftype == TType.LIST:
20635 
          self.success = []
6188 rajveer 20636 
          (_etype497, _size494) = iprot.readListBegin()
20637 
          for _i498 in xrange(_size494):
20638 
            _elem499 = Order()
20639 
            _elem499.read(iprot)
20640 
            self.success.append(_elem499)
4295 varun.gupt 20641 
          iprot.readListEnd()
20642 
        else:
20643 
          iprot.skip(ftype)
20644 
      else:
20645 
        iprot.skip(ftype)
20646 
      iprot.readFieldEnd()
20647 
    iprot.readStructEnd()
20648 
 
20649 
  def write(self, oprot):
20650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20652 
      return
20653 
    oprot.writeStructBegin('getOrdersForItemIds_result')
20654 
    if self.success is not None:
20655 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20656 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20657 
      for iter500 in self.success:
20658 
        iter500.write(oprot)
4295 varun.gupt 20659 
      oprot.writeListEnd()
20660 
      oprot.writeFieldEnd()
20661 
    oprot.writeFieldStop()
20662 
    oprot.writeStructEnd()
20663 
 
20664 
  def validate(self):
20665 
    return
20666 
 
20667 
 
20668 
  def __repr__(self):
20669 
    L = ['%s=%r' % (key, value)
20670 
      for key, value in self.__dict__.iteritems()]
20671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20672 
 
20673 
  def __eq__(self, other):
20674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20675 
 
20676 
  def __ne__(self, other):
20677 
    return not (self == other)
20678 
 
4247 rajveer 20679 
class markOrderCancellationRequestReceived_args:
20680 
  """
20681 
  Attributes:
20682 
   - orderId
20683 
  """
20684 
 
20685 
  thrift_spec = (
20686 
    None, # 0
20687 
    (1, TType.I64, 'orderId', None, None, ), # 1
20688 
  )
20689 
 
20690 
  def __init__(self, orderId=None,):
20691 
    self.orderId = orderId
20692 
 
20693 
  def read(self, iprot):
20694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20696 
      return
20697 
    iprot.readStructBegin()
20698 
    while True:
20699 
      (fname, ftype, fid) = iprot.readFieldBegin()
20700 
      if ftype == TType.STOP:
20701 
        break
20702 
      if fid == 1:
20703 
        if ftype == TType.I64:
20704 
          self.orderId = iprot.readI64();
20705 
        else:
20706 
          iprot.skip(ftype)
20707 
      else:
20708 
        iprot.skip(ftype)
20709 
      iprot.readFieldEnd()
20710 
    iprot.readStructEnd()
20711 
 
20712 
  def write(self, oprot):
20713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20715 
      return
20716 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
20717 
    if self.orderId is not None:
20718 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20719 
      oprot.writeI64(self.orderId)
20720 
      oprot.writeFieldEnd()
20721 
    oprot.writeFieldStop()
20722 
    oprot.writeStructEnd()
20723 
 
20724 
  def validate(self):
20725 
    return
20726 
 
20727 
 
20728 
  def __repr__(self):
20729 
    L = ['%s=%r' % (key, value)
20730 
      for key, value in self.__dict__.iteritems()]
20731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20732 
 
20733 
  def __eq__(self, other):
20734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20735 
 
20736 
  def __ne__(self, other):
20737 
    return not (self == other)
20738 
 
20739 
class markOrderCancellationRequestReceived_result:
20740 
  """
20741 
  Attributes:
20742 
   - ex
20743 
  """
20744 
 
20745 
  thrift_spec = (
20746 
    None, # 0
20747 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20748 
  )
20749 
 
20750 
  def __init__(self, ex=None,):
20751 
    self.ex = ex
20752 
 
20753 
  def read(self, iprot):
20754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20756 
      return
20757 
    iprot.readStructBegin()
20758 
    while True:
20759 
      (fname, ftype, fid) = iprot.readFieldBegin()
20760 
      if ftype == TType.STOP:
20761 
        break
20762 
      if fid == 1:
20763 
        if ftype == TType.STRUCT:
20764 
          self.ex = TransactionServiceException()
20765 
          self.ex.read(iprot)
20766 
        else:
20767 
          iprot.skip(ftype)
20768 
      else:
20769 
        iprot.skip(ftype)
20770 
      iprot.readFieldEnd()
20771 
    iprot.readStructEnd()
20772 
 
20773 
  def write(self, oprot):
20774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20776 
      return
20777 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20778 
    if self.ex is not None:
20779 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20780 
      self.ex.write(oprot)
20781 
      oprot.writeFieldEnd()
20782 
    oprot.writeFieldStop()
20783 
    oprot.writeStructEnd()
20784 
 
20785 
  def validate(self):
20786 
    return
20787 
 
20788 
 
20789 
  def __repr__(self):
20790 
    L = ['%s=%r' % (key, value)
20791 
      for key, value in self.__dict__.iteritems()]
20792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20793 
 
20794 
  def __eq__(self, other):
20795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20796 
 
20797 
  def __ne__(self, other):
20798 
    return not (self == other)
20799 
 
20800 
class markOrderCancellationRequestConfirmed_args:
20801 
  """
20802 
  Attributes:
20803 
   - orderId
20804 
  """
20805 
 
20806 
  thrift_spec = (
20807 
    None, # 0
20808 
    (1, TType.I64, 'orderId', None, None, ), # 1
20809 
  )
20810 
 
20811 
  def __init__(self, orderId=None,):
20812 
    self.orderId = orderId
20813 
 
20814 
  def read(self, iprot):
20815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20817 
      return
20818 
    iprot.readStructBegin()
20819 
    while True:
20820 
      (fname, ftype, fid) = iprot.readFieldBegin()
20821 
      if ftype == TType.STOP:
20822 
        break
20823 
      if fid == 1:
20824 
        if ftype == TType.I64:
20825 
          self.orderId = iprot.readI64();
20826 
        else:
20827 
          iprot.skip(ftype)
20828 
      else:
20829 
        iprot.skip(ftype)
20830 
      iprot.readFieldEnd()
20831 
    iprot.readStructEnd()
20832 
 
20833 
  def write(self, oprot):
20834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20836 
      return
20837 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
20838 
    if self.orderId is not None:
20839 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20840 
      oprot.writeI64(self.orderId)
20841 
      oprot.writeFieldEnd()
20842 
    oprot.writeFieldStop()
20843 
    oprot.writeStructEnd()
20844 
 
20845 
  def validate(self):
20846 
    return
20847 
 
20848 
 
20849 
  def __repr__(self):
20850 
    L = ['%s=%r' % (key, value)
20851 
      for key, value in self.__dict__.iteritems()]
20852 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20853 
 
20854 
  def __eq__(self, other):
20855 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20856 
 
20857 
  def __ne__(self, other):
20858 
    return not (self == other)
20859 
 
20860 
class markOrderCancellationRequestConfirmed_result:
20861 
  """
20862 
  Attributes:
20863 
   - ex
20864 
  """
20865 
 
20866 
  thrift_spec = (
20867 
    None, # 0
20868 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20869 
  )
20870 
 
20871 
  def __init__(self, ex=None,):
20872 
    self.ex = ex
20873 
 
20874 
  def read(self, iprot):
20875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20877 
      return
20878 
    iprot.readStructBegin()
20879 
    while True:
20880 
      (fname, ftype, fid) = iprot.readFieldBegin()
20881 
      if ftype == TType.STOP:
20882 
        break
20883 
      if fid == 1:
20884 
        if ftype == TType.STRUCT:
20885 
          self.ex = TransactionServiceException()
20886 
          self.ex.read(iprot)
20887 
        else:
20888 
          iprot.skip(ftype)
20889 
      else:
20890 
        iprot.skip(ftype)
20891 
      iprot.readFieldEnd()
20892 
    iprot.readStructEnd()
20893 
 
20894 
  def write(self, oprot):
20895 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20896 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20897 
      return
20898 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
20899 
    if self.ex is not None:
20900 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20901 
      self.ex.write(oprot)
20902 
      oprot.writeFieldEnd()
20903 
    oprot.writeFieldStop()
20904 
    oprot.writeStructEnd()
20905 
 
20906 
  def validate(self):
20907 
    return
20908 
 
20909 
 
20910 
  def __repr__(self):
20911 
    L = ['%s=%r' % (key, value)
20912 
      for key, value in self.__dict__.iteritems()]
20913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20914 
 
20915 
  def __eq__(self, other):
20916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20917 
 
20918 
  def __ne__(self, other):
20919 
    return not (self == other)
20920 
 
20921 
class markOrderCancellationRequestDenied_args:
20922 
  """
20923 
  Attributes:
20924 
   - orderId
20925 
  """
20926 
 
20927 
  thrift_spec = (
20928 
    None, # 0
20929 
    (1, TType.I64, 'orderId', None, None, ), # 1
20930 
  )
20931 
 
20932 
  def __init__(self, orderId=None,):
20933 
    self.orderId = orderId
20934 
 
20935 
  def read(self, iprot):
20936 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20937 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20938 
      return
20939 
    iprot.readStructBegin()
20940 
    while True:
20941 
      (fname, ftype, fid) = iprot.readFieldBegin()
20942 
      if ftype == TType.STOP:
20943 
        break
20944 
      if fid == 1:
20945 
        if ftype == TType.I64:
20946 
          self.orderId = iprot.readI64();
20947 
        else:
20948 
          iprot.skip(ftype)
20949 
      else:
20950 
        iprot.skip(ftype)
20951 
      iprot.readFieldEnd()
20952 
    iprot.readStructEnd()
20953 
 
20954 
  def write(self, oprot):
20955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20957 
      return
20958 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
20959 
    if self.orderId is not None:
20960 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20961 
      oprot.writeI64(self.orderId)
20962 
      oprot.writeFieldEnd()
20963 
    oprot.writeFieldStop()
20964 
    oprot.writeStructEnd()
20965 
 
20966 
  def validate(self):
20967 
    return
20968 
 
20969 
 
20970 
  def __repr__(self):
20971 
    L = ['%s=%r' % (key, value)
20972 
      for key, value in self.__dict__.iteritems()]
20973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20974 
 
20975 
  def __eq__(self, other):
20976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20977 
 
20978 
  def __ne__(self, other):
20979 
    return not (self == other)
20980 
 
20981 
class markOrderCancellationRequestDenied_result:
20982 
  """
20983 
  Attributes:
20984 
   - ex
20985 
  """
20986 
 
20987 
  thrift_spec = (
20988 
    None, # 0
20989 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20990 
  )
20991 
 
20992 
  def __init__(self, ex=None,):
20993 
    self.ex = ex
20994 
 
20995 
  def read(self, iprot):
20996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20998 
      return
20999 
    iprot.readStructBegin()
21000 
    while True:
21001 
      (fname, ftype, fid) = iprot.readFieldBegin()
21002 
      if ftype == TType.STOP:
21003 
        break
21004 
      if fid == 1:
21005 
        if ftype == TType.STRUCT:
21006 
          self.ex = TransactionServiceException()
21007 
          self.ex.read(iprot)
21008 
        else:
21009 
          iprot.skip(ftype)
21010 
      else:
21011 
        iprot.skip(ftype)
21012 
      iprot.readFieldEnd()
21013 
    iprot.readStructEnd()
21014 
 
21015 
  def write(self, oprot):
21016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21018 
      return
21019 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
21020 
    if self.ex is not None:
21021 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21022 
      self.ex.write(oprot)
21023 
      oprot.writeFieldEnd()
21024 
    oprot.writeFieldStop()
21025 
    oprot.writeStructEnd()
21026 
 
21027 
  def validate(self):
21028 
    return
21029 
 
21030 
 
21031 
  def __repr__(self):
21032 
    L = ['%s=%r' % (key, value)
21033 
      for key, value in self.__dict__.iteritems()]
21034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21035 
 
21036 
  def __eq__(self, other):
21037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21038 
 
21039 
  def __ne__(self, other):
21040 
    return not (self == other)
21041 
 
4258 rajveer 21042 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 21043 
  """
21044 
  Attributes:
4258 rajveer 21045 
   - transactionId
4247 rajveer 21046 
  """
21047 
 
21048 
  thrift_spec = (
21049 
    None, # 0
4258 rajveer 21050 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 21051 
  )
21052 
 
4258 rajveer 21053 
  def __init__(self, transactionId=None,):
21054 
    self.transactionId = transactionId
4247 rajveer 21055 
 
21056 
  def read(self, iprot):
21057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21059 
      return
21060 
    iprot.readStructBegin()
21061 
    while True:
21062 
      (fname, ftype, fid) = iprot.readFieldBegin()
21063 
      if ftype == TType.STOP:
21064 
        break
21065 
      if fid == 1:
21066 
        if ftype == TType.I64:
4258 rajveer 21067 
          self.transactionId = iprot.readI64();
4247 rajveer 21068 
        else:
21069 
          iprot.skip(ftype)
21070 
      else:
21071 
        iprot.skip(ftype)
21072 
      iprot.readFieldEnd()
21073 
    iprot.readStructEnd()
21074 
 
21075 
  def write(self, oprot):
21076 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21077 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21078 
      return
4258 rajveer 21079 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
21080 
    if self.transactionId is not None:
21081 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21082 
      oprot.writeI64(self.transactionId)
4247 rajveer 21083 
      oprot.writeFieldEnd()
21084 
    oprot.writeFieldStop()
21085 
    oprot.writeStructEnd()
21086 
 
21087 
  def validate(self):
21088 
    return
21089 
 
21090 
 
21091 
  def __repr__(self):
21092 
    L = ['%s=%r' % (key, value)
21093 
      for key, value in self.__dict__.iteritems()]
21094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21095 
 
21096 
  def __eq__(self, other):
21097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21098 
 
21099 
  def __ne__(self, other):
21100 
    return not (self == other)
21101 
 
4258 rajveer 21102 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 21103 
  """
21104 
  Attributes:
21105 
   - ex
21106 
  """
21107 
 
21108 
  thrift_spec = (
21109 
    None, # 0
21110 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21111 
  )
21112 
 
21113 
  def __init__(self, ex=None,):
21114 
    self.ex = ex
21115 
 
21116 
  def read(self, iprot):
21117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21119 
      return
21120 
    iprot.readStructBegin()
21121 
    while True:
21122 
      (fname, ftype, fid) = iprot.readFieldBegin()
21123 
      if ftype == TType.STOP:
21124 
        break
21125 
      if fid == 1:
21126 
        if ftype == TType.STRUCT:
21127 
          self.ex = TransactionServiceException()
21128 
          self.ex.read(iprot)
21129 
        else:
21130 
          iprot.skip(ftype)
21131 
      else:
21132 
        iprot.skip(ftype)
21133 
      iprot.readFieldEnd()
21134 
    iprot.readStructEnd()
21135 
 
21136 
  def write(self, oprot):
21137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21139 
      return
4258 rajveer 21140 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 21141 
    if self.ex is not None:
21142 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21143 
      self.ex.write(oprot)
21144 
      oprot.writeFieldEnd()
21145 
    oprot.writeFieldStop()
21146 
    oprot.writeStructEnd()
21147 
 
21148 
  def validate(self):
21149 
    return
21150 
 
21151 
 
21152 
  def __repr__(self):
21153 
    L = ['%s=%r' % (key, value)
21154 
      for key, value in self.__dict__.iteritems()]
21155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21156 
 
21157 
  def __eq__(self, other):
21158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21159 
 
21160 
  def __ne__(self, other):
21161 
    return not (self == other)
4259 anupam.sin 21162 
 
21163 
class refundTransaction_args:
21164 
  """
21165 
  Attributes:
21166 
   - transactionId
21167 
   - refundedBy
21168 
   - reason
21169 
  """
21170 
 
21171 
  thrift_spec = (
21172 
    None, # 0
21173 
    (1, TType.I64, 'transactionId', None, None, ), # 1
21174 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
21175 
    (3, TType.STRING, 'reason', None, None, ), # 3
21176 
  )
21177 
 
21178 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
21179 
    self.transactionId = transactionId
21180 
    self.refundedBy = refundedBy
21181 
    self.reason = reason
21182 
 
21183 
  def read(self, iprot):
21184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21186 
      return
21187 
    iprot.readStructBegin()
21188 
    while True:
21189 
      (fname, ftype, fid) = iprot.readFieldBegin()
21190 
      if ftype == TType.STOP:
21191 
        break
21192 
      if fid == 1:
21193 
        if ftype == TType.I64:
21194 
          self.transactionId = iprot.readI64();
21195 
        else:
21196 
          iprot.skip(ftype)
21197 
      elif fid == 2:
21198 
        if ftype == TType.STRING:
21199 
          self.refundedBy = iprot.readString();
21200 
        else:
21201 
          iprot.skip(ftype)
21202 
      elif fid == 3:
21203 
        if ftype == TType.STRING:
21204 
          self.reason = iprot.readString();
21205 
        else:
21206 
          iprot.skip(ftype)
21207 
      else:
21208 
        iprot.skip(ftype)
21209 
      iprot.readFieldEnd()
21210 
    iprot.readStructEnd()
21211 
 
21212 
  def write(self, oprot):
21213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21215 
      return
21216 
    oprot.writeStructBegin('refundTransaction_args')
21217 
    if self.transactionId is not None:
21218 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21219 
      oprot.writeI64(self.transactionId)
21220 
      oprot.writeFieldEnd()
21221 
    if self.refundedBy is not None:
21222 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
21223 
      oprot.writeString(self.refundedBy)
21224 
      oprot.writeFieldEnd()
21225 
    if self.reason is not None:
21226 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
21227 
      oprot.writeString(self.reason)
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 refundTransaction_result:
21248 
  """
21249 
  Attributes:
21250 
   - ex
21251 
  """
21252 
 
21253 
  thrift_spec = (
21254 
    None, # 0
21255 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21256 
  )
21257 
 
21258 
  def __init__(self, ex=None,):
21259 
    self.ex = ex
21260 
 
21261 
  def read(self, iprot):
21262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21264 
      return
21265 
    iprot.readStructBegin()
21266 
    while True:
21267 
      (fname, ftype, fid) = iprot.readFieldBegin()
21268 
      if ftype == TType.STOP:
21269 
        break
21270 
      if fid == 1:
21271 
        if ftype == TType.STRUCT:
21272 
          self.ex = TransactionServiceException()
21273 
          self.ex.read(iprot)
21274 
        else:
21275 
          iprot.skip(ftype)
21276 
      else:
21277 
        iprot.skip(ftype)
21278 
      iprot.readFieldEnd()
21279 
    iprot.readStructEnd()
21280 
 
21281 
  def write(self, oprot):
21282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21284 
      return
21285 
    oprot.writeStructBegin('refundTransaction_result')
21286 
    if self.ex is not None:
21287 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21288 
      self.ex.write(oprot)
21289 
      oprot.writeFieldEnd()
21290 
    oprot.writeFieldStop()
21291 
    oprot.writeStructEnd()
21292 
 
21293 
  def validate(self):
21294 
    return
21295 
 
21296 
 
21297 
  def __repr__(self):
21298 
    L = ['%s=%r' % (key, value)
21299 
      for key, value in self.__dict__.iteritems()]
21300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21301 
 
21302 
  def __eq__(self, other):
21303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21304 
 
21305 
  def __ne__(self, other):
21306 
    return not (self == other)
4285 rajveer 21307 
 
4324 mandeep.dh 21308 
class updateShipmentAddress_args:
21309 
  """
21310 
  Attributes:
21311 
   - orderId
21312 
   - addressId
21313 
  """
21314 
 
21315 
  thrift_spec = (
21316 
    None, # 0
21317 
    (1, TType.I64, 'orderId', None, None, ), # 1
21318 
    (2, TType.I64, 'addressId', None, None, ), # 2
21319 
  )
21320 
 
21321 
  def __init__(self, orderId=None, addressId=None,):
21322 
    self.orderId = orderId
21323 
    self.addressId = addressId
21324 
 
21325 
  def read(self, iprot):
21326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21328 
      return
21329 
    iprot.readStructBegin()
21330 
    while True:
21331 
      (fname, ftype, fid) = iprot.readFieldBegin()
21332 
      if ftype == TType.STOP:
21333 
        break
21334 
      if fid == 1:
21335 
        if ftype == TType.I64:
21336 
          self.orderId = iprot.readI64();
21337 
        else:
21338 
          iprot.skip(ftype)
21339 
      elif fid == 2:
21340 
        if ftype == TType.I64:
21341 
          self.addressId = iprot.readI64();
21342 
        else:
21343 
          iprot.skip(ftype)
21344 
      else:
21345 
        iprot.skip(ftype)
21346 
      iprot.readFieldEnd()
21347 
    iprot.readStructEnd()
21348 
 
21349 
  def write(self, oprot):
21350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21352 
      return
21353 
    oprot.writeStructBegin('updateShipmentAddress_args')
21354 
    if self.orderId is not None:
21355 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21356 
      oprot.writeI64(self.orderId)
21357 
      oprot.writeFieldEnd()
21358 
    if self.addressId is not None:
21359 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
21360 
      oprot.writeI64(self.addressId)
21361 
      oprot.writeFieldEnd()
21362 
    oprot.writeFieldStop()
21363 
    oprot.writeStructEnd()
21364 
 
21365 
  def validate(self):
21366 
    return
21367 
 
21368 
 
21369 
  def __repr__(self):
21370 
    L = ['%s=%r' % (key, value)
21371 
      for key, value in self.__dict__.iteritems()]
21372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21373 
 
21374 
  def __eq__(self, other):
21375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21376 
 
21377 
  def __ne__(self, other):
21378 
    return not (self == other)
21379 
 
21380 
class updateShipmentAddress_result:
21381 
  """
21382 
  Attributes:
21383 
   - ex
21384 
  """
21385 
 
21386 
  thrift_spec = (
21387 
    None, # 0
21388 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21389 
  )
21390 
 
21391 
  def __init__(self, ex=None,):
21392 
    self.ex = ex
21393 
 
21394 
  def read(self, iprot):
21395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21397 
      return
21398 
    iprot.readStructBegin()
21399 
    while True:
21400 
      (fname, ftype, fid) = iprot.readFieldBegin()
21401 
      if ftype == TType.STOP:
21402 
        break
21403 
      if fid == 1:
21404 
        if ftype == TType.STRUCT:
21405 
          self.ex = TransactionServiceException()
21406 
          self.ex.read(iprot)
21407 
        else:
21408 
          iprot.skip(ftype)
21409 
      else:
21410 
        iprot.skip(ftype)
21411 
      iprot.readFieldEnd()
21412 
    iprot.readStructEnd()
21413 
 
21414 
  def write(self, oprot):
21415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21417 
      return
21418 
    oprot.writeStructBegin('updateShipmentAddress_result')
21419 
    if self.ex is not None:
21420 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21421 
      self.ex.write(oprot)
21422 
      oprot.writeFieldEnd()
21423 
    oprot.writeFieldStop()
21424 
    oprot.writeStructEnd()
21425 
 
21426 
  def validate(self):
21427 
    return
21428 
 
21429 
 
21430 
  def __repr__(self):
21431 
    L = ['%s=%r' % (key, value)
21432 
      for key, value in self.__dict__.iteritems()]
21433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21434 
 
21435 
  def __eq__(self, other):
21436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21437 
 
21438 
  def __ne__(self, other):
21439 
    return not (self == other)
21440 
 
4285 rajveer 21441 
class acceptOrdersForItemId_args:
21442 
  """
21443 
  Attributes:
21444 
   - itemId
21445 
   - inventory
21446 
  """
21447 
 
21448 
  thrift_spec = (
21449 
    None, # 0
21450 
    (1, TType.I64, 'itemId', None, None, ), # 1
21451 
    (2, TType.I64, 'inventory', None, None, ), # 2
21452 
  )
21453 
 
21454 
  def __init__(self, itemId=None, inventory=None,):
21455 
    self.itemId = itemId
21456 
    self.inventory = inventory
21457 
 
21458 
  def read(self, iprot):
21459 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21460 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21461 
      return
21462 
    iprot.readStructBegin()
21463 
    while True:
21464 
      (fname, ftype, fid) = iprot.readFieldBegin()
21465 
      if ftype == TType.STOP:
21466 
        break
21467 
      if fid == 1:
21468 
        if ftype == TType.I64:
21469 
          self.itemId = iprot.readI64();
21470 
        else:
21471 
          iprot.skip(ftype)
21472 
      elif fid == 2:
21473 
        if ftype == TType.I64:
21474 
          self.inventory = iprot.readI64();
21475 
        else:
21476 
          iprot.skip(ftype)
21477 
      else:
21478 
        iprot.skip(ftype)
21479 
      iprot.readFieldEnd()
21480 
    iprot.readStructEnd()
21481 
 
21482 
  def write(self, oprot):
21483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21485 
      return
21486 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
21487 
    if self.itemId is not None:
21488 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21489 
      oprot.writeI64(self.itemId)
21490 
      oprot.writeFieldEnd()
21491 
    if self.inventory is not None:
21492 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
21493 
      oprot.writeI64(self.inventory)
21494 
      oprot.writeFieldEnd()
21495 
    oprot.writeFieldStop()
21496 
    oprot.writeStructEnd()
21497 
 
21498 
  def validate(self):
21499 
    return
21500 
 
21501 
 
21502 
  def __repr__(self):
21503 
    L = ['%s=%r' % (key, value)
21504 
      for key, value in self.__dict__.iteritems()]
21505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21506 
 
21507 
  def __eq__(self, other):
21508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21509 
 
21510 
  def __ne__(self, other):
21511 
    return not (self == other)
21512 
 
21513 
class acceptOrdersForItemId_result:
21514 
  """
21515 
  Attributes:
21516 
   - success
21517 
   - ex
21518 
  """
21519 
 
21520 
  thrift_spec = (
21521 
    (0, TType.BOOL, 'success', None, None, ), # 0
21522 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21523 
  )
21524 
 
21525 
  def __init__(self, success=None, ex=None,):
21526 
    self.success = success
21527 
    self.ex = ex
21528 
 
21529 
  def read(self, iprot):
21530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21532 
      return
21533 
    iprot.readStructBegin()
21534 
    while True:
21535 
      (fname, ftype, fid) = iprot.readFieldBegin()
21536 
      if ftype == TType.STOP:
21537 
        break
21538 
      if fid == 0:
21539 
        if ftype == TType.BOOL:
21540 
          self.success = iprot.readBool();
21541 
        else:
21542 
          iprot.skip(ftype)
21543 
      elif fid == 1:
21544 
        if ftype == TType.STRUCT:
21545 
          self.ex = TransactionServiceException()
21546 
          self.ex.read(iprot)
21547 
        else:
21548 
          iprot.skip(ftype)
21549 
      else:
21550 
        iprot.skip(ftype)
21551 
      iprot.readFieldEnd()
21552 
    iprot.readStructEnd()
21553 
 
21554 
  def write(self, oprot):
21555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21557 
      return
21558 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
21559 
    if self.success is not None:
21560 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21561 
      oprot.writeBool(self.success)
21562 
      oprot.writeFieldEnd()
21563 
    if self.ex is not None:
21564 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21565 
      self.ex.write(oprot)
21566 
      oprot.writeFieldEnd()
21567 
    oprot.writeFieldStop()
21568 
    oprot.writeStructEnd()
21569 
 
21570 
  def validate(self):
21571 
    return
21572 
 
21573 
 
21574 
  def __repr__(self):
21575 
    L = ['%s=%r' % (key, value)
21576 
      for key, value in self.__dict__.iteritems()]
21577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21578 
 
21579 
  def __eq__(self, other):
21580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21581 
 
21582 
  def __ne__(self, other):
21583 
    return not (self == other)
4303 rajveer 21584 
 
21585 
class markOrdersAsPORaised_args:
21586 
  """
21587 
  Attributes:
21588 
   - vendorId
21589 
   - itemId
21590 
   - quantity
21591 
   - estimate
4369 rajveer 21592 
   - isReminder
4303 rajveer 21593 
  """
21594 
 
21595 
  thrift_spec = (
21596 
    None, # 0
21597 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21598 
    (2, TType.I64, 'itemId', None, None, ), # 2
21599 
    (3, TType.I64, 'quantity', None, None, ), # 3
21600 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21601 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21602 
  )
21603 
 
4369 rajveer 21604 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21605 
    self.vendorId = vendorId
21606 
    self.itemId = itemId
21607 
    self.quantity = quantity
21608 
    self.estimate = estimate
4369 rajveer 21609 
    self.isReminder = isReminder
4303 rajveer 21610 
 
21611 
  def read(self, iprot):
21612 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21613 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21614 
      return
21615 
    iprot.readStructBegin()
21616 
    while True:
21617 
      (fname, ftype, fid) = iprot.readFieldBegin()
21618 
      if ftype == TType.STOP:
21619 
        break
21620 
      if fid == 1:
21621 
        if ftype == TType.I64:
21622 
          self.vendorId = iprot.readI64();
21623 
        else:
21624 
          iprot.skip(ftype)
21625 
      elif fid == 2:
21626 
        if ftype == TType.I64:
21627 
          self.itemId = iprot.readI64();
21628 
        else:
21629 
          iprot.skip(ftype)
21630 
      elif fid == 3:
21631 
        if ftype == TType.I64:
21632 
          self.quantity = iprot.readI64();
21633 
        else:
21634 
          iprot.skip(ftype)
21635 
      elif fid == 4:
21636 
        if ftype == TType.I64:
21637 
          self.estimate = iprot.readI64();
21638 
        else:
21639 
          iprot.skip(ftype)
4369 rajveer 21640 
      elif fid == 5:
21641 
        if ftype == TType.BOOL:
21642 
          self.isReminder = iprot.readBool();
21643 
        else:
21644 
          iprot.skip(ftype)
4303 rajveer 21645 
      else:
21646 
        iprot.skip(ftype)
21647 
      iprot.readFieldEnd()
21648 
    iprot.readStructEnd()
21649 
 
21650 
  def write(self, oprot):
21651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21653 
      return
21654 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
21655 
    if self.vendorId is not None:
21656 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21657 
      oprot.writeI64(self.vendorId)
21658 
      oprot.writeFieldEnd()
21659 
    if self.itemId is not None:
21660 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21661 
      oprot.writeI64(self.itemId)
21662 
      oprot.writeFieldEnd()
21663 
    if self.quantity is not None:
21664 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21665 
      oprot.writeI64(self.quantity)
21666 
      oprot.writeFieldEnd()
21667 
    if self.estimate is not None:
21668 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21669 
      oprot.writeI64(self.estimate)
21670 
      oprot.writeFieldEnd()
4369 rajveer 21671 
    if self.isReminder is not None:
21672 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21673 
      oprot.writeBool(self.isReminder)
21674 
      oprot.writeFieldEnd()
4303 rajveer 21675 
    oprot.writeFieldStop()
21676 
    oprot.writeStructEnd()
21677 
 
21678 
  def validate(self):
21679 
    return
21680 
 
21681 
 
21682 
  def __repr__(self):
21683 
    L = ['%s=%r' % (key, value)
21684 
      for key, value in self.__dict__.iteritems()]
21685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21686 
 
21687 
  def __eq__(self, other):
21688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21689 
 
21690 
  def __ne__(self, other):
21691 
    return not (self == other)
21692 
 
21693 
class markOrdersAsPORaised_result:
21694 
  """
21695 
  Attributes:
21696 
   - ex
21697 
  """
21698 
 
21699 
  thrift_spec = (
21700 
    None, # 0
21701 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21702 
  )
21703 
 
21704 
  def __init__(self, ex=None,):
21705 
    self.ex = ex
21706 
 
21707 
  def read(self, iprot):
21708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21710 
      return
21711 
    iprot.readStructBegin()
21712 
    while True:
21713 
      (fname, ftype, fid) = iprot.readFieldBegin()
21714 
      if ftype == TType.STOP:
21715 
        break
21716 
      if fid == 1:
21717 
        if ftype == TType.STRUCT:
21718 
          self.ex = TransactionServiceException()
21719 
          self.ex.read(iprot)
21720 
        else:
21721 
          iprot.skip(ftype)
21722 
      else:
21723 
        iprot.skip(ftype)
21724 
      iprot.readFieldEnd()
21725 
    iprot.readStructEnd()
21726 
 
21727 
  def write(self, oprot):
21728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21730 
      return
21731 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
21732 
    if self.ex is not None:
21733 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21734 
      self.ex.write(oprot)
21735 
      oprot.writeFieldEnd()
21736 
    oprot.writeFieldStop()
21737 
    oprot.writeStructEnd()
21738 
 
21739 
  def validate(self):
21740 
    return
21741 
 
21742 
 
21743 
  def __repr__(self):
21744 
    L = ['%s=%r' % (key, value)
21745 
      for key, value in self.__dict__.iteritems()]
21746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21747 
 
21748 
  def __eq__(self, other):
21749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21750 
 
21751 
  def __ne__(self, other):
21752 
    return not (self == other)
21753 
 
21754 
class markOrdersAsReversalInitiated_args:
21755 
  """
21756 
  Attributes:
21757 
   - vendorId
21758 
   - itemId
21759 
   - quantity
21760 
   - estimate
4369 rajveer 21761 
   - isReminder
4303 rajveer 21762 
  """
21763 
 
21764 
  thrift_spec = (
21765 
    None, # 0
21766 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21767 
    (2, TType.I64, 'itemId', None, None, ), # 2
21768 
    (3, TType.I64, 'quantity', None, None, ), # 3
21769 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21770 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21771 
  )
21772 
 
4369 rajveer 21773 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21774 
    self.vendorId = vendorId
21775 
    self.itemId = itemId
21776 
    self.quantity = quantity
21777 
    self.estimate = estimate
4369 rajveer 21778 
    self.isReminder = isReminder
4303 rajveer 21779 
 
21780 
  def read(self, iprot):
21781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21783 
      return
21784 
    iprot.readStructBegin()
21785 
    while True:
21786 
      (fname, ftype, fid) = iprot.readFieldBegin()
21787 
      if ftype == TType.STOP:
21788 
        break
21789 
      if fid == 1:
21790 
        if ftype == TType.I64:
21791 
          self.vendorId = iprot.readI64();
21792 
        else:
21793 
          iprot.skip(ftype)
21794 
      elif fid == 2:
21795 
        if ftype == TType.I64:
21796 
          self.itemId = iprot.readI64();
21797 
        else:
21798 
          iprot.skip(ftype)
21799 
      elif fid == 3:
21800 
        if ftype == TType.I64:
21801 
          self.quantity = iprot.readI64();
21802 
        else:
21803 
          iprot.skip(ftype)
21804 
      elif fid == 4:
21805 
        if ftype == TType.I64:
21806 
          self.estimate = iprot.readI64();
21807 
        else:
21808 
          iprot.skip(ftype)
4369 rajveer 21809 
      elif fid == 5:
21810 
        if ftype == TType.BOOL:
21811 
          self.isReminder = iprot.readBool();
21812 
        else:
21813 
          iprot.skip(ftype)
4303 rajveer 21814 
      else:
21815 
        iprot.skip(ftype)
21816 
      iprot.readFieldEnd()
21817 
    iprot.readStructEnd()
21818 
 
21819 
  def write(self, oprot):
21820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21822 
      return
21823 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
21824 
    if self.vendorId is not None:
21825 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21826 
      oprot.writeI64(self.vendorId)
21827 
      oprot.writeFieldEnd()
21828 
    if self.itemId is not None:
21829 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21830 
      oprot.writeI64(self.itemId)
21831 
      oprot.writeFieldEnd()
21832 
    if self.quantity is not None:
21833 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21834 
      oprot.writeI64(self.quantity)
21835 
      oprot.writeFieldEnd()
21836 
    if self.estimate is not None:
21837 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21838 
      oprot.writeI64(self.estimate)
21839 
      oprot.writeFieldEnd()
4369 rajveer 21840 
    if self.isReminder is not None:
21841 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21842 
      oprot.writeBool(self.isReminder)
21843 
      oprot.writeFieldEnd()
4303 rajveer 21844 
    oprot.writeFieldStop()
21845 
    oprot.writeStructEnd()
21846 
 
21847 
  def validate(self):
21848 
    return
21849 
 
21850 
 
21851 
  def __repr__(self):
21852 
    L = ['%s=%r' % (key, value)
21853 
      for key, value in self.__dict__.iteritems()]
21854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21855 
 
21856 
  def __eq__(self, other):
21857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21858 
 
21859 
  def __ne__(self, other):
21860 
    return not (self == other)
21861 
 
21862 
class markOrdersAsReversalInitiated_result:
21863 
  """
21864 
  Attributes:
21865 
   - ex
21866 
  """
21867 
 
21868 
  thrift_spec = (
21869 
    None, # 0
21870 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21871 
  )
21872 
 
21873 
  def __init__(self, ex=None,):
21874 
    self.ex = ex
21875 
 
21876 
  def read(self, iprot):
21877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21879 
      return
21880 
    iprot.readStructBegin()
21881 
    while True:
21882 
      (fname, ftype, fid) = iprot.readFieldBegin()
21883 
      if ftype == TType.STOP:
21884 
        break
21885 
      if fid == 1:
21886 
        if ftype == TType.STRUCT:
21887 
          self.ex = TransactionServiceException()
21888 
          self.ex.read(iprot)
21889 
        else:
21890 
          iprot.skip(ftype)
21891 
      else:
21892 
        iprot.skip(ftype)
21893 
      iprot.readFieldEnd()
21894 
    iprot.readStructEnd()
21895 
 
21896 
  def write(self, oprot):
21897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21899 
      return
21900 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
21901 
    if self.ex is not None:
21902 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21903 
      self.ex.write(oprot)
21904 
      oprot.writeFieldEnd()
21905 
    oprot.writeFieldStop()
21906 
    oprot.writeStructEnd()
21907 
 
21908 
  def validate(self):
21909 
    return
21910 
 
21911 
 
21912 
  def __repr__(self):
21913 
    L = ['%s=%r' % (key, value)
21914 
      for key, value in self.__dict__.iteritems()]
21915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21916 
 
21917 
  def __eq__(self, other):
21918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21919 
 
21920 
  def __ne__(self, other):
21921 
    return not (self == other)
21922 
 
21923 
class markOrdersAsNotAvailabke_args:
21924 
  """
21925 
  Attributes:
21926 
   - vendorId
21927 
   - itemId
21928 
   - quantity
21929 
   - estimate
4369 rajveer 21930 
   - isReminder
4303 rajveer 21931 
  """
21932 
 
21933 
  thrift_spec = (
21934 
    None, # 0
21935 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21936 
    (2, TType.I64, 'itemId', None, None, ), # 2
21937 
    (3, TType.I64, 'quantity', None, None, ), # 3
21938 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21939 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21940 
  )
21941 
 
4369 rajveer 21942 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21943 
    self.vendorId = vendorId
21944 
    self.itemId = itemId
21945 
    self.quantity = quantity
21946 
    self.estimate = estimate
4369 rajveer 21947 
    self.isReminder = isReminder
4303 rajveer 21948 
 
21949 
  def read(self, iprot):
21950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21952 
      return
21953 
    iprot.readStructBegin()
21954 
    while True:
21955 
      (fname, ftype, fid) = iprot.readFieldBegin()
21956 
      if ftype == TType.STOP:
21957 
        break
21958 
      if fid == 1:
21959 
        if ftype == TType.I64:
21960 
          self.vendorId = iprot.readI64();
21961 
        else:
21962 
          iprot.skip(ftype)
21963 
      elif fid == 2:
21964 
        if ftype == TType.I64:
21965 
          self.itemId = iprot.readI64();
21966 
        else:
21967 
          iprot.skip(ftype)
21968 
      elif fid == 3:
21969 
        if ftype == TType.I64:
21970 
          self.quantity = iprot.readI64();
21971 
        else:
21972 
          iprot.skip(ftype)
21973 
      elif fid == 4:
21974 
        if ftype == TType.I64:
21975 
          self.estimate = iprot.readI64();
21976 
        else:
21977 
          iprot.skip(ftype)
4369 rajveer 21978 
      elif fid == 5:
21979 
        if ftype == TType.BOOL:
21980 
          self.isReminder = iprot.readBool();
21981 
        else:
21982 
          iprot.skip(ftype)
4303 rajveer 21983 
      else:
21984 
        iprot.skip(ftype)
21985 
      iprot.readFieldEnd()
21986 
    iprot.readStructEnd()
21987 
 
21988 
  def write(self, oprot):
21989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21991 
      return
21992 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
21993 
    if self.vendorId is not None:
21994 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21995 
      oprot.writeI64(self.vendorId)
21996 
      oprot.writeFieldEnd()
21997 
    if self.itemId is not None:
21998 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21999 
      oprot.writeI64(self.itemId)
22000 
      oprot.writeFieldEnd()
22001 
    if self.quantity is not None:
22002 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
22003 
      oprot.writeI64(self.quantity)
22004 
      oprot.writeFieldEnd()
22005 
    if self.estimate is not None:
22006 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
22007 
      oprot.writeI64(self.estimate)
22008 
      oprot.writeFieldEnd()
4369 rajveer 22009 
    if self.isReminder is not None:
22010 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
22011 
      oprot.writeBool(self.isReminder)
22012 
      oprot.writeFieldEnd()
4303 rajveer 22013 
    oprot.writeFieldStop()
22014 
    oprot.writeStructEnd()
22015 
 
22016 
  def validate(self):
22017 
    return
22018 
 
22019 
 
22020 
  def __repr__(self):
22021 
    L = ['%s=%r' % (key, value)
22022 
      for key, value in self.__dict__.iteritems()]
22023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22024 
 
22025 
  def __eq__(self, other):
22026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22027 
 
22028 
  def __ne__(self, other):
22029 
    return not (self == other)
22030 
 
22031 
class markOrdersAsNotAvailabke_result:
22032 
  """
22033 
  Attributes:
22034 
   - ex
22035 
  """
22036 
 
22037 
  thrift_spec = (
22038 
    None, # 0
22039 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22040 
  )
22041 
 
22042 
  def __init__(self, ex=None,):
22043 
    self.ex = ex
22044 
 
22045 
  def read(self, iprot):
22046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22048 
      return
22049 
    iprot.readStructBegin()
22050 
    while True:
22051 
      (fname, ftype, fid) = iprot.readFieldBegin()
22052 
      if ftype == TType.STOP:
22053 
        break
22054 
      if fid == 1:
22055 
        if ftype == TType.STRUCT:
22056 
          self.ex = TransactionServiceException()
22057 
          self.ex.read(iprot)
22058 
        else:
22059 
          iprot.skip(ftype)
22060 
      else:
22061 
        iprot.skip(ftype)
22062 
      iprot.readFieldEnd()
22063 
    iprot.readStructEnd()
22064 
 
22065 
  def write(self, oprot):
22066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22068 
      return
22069 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
22070 
    if self.ex is not None:
22071 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22072 
      self.ex.write(oprot)
22073 
      oprot.writeFieldEnd()
22074 
    oprot.writeFieldStop()
22075 
    oprot.writeStructEnd()
22076 
 
22077 
  def validate(self):
22078 
    return
22079 
 
22080 
 
22081 
  def __repr__(self):
22082 
    L = ['%s=%r' % (key, value)
22083 
      for key, value in self.__dict__.iteritems()]
22084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22085 
 
22086 
  def __eq__(self, other):
22087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22088 
 
22089 
  def __ne__(self, other):
22090 
    return not (self == other)
4369 rajveer 22091 
 
22092 
class markOrdersAsTimeout_args:
22093 
  """
22094 
  Attributes:
22095 
   - vendorId
22096 
  """
22097 
 
22098 
  thrift_spec = (
22099 
    None, # 0
22100 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22101 
  )
22102 
 
22103 
  def __init__(self, vendorId=None,):
22104 
    self.vendorId = vendorId
22105 
 
22106 
  def read(self, iprot):
22107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22109 
      return
22110 
    iprot.readStructBegin()
22111 
    while True:
22112 
      (fname, ftype, fid) = iprot.readFieldBegin()
22113 
      if ftype == TType.STOP:
22114 
        break
22115 
      if fid == 1:
22116 
        if ftype == TType.I64:
22117 
          self.vendorId = iprot.readI64();
22118 
        else:
22119 
          iprot.skip(ftype)
22120 
      else:
22121 
        iprot.skip(ftype)
22122 
      iprot.readFieldEnd()
22123 
    iprot.readStructEnd()
22124 
 
22125 
  def write(self, oprot):
22126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22128 
      return
22129 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
22130 
    if self.vendorId is not None:
22131 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22132 
      oprot.writeI64(self.vendorId)
22133 
      oprot.writeFieldEnd()
22134 
    oprot.writeFieldStop()
22135 
    oprot.writeStructEnd()
22136 
 
22137 
  def validate(self):
22138 
    return
22139 
 
22140 
 
22141 
  def __repr__(self):
22142 
    L = ['%s=%r' % (key, value)
22143 
      for key, value in self.__dict__.iteritems()]
22144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22145 
 
22146 
  def __eq__(self, other):
22147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22148 
 
22149 
  def __ne__(self, other):
22150 
    return not (self == other)
22151 
 
22152 
class markOrdersAsTimeout_result:
22153 
  """
22154 
  Attributes:
22155 
   - success
22156 
   - ex
22157 
  """
22158 
 
22159 
  thrift_spec = (
22160 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
22161 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22162 
  )
22163 
 
22164 
  def __init__(self, success=None, ex=None,):
22165 
    self.success = success
22166 
    self.ex = ex
22167 
 
22168 
  def read(self, iprot):
22169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22171 
      return
22172 
    iprot.readStructBegin()
22173 
    while True:
22174 
      (fname, ftype, fid) = iprot.readFieldBegin()
22175 
      if ftype == TType.STOP:
22176 
        break
22177 
      if fid == 0:
22178 
        if ftype == TType.MAP:
22179 
          self.success = {}
6188 rajveer 22180 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
22181 
          for _i505 in xrange(_size501):
22182 
            _key506 = iprot.readI32();
22183 
            _val507 = TimeoutSummary()
22184 
            _val507.read(iprot)
22185 
            self.success[_key506] = _val507
4369 rajveer 22186 
          iprot.readMapEnd()
22187 
        else:
22188 
          iprot.skip(ftype)
22189 
      elif fid == 1:
22190 
        if ftype == TType.STRUCT:
22191 
          self.ex = TransactionServiceException()
22192 
          self.ex.read(iprot)
22193 
        else:
22194 
          iprot.skip(ftype)
22195 
      else:
22196 
        iprot.skip(ftype)
22197 
      iprot.readFieldEnd()
22198 
    iprot.readStructEnd()
22199 
 
22200 
  def write(self, oprot):
22201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22203 
      return
22204 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
22205 
    if self.success is not None:
22206 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22207 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 22208 
      for kiter508,viter509 in self.success.items():
22209 
        oprot.writeI32(kiter508)
22210 
        viter509.write(oprot)
4369 rajveer 22211 
      oprot.writeMapEnd()
22212 
      oprot.writeFieldEnd()
22213 
    if self.ex is not None:
22214 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22215 
      self.ex.write(oprot)
22216 
      oprot.writeFieldEnd()
22217 
    oprot.writeFieldStop()
22218 
    oprot.writeStructEnd()
22219 
 
22220 
  def validate(self):
22221 
    return
22222 
 
22223 
 
22224 
  def __repr__(self):
22225 
    L = ['%s=%r' % (key, value)
22226 
      for key, value in self.__dict__.iteritems()]
22227 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22228 
 
22229 
  def __eq__(self, other):
22230 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22231 
 
22232 
  def __ne__(self, other):
22233 
    return not (self == other)
4386 anupam.sin 22234 
 
4662 rajveer 22235 
class markOrderAsLostInTransit_args:
22236 
  """
22237 
  Attributes:
22238 
   - orderId
22239 
  """
22240 
 
22241 
  thrift_spec = (
22242 
    None, # 0
22243 
    (1, TType.I64, 'orderId', None, None, ), # 1
22244 
  )
22245 
 
22246 
  def __init__(self, orderId=None,):
22247 
    self.orderId = orderId
22248 
 
22249 
  def read(self, iprot):
22250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22252 
      return
22253 
    iprot.readStructBegin()
22254 
    while True:
22255 
      (fname, ftype, fid) = iprot.readFieldBegin()
22256 
      if ftype == TType.STOP:
22257 
        break
22258 
      if fid == 1:
22259 
        if ftype == TType.I64:
22260 
          self.orderId = iprot.readI64();
22261 
        else:
22262 
          iprot.skip(ftype)
22263 
      else:
22264 
        iprot.skip(ftype)
22265 
      iprot.readFieldEnd()
22266 
    iprot.readStructEnd()
22267 
 
22268 
  def write(self, oprot):
22269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22271 
      return
22272 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
22273 
    if self.orderId is not None:
22274 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22275 
      oprot.writeI64(self.orderId)
22276 
      oprot.writeFieldEnd()
22277 
    oprot.writeFieldStop()
22278 
    oprot.writeStructEnd()
22279 
 
22280 
  def validate(self):
22281 
    return
22282 
 
22283 
 
22284 
  def __repr__(self):
22285 
    L = ['%s=%r' % (key, value)
22286 
      for key, value in self.__dict__.iteritems()]
22287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22288 
 
22289 
  def __eq__(self, other):
22290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22291 
 
22292 
  def __ne__(self, other):
22293 
    return not (self == other)
22294 
 
22295 
class markOrderAsLostInTransit_result:
22296 
  """
22297 
  Attributes:
22298 
   - success
22299 
   - ex
22300 
  """
22301 
 
22302 
  thrift_spec = (
22303 
    (0, TType.BOOL, 'success', None, None, ), # 0
22304 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22305 
  )
22306 
 
22307 
  def __init__(self, success=None, ex=None,):
22308 
    self.success = success
22309 
    self.ex = ex
22310 
 
22311 
  def read(self, iprot):
22312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22314 
      return
22315 
    iprot.readStructBegin()
22316 
    while True:
22317 
      (fname, ftype, fid) = iprot.readFieldBegin()
22318 
      if ftype == TType.STOP:
22319 
        break
22320 
      if fid == 0:
22321 
        if ftype == TType.BOOL:
22322 
          self.success = iprot.readBool();
22323 
        else:
22324 
          iprot.skip(ftype)
22325 
      elif fid == 1:
22326 
        if ftype == TType.STRUCT:
22327 
          self.ex = TransactionServiceException()
22328 
          self.ex.read(iprot)
22329 
        else:
22330 
          iprot.skip(ftype)
22331 
      else:
22332 
        iprot.skip(ftype)
22333 
      iprot.readFieldEnd()
22334 
    iprot.readStructEnd()
22335 
 
22336 
  def write(self, oprot):
22337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22339 
      return
22340 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
22341 
    if self.success is not None:
22342 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22343 
      oprot.writeBool(self.success)
22344 
      oprot.writeFieldEnd()
22345 
    if self.ex is not None:
22346 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22347 
      self.ex.write(oprot)
22348 
      oprot.writeFieldEnd()
22349 
    oprot.writeFieldStop()
22350 
    oprot.writeStructEnd()
22351 
 
22352 
  def validate(self):
22353 
    return
22354 
 
22355 
 
22356 
  def __repr__(self):
22357 
    L = ['%s=%r' % (key, value)
22358 
      for key, value in self.__dict__.iteritems()]
22359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22360 
 
22361 
  def __eq__(self, other):
22362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22363 
 
22364 
  def __ne__(self, other):
22365 
    return not (self == other)
22366 
 
4386 anupam.sin 22367 
class getOrderForAwb_args:
22368 
  """
22369 
  Attributes:
22370 
   - awb
22371 
  """
22372 
 
22373 
  thrift_spec = (
22374 
    None, # 0
22375 
    (1, TType.STRING, 'awb', None, None, ), # 1
22376 
  )
22377 
 
22378 
  def __init__(self, awb=None,):
22379 
    self.awb = awb
22380 
 
22381 
  def read(self, iprot):
22382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22384 
      return
22385 
    iprot.readStructBegin()
22386 
    while True:
22387 
      (fname, ftype, fid) = iprot.readFieldBegin()
22388 
      if ftype == TType.STOP:
22389 
        break
22390 
      if fid == 1:
22391 
        if ftype == TType.STRING:
22392 
          self.awb = iprot.readString();
22393 
        else:
22394 
          iprot.skip(ftype)
22395 
      else:
22396 
        iprot.skip(ftype)
22397 
      iprot.readFieldEnd()
22398 
    iprot.readStructEnd()
22399 
 
22400 
  def write(self, oprot):
22401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22403 
      return
22404 
    oprot.writeStructBegin('getOrderForAwb_args')
22405 
    if self.awb is not None:
22406 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
22407 
      oprot.writeString(self.awb)
22408 
      oprot.writeFieldEnd()
22409 
    oprot.writeFieldStop()
22410 
    oprot.writeStructEnd()
22411 
 
22412 
  def validate(self):
22413 
    return
22414 
 
22415 
 
22416 
  def __repr__(self):
22417 
    L = ['%s=%r' % (key, value)
22418 
      for key, value in self.__dict__.iteritems()]
22419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22420 
 
22421 
  def __eq__(self, other):
22422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22423 
 
22424 
  def __ne__(self, other):
22425 
    return not (self == other)
22426 
 
22427 
class getOrderForAwb_result:
22428 
  """
22429 
  Attributes:
22430 
   - success
22431 
   - ex
22432 
  """
22433 
 
22434 
  thrift_spec = (
22435 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
22436 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22437 
  )
22438 
 
22439 
  def __init__(self, success=None, ex=None,):
22440 
    self.success = success
22441 
    self.ex = ex
22442 
 
22443 
  def read(self, iprot):
22444 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22445 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22446 
      return
22447 
    iprot.readStructBegin()
22448 
    while True:
22449 
      (fname, ftype, fid) = iprot.readFieldBegin()
22450 
      if ftype == TType.STOP:
22451 
        break
22452 
      if fid == 0:
22453 
        if ftype == TType.STRUCT:
22454 
          self.success = Order()
22455 
          self.success.read(iprot)
22456 
        else:
22457 
          iprot.skip(ftype)
22458 
      elif fid == 1:
22459 
        if ftype == TType.STRUCT:
22460 
          self.ex = TransactionServiceException()
22461 
          self.ex.read(iprot)
22462 
        else:
22463 
          iprot.skip(ftype)
22464 
      else:
22465 
        iprot.skip(ftype)
22466 
      iprot.readFieldEnd()
22467 
    iprot.readStructEnd()
22468 
 
22469 
  def write(self, oprot):
22470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22472 
      return
22473 
    oprot.writeStructBegin('getOrderForAwb_result')
22474 
    if self.success is not None:
22475 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22476 
      self.success.write(oprot)
22477 
      oprot.writeFieldEnd()
22478 
    if self.ex is not None:
22479 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22480 
      self.ex.write(oprot)
22481 
      oprot.writeFieldEnd()
22482 
    oprot.writeFieldStop()
22483 
    oprot.writeStructEnd()
22484 
 
22485 
  def validate(self):
22486 
    return
22487 
 
22488 
 
22489 
  def __repr__(self):
22490 
    L = ['%s=%r' % (key, value)
22491 
      for key, value in self.__dict__.iteritems()]
22492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22493 
 
22494 
  def __eq__(self, other):
22495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22496 
 
22497 
  def __ne__(self, other):
22498 
    return not (self == other)
4506 phani.kuma 22499 
 
22500 
class getOrdersForProviderForStatus_args:
22501 
  """
22502 
  Attributes:
22503 
   - logistics_provider_id
4910 phani.kuma 22504 
   - order_status_list
4506 phani.kuma 22505 
  """
22506 
 
22507 
  thrift_spec = (
22508 
    None, # 0
22509 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 22510 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 22511 
  )
22512 
 
4910 phani.kuma 22513 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 22514 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 22515 
    self.order_status_list = order_status_list
4506 phani.kuma 22516 
 
22517 
  def read(self, iprot):
22518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22520 
      return
22521 
    iprot.readStructBegin()
22522 
    while True:
22523 
      (fname, ftype, fid) = iprot.readFieldBegin()
22524 
      if ftype == TType.STOP:
22525 
        break
22526 
      if fid == 1:
22527 
        if ftype == TType.I64:
22528 
          self.logistics_provider_id = iprot.readI64();
22529 
        else:
22530 
          iprot.skip(ftype)
22531 
      elif fid == 2:
4910 phani.kuma 22532 
        if ftype == TType.LIST:
22533 
          self.order_status_list = []
6188 rajveer 22534 
          (_etype513, _size510) = iprot.readListBegin()
22535 
          for _i514 in xrange(_size510):
22536 
            _elem515 = iprot.readI32();
22537 
            self.order_status_list.append(_elem515)
4910 phani.kuma 22538 
          iprot.readListEnd()
4506 phani.kuma 22539 
        else:
22540 
          iprot.skip(ftype)
22541 
      else:
22542 
        iprot.skip(ftype)
22543 
      iprot.readFieldEnd()
22544 
    iprot.readStructEnd()
22545 
 
22546 
  def write(self, oprot):
22547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22549 
      return
22550 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
22551 
    if self.logistics_provider_id is not None:
22552 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
22553 
      oprot.writeI64(self.logistics_provider_id)
22554 
      oprot.writeFieldEnd()
4910 phani.kuma 22555 
    if self.order_status_list is not None:
22556 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
22557 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 22558 
      for iter516 in self.order_status_list:
22559 
        oprot.writeI32(iter516)
4910 phani.kuma 22560 
      oprot.writeListEnd()
4506 phani.kuma 22561 
      oprot.writeFieldEnd()
22562 
    oprot.writeFieldStop()
22563 
    oprot.writeStructEnd()
22564 
 
22565 
  def validate(self):
22566 
    return
22567 
 
22568 
 
22569 
  def __repr__(self):
22570 
    L = ['%s=%r' % (key, value)
22571 
      for key, value in self.__dict__.iteritems()]
22572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22573 
 
22574 
  def __eq__(self, other):
22575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22576 
 
22577 
  def __ne__(self, other):
22578 
    return not (self == other)
22579 
 
22580 
class getOrdersForProviderForStatus_result:
22581 
  """
22582 
  Attributes:
22583 
   - success
22584 
   - ex
22585 
  """
22586 
 
22587 
  thrift_spec = (
22588 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22589 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22590 
  )
22591 
 
22592 
  def __init__(self, success=None, ex=None,):
22593 
    self.success = success
22594 
    self.ex = ex
22595 
 
22596 
  def read(self, iprot):
22597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22599 
      return
22600 
    iprot.readStructBegin()
22601 
    while True:
22602 
      (fname, ftype, fid) = iprot.readFieldBegin()
22603 
      if ftype == TType.STOP:
22604 
        break
22605 
      if fid == 0:
22606 
        if ftype == TType.LIST:
22607 
          self.success = []
6188 rajveer 22608 
          (_etype520, _size517) = iprot.readListBegin()
22609 
          for _i521 in xrange(_size517):
22610 
            _elem522 = Order()
22611 
            _elem522.read(iprot)
22612 
            self.success.append(_elem522)
4506 phani.kuma 22613 
          iprot.readListEnd()
22614 
        else:
22615 
          iprot.skip(ftype)
22616 
      elif fid == 1:
22617 
        if ftype == TType.STRUCT:
22618 
          self.ex = TransactionServiceException()
22619 
          self.ex.read(iprot)
22620 
        else:
22621 
          iprot.skip(ftype)
22622 
      else:
22623 
        iprot.skip(ftype)
22624 
      iprot.readFieldEnd()
22625 
    iprot.readStructEnd()
22626 
 
22627 
  def write(self, oprot):
22628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22630 
      return
22631 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
22632 
    if self.success is not None:
22633 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22634 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22635 
      for iter523 in self.success:
22636 
        iter523.write(oprot)
4506 phani.kuma 22637 
      oprot.writeListEnd()
22638 
      oprot.writeFieldEnd()
22639 
    if self.ex is not None:
22640 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22641 
      self.ex.write(oprot)
22642 
      oprot.writeFieldEnd()
22643 
    oprot.writeFieldStop()
22644 
    oprot.writeStructEnd()
22645 
 
22646 
  def validate(self):
22647 
    return
22648 
 
22649 
 
22650 
  def __repr__(self):
22651 
    L = ['%s=%r' % (key, value)
22652 
      for key, value in self.__dict__.iteritems()]
22653 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22654 
 
22655 
  def __eq__(self, other):
22656 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22657 
 
22658 
  def __ne__(self, other):
22659 
    return not (self == other)
4600 varun.gupt 22660 
 
22661 
class getBilledOrdersForVendor_args:
22662 
  """
22663 
  Attributes:
22664 
   - vendorId
22665 
   - billingDateFrom
22666 
   - billingDateTo
22667 
  """
22668 
 
22669 
  thrift_spec = (
22670 
    None, # 0
22671 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22672 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
22673 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
22674 
  )
22675 
 
22676 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
22677 
    self.vendorId = vendorId
22678 
    self.billingDateFrom = billingDateFrom
22679 
    self.billingDateTo = billingDateTo
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.I64:
22692 
          self.vendorId = iprot.readI64();
22693 
        else:
22694 
          iprot.skip(ftype)
22695 
      elif fid == 2:
22696 
        if ftype == TType.I64:
22697 
          self.billingDateFrom = iprot.readI64();
22698 
        else:
22699 
          iprot.skip(ftype)
22700 
      elif fid == 3:
22701 
        if ftype == TType.I64:
22702 
          self.billingDateTo = iprot.readI64();
22703 
        else:
22704 
          iprot.skip(ftype)
22705 
      else:
22706 
        iprot.skip(ftype)
22707 
      iprot.readFieldEnd()
22708 
    iprot.readStructEnd()
22709 
 
22710 
  def write(self, oprot):
22711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22713 
      return
22714 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
22715 
    if self.vendorId is not None:
22716 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22717 
      oprot.writeI64(self.vendorId)
22718 
      oprot.writeFieldEnd()
22719 
    if self.billingDateFrom is not None:
22720 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
22721 
      oprot.writeI64(self.billingDateFrom)
22722 
      oprot.writeFieldEnd()
22723 
    if self.billingDateTo is not None:
22724 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
22725 
      oprot.writeI64(self.billingDateTo)
22726 
      oprot.writeFieldEnd()
22727 
    oprot.writeFieldStop()
22728 
    oprot.writeStructEnd()
22729 
 
22730 
  def validate(self):
22731 
    return
22732 
 
22733 
 
22734 
  def __repr__(self):
22735 
    L = ['%s=%r' % (key, value)
22736 
      for key, value in self.__dict__.iteritems()]
22737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22738 
 
22739 
  def __eq__(self, other):
22740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22741 
 
22742 
  def __ne__(self, other):
22743 
    return not (self == other)
22744 
 
22745 
class getBilledOrdersForVendor_result:
22746 
  """
22747 
  Attributes:
22748 
   - success
22749 
   - ex
22750 
  """
22751 
 
22752 
  thrift_spec = (
22753 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22754 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22755 
  )
22756 
 
22757 
  def __init__(self, success=None, ex=None,):
22758 
    self.success = success
22759 
    self.ex = ex
22760 
 
22761 
  def read(self, iprot):
22762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22764 
      return
22765 
    iprot.readStructBegin()
22766 
    while True:
22767 
      (fname, ftype, fid) = iprot.readFieldBegin()
22768 
      if ftype == TType.STOP:
22769 
        break
22770 
      if fid == 0:
22771 
        if ftype == TType.LIST:
22772 
          self.success = []
6188 rajveer 22773 
          (_etype527, _size524) = iprot.readListBegin()
22774 
          for _i528 in xrange(_size524):
22775 
            _elem529 = Order()
22776 
            _elem529.read(iprot)
22777 
            self.success.append(_elem529)
4600 varun.gupt 22778 
          iprot.readListEnd()
22779 
        else:
22780 
          iprot.skip(ftype)
22781 
      elif fid == 1:
22782 
        if ftype == TType.STRUCT:
22783 
          self.ex = TransactionServiceException()
22784 
          self.ex.read(iprot)
22785 
        else:
22786 
          iprot.skip(ftype)
22787 
      else:
22788 
        iprot.skip(ftype)
22789 
      iprot.readFieldEnd()
22790 
    iprot.readStructEnd()
22791 
 
22792 
  def write(self, oprot):
22793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22795 
      return
22796 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
22797 
    if self.success is not None:
22798 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22799 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22800 
      for iter530 in self.success:
22801 
        iter530.write(oprot)
4600 varun.gupt 22802 
      oprot.writeListEnd()
22803 
      oprot.writeFieldEnd()
22804 
    if self.ex is not None:
22805 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22806 
      self.ex.write(oprot)
22807 
      oprot.writeFieldEnd()
22808 
    oprot.writeFieldStop()
22809 
    oprot.writeStructEnd()
22810 
 
22811 
  def validate(self):
22812 
    return
22813 
 
22814 
 
22815 
  def __repr__(self):
22816 
    L = ['%s=%r' % (key, value)
22817 
      for key, value in self.__dict__.iteritems()]
22818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22819 
 
22820 
  def __eq__(self, other):
22821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22822 
 
22823 
  def __ne__(self, other):
22824 
    return not (self == other)
22825 
 
4607 rajveer 22826 
class getSlippedSippingDateOrders_args:
22827 
 
22828 
  thrift_spec = (
22829 
  )
22830 
 
22831 
  def read(self, iprot):
22832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22834 
      return
22835 
    iprot.readStructBegin()
22836 
    while True:
22837 
      (fname, ftype, fid) = iprot.readFieldBegin()
22838 
      if ftype == TType.STOP:
22839 
        break
22840 
      else:
22841 
        iprot.skip(ftype)
22842 
      iprot.readFieldEnd()
22843 
    iprot.readStructEnd()
22844 
 
22845 
  def write(self, oprot):
22846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22848 
      return
22849 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
22850 
    oprot.writeFieldStop()
22851 
    oprot.writeStructEnd()
22852 
 
22853 
  def validate(self):
22854 
    return
22855 
 
22856 
 
22857 
  def __repr__(self):
22858 
    L = ['%s=%r' % (key, value)
22859 
      for key, value in self.__dict__.iteritems()]
22860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22861 
 
22862 
  def __eq__(self, other):
22863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22864 
 
22865 
  def __ne__(self, other):
22866 
    return not (self == other)
22867 
 
22868 
class getSlippedSippingDateOrders_result:
22869 
  """
22870 
  Attributes:
22871 
   - success
22872 
   - ex
22873 
  """
22874 
 
22875 
  thrift_spec = (
22876 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22877 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22878 
  )
22879 
 
22880 
  def __init__(self, success=None, ex=None,):
22881 
    self.success = success
22882 
    self.ex = ex
22883 
 
22884 
  def read(self, iprot):
22885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22887 
      return
22888 
    iprot.readStructBegin()
22889 
    while True:
22890 
      (fname, ftype, fid) = iprot.readFieldBegin()
22891 
      if ftype == TType.STOP:
22892 
        break
22893 
      if fid == 0:
22894 
        if ftype == TType.LIST:
22895 
          self.success = []
6188 rajveer 22896 
          (_etype534, _size531) = iprot.readListBegin()
22897 
          for _i535 in xrange(_size531):
22898 
            _elem536 = Order()
22899 
            _elem536.read(iprot)
22900 
            self.success.append(_elem536)
4607 rajveer 22901 
          iprot.readListEnd()
22902 
        else:
22903 
          iprot.skip(ftype)
22904 
      elif fid == 1:
22905 
        if ftype == TType.STRUCT:
22906 
          self.ex = TransactionServiceException()
22907 
          self.ex.read(iprot)
22908 
        else:
22909 
          iprot.skip(ftype)
22910 
      else:
22911 
        iprot.skip(ftype)
22912 
      iprot.readFieldEnd()
22913 
    iprot.readStructEnd()
22914 
 
22915 
  def write(self, oprot):
22916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22918 
      return
22919 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22920 
    if self.success is not None:
22921 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22922 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22923 
      for iter537 in self.success:
22924 
        iter537.write(oprot)
4607 rajveer 22925 
      oprot.writeListEnd()
22926 
      oprot.writeFieldEnd()
22927 
    if self.ex is not None:
22928 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22929 
      self.ex.write(oprot)
22930 
      oprot.writeFieldEnd()
22931 
    oprot.writeFieldStop()
22932 
    oprot.writeStructEnd()
22933 
 
22934 
  def validate(self):
22935 
    return
22936 
 
22937 
 
22938 
  def __repr__(self):
22939 
    L = ['%s=%r' % (key, value)
22940 
      for key, value in self.__dict__.iteritems()]
22941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22942 
 
22943 
  def __eq__(self, other):
22944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22945 
 
22946 
  def __ne__(self, other):
22947 
    return not (self == other)
22948 
 
4709 rajveer 22949 
class getCancelledOrders_args:
22950 
  """
22951 
  Attributes:
22952 
   - cancelDateFrom
22953 
   - cancelDateTo
22954 
  """
22955 
 
22956 
  thrift_spec = (
22957 
    None, # 0
22958 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
22959 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
22960 
  )
22961 
 
22962 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
22963 
    self.cancelDateFrom = cancelDateFrom
22964 
    self.cancelDateTo = cancelDateTo
22965 
 
22966 
  def read(self, iprot):
22967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22969 
      return
22970 
    iprot.readStructBegin()
22971 
    while True:
22972 
      (fname, ftype, fid) = iprot.readFieldBegin()
22973 
      if ftype == TType.STOP:
22974 
        break
22975 
      if fid == 1:
22976 
        if ftype == TType.I64:
22977 
          self.cancelDateFrom = iprot.readI64();
22978 
        else:
22979 
          iprot.skip(ftype)
22980 
      elif fid == 2:
22981 
        if ftype == TType.I64:
22982 
          self.cancelDateTo = iprot.readI64();
22983 
        else:
22984 
          iprot.skip(ftype)
22985 
      else:
22986 
        iprot.skip(ftype)
22987 
      iprot.readFieldEnd()
22988 
    iprot.readStructEnd()
22989 
 
22990 
  def write(self, oprot):
22991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22993 
      return
22994 
    oprot.writeStructBegin('getCancelledOrders_args')
22995 
    if self.cancelDateFrom is not None:
22996 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
22997 
      oprot.writeI64(self.cancelDateFrom)
22998 
      oprot.writeFieldEnd()
22999 
    if self.cancelDateTo is not None:
23000 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
23001 
      oprot.writeI64(self.cancelDateTo)
23002 
      oprot.writeFieldEnd()
23003 
    oprot.writeFieldStop()
23004 
    oprot.writeStructEnd()
23005 
 
23006 
  def validate(self):
23007 
    return
23008 
 
23009 
 
23010 
  def __repr__(self):
23011 
    L = ['%s=%r' % (key, value)
23012 
      for key, value in self.__dict__.iteritems()]
23013 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23014 
 
23015 
  def __eq__(self, other):
23016 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23017 
 
23018 
  def __ne__(self, other):
23019 
    return not (self == other)
23020 
 
23021 
class getCancelledOrders_result:
23022 
  """
23023 
  Attributes:
23024 
   - success
23025 
   - ex
23026 
  """
23027 
 
23028 
  thrift_spec = (
23029 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
23030 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23031 
  )
23032 
 
23033 
  def __init__(self, success=None, ex=None,):
23034 
    self.success = success
23035 
    self.ex = ex
23036 
 
23037 
  def read(self, iprot):
23038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23040 
      return
23041 
    iprot.readStructBegin()
23042 
    while True:
23043 
      (fname, ftype, fid) = iprot.readFieldBegin()
23044 
      if ftype == TType.STOP:
23045 
        break
23046 
      if fid == 0:
23047 
        if ftype == TType.LIST:
23048 
          self.success = []
6188 rajveer 23049 
          (_etype541, _size538) = iprot.readListBegin()
23050 
          for _i542 in xrange(_size538):
23051 
            _elem543 = Order()
23052 
            _elem543.read(iprot)
23053 
            self.success.append(_elem543)
4709 rajveer 23054 
          iprot.readListEnd()
23055 
        else:
23056 
          iprot.skip(ftype)
23057 
      elif fid == 1:
23058 
        if ftype == TType.STRUCT:
23059 
          self.ex = TransactionServiceException()
23060 
          self.ex.read(iprot)
23061 
        else:
23062 
          iprot.skip(ftype)
23063 
      else:
23064 
        iprot.skip(ftype)
23065 
      iprot.readFieldEnd()
23066 
    iprot.readStructEnd()
23067 
 
23068 
  def write(self, oprot):
23069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23071 
      return
23072 
    oprot.writeStructBegin('getCancelledOrders_result')
23073 
    if self.success is not None:
23074 
      oprot.writeFieldBegin('success', TType.LIST, 0)
23075 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 23076 
      for iter544 in self.success:
23077 
        iter544.write(oprot)
4709 rajveer 23078 
      oprot.writeListEnd()
23079 
      oprot.writeFieldEnd()
23080 
    if self.ex is not None:
23081 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23082 
      self.ex.write(oprot)
23083 
      oprot.writeFieldEnd()
23084 
    oprot.writeFieldStop()
23085 
    oprot.writeStructEnd()
23086 
 
23087 
  def validate(self):
23088 
    return
23089 
 
23090 
 
23091 
  def __repr__(self):
23092 
    L = ['%s=%r' % (key, value)
23093 
      for key, value in self.__dict__.iteritems()]
23094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23095 
 
23096 
  def __eq__(self, other):
23097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23098 
 
23099 
  def __ne__(self, other):
23100 
    return not (self == other)
23101 
 
4600 varun.gupt 23102 
class saveBluedartSettlements_args:
23103 
  """
23104 
  Attributes:
23105 
   - mapAWBAndAmount
23106 
  """
23107 
 
23108 
  thrift_spec = (
23109 
    None, # 0
23110 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
23111 
  )
23112 
 
23113 
  def __init__(self, mapAWBAndAmount=None,):
23114 
    self.mapAWBAndAmount = mapAWBAndAmount
23115 
 
23116 
  def read(self, iprot):
23117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23119 
      return
23120 
    iprot.readStructBegin()
23121 
    while True:
23122 
      (fname, ftype, fid) = iprot.readFieldBegin()
23123 
      if ftype == TType.STOP:
23124 
        break
23125 
      if fid == 1:
23126 
        if ftype == TType.MAP:
23127 
          self.mapAWBAndAmount = {}
6188 rajveer 23128 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
23129 
          for _i549 in xrange(_size545):
23130 
            _key550 = iprot.readI64();
23131 
            _val551 = iprot.readDouble();
23132 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 23133 
          iprot.readMapEnd()
23134 
        else:
23135 
          iprot.skip(ftype)
23136 
      else:
23137 
        iprot.skip(ftype)
23138 
      iprot.readFieldEnd()
23139 
    iprot.readStructEnd()
23140 
 
23141 
  def write(self, oprot):
23142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23144 
      return
23145 
    oprot.writeStructBegin('saveBluedartSettlements_args')
23146 
    if self.mapAWBAndAmount is not None:
23147 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
23148 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 23149 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
23150 
        oprot.writeI64(kiter552)
23151 
        oprot.writeDouble(viter553)
4600 varun.gupt 23152 
      oprot.writeMapEnd()
23153 
      oprot.writeFieldEnd()
23154 
    oprot.writeFieldStop()
23155 
    oprot.writeStructEnd()
23156 
 
23157 
  def validate(self):
23158 
    return
23159 
 
23160 
 
23161 
  def __repr__(self):
23162 
    L = ['%s=%r' % (key, value)
23163 
      for key, value in self.__dict__.iteritems()]
23164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23165 
 
23166 
  def __eq__(self, other):
23167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23168 
 
23169 
  def __ne__(self, other):
23170 
    return not (self == other)
23171 
 
23172 
class saveBluedartSettlements_result:
23173 
  """
23174 
  Attributes:
23175 
   - ex
23176 
  """
23177 
 
23178 
  thrift_spec = (
23179 
    None, # 0
23180 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23181 
  )
23182 
 
23183 
  def __init__(self, ex=None,):
23184 
    self.ex = ex
23185 
 
23186 
  def read(self, iprot):
23187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23189 
      return
23190 
    iprot.readStructBegin()
23191 
    while True:
23192 
      (fname, ftype, fid) = iprot.readFieldBegin()
23193 
      if ftype == TType.STOP:
23194 
        break
23195 
      if fid == 1:
23196 
        if ftype == TType.STRUCT:
23197 
          self.ex = TransactionServiceException()
23198 
          self.ex.read(iprot)
23199 
        else:
23200 
          iprot.skip(ftype)
23201 
      else:
23202 
        iprot.skip(ftype)
23203 
      iprot.readFieldEnd()
23204 
    iprot.readStructEnd()
23205 
 
23206 
  def write(self, oprot):
23207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23209 
      return
23210 
    oprot.writeStructBegin('saveBluedartSettlements_result')
23211 
    if self.ex is not None:
23212 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23213 
      self.ex.write(oprot)
23214 
      oprot.writeFieldEnd()
23215 
    oprot.writeFieldStop()
23216 
    oprot.writeStructEnd()
23217 
 
23218 
  def validate(self):
23219 
    return
23220 
 
23221 
 
23222 
  def __repr__(self):
23223 
    L = ['%s=%r' % (key, value)
23224 
      for key, value in self.__dict__.iteritems()]
23225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23226 
 
23227 
  def __eq__(self, other):
23228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23229 
 
23230 
  def __ne__(self, other):
23231 
    return not (self == other)
23232 
 
23233 
class savePaymentSettlements_args:
23234 
  """
23235 
  Attributes:
23236 
   - settlementDate
23237 
   - paymentGatewayId
4905 varun.gupt 23238 
   - referenceId
4600 varun.gupt 23239 
   - serviceTax
23240 
   - otherCharges
23241 
   - netCollection
23242 
  """
23243 
 
23244 
  thrift_spec = (
23245 
    None, # 0
23246 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
23247 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 23248 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 23249 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
23250 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
23251 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
23252 
  )
23253 
 
4905 varun.gupt 23254 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 23255 
    self.settlementDate = settlementDate
23256 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 23257 
    self.referenceId = referenceId
4600 varun.gupt 23258 
    self.serviceTax = serviceTax
23259 
    self.otherCharges = otherCharges
23260 
    self.netCollection = netCollection
23261 
 
23262 
  def read(self, iprot):
23263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23265 
      return
23266 
    iprot.readStructBegin()
23267 
    while True:
23268 
      (fname, ftype, fid) = iprot.readFieldBegin()
23269 
      if ftype == TType.STOP:
23270 
        break
23271 
      if fid == 1:
23272 
        if ftype == TType.I64:
23273 
          self.settlementDate = iprot.readI64();
23274 
        else:
23275 
          iprot.skip(ftype)
23276 
      elif fid == 2:
23277 
        if ftype == TType.I64:
23278 
          self.paymentGatewayId = iprot.readI64();
23279 
        else:
23280 
          iprot.skip(ftype)
23281 
      elif fid == 3:
23282 
        if ftype == TType.I64:
4905 varun.gupt 23283 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23284 
        else:
23285 
          iprot.skip(ftype)
23286 
      elif fid == 4:
23287 
        if ftype == TType.DOUBLE:
23288 
          self.serviceTax = iprot.readDouble();
23289 
        else:
23290 
          iprot.skip(ftype)
23291 
      elif fid == 5:
23292 
        if ftype == TType.DOUBLE:
23293 
          self.otherCharges = iprot.readDouble();
23294 
        else:
23295 
          iprot.skip(ftype)
23296 
      elif fid == 6:
23297 
        if ftype == TType.DOUBLE:
23298 
          self.netCollection = iprot.readDouble();
23299 
        else:
23300 
          iprot.skip(ftype)
23301 
      else:
23302 
        iprot.skip(ftype)
23303 
      iprot.readFieldEnd()
23304 
    iprot.readStructEnd()
23305 
 
23306 
  def write(self, oprot):
23307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23309 
      return
23310 
    oprot.writeStructBegin('savePaymentSettlements_args')
23311 
    if self.settlementDate is not None:
23312 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
23313 
      oprot.writeI64(self.settlementDate)
23314 
      oprot.writeFieldEnd()
23315 
    if self.paymentGatewayId is not None:
23316 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
23317 
      oprot.writeI64(self.paymentGatewayId)
23318 
      oprot.writeFieldEnd()
4905 varun.gupt 23319 
    if self.referenceId is not None:
23320 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
23321 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23322 
      oprot.writeFieldEnd()
23323 
    if self.serviceTax is not None:
23324 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
23325 
      oprot.writeDouble(self.serviceTax)
23326 
      oprot.writeFieldEnd()
23327 
    if self.otherCharges is not None:
23328 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
23329 
      oprot.writeDouble(self.otherCharges)
23330 
      oprot.writeFieldEnd()
23331 
    if self.netCollection is not None:
23332 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
23333 
      oprot.writeDouble(self.netCollection)
23334 
      oprot.writeFieldEnd()
23335 
    oprot.writeFieldStop()
23336 
    oprot.writeStructEnd()
23337 
 
23338 
  def validate(self):
23339 
    return
23340 
 
23341 
 
23342 
  def __repr__(self):
23343 
    L = ['%s=%r' % (key, value)
23344 
      for key, value in self.__dict__.iteritems()]
23345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23346 
 
23347 
  def __eq__(self, other):
23348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23349 
 
23350 
  def __ne__(self, other):
23351 
    return not (self == other)
23352 
 
23353 
class savePaymentSettlements_result:
23354 
  """
23355 
  Attributes:
23356 
   - ex
23357 
  """
23358 
 
23359 
  thrift_spec = (
23360 
    None, # 0
23361 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23362 
  )
23363 
 
23364 
  def __init__(self, ex=None,):
23365 
    self.ex = ex
23366 
 
23367 
  def read(self, iprot):
23368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23370 
      return
23371 
    iprot.readStructBegin()
23372 
    while True:
23373 
      (fname, ftype, fid) = iprot.readFieldBegin()
23374 
      if ftype == TType.STOP:
23375 
        break
23376 
      if fid == 1:
23377 
        if ftype == TType.STRUCT:
23378 
          self.ex = TransactionServiceException()
23379 
          self.ex.read(iprot)
23380 
        else:
23381 
          iprot.skip(ftype)
23382 
      else:
23383 
        iprot.skip(ftype)
23384 
      iprot.readFieldEnd()
23385 
    iprot.readStructEnd()
23386 
 
23387 
  def write(self, oprot):
23388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23390 
      return
23391 
    oprot.writeStructBegin('savePaymentSettlements_result')
23392 
    if self.ex is not None:
23393 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23394 
      self.ex.write(oprot)
23395 
      oprot.writeFieldEnd()
23396 
    oprot.writeFieldStop()
23397 
    oprot.writeStructEnd()
23398 
 
23399 
  def validate(self):
23400 
    return
23401 
 
23402 
 
23403 
  def __repr__(self):
23404 
    L = ['%s=%r' % (key, value)
23405 
      for key, value in self.__dict__.iteritems()]
23406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23407 
 
23408 
  def __eq__(self, other):
23409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23410 
 
23411 
  def __ne__(self, other):
23412 
    return not (self == other)
23413 
 
23414 
class saveEBSSettlementSummary_args:
23415 
  """
23416 
  Attributes:
23417 
   - settlementId
23418 
   - settlementDate
23419 
   - transactionDateFrom
23420 
   - transactionDateTo
23421 
   - amount
23422 
  """
23423 
 
23424 
  thrift_spec = (
23425 
    None, # 0
23426 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23427 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
23428 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
23429 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
23430 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
23431 
  )
23432 
 
23433 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
23434 
    self.settlementId = settlementId
23435 
    self.settlementDate = settlementDate
23436 
    self.transactionDateFrom = transactionDateFrom
23437 
    self.transactionDateTo = transactionDateTo
23438 
    self.amount = amount
23439 
 
23440 
  def read(self, iprot):
23441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23443 
      return
23444 
    iprot.readStructBegin()
23445 
    while True:
23446 
      (fname, ftype, fid) = iprot.readFieldBegin()
23447 
      if ftype == TType.STOP:
23448 
        break
23449 
      if fid == 1:
23450 
        if ftype == TType.I64:
23451 
          self.settlementId = iprot.readI64();
23452 
        else:
23453 
          iprot.skip(ftype)
23454 
      elif fid == 2:
23455 
        if ftype == TType.I64:
23456 
          self.settlementDate = iprot.readI64();
23457 
        else:
23458 
          iprot.skip(ftype)
23459 
      elif fid == 3:
23460 
        if ftype == TType.I64:
23461 
          self.transactionDateFrom = iprot.readI64();
23462 
        else:
23463 
          iprot.skip(ftype)
23464 
      elif fid == 4:
23465 
        if ftype == TType.I64:
23466 
          self.transactionDateTo = iprot.readI64();
23467 
        else:
23468 
          iprot.skip(ftype)
23469 
      elif fid == 5:
23470 
        if ftype == TType.DOUBLE:
23471 
          self.amount = iprot.readDouble();
23472 
        else:
23473 
          iprot.skip(ftype)
23474 
      else:
23475 
        iprot.skip(ftype)
23476 
      iprot.readFieldEnd()
23477 
    iprot.readStructEnd()
23478 
 
23479 
  def write(self, oprot):
23480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23482 
      return
23483 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
23484 
    if self.settlementId is not None:
23485 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23486 
      oprot.writeI64(self.settlementId)
23487 
      oprot.writeFieldEnd()
23488 
    if self.settlementDate is not None:
23489 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
23490 
      oprot.writeI64(self.settlementDate)
23491 
      oprot.writeFieldEnd()
23492 
    if self.transactionDateFrom is not None:
23493 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
23494 
      oprot.writeI64(self.transactionDateFrom)
23495 
      oprot.writeFieldEnd()
23496 
    if self.transactionDateTo is not None:
23497 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
23498 
      oprot.writeI64(self.transactionDateTo)
23499 
      oprot.writeFieldEnd()
23500 
    if self.amount is not None:
23501 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
23502 
      oprot.writeDouble(self.amount)
23503 
      oprot.writeFieldEnd()
23504 
    oprot.writeFieldStop()
23505 
    oprot.writeStructEnd()
23506 
 
23507 
  def validate(self):
23508 
    return
23509 
 
23510 
 
23511 
  def __repr__(self):
23512 
    L = ['%s=%r' % (key, value)
23513 
      for key, value in self.__dict__.iteritems()]
23514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23515 
 
23516 
  def __eq__(self, other):
23517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23518 
 
23519 
  def __ne__(self, other):
23520 
    return not (self == other)
23521 
 
23522 
class saveEBSSettlementSummary_result:
23523 
  """
23524 
  Attributes:
23525 
   - ex
23526 
  """
23527 
 
23528 
  thrift_spec = (
23529 
    None, # 0
23530 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23531 
  )
23532 
 
23533 
  def __init__(self, ex=None,):
23534 
    self.ex = ex
23535 
 
23536 
  def read(self, iprot):
23537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23539 
      return
23540 
    iprot.readStructBegin()
23541 
    while True:
23542 
      (fname, ftype, fid) = iprot.readFieldBegin()
23543 
      if ftype == TType.STOP:
23544 
        break
23545 
      if fid == 1:
23546 
        if ftype == TType.STRUCT:
23547 
          self.ex = TransactionServiceException()
23548 
          self.ex.read(iprot)
23549 
        else:
23550 
          iprot.skip(ftype)
23551 
      else:
23552 
        iprot.skip(ftype)
23553 
      iprot.readFieldEnd()
23554 
    iprot.readStructEnd()
23555 
 
23556 
  def write(self, oprot):
23557 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23558 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23559 
      return
23560 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
23561 
    if self.ex is not None:
23562 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23563 
      self.ex.write(oprot)
23564 
      oprot.writeFieldEnd()
23565 
    oprot.writeFieldStop()
23566 
    oprot.writeStructEnd()
23567 
 
23568 
  def validate(self):
23569 
    return
23570 
 
23571 
 
23572 
  def __repr__(self):
23573 
    L = ['%s=%r' % (key, value)
23574 
      for key, value in self.__dict__.iteritems()]
23575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23576 
 
23577 
  def __eq__(self, other):
23578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23579 
 
23580 
  def __ne__(self, other):
23581 
    return not (self == other)
23582 
 
5386 phani.kuma 23583 
class getSettlementForPrepaid_args:
4600 varun.gupt 23584 
  """
23585 
  Attributes:
5189 varun.gupt 23586 
   - referenceId
23587 
   - isRefund
4600 varun.gupt 23588 
  """
23589 
 
23590 
  thrift_spec = (
23591 
    None, # 0
5189 varun.gupt 23592 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 23593 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 23594 
  )
23595 
 
5386 phani.kuma 23596 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 23597 
    self.referenceId = referenceId
23598 
    self.isRefund = isRefund
4600 varun.gupt 23599 
 
23600 
  def read(self, iprot):
23601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23603 
      return
23604 
    iprot.readStructBegin()
23605 
    while True:
23606 
      (fname, ftype, fid) = iprot.readFieldBegin()
23607 
      if ftype == TType.STOP:
23608 
        break
23609 
      if fid == 1:
23610 
        if ftype == TType.I64:
5189 varun.gupt 23611 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23612 
        else:
23613 
          iprot.skip(ftype)
5189 varun.gupt 23614 
      elif fid == 2:
23615 
        if ftype == TType.BOOL:
23616 
          self.isRefund = iprot.readBool();
23617 
        else:
23618 
          iprot.skip(ftype)
4600 varun.gupt 23619 
      else:
23620 
        iprot.skip(ftype)
23621 
      iprot.readFieldEnd()
23622 
    iprot.readStructEnd()
23623 
 
23624 
  def write(self, oprot):
23625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23627 
      return
5386 phani.kuma 23628 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 23629 
    if self.referenceId is not None:
23630 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
23631 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23632 
      oprot.writeFieldEnd()
5386 phani.kuma 23633 
    if self.isRefund is not None:
23634 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
23635 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 23636 
      oprot.writeFieldEnd()
5386 phani.kuma 23637 
    oprot.writeFieldStop()
23638 
    oprot.writeStructEnd()
23639 
 
23640 
  def validate(self):
23641 
    return
23642 
 
23643 
 
23644 
  def __repr__(self):
23645 
    L = ['%s=%r' % (key, value)
23646 
      for key, value in self.__dict__.iteritems()]
23647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23648 
 
23649 
  def __eq__(self, other):
23650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23651 
 
23652 
  def __ne__(self, other):
23653 
    return not (self == other)
23654 
 
23655 
class getSettlementForPrepaid_result:
23656 
  """
23657 
  Attributes:
23658 
   - success
23659 
   - ex
23660 
  """
23661 
 
23662 
  thrift_spec = (
23663 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23664 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23665 
  )
23666 
 
23667 
  def __init__(self, success=None, ex=None,):
23668 
    self.success = success
23669 
    self.ex = ex
23670 
 
23671 
  def read(self, iprot):
23672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23674 
      return
23675 
    iprot.readStructBegin()
23676 
    while True:
23677 
      (fname, ftype, fid) = iprot.readFieldBegin()
23678 
      if ftype == TType.STOP:
23679 
        break
23680 
      if fid == 0:
23681 
        if ftype == TType.STRUCT:
23682 
          self.success = PaymentSettlement()
23683 
          self.success.read(iprot)
23684 
        else:
23685 
          iprot.skip(ftype)
23686 
      elif fid == 1:
23687 
        if ftype == TType.STRUCT:
23688 
          self.ex = TransactionServiceException()
23689 
          self.ex.read(iprot)
23690 
        else:
23691 
          iprot.skip(ftype)
23692 
      else:
23693 
        iprot.skip(ftype)
23694 
      iprot.readFieldEnd()
23695 
    iprot.readStructEnd()
23696 
 
23697 
  def write(self, oprot):
23698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23700 
      return
23701 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
23702 
    if self.success is not None:
23703 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23704 
      self.success.write(oprot)
23705 
      oprot.writeFieldEnd()
23706 
    if self.ex is not None:
23707 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23708 
      self.ex.write(oprot)
23709 
      oprot.writeFieldEnd()
23710 
    oprot.writeFieldStop()
23711 
    oprot.writeStructEnd()
23712 
 
23713 
  def validate(self):
23714 
    return
23715 
 
23716 
 
23717 
  def __repr__(self):
23718 
    L = ['%s=%r' % (key, value)
23719 
      for key, value in self.__dict__.iteritems()]
23720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23721 
 
23722 
  def __eq__(self, other):
23723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23724 
 
23725 
  def __ne__(self, other):
23726 
    return not (self == other)
23727 
 
23728 
class getSettlementForCod_args:
23729 
  """
23730 
  Attributes:
23731 
   - orderId
23732 
   - isRefund
23733 
  """
23734 
 
23735 
  thrift_spec = (
23736 
    None, # 0
23737 
    (1, TType.I64, 'orderId', None, None, ), # 1
23738 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
23739 
  )
23740 
 
23741 
  def __init__(self, orderId=None, isRefund=None,):
23742 
    self.orderId = orderId
23743 
    self.isRefund = isRefund
23744 
 
23745 
  def read(self, iprot):
23746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23748 
      return
23749 
    iprot.readStructBegin()
23750 
    while True:
23751 
      (fname, ftype, fid) = iprot.readFieldBegin()
23752 
      if ftype == TType.STOP:
23753 
        break
23754 
      if fid == 1:
23755 
        if ftype == TType.I64:
23756 
          self.orderId = iprot.readI64();
23757 
        else:
23758 
          iprot.skip(ftype)
23759 
      elif fid == 2:
23760 
        if ftype == TType.BOOL:
23761 
          self.isRefund = iprot.readBool();
23762 
        else:
23763 
          iprot.skip(ftype)
23764 
      else:
23765 
        iprot.skip(ftype)
23766 
      iprot.readFieldEnd()
23767 
    iprot.readStructEnd()
23768 
 
23769 
  def write(self, oprot):
23770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23772 
      return
23773 
    oprot.writeStructBegin('getSettlementForCod_args')
23774 
    if self.orderId is not None:
23775 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23776 
      oprot.writeI64(self.orderId)
23777 
      oprot.writeFieldEnd()
5189 varun.gupt 23778 
    if self.isRefund is not None:
5386 phani.kuma 23779 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23780 
      oprot.writeBool(self.isRefund)
23781 
      oprot.writeFieldEnd()
4600 varun.gupt 23782 
    oprot.writeFieldStop()
23783 
    oprot.writeStructEnd()
23784 
 
23785 
  def validate(self):
23786 
    return
23787 
 
23788 
 
23789 
  def __repr__(self):
23790 
    L = ['%s=%r' % (key, value)
23791 
      for key, value in self.__dict__.iteritems()]
23792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23793 
 
23794 
  def __eq__(self, other):
23795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23796 
 
23797 
  def __ne__(self, other):
23798 
    return not (self == other)
23799 
 
5386 phani.kuma 23800 
class getSettlementForCod_result:
4600 varun.gupt 23801 
  """
23802 
  Attributes:
23803 
   - success
23804 
   - ex
23805 
  """
23806 
 
23807 
  thrift_spec = (
23808 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23809 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23810 
  )
23811 
 
23812 
  def __init__(self, success=None, ex=None,):
23813 
    self.success = success
23814 
    self.ex = ex
23815 
 
23816 
  def read(self, iprot):
23817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23819 
      return
23820 
    iprot.readStructBegin()
23821 
    while True:
23822 
      (fname, ftype, fid) = iprot.readFieldBegin()
23823 
      if ftype == TType.STOP:
23824 
        break
23825 
      if fid == 0:
23826 
        if ftype == TType.STRUCT:
23827 
          self.success = PaymentSettlement()
23828 
          self.success.read(iprot)
23829 
        else:
23830 
          iprot.skip(ftype)
23831 
      elif 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
5386 phani.kuma 23846 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 23847 
    if self.success is not None:
23848 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23849 
      self.success.write(oprot)
23850 
      oprot.writeFieldEnd()
23851 
    if self.ex is not None:
23852 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23853 
      self.ex.write(oprot)
23854 
      oprot.writeFieldEnd()
23855 
    oprot.writeFieldStop()
23856 
    oprot.writeStructEnd()
23857 
 
23858 
  def validate(self):
23859 
    return
23860 
 
23861 
 
23862 
  def __repr__(self):
23863 
    L = ['%s=%r' % (key, value)
23864 
      for key, value in self.__dict__.iteritems()]
23865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23866 
 
23867 
  def __eq__(self, other):
23868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23869 
 
23870 
  def __ne__(self, other):
23871 
    return not (self == other)
23872 
 
23873 
class getEBSSettlementSummaries_args:
23874 
 
23875 
  thrift_spec = (
23876 
  )
23877 
 
23878 
  def read(self, iprot):
23879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23881 
      return
23882 
    iprot.readStructBegin()
23883 
    while True:
23884 
      (fname, ftype, fid) = iprot.readFieldBegin()
23885 
      if ftype == TType.STOP:
23886 
        break
23887 
      else:
23888 
        iprot.skip(ftype)
23889 
      iprot.readFieldEnd()
23890 
    iprot.readStructEnd()
23891 
 
23892 
  def write(self, oprot):
23893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23895 
      return
23896 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
23897 
    oprot.writeFieldStop()
23898 
    oprot.writeStructEnd()
23899 
 
23900 
  def validate(self):
23901 
    return
23902 
 
23903 
 
23904 
  def __repr__(self):
23905 
    L = ['%s=%r' % (key, value)
23906 
      for key, value in self.__dict__.iteritems()]
23907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23908 
 
23909 
  def __eq__(self, other):
23910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23911 
 
23912 
  def __ne__(self, other):
23913 
    return not (self == other)
23914 
 
23915 
class getEBSSettlementSummaries_result:
23916 
  """
23917 
  Attributes:
23918 
   - success
23919 
   - ex
23920 
  """
23921 
 
23922 
  thrift_spec = (
23923 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23924 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23925 
  )
23926 
 
23927 
  def __init__(self, success=None, ex=None,):
23928 
    self.success = success
23929 
    self.ex = ex
23930 
 
23931 
  def read(self, iprot):
23932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23934 
      return
23935 
    iprot.readStructBegin()
23936 
    while True:
23937 
      (fname, ftype, fid) = iprot.readFieldBegin()
23938 
      if ftype == TType.STOP:
23939 
        break
23940 
      if fid == 0:
23941 
        if ftype == TType.MAP:
23942 
          self.success = {}
6188 rajveer 23943 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
23944 
          for _i558 in xrange(_size554):
23945 
            _key559 = iprot.readI64();
23946 
            _val560 = iprot.readString();
23947 
            self.success[_key559] = _val560
4600 varun.gupt 23948 
          iprot.readMapEnd()
23949 
        else:
23950 
          iprot.skip(ftype)
23951 
      elif fid == 1:
23952 
        if ftype == TType.STRUCT:
23953 
          self.ex = TransactionServiceException()
23954 
          self.ex.read(iprot)
23955 
        else:
23956 
          iprot.skip(ftype)
23957 
      else:
23958 
        iprot.skip(ftype)
23959 
      iprot.readFieldEnd()
23960 
    iprot.readStructEnd()
23961 
 
23962 
  def write(self, oprot):
23963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23965 
      return
23966 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
23967 
    if self.success is not None:
23968 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23969 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 23970 
      for kiter561,viter562 in self.success.items():
23971 
        oprot.writeI64(kiter561)
23972 
        oprot.writeString(viter562)
4600 varun.gupt 23973 
      oprot.writeMapEnd()
23974 
      oprot.writeFieldEnd()
23975 
    if self.ex is not None:
23976 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23977 
      self.ex.write(oprot)
23978 
      oprot.writeFieldEnd()
23979 
    oprot.writeFieldStop()
23980 
    oprot.writeStructEnd()
23981 
 
23982 
  def validate(self):
23983 
    return
23984 
 
23985 
 
23986 
  def __repr__(self):
23987 
    L = ['%s=%r' % (key, value)
23988 
      for key, value in self.__dict__.iteritems()]
23989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23990 
 
23991 
  def __eq__(self, other):
23992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23993 
 
23994 
  def __ne__(self, other):
23995 
    return not (self == other)
23996 
 
23997 
class markEBSSettlementUploaded_args:
23998 
  """
23999 
  Attributes:
24000 
   - settlementId
24001 
  """
24002 
 
24003 
  thrift_spec = (
24004 
    None, # 0
24005 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24006 
  )
24007 
 
24008 
  def __init__(self, settlementId=None,):
24009 
    self.settlementId = settlementId
24010 
 
24011 
  def read(self, iprot):
24012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24014 
      return
24015 
    iprot.readStructBegin()
24016 
    while True:
24017 
      (fname, ftype, fid) = iprot.readFieldBegin()
24018 
      if ftype == TType.STOP:
24019 
        break
24020 
      if fid == 1:
24021 
        if ftype == TType.I64:
24022 
          self.settlementId = iprot.readI64();
24023 
        else:
24024 
          iprot.skip(ftype)
24025 
      else:
24026 
        iprot.skip(ftype)
24027 
      iprot.readFieldEnd()
24028 
    iprot.readStructEnd()
24029 
 
24030 
  def write(self, oprot):
24031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24033 
      return
24034 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
24035 
    if self.settlementId is not None:
24036 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24037 
      oprot.writeI64(self.settlementId)
24038 
      oprot.writeFieldEnd()
24039 
    oprot.writeFieldStop()
24040 
    oprot.writeStructEnd()
24041 
 
24042 
  def validate(self):
24043 
    return
24044 
 
24045 
 
24046 
  def __repr__(self):
24047 
    L = ['%s=%r' % (key, value)
24048 
      for key, value in self.__dict__.iteritems()]
24049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24050 
 
24051 
  def __eq__(self, other):
24052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24053 
 
24054 
  def __ne__(self, other):
24055 
    return not (self == other)
24056 
 
24057 
class markEBSSettlementUploaded_result:
24058 
  """
24059 
  Attributes:
24060 
   - ex
24061 
  """
24062 
 
24063 
  thrift_spec = (
24064 
    None, # 0
24065 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24066 
  )
24067 
 
24068 
  def __init__(self, ex=None,):
24069 
    self.ex = ex
24070 
 
24071 
  def read(self, iprot):
24072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24074 
      return
24075 
    iprot.readStructBegin()
24076 
    while True:
24077 
      (fname, ftype, fid) = iprot.readFieldBegin()
24078 
      if ftype == TType.STOP:
24079 
        break
24080 
      if fid == 1:
24081 
        if ftype == TType.STRUCT:
24082 
          self.ex = TransactionServiceException()
24083 
          self.ex.read(iprot)
24084 
        else:
24085 
          iprot.skip(ftype)
24086 
      else:
24087 
        iprot.skip(ftype)
24088 
      iprot.readFieldEnd()
24089 
    iprot.readStructEnd()
24090 
 
24091 
  def write(self, oprot):
24092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24094 
      return
24095 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
24096 
    if self.ex is not None:
24097 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24098 
      self.ex.write(oprot)
24099 
      oprot.writeFieldEnd()
24100 
    oprot.writeFieldStop()
24101 
    oprot.writeStructEnd()
24102 
 
24103 
  def validate(self):
24104 
    return
24105 
 
24106 
 
24107 
  def __repr__(self):
24108 
    L = ['%s=%r' % (key, value)
24109 
      for key, value in self.__dict__.iteritems()]
24110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24111 
 
24112 
  def __eq__(self, other):
24113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24114 
 
24115 
  def __ne__(self, other):
24116 
    return not (self == other)
24117 
 
24118 
class getEBSSettlementDate_args:
24119 
  """
24120 
  Attributes:
24121 
   - settlementId
24122 
  """
24123 
 
24124 
  thrift_spec = (
24125 
    None, # 0
24126 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24127 
  )
24128 
 
24129 
  def __init__(self, settlementId=None,):
24130 
    self.settlementId = settlementId
24131 
 
24132 
  def read(self, iprot):
24133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24135 
      return
24136 
    iprot.readStructBegin()
24137 
    while True:
24138 
      (fname, ftype, fid) = iprot.readFieldBegin()
24139 
      if ftype == TType.STOP:
24140 
        break
24141 
      if fid == 1:
24142 
        if ftype == TType.I64:
24143 
          self.settlementId = iprot.readI64();
24144 
        else:
24145 
          iprot.skip(ftype)
24146 
      else:
24147 
        iprot.skip(ftype)
24148 
      iprot.readFieldEnd()
24149 
    iprot.readStructEnd()
24150 
 
24151 
  def write(self, oprot):
24152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24154 
      return
24155 
    oprot.writeStructBegin('getEBSSettlementDate_args')
24156 
    if self.settlementId is not None:
24157 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24158 
      oprot.writeI64(self.settlementId)
24159 
      oprot.writeFieldEnd()
24160 
    oprot.writeFieldStop()
24161 
    oprot.writeStructEnd()
24162 
 
24163 
  def validate(self):
24164 
    return
24165 
 
24166 
 
24167 
  def __repr__(self):
24168 
    L = ['%s=%r' % (key, value)
24169 
      for key, value in self.__dict__.iteritems()]
24170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24171 
 
24172 
  def __eq__(self, other):
24173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24174 
 
24175 
  def __ne__(self, other):
24176 
    return not (self == other)
24177 
 
24178 
class getEBSSettlementDate_result:
24179 
  """
24180 
  Attributes:
24181 
   - success
24182 
   - ex
24183 
  """
24184 
 
24185 
  thrift_spec = (
24186 
    (0, TType.I64, 'success', None, None, ), # 0
24187 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24188 
  )
24189 
 
24190 
  def __init__(self, success=None, ex=None,):
24191 
    self.success = success
24192 
    self.ex = ex
24193 
 
24194 
  def read(self, iprot):
24195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24197 
      return
24198 
    iprot.readStructBegin()
24199 
    while True:
24200 
      (fname, ftype, fid) = iprot.readFieldBegin()
24201 
      if ftype == TType.STOP:
24202 
        break
24203 
      if fid == 0:
24204 
        if ftype == TType.I64:
24205 
          self.success = iprot.readI64();
24206 
        else:
24207 
          iprot.skip(ftype)
24208 
      elif fid == 1:
24209 
        if ftype == TType.STRUCT:
24210 
          self.ex = TransactionServiceException()
24211 
          self.ex.read(iprot)
24212 
        else:
24213 
          iprot.skip(ftype)
24214 
      else:
24215 
        iprot.skip(ftype)
24216 
      iprot.readFieldEnd()
24217 
    iprot.readStructEnd()
24218 
 
24219 
  def write(self, oprot):
24220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24222 
      return
24223 
    oprot.writeStructBegin('getEBSSettlementDate_result')
24224 
    if self.success is not None:
24225 
      oprot.writeFieldBegin('success', TType.I64, 0)
24226 
      oprot.writeI64(self.success)
24227 
      oprot.writeFieldEnd()
24228 
    if self.ex is not None:
24229 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24230 
      self.ex.write(oprot)
24231 
      oprot.writeFieldEnd()
24232 
    oprot.writeFieldStop()
24233 
    oprot.writeStructEnd()
24234 
 
24235 
  def validate(self):
24236 
    return
24237 
 
24238 
 
24239 
  def __repr__(self):
24240 
    L = ['%s=%r' % (key, value)
24241 
      for key, value in self.__dict__.iteritems()]
24242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24243 
 
24244 
  def __eq__(self, other):
24245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24246 
 
24247 
  def __ne__(self, other):
24248 
    return not (self == other)
4715 varun.gupt 24249 
 
24250 
class getSettlementsByDate_args:
24251 
  """
24252 
  Attributes:
24253 
   - settlementDateFrom
24254 
   - settlementDateTo
24255 
   - isRefund
24256 
  """
24257 
 
24258 
  thrift_spec = (
24259 
    None, # 0
24260 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
24261 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
24262 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
24263 
  )
24264 
 
24265 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
24266 
    self.settlementDateFrom = settlementDateFrom
24267 
    self.settlementDateTo = settlementDateTo
24268 
    self.isRefund = isRefund
24269 
 
24270 
  def read(self, iprot):
24271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24273 
      return
24274 
    iprot.readStructBegin()
24275 
    while True:
24276 
      (fname, ftype, fid) = iprot.readFieldBegin()
24277 
      if ftype == TType.STOP:
24278 
        break
24279 
      if fid == 1:
24280 
        if ftype == TType.I64:
24281 
          self.settlementDateFrom = iprot.readI64();
24282 
        else:
24283 
          iprot.skip(ftype)
24284 
      elif fid == 2:
24285 
        if ftype == TType.I64:
24286 
          self.settlementDateTo = iprot.readI64();
24287 
        else:
24288 
          iprot.skip(ftype)
24289 
      elif fid == 3:
24290 
        if ftype == TType.BOOL:
24291 
          self.isRefund = iprot.readBool();
24292 
        else:
24293 
          iprot.skip(ftype)
24294 
      else:
24295 
        iprot.skip(ftype)
24296 
      iprot.readFieldEnd()
24297 
    iprot.readStructEnd()
24298 
 
24299 
  def write(self, oprot):
24300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24302 
      return
24303 
    oprot.writeStructBegin('getSettlementsByDate_args')
24304 
    if self.settlementDateFrom is not None:
24305 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
24306 
      oprot.writeI64(self.settlementDateFrom)
24307 
      oprot.writeFieldEnd()
24308 
    if self.settlementDateTo is not None:
24309 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
24310 
      oprot.writeI64(self.settlementDateTo)
24311 
      oprot.writeFieldEnd()
24312 
    if self.isRefund is not None:
24313 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
24314 
      oprot.writeBool(self.isRefund)
24315 
      oprot.writeFieldEnd()
24316 
    oprot.writeFieldStop()
24317 
    oprot.writeStructEnd()
24318 
 
24319 
  def validate(self):
24320 
    return
24321 
 
24322 
 
24323 
  def __repr__(self):
24324 
    L = ['%s=%r' % (key, value)
24325 
      for key, value in self.__dict__.iteritems()]
24326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24327 
 
24328 
  def __eq__(self, other):
24329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24330 
 
24331 
  def __ne__(self, other):
24332 
    return not (self == other)
24333 
 
24334 
class getSettlementsByDate_result:
24335 
  """
24336 
  Attributes:
24337 
   - success
24338 
   - ex
24339 
  """
24340 
 
24341 
  thrift_spec = (
24342 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
24343 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24344 
  )
24345 
 
24346 
  def __init__(self, success=None, ex=None,):
24347 
    self.success = success
24348 
    self.ex = ex
24349 
 
24350 
  def read(self, iprot):
24351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24353 
      return
24354 
    iprot.readStructBegin()
24355 
    while True:
24356 
      (fname, ftype, fid) = iprot.readFieldBegin()
24357 
      if ftype == TType.STOP:
24358 
        break
24359 
      if fid == 0:
24360 
        if ftype == TType.LIST:
24361 
          self.success = []
6188 rajveer 24362 
          (_etype566, _size563) = iprot.readListBegin()
24363 
          for _i567 in xrange(_size563):
24364 
            _elem568 = PaymentSettlement()
24365 
            _elem568.read(iprot)
24366 
            self.success.append(_elem568)
4715 varun.gupt 24367 
          iprot.readListEnd()
24368 
        else:
24369 
          iprot.skip(ftype)
24370 
      elif fid == 1:
24371 
        if ftype == TType.STRUCT:
24372 
          self.ex = TransactionServiceException()
24373 
          self.ex.read(iprot)
24374 
        else:
24375 
          iprot.skip(ftype)
24376 
      else:
24377 
        iprot.skip(ftype)
24378 
      iprot.readFieldEnd()
24379 
    iprot.readStructEnd()
24380 
 
24381 
  def write(self, oprot):
24382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24384 
      return
24385 
    oprot.writeStructBegin('getSettlementsByDate_result')
24386 
    if self.success is not None:
24387 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24388 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24389 
      for iter569 in self.success:
24390 
        iter569.write(oprot)
4715 varun.gupt 24391 
      oprot.writeListEnd()
24392 
      oprot.writeFieldEnd()
24393 
    if self.ex is not None:
24394 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24395 
      self.ex.write(oprot)
24396 
      oprot.writeFieldEnd()
24397 
    oprot.writeFieldStop()
24398 
    oprot.writeStructEnd()
24399 
 
24400 
  def validate(self):
24401 
    return
24402 
 
24403 
 
24404 
  def __repr__(self):
24405 
    L = ['%s=%r' % (key, value)
24406 
      for key, value in self.__dict__.iteritems()]
24407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24408 
 
24409 
  def __eq__(self, other):
24410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24411 
 
24412 
  def __ne__(self, other):
24413 
    return not (self == other)
24414 
 
24415 
class getReshippedOrderIds_args:
24416 
  """
24417 
  Attributes:
24418 
   - orderIds
24419 
  """
24420 
 
24421 
  thrift_spec = (
24422 
    None, # 0
24423 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
24424 
  )
24425 
 
24426 
  def __init__(self, orderIds=None,):
24427 
    self.orderIds = orderIds
24428 
 
24429 
  def read(self, iprot):
24430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24432 
      return
24433 
    iprot.readStructBegin()
24434 
    while True:
24435 
      (fname, ftype, fid) = iprot.readFieldBegin()
24436 
      if ftype == TType.STOP:
24437 
        break
24438 
      if fid == 1:
24439 
        if ftype == TType.LIST:
24440 
          self.orderIds = []
6188 rajveer 24441 
          (_etype573, _size570) = iprot.readListBegin()
24442 
          for _i574 in xrange(_size570):
24443 
            _elem575 = iprot.readI64();
24444 
            self.orderIds.append(_elem575)
4715 varun.gupt 24445 
          iprot.readListEnd()
24446 
        else:
24447 
          iprot.skip(ftype)
24448 
      else:
24449 
        iprot.skip(ftype)
24450 
      iprot.readFieldEnd()
24451 
    iprot.readStructEnd()
24452 
 
24453 
  def write(self, oprot):
24454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24456 
      return
24457 
    oprot.writeStructBegin('getReshippedOrderIds_args')
24458 
    if self.orderIds is not None:
24459 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
24460 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 24461 
      for iter576 in self.orderIds:
24462 
        oprot.writeI64(iter576)
4715 varun.gupt 24463 
      oprot.writeListEnd()
24464 
      oprot.writeFieldEnd()
24465 
    oprot.writeFieldStop()
24466 
    oprot.writeStructEnd()
24467 
 
24468 
  def validate(self):
24469 
    return
24470 
 
24471 
 
24472 
  def __repr__(self):
24473 
    L = ['%s=%r' % (key, value)
24474 
      for key, value in self.__dict__.iteritems()]
24475 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24476 
 
24477 
  def __eq__(self, other):
24478 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24479 
 
24480 
  def __ne__(self, other):
24481 
    return not (self == other)
24482 
 
24483 
class getReshippedOrderIds_result:
24484 
  """
24485 
  Attributes:
24486 
   - success
24487 
   - ex
24488 
  """
24489 
 
24490 
  thrift_spec = (
24491 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24492 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24493 
  )
24494 
 
24495 
  def __init__(self, success=None, ex=None,):
24496 
    self.success = success
24497 
    self.ex = ex
24498 
 
24499 
  def read(self, iprot):
24500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24502 
      return
24503 
    iprot.readStructBegin()
24504 
    while True:
24505 
      (fname, ftype, fid) = iprot.readFieldBegin()
24506 
      if ftype == TType.STOP:
24507 
        break
24508 
      if fid == 0:
24509 
        if ftype == TType.LIST:
24510 
          self.success = []
6188 rajveer 24511 
          (_etype580, _size577) = iprot.readListBegin()
24512 
          for _i581 in xrange(_size577):
24513 
            _elem582 = iprot.readI64();
24514 
            self.success.append(_elem582)
4715 varun.gupt 24515 
          iprot.readListEnd()
24516 
        else:
24517 
          iprot.skip(ftype)
24518 
      elif fid == 1:
24519 
        if ftype == TType.STRUCT:
24520 
          self.ex = TransactionServiceException()
24521 
          self.ex.read(iprot)
24522 
        else:
24523 
          iprot.skip(ftype)
24524 
      else:
24525 
        iprot.skip(ftype)
24526 
      iprot.readFieldEnd()
24527 
    iprot.readStructEnd()
24528 
 
24529 
  def write(self, oprot):
24530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24532 
      return
24533 
    oprot.writeStructBegin('getReshippedOrderIds_result')
24534 
    if self.success is not None:
24535 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24536 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24537 
      for iter583 in self.success:
24538 
        oprot.writeI64(iter583)
4715 varun.gupt 24539 
      oprot.writeListEnd()
24540 
      oprot.writeFieldEnd()
24541 
    if self.ex is not None:
24542 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24543 
      self.ex.write(oprot)
24544 
      oprot.writeFieldEnd()
24545 
    oprot.writeFieldStop()
24546 
    oprot.writeStructEnd()
24547 
 
24548 
  def validate(self):
24549 
    return
24550 
 
24551 
 
24552 
  def __repr__(self):
24553 
    L = ['%s=%r' % (key, value)
24554 
      for key, value in self.__dict__.iteritems()]
24555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24556 
 
24557 
  def __eq__(self, other):
24558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24559 
 
24560 
  def __ne__(self, other):
24561 
    return not (self == other)
4757 mandeep.dh 24562 
 
5481 phani.kuma 24563 
class getBilledOrders_args:
4875 varun.gupt 24564 
  """
24565 
  Attributes:
24566 
   - vendorId
5481 phani.kuma 24567 
   - onlyVendorNotPaid
24568 
   - billingDateFrom
24569 
   - billingDateTo
4875 varun.gupt 24570 
  """
24571 
 
24572 
  thrift_spec = (
24573 
    None, # 0
24574 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 24575 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
24576 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
24577 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 24578 
  )
24579 
 
5481 phani.kuma 24580 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 24581 
    self.vendorId = vendorId
5481 phani.kuma 24582 
    self.onlyVendorNotPaid = onlyVendorNotPaid
24583 
    self.billingDateFrom = billingDateFrom
24584 
    self.billingDateTo = billingDateTo
4875 varun.gupt 24585 
 
24586 
  def read(self, iprot):
24587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24589 
      return
24590 
    iprot.readStructBegin()
24591 
    while True:
24592 
      (fname, ftype, fid) = iprot.readFieldBegin()
24593 
      if ftype == TType.STOP:
24594 
        break
24595 
      if fid == 1:
24596 
        if ftype == TType.I64:
24597 
          self.vendorId = iprot.readI64();
24598 
        else:
24599 
          iprot.skip(ftype)
5481 phani.kuma 24600 
      elif fid == 2:
24601 
        if ftype == TType.BOOL:
24602 
          self.onlyVendorNotPaid = iprot.readBool();
24603 
        else:
24604 
          iprot.skip(ftype)
24605 
      elif fid == 3:
24606 
        if ftype == TType.I64:
24607 
          self.billingDateFrom = iprot.readI64();
24608 
        else:
24609 
          iprot.skip(ftype)
24610 
      elif fid == 4:
24611 
        if ftype == TType.I64:
24612 
          self.billingDateTo = iprot.readI64();
24613 
        else:
24614 
          iprot.skip(ftype)
4875 varun.gupt 24615 
      else:
24616 
        iprot.skip(ftype)
24617 
      iprot.readFieldEnd()
24618 
    iprot.readStructEnd()
24619 
 
24620 
  def write(self, oprot):
24621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24623 
      return
5481 phani.kuma 24624 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 24625 
    if self.vendorId is not None:
24626 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
24627 
      oprot.writeI64(self.vendorId)
24628 
      oprot.writeFieldEnd()
5481 phani.kuma 24629 
    if self.onlyVendorNotPaid is not None:
24630 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
24631 
      oprot.writeBool(self.onlyVendorNotPaid)
24632 
      oprot.writeFieldEnd()
24633 
    if self.billingDateFrom is not None:
24634 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
24635 
      oprot.writeI64(self.billingDateFrom)
24636 
      oprot.writeFieldEnd()
24637 
    if self.billingDateTo is not None:
24638 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
24639 
      oprot.writeI64(self.billingDateTo)
24640 
      oprot.writeFieldEnd()
4875 varun.gupt 24641 
    oprot.writeFieldStop()
24642 
    oprot.writeStructEnd()
24643 
 
24644 
  def validate(self):
24645 
    return
24646 
 
24647 
 
24648 
  def __repr__(self):
24649 
    L = ['%s=%r' % (key, value)
24650 
      for key, value in self.__dict__.iteritems()]
24651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24652 
 
24653 
  def __eq__(self, other):
24654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24655 
 
24656 
  def __ne__(self, other):
24657 
    return not (self == other)
24658 
 
5481 phani.kuma 24659 
class getBilledOrders_result:
4875 varun.gupt 24660 
  """
24661 
  Attributes:
24662 
   - success
24663 
   - ex
24664 
  """
24665 
 
24666 
  thrift_spec = (
24667 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24668 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24669 
  )
24670 
 
24671 
  def __init__(self, success=None, ex=None,):
24672 
    self.success = success
24673 
    self.ex = ex
24674 
 
24675 
  def read(self, iprot):
24676 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24677 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24678 
      return
24679 
    iprot.readStructBegin()
24680 
    while True:
24681 
      (fname, ftype, fid) = iprot.readFieldBegin()
24682 
      if ftype == TType.STOP:
24683 
        break
24684 
      if fid == 0:
24685 
        if ftype == TType.LIST:
24686 
          self.success = []
6188 rajveer 24687 
          (_etype587, _size584) = iprot.readListBegin()
24688 
          for _i588 in xrange(_size584):
24689 
            _elem589 = Order()
24690 
            _elem589.read(iprot)
24691 
            self.success.append(_elem589)
4875 varun.gupt 24692 
          iprot.readListEnd()
24693 
        else:
24694 
          iprot.skip(ftype)
24695 
      elif fid == 1:
24696 
        if ftype == TType.STRUCT:
24697 
          self.ex = TransactionServiceException()
24698 
          self.ex.read(iprot)
24699 
        else:
24700 
          iprot.skip(ftype)
24701 
      else:
24702 
        iprot.skip(ftype)
24703 
      iprot.readFieldEnd()
24704 
    iprot.readStructEnd()
24705 
 
24706 
  def write(self, oprot):
24707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24709 
      return
5481 phani.kuma 24710 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 24711 
    if self.success is not None:
24712 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24713 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24714 
      for iter590 in self.success:
24715 
        iter590.write(oprot)
4875 varun.gupt 24716 
      oprot.writeListEnd()
24717 
      oprot.writeFieldEnd()
24718 
    if self.ex is not None:
24719 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24720 
      self.ex.write(oprot)
24721 
      oprot.writeFieldEnd()
24722 
    oprot.writeFieldStop()
24723 
    oprot.writeStructEnd()
24724 
 
24725 
  def validate(self):
24726 
    return
24727 
 
24728 
 
24729 
  def __repr__(self):
24730 
    L = ['%s=%r' % (key, value)
24731 
      for key, value in self.__dict__.iteritems()]
24732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24733 
 
24734 
  def __eq__(self, other):
24735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24736 
 
24737 
  def __ne__(self, other):
24738 
    return not (self == other)
5031 varun.gupt 24739 
 
24740 
class getStatusDistributionOfOrders_args:
24741 
  """
24742 
  Attributes:
24743 
   - startDate
24744 
   - endDate
24745 
  """
24746 
 
24747 
  thrift_spec = (
24748 
    None, # 0
24749 
    (1, TType.I64, 'startDate', None, None, ), # 1
24750 
    (2, TType.I64, 'endDate', None, None, ), # 2
24751 
  )
24752 
 
24753 
  def __init__(self, startDate=None, endDate=None,):
24754 
    self.startDate = startDate
24755 
    self.endDate = endDate
24756 
 
24757 
  def read(self, iprot):
24758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24760 
      return
24761 
    iprot.readStructBegin()
24762 
    while True:
24763 
      (fname, ftype, fid) = iprot.readFieldBegin()
24764 
      if ftype == TType.STOP:
24765 
        break
24766 
      if fid == 1:
24767 
        if ftype == TType.I64:
24768 
          self.startDate = iprot.readI64();
24769 
        else:
24770 
          iprot.skip(ftype)
24771 
      elif fid == 2:
24772 
        if ftype == TType.I64:
24773 
          self.endDate = iprot.readI64();
24774 
        else:
24775 
          iprot.skip(ftype)
24776 
      else:
24777 
        iprot.skip(ftype)
24778 
      iprot.readFieldEnd()
24779 
    iprot.readStructEnd()
24780 
 
24781 
  def write(self, oprot):
24782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24784 
      return
24785 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24786 
    if self.startDate is not None:
24787 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24788 
      oprot.writeI64(self.startDate)
24789 
      oprot.writeFieldEnd()
24790 
    if self.endDate is not None:
24791 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24792 
      oprot.writeI64(self.endDate)
24793 
      oprot.writeFieldEnd()
24794 
    oprot.writeFieldStop()
24795 
    oprot.writeStructEnd()
24796 
 
24797 
  def validate(self):
24798 
    return
24799 
 
24800 
 
24801 
  def __repr__(self):
24802 
    L = ['%s=%r' % (key, value)
24803 
      for key, value in self.__dict__.iteritems()]
24804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24805 
 
24806 
  def __eq__(self, other):
24807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24808 
 
24809 
  def __ne__(self, other):
24810 
    return not (self == other)
24811 
 
24812 
class getStatusDistributionOfOrders_result:
24813 
  """
24814 
  Attributes:
24815 
   - success
24816 
   - ex
24817 
  """
24818 
 
24819 
  thrift_spec = (
24820 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
24821 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24822 
  )
24823 
 
24824 
  def __init__(self, success=None, ex=None,):
24825 
    self.success = success
24826 
    self.ex = ex
24827 
 
24828 
  def read(self, iprot):
24829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24831 
      return
24832 
    iprot.readStructBegin()
24833 
    while True:
24834 
      (fname, ftype, fid) = iprot.readFieldBegin()
24835 
      if ftype == TType.STOP:
24836 
        break
24837 
      if fid == 0:
24838 
        if ftype == TType.MAP:
24839 
          self.success = {}
6188 rajveer 24840 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
24841 
          for _i595 in xrange(_size591):
24842 
            _key596 = iprot.readI64();
24843 
            _val597 = iprot.readI64();
24844 
            self.success[_key596] = _val597
5031 varun.gupt 24845 
          iprot.readMapEnd()
24846 
        else:
24847 
          iprot.skip(ftype)
24848 
      elif fid == 1:
24849 
        if ftype == TType.STRUCT:
24850 
          self.ex = TransactionServiceException()
24851 
          self.ex.read(iprot)
24852 
        else:
24853 
          iprot.skip(ftype)
24854 
      else:
24855 
        iprot.skip(ftype)
24856 
      iprot.readFieldEnd()
24857 
    iprot.readStructEnd()
24858 
 
24859 
  def write(self, oprot):
24860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24862 
      return
24863 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
24864 
    if self.success is not None:
24865 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24866 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 24867 
      for kiter598,viter599 in self.success.items():
24868 
        oprot.writeI64(kiter598)
24869 
        oprot.writeI64(viter599)
5031 varun.gupt 24870 
      oprot.writeMapEnd()
24871 
      oprot.writeFieldEnd()
24872 
    if self.ex is not None:
24873 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24874 
      self.ex.write(oprot)
24875 
      oprot.writeFieldEnd()
24876 
    oprot.writeFieldStop()
24877 
    oprot.writeStructEnd()
24878 
 
24879 
  def validate(self):
24880 
    return
24881 
 
24882 
 
24883 
  def __repr__(self):
24884 
    L = ['%s=%r' % (key, value)
24885 
      for key, value in self.__dict__.iteritems()]
24886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24887 
 
24888 
  def __eq__(self, other):
24889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24890 
 
24891 
  def __ne__(self, other):
24892 
    return not (self == other)
5067 varun.gupt 24893 
 
24894 
class getOrderIdsForStatus_args:
24895 
  """
24896 
  Attributes:
24897 
   - status
24898 
   - startDatetime
24899 
   - endDatetime
24900 
  """
24901 
 
24902 
  thrift_spec = (
24903 
    None, # 0
24904 
    (1, TType.I64, 'status', None, None, ), # 1
24905 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
24906 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
24907 
  )
24908 
 
24909 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
24910 
    self.status = status
24911 
    self.startDatetime = startDatetime
24912 
    self.endDatetime = endDatetime
24913 
 
24914 
  def read(self, iprot):
24915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24917 
      return
24918 
    iprot.readStructBegin()
24919 
    while True:
24920 
      (fname, ftype, fid) = iprot.readFieldBegin()
24921 
      if ftype == TType.STOP:
24922 
        break
24923 
      if fid == 1:
24924 
        if ftype == TType.I64:
24925 
          self.status = iprot.readI64();
24926 
        else:
24927 
          iprot.skip(ftype)
24928 
      elif fid == 2:
24929 
        if ftype == TType.I64:
24930 
          self.startDatetime = iprot.readI64();
24931 
        else:
24932 
          iprot.skip(ftype)
24933 
      elif fid == 3:
24934 
        if ftype == TType.I64:
24935 
          self.endDatetime = iprot.readI64();
24936 
        else:
24937 
          iprot.skip(ftype)
24938 
      else:
24939 
        iprot.skip(ftype)
24940 
      iprot.readFieldEnd()
24941 
    iprot.readStructEnd()
24942 
 
24943 
  def write(self, oprot):
24944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24946 
      return
24947 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
24948 
    if self.status is not None:
24949 
      oprot.writeFieldBegin('status', TType.I64, 1)
24950 
      oprot.writeI64(self.status)
24951 
      oprot.writeFieldEnd()
24952 
    if self.startDatetime is not None:
24953 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
24954 
      oprot.writeI64(self.startDatetime)
24955 
      oprot.writeFieldEnd()
24956 
    if self.endDatetime is not None:
24957 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
24958 
      oprot.writeI64(self.endDatetime)
24959 
      oprot.writeFieldEnd()
24960 
    oprot.writeFieldStop()
24961 
    oprot.writeStructEnd()
24962 
 
24963 
  def validate(self):
24964 
    return
24965 
 
24966 
 
24967 
  def __repr__(self):
24968 
    L = ['%s=%r' % (key, value)
24969 
      for key, value in self.__dict__.iteritems()]
24970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24971 
 
24972 
  def __eq__(self, other):
24973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24974 
 
24975 
  def __ne__(self, other):
24976 
    return not (self == other)
24977 
 
24978 
class getOrderIdsForStatus_result:
24979 
  """
24980 
  Attributes:
24981 
   - success
24982 
   - ex
24983 
  """
24984 
 
24985 
  thrift_spec = (
24986 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24987 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24988 
  )
24989 
 
24990 
  def __init__(self, success=None, ex=None,):
24991 
    self.success = success
24992 
    self.ex = ex
24993 
 
24994 
  def read(self, iprot):
24995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24997 
      return
24998 
    iprot.readStructBegin()
24999 
    while True:
25000 
      (fname, ftype, fid) = iprot.readFieldBegin()
25001 
      if ftype == TType.STOP:
25002 
        break
25003 
      if fid == 0:
25004 
        if ftype == TType.LIST:
25005 
          self.success = []
6188 rajveer 25006 
          (_etype603, _size600) = iprot.readListBegin()
25007 
          for _i604 in xrange(_size600):
25008 
            _elem605 = iprot.readI64();
25009 
            self.success.append(_elem605)
5067 varun.gupt 25010 
          iprot.readListEnd()
25011 
        else:
25012 
          iprot.skip(ftype)
25013 
      elif fid == 1:
25014 
        if ftype == TType.STRUCT:
25015 
          self.ex = TransactionServiceException()
25016 
          self.ex.read(iprot)
25017 
        else:
25018 
          iprot.skip(ftype)
25019 
      else:
25020 
        iprot.skip(ftype)
25021 
      iprot.readFieldEnd()
25022 
    iprot.readStructEnd()
25023 
 
25024 
  def write(self, oprot):
25025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25027 
      return
25028 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
25029 
    if self.success is not None:
25030 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25031 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 25032 
      for iter606 in self.success:
25033 
        oprot.writeI64(iter606)
5067 varun.gupt 25034 
      oprot.writeListEnd()
25035 
      oprot.writeFieldEnd()
25036 
    if self.ex is not None:
25037 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25038 
      self.ex.write(oprot)
25039 
      oprot.writeFieldEnd()
25040 
    oprot.writeFieldStop()
25041 
    oprot.writeStructEnd()
25042 
 
25043 
  def validate(self):
25044 
    return
25045 
 
25046 
 
25047 
  def __repr__(self):
25048 
    L = ['%s=%r' % (key, value)
25049 
      for key, value in self.__dict__.iteritems()]
25050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25051 
 
25052 
  def __eq__(self, other):
25053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25054 
 
25055 
  def __ne__(self, other):
25056 
    return not (self == other)
5099 varun.gupt 25057 
 
5348 anupam.sin 25058 
class updateCODAgent_args:
25059 
  """
25060 
  Attributes:
25061 
   - agent
25062 
   - orderId
25063 
  """
25064 
 
25065 
  thrift_spec = (
25066 
    None, # 0
25067 
    (1, TType.STRING, 'agent', None, None, ), # 1
25068 
    (2, TType.I64, 'orderId', None, None, ), # 2
25069 
  )
25070 
 
25071 
  def __init__(self, agent=None, orderId=None,):
25072 
    self.agent = agent
25073 
    self.orderId = orderId
25074 
 
25075 
  def read(self, iprot):
25076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25078 
      return
25079 
    iprot.readStructBegin()
25080 
    while True:
25081 
      (fname, ftype, fid) = iprot.readFieldBegin()
25082 
      if ftype == TType.STOP:
25083 
        break
25084 
      if fid == 1:
25085 
        if ftype == TType.STRING:
25086 
          self.agent = iprot.readString();
25087 
        else:
25088 
          iprot.skip(ftype)
25089 
      elif fid == 2:
25090 
        if ftype == TType.I64:
25091 
          self.orderId = iprot.readI64();
25092 
        else:
25093 
          iprot.skip(ftype)
25094 
      else:
25095 
        iprot.skip(ftype)
25096 
      iprot.readFieldEnd()
25097 
    iprot.readStructEnd()
25098 
 
25099 
  def write(self, oprot):
25100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25102 
      return
25103 
    oprot.writeStructBegin('updateCODAgent_args')
25104 
    if self.agent is not None:
25105 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
25106 
      oprot.writeString(self.agent)
25107 
      oprot.writeFieldEnd()
25108 
    if self.orderId is not None:
25109 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
25110 
      oprot.writeI64(self.orderId)
25111 
      oprot.writeFieldEnd()
25112 
    oprot.writeFieldStop()
25113 
    oprot.writeStructEnd()
25114 
 
25115 
  def validate(self):
25116 
    return
25117 
 
25118 
 
25119 
  def __repr__(self):
25120 
    L = ['%s=%r' % (key, value)
25121 
      for key, value in self.__dict__.iteritems()]
25122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25123 
 
25124 
  def __eq__(self, other):
25125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25126 
 
25127 
  def __ne__(self, other):
25128 
    return not (self == other)
25129 
 
25130 
class updateCODAgent_result:
25131 
  """
25132 
  Attributes:
25133 
   - ex
25134 
  """
25135 
 
25136 
  thrift_spec = (
25137 
    None, # 0
25138 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25139 
  )
25140 
 
25141 
  def __init__(self, ex=None,):
25142 
    self.ex = ex
25143 
 
25144 
  def read(self, iprot):
25145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25147 
      return
25148 
    iprot.readStructBegin()
25149 
    while True:
25150 
      (fname, ftype, fid) = iprot.readFieldBegin()
25151 
      if ftype == TType.STOP:
25152 
        break
25153 
      if fid == 1:
25154 
        if ftype == TType.STRUCT:
25155 
          self.ex = TransactionServiceException()
25156 
          self.ex.read(iprot)
25157 
        else:
25158 
          iprot.skip(ftype)
25159 
      else:
25160 
        iprot.skip(ftype)
25161 
      iprot.readFieldEnd()
25162 
    iprot.readStructEnd()
25163 
 
25164 
  def write(self, oprot):
25165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25167 
      return
25168 
    oprot.writeStructBegin('updateCODAgent_result')
25169 
    if self.ex is not None:
25170 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25171 
      self.ex.write(oprot)
25172 
      oprot.writeFieldEnd()
25173 
    oprot.writeFieldStop()
25174 
    oprot.writeStructEnd()
25175 
 
25176 
  def validate(self):
25177 
    return
25178 
 
25179 
 
25180 
  def __repr__(self):
25181 
    L = ['%s=%r' % (key, value)
25182 
      for key, value in self.__dict__.iteritems()]
25183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25184 
 
25185 
  def __eq__(self, other):
25186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25187 
 
25188 
  def __ne__(self, other):
25189 
    return not (self == other)
25190 
 
5099 varun.gupt 25191 
class updateOrderAsPaidToVendor_args:
25192 
  """
25193 
  Attributes:
25194 
   - orderId
25195 
  """
25196 
 
25197 
  thrift_spec = (
25198 
    None, # 0
25199 
    (1, TType.I64, 'orderId', None, None, ), # 1
25200 
  )
25201 
 
25202 
  def __init__(self, orderId=None,):
25203 
    self.orderId = orderId
25204 
 
25205 
  def read(self, iprot):
25206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25208 
      return
25209 
    iprot.readStructBegin()
25210 
    while True:
25211 
      (fname, ftype, fid) = iprot.readFieldBegin()
25212 
      if ftype == TType.STOP:
25213 
        break
25214 
      if fid == 1:
25215 
        if ftype == TType.I64:
25216 
          self.orderId = iprot.readI64();
25217 
        else:
25218 
          iprot.skip(ftype)
25219 
      else:
25220 
        iprot.skip(ftype)
25221 
      iprot.readFieldEnd()
25222 
    iprot.readStructEnd()
25223 
 
25224 
  def write(self, oprot):
25225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25227 
      return
25228 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
25229 
    if self.orderId is not None:
25230 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25231 
      oprot.writeI64(self.orderId)
25232 
      oprot.writeFieldEnd()
25233 
    oprot.writeFieldStop()
25234 
    oprot.writeStructEnd()
25235 
 
25236 
  def validate(self):
25237 
    return
25238 
 
25239 
 
25240 
  def __repr__(self):
25241 
    L = ['%s=%r' % (key, value)
25242 
      for key, value in self.__dict__.iteritems()]
25243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25244 
 
25245 
  def __eq__(self, other):
25246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25247 
 
25248 
  def __ne__(self, other):
25249 
    return not (self == other)
25250 
 
25251 
class updateOrderAsPaidToVendor_result:
25252 
  """
25253 
  Attributes:
25254 
   - ex
25255 
  """
25256 
 
25257 
  thrift_spec = (
25258 
    None, # 0
25259 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25260 
  )
25261 
 
25262 
  def __init__(self, ex=None,):
25263 
    self.ex = ex
25264 
 
25265 
  def read(self, iprot):
25266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25268 
      return
25269 
    iprot.readStructBegin()
25270 
    while True:
25271 
      (fname, ftype, fid) = iprot.readFieldBegin()
25272 
      if ftype == TType.STOP:
25273 
        break
25274 
      if fid == 1:
25275 
        if ftype == TType.STRUCT:
25276 
          self.ex = TransactionServiceException()
25277 
          self.ex.read(iprot)
25278 
        else:
25279 
          iprot.skip(ftype)
25280 
      else:
25281 
        iprot.skip(ftype)
25282 
      iprot.readFieldEnd()
25283 
    iprot.readStructEnd()
25284 
 
25285 
  def write(self, oprot):
25286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25288 
      return
25289 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
25290 
    if self.ex is not None:
25291 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25292 
      self.ex.write(oprot)
25293 
      oprot.writeFieldEnd()
25294 
    oprot.writeFieldStop()
25295 
    oprot.writeStructEnd()
25296 
 
25297 
  def validate(self):
25298 
    return
25299 
 
25300 
 
25301 
  def __repr__(self):
25302 
    L = ['%s=%r' % (key, value)
25303 
      for key, value in self.__dict__.iteritems()]
25304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25305 
 
25306 
  def __eq__(self, other):
25307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25308 
 
25309 
  def __ne__(self, other):
25310 
    return not (self == other)
5208 varun.gupt 25311 
 
5386 phani.kuma 25312 
class updateOrderOnlyAsPaidToVendor_args:
25313 
  """
25314 
  Attributes:
25315 
   - orderId
25316 
  """
25317 
 
25318 
  thrift_spec = (
25319 
    None, # 0
25320 
    (1, TType.I64, 'orderId', None, None, ), # 1
25321 
  )
25322 
 
25323 
  def __init__(self, orderId=None,):
25324 
    self.orderId = orderId
25325 
 
25326 
  def read(self, iprot):
25327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25329 
      return
25330 
    iprot.readStructBegin()
25331 
    while True:
25332 
      (fname, ftype, fid) = iprot.readFieldBegin()
25333 
      if ftype == TType.STOP:
25334 
        break
25335 
      if fid == 1:
25336 
        if ftype == TType.I64:
25337 
          self.orderId = iprot.readI64();
25338 
        else:
25339 
          iprot.skip(ftype)
25340 
      else:
25341 
        iprot.skip(ftype)
25342 
      iprot.readFieldEnd()
25343 
    iprot.readStructEnd()
25344 
 
25345 
  def write(self, oprot):
25346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25348 
      return
25349 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
25350 
    if self.orderId is not None:
25351 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25352 
      oprot.writeI64(self.orderId)
25353 
      oprot.writeFieldEnd()
25354 
    oprot.writeFieldStop()
25355 
    oprot.writeStructEnd()
25356 
 
25357 
  def validate(self):
25358 
    return
25359 
 
25360 
 
25361 
  def __repr__(self):
25362 
    L = ['%s=%r' % (key, value)
25363 
      for key, value in self.__dict__.iteritems()]
25364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25365 
 
25366 
  def __eq__(self, other):
25367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25368 
 
25369 
  def __ne__(self, other):
25370 
    return not (self == other)
25371 
 
25372 
class updateOrderOnlyAsPaidToVendor_result:
25373 
  """
25374 
  Attributes:
25375 
   - ex
25376 
  """
25377 
 
25378 
  thrift_spec = (
25379 
    None, # 0
25380 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25381 
  )
25382 
 
25383 
  def __init__(self, ex=None,):
25384 
    self.ex = ex
25385 
 
25386 
  def read(self, iprot):
25387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25389 
      return
25390 
    iprot.readStructBegin()
25391 
    while True:
25392 
      (fname, ftype, fid) = iprot.readFieldBegin()
25393 
      if ftype == TType.STOP:
25394 
        break
25395 
      if fid == 1:
25396 
        if ftype == TType.STRUCT:
25397 
          self.ex = TransactionServiceException()
25398 
          self.ex.read(iprot)
25399 
        else:
25400 
          iprot.skip(ftype)
25401 
      else:
25402 
        iprot.skip(ftype)
25403 
      iprot.readFieldEnd()
25404 
    iprot.readStructEnd()
25405 
 
25406 
  def write(self, oprot):
25407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25409 
      return
25410 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
25411 
    if self.ex is not None:
25412 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25413 
      self.ex.write(oprot)
25414 
      oprot.writeFieldEnd()
25415 
    oprot.writeFieldStop()
25416 
    oprot.writeStructEnd()
25417 
 
25418 
  def validate(self):
25419 
    return
25420 
 
25421 
 
25422 
  def __repr__(self):
25423 
    L = ['%s=%r' % (key, value)
25424 
      for key, value in self.__dict__.iteritems()]
25425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25426 
 
25427 
  def __eq__(self, other):
25428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25429 
 
25430 
  def __ne__(self, other):
25431 
    return not (self == other)
25432 
 
5208 varun.gupt 25433 
class getRefundedOrdersMarkedPaid_args:
25434 
 
25435 
  thrift_spec = (
25436 
  )
25437 
 
25438 
  def read(self, iprot):
25439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25441 
      return
25442 
    iprot.readStructBegin()
25443 
    while True:
25444 
      (fname, ftype, fid) = iprot.readFieldBegin()
25445 
      if ftype == TType.STOP:
25446 
        break
25447 
      else:
25448 
        iprot.skip(ftype)
25449 
      iprot.readFieldEnd()
25450 
    iprot.readStructEnd()
25451 
 
25452 
  def write(self, oprot):
25453 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25454 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25455 
      return
25456 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
25457 
    oprot.writeFieldStop()
25458 
    oprot.writeStructEnd()
25459 
 
25460 
  def validate(self):
25461 
    return
25462 
 
25463 
 
25464 
  def __repr__(self):
25465 
    L = ['%s=%r' % (key, value)
25466 
      for key, value in self.__dict__.iteritems()]
25467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25468 
 
25469 
  def __eq__(self, other):
25470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25471 
 
25472 
  def __ne__(self, other):
25473 
    return not (self == other)
25474 
 
25475 
class getRefundedOrdersMarkedPaid_result:
25476 
  """
25477 
  Attributes:
25478 
   - success
25479 
   - ex
25480 
  """
25481 
 
25482 
  thrift_spec = (
25483 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25484 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25485 
  )
25486 
 
25487 
  def __init__(self, success=None, ex=None,):
25488 
    self.success = success
25489 
    self.ex = ex
25490 
 
25491 
  def read(self, iprot):
25492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25494 
      return
25495 
    iprot.readStructBegin()
25496 
    while True:
25497 
      (fname, ftype, fid) = iprot.readFieldBegin()
25498 
      if ftype == TType.STOP:
25499 
        break
25500 
      if fid == 0:
25501 
        if ftype == TType.LIST:
25502 
          self.success = []
6188 rajveer 25503 
          (_etype610, _size607) = iprot.readListBegin()
25504 
          for _i611 in xrange(_size607):
25505 
            _elem612 = Order()
25506 
            _elem612.read(iprot)
25507 
            self.success.append(_elem612)
5208 varun.gupt 25508 
          iprot.readListEnd()
25509 
        else:
25510 
          iprot.skip(ftype)
25511 
      elif fid == 1:
25512 
        if ftype == TType.STRUCT:
25513 
          self.ex = TransactionServiceException()
25514 
          self.ex.read(iprot)
25515 
        else:
25516 
          iprot.skip(ftype)
25517 
      else:
25518 
        iprot.skip(ftype)
25519 
      iprot.readFieldEnd()
25520 
    iprot.readStructEnd()
25521 
 
25522 
  def write(self, oprot):
25523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25525 
      return
25526 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
25527 
    if self.success is not None:
25528 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25529 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25530 
      for iter613 in self.success:
25531 
        iter613.write(oprot)
5208 varun.gupt 25532 
      oprot.writeListEnd()
25533 
      oprot.writeFieldEnd()
25534 
    if self.ex is not None:
25535 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25536 
      self.ex.write(oprot)
25537 
      oprot.writeFieldEnd()
25538 
    oprot.writeFieldStop()
25539 
    oprot.writeStructEnd()
25540 
 
25541 
  def validate(self):
25542 
    return
25543 
 
25544 
 
25545 
  def __repr__(self):
25546 
    L = ['%s=%r' % (key, value)
25547 
      for key, value in self.__dict__.iteritems()]
25548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25549 
 
25550 
  def __eq__(self, other):
25551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25552 
 
25553 
  def __ne__(self, other):
25554 
    return not (self == other)
5447 anupam.sin 25555 
 
25556 
class getAllVerificationAgents_args:
25557 
  """
25558 
  Attributes:
25559 
   - minOrderId
25560 
   - maxOrderId
25561 
  """
25562 
 
25563 
  thrift_spec = (
25564 
    None, # 0
25565 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
25566 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
25567 
  )
25568 
 
25569 
  def __init__(self, minOrderId=None, maxOrderId=None,):
25570 
    self.minOrderId = minOrderId
25571 
    self.maxOrderId = maxOrderId
25572 
 
25573 
  def read(self, iprot):
25574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25576 
      return
25577 
    iprot.readStructBegin()
25578 
    while True:
25579 
      (fname, ftype, fid) = iprot.readFieldBegin()
25580 
      if ftype == TType.STOP:
25581 
        break
25582 
      if fid == 1:
25583 
        if ftype == TType.I64:
25584 
          self.minOrderId = iprot.readI64();
25585 
        else:
25586 
          iprot.skip(ftype)
25587 
      elif fid == 2:
25588 
        if ftype == TType.I64:
25589 
          self.maxOrderId = iprot.readI64();
25590 
        else:
25591 
          iprot.skip(ftype)
25592 
      else:
25593 
        iprot.skip(ftype)
25594 
      iprot.readFieldEnd()
25595 
    iprot.readStructEnd()
25596 
 
25597 
  def write(self, oprot):
25598 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25599 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25600 
      return
25601 
    oprot.writeStructBegin('getAllVerificationAgents_args')
25602 
    if self.minOrderId is not None:
25603 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
25604 
      oprot.writeI64(self.minOrderId)
25605 
      oprot.writeFieldEnd()
25606 
    if self.maxOrderId is not None:
25607 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
25608 
      oprot.writeI64(self.maxOrderId)
25609 
      oprot.writeFieldEnd()
25610 
    oprot.writeFieldStop()
25611 
    oprot.writeStructEnd()
25612 
 
25613 
  def validate(self):
25614 
    return
25615 
 
25616 
 
25617 
  def __repr__(self):
25618 
    L = ['%s=%r' % (key, value)
25619 
      for key, value in self.__dict__.iteritems()]
25620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25621 
 
25622 
  def __eq__(self, other):
25623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25624 
 
25625 
  def __ne__(self, other):
25626 
    return not (self == other)
25627 
 
25628 
class getAllVerificationAgents_result:
25629 
  """
25630 
  Attributes:
25631 
   - success
25632 
  """
25633 
 
25634 
  thrift_spec = (
25635 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
25636 
  )
25637 
 
25638 
  def __init__(self, success=None,):
25639 
    self.success = success
25640 
 
25641 
  def read(self, iprot):
25642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25644 
      return
25645 
    iprot.readStructBegin()
25646 
    while True:
25647 
      (fname, ftype, fid) = iprot.readFieldBegin()
25648 
      if ftype == TType.STOP:
25649 
        break
25650 
      if fid == 0:
25651 
        if ftype == TType.LIST:
25652 
          self.success = []
6188 rajveer 25653 
          (_etype617, _size614) = iprot.readListBegin()
25654 
          for _i618 in xrange(_size614):
25655 
            _elem619 = CODVerificationAgent()
25656 
            _elem619.read(iprot)
25657 
            self.success.append(_elem619)
5447 anupam.sin 25658 
          iprot.readListEnd()
25659 
        else:
25660 
          iprot.skip(ftype)
25661 
      else:
25662 
        iprot.skip(ftype)
25663 
      iprot.readFieldEnd()
25664 
    iprot.readStructEnd()
25665 
 
25666 
  def write(self, oprot):
25667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25669 
      return
25670 
    oprot.writeStructBegin('getAllVerificationAgents_result')
25671 
    if self.success is not None:
25672 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25673 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25674 
      for iter620 in self.success:
25675 
        iter620.write(oprot)
5447 anupam.sin 25676 
      oprot.writeListEnd()
25677 
      oprot.writeFieldEnd()
25678 
    oprot.writeFieldStop()
25679 
    oprot.writeStructEnd()
25680 
 
25681 
  def validate(self):
25682 
    return
25683 
 
25684 
 
25685 
  def __repr__(self):
25686 
    L = ['%s=%r' % (key, value)
25687 
      for key, value in self.__dict__.iteritems()]
25688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25689 
 
25690 
  def __eq__(self, other):
25691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25692 
 
25693 
  def __ne__(self, other):
25694 
    return not (self == other)
5527 anupam.sin 25695 
 
25696 
class getAllAttributesForOrderId_args:
25697 
  """
25698 
  Attributes:
25699 
   - orderId
25700 
  """
25701 
 
25702 
  thrift_spec = (
25703 
    None, # 0
25704 
    (1, TType.I64, 'orderId', None, None, ), # 1
25705 
  )
25706 
 
25707 
  def __init__(self, orderId=None,):
25708 
    self.orderId = orderId
25709 
 
25710 
  def read(self, iprot):
25711 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25712 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25713 
      return
25714 
    iprot.readStructBegin()
25715 
    while True:
25716 
      (fname, ftype, fid) = iprot.readFieldBegin()
25717 
      if ftype == TType.STOP:
25718 
        break
25719 
      if fid == 1:
25720 
        if ftype == TType.I64:
25721 
          self.orderId = iprot.readI64();
25722 
        else:
25723 
          iprot.skip(ftype)
25724 
      else:
25725 
        iprot.skip(ftype)
25726 
      iprot.readFieldEnd()
25727 
    iprot.readStructEnd()
25728 
 
25729 
  def write(self, oprot):
25730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25732 
      return
25733 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
25734 
    if self.orderId is not None:
25735 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25736 
      oprot.writeI64(self.orderId)
25737 
      oprot.writeFieldEnd()
25738 
    oprot.writeFieldStop()
25739 
    oprot.writeStructEnd()
25740 
 
25741 
  def validate(self):
25742 
    return
25743 
 
25744 
 
25745 
  def __repr__(self):
25746 
    L = ['%s=%r' % (key, value)
25747 
      for key, value in self.__dict__.iteritems()]
25748 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25749 
 
25750 
  def __eq__(self, other):
25751 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25752 
 
25753 
  def __ne__(self, other):
25754 
    return not (self == other)
25755 
 
25756 
class getAllAttributesForOrderId_result:
25757 
  """
25758 
  Attributes:
25759 
   - success
25760 
  """
25761 
 
25762 
  thrift_spec = (
25763 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25764 
  )
25765 
 
25766 
  def __init__(self, success=None,):
25767 
    self.success = success
25768 
 
25769 
  def read(self, iprot):
25770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25772 
      return
25773 
    iprot.readStructBegin()
25774 
    while True:
25775 
      (fname, ftype, fid) = iprot.readFieldBegin()
25776 
      if ftype == TType.STOP:
25777 
        break
25778 
      if fid == 0:
25779 
        if ftype == TType.LIST:
25780 
          self.success = []
6188 rajveer 25781 
          (_etype624, _size621) = iprot.readListBegin()
25782 
          for _i625 in xrange(_size621):
25783 
            _elem626 = Attribute()
25784 
            _elem626.read(iprot)
25785 
            self.success.append(_elem626)
5527 anupam.sin 25786 
          iprot.readListEnd()
25787 
        else:
25788 
          iprot.skip(ftype)
25789 
      else:
25790 
        iprot.skip(ftype)
25791 
      iprot.readFieldEnd()
25792 
    iprot.readStructEnd()
25793 
 
25794 
  def write(self, oprot):
25795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25797 
      return
25798 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
25799 
    if self.success is not None:
25800 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25801 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25802 
      for iter627 in self.success:
25803 
        iter627.write(oprot)
5527 anupam.sin 25804 
      oprot.writeListEnd()
25805 
      oprot.writeFieldEnd()
25806 
    oprot.writeFieldStop()
25807 
    oprot.writeStructEnd()
25808 
 
25809 
  def validate(self):
25810 
    return
25811 
 
25812 
 
25813 
  def __repr__(self):
25814 
    L = ['%s=%r' % (key, value)
25815 
      for key, value in self.__dict__.iteritems()]
25816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25817 
 
25818 
  def __eq__(self, other):
25819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25820 
 
25821 
  def __ne__(self, other):
25822 
    return not (self == other)
25823 
 
5676 rajveer 25824 
class setOrderAttributes_args:
25825 
  """
25826 
  Attributes:
25827 
   - orderId
25828 
   - attributes
25829 
  """
25830 
 
25831 
  thrift_spec = None
25832 
  def __init__(self, orderId=None, attributes=None,):
25833 
    self.orderId = orderId
25834 
    self.attributes = attributes
25835 
 
25836 
  def read(self, iprot):
25837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25839 
      return
25840 
    iprot.readStructBegin()
25841 
    while True:
25842 
      (fname, ftype, fid) = iprot.readFieldBegin()
25843 
      if ftype == TType.STOP:
25844 
        break
25845 
      if fid == 1:
25846 
        if ftype == TType.I64:
25847 
          self.orderId = iprot.readI64();
25848 
        else:
25849 
          iprot.skip(ftype)
25850 
      elif fid == -1:
25851 
        if ftype == TType.LIST:
25852 
          self.attributes = []
6188 rajveer 25853 
          (_etype631, _size628) = iprot.readListBegin()
25854 
          for _i632 in xrange(_size628):
25855 
            _elem633 = Attribute()
25856 
            _elem633.read(iprot)
25857 
            self.attributes.append(_elem633)
5676 rajveer 25858 
          iprot.readListEnd()
25859 
        else:
25860 
          iprot.skip(ftype)
25861 
      else:
25862 
        iprot.skip(ftype)
25863 
      iprot.readFieldEnd()
25864 
    iprot.readStructEnd()
25865 
 
25866 
  def write(self, oprot):
25867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25869 
      return
25870 
    oprot.writeStructBegin('setOrderAttributes_args')
25871 
    if self.attributes is not None:
25872 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
25873 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 25874 
      for iter634 in self.attributes:
25875 
        iter634.write(oprot)
5676 rajveer 25876 
      oprot.writeListEnd()
25877 
      oprot.writeFieldEnd()
25878 
    if self.orderId is not None:
25879 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25880 
      oprot.writeI64(self.orderId)
25881 
      oprot.writeFieldEnd()
25882 
    oprot.writeFieldStop()
25883 
    oprot.writeStructEnd()
25884 
 
25885 
  def validate(self):
25886 
    return
25887 
 
25888 
 
25889 
  def __repr__(self):
25890 
    L = ['%s=%r' % (key, value)
25891 
      for key, value in self.__dict__.iteritems()]
25892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25893 
 
25894 
  def __eq__(self, other):
25895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25896 
 
25897 
  def __ne__(self, other):
25898 
    return not (self == other)
25899 
 
25900 
class setOrderAttributes_result:
25901 
 
25902 
  thrift_spec = (
25903 
  )
25904 
 
25905 
  def read(self, iprot):
25906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25908 
      return
25909 
    iprot.readStructBegin()
25910 
    while True:
25911 
      (fname, ftype, fid) = iprot.readFieldBegin()
25912 
      if ftype == TType.STOP:
25913 
        break
25914 
      else:
25915 
        iprot.skip(ftype)
25916 
      iprot.readFieldEnd()
25917 
    iprot.readStructEnd()
25918 
 
25919 
  def write(self, oprot):
25920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25922 
      return
25923 
    oprot.writeStructBegin('setOrderAttributes_result')
25924 
    oprot.writeFieldStop()
25925 
    oprot.writeStructEnd()
25926 
 
25927 
  def validate(self):
25928 
    return
25929 
 
25930 
 
25931 
  def __repr__(self):
25932 
    L = ['%s=%r' % (key, value)
25933 
      for key, value in self.__dict__.iteritems()]
25934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25935 
 
25936 
  def __eq__(self, other):
25937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25938 
 
25939 
  def __ne__(self, other):
25940 
    return not (self == other)
25941 
 
5527 anupam.sin 25942 
class setOrderAttributeForTransaction_args:
25943 
  """
25944 
  Attributes:
25945 
   - transactionId
25946 
   - attribute
25947 
  """
25948 
 
25949 
  thrift_spec = None
25950 
  def __init__(self, transactionId=None, attribute=None,):
25951 
    self.transactionId = transactionId
25952 
    self.attribute = attribute
25953 
 
25954 
  def read(self, iprot):
25955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25957 
      return
25958 
    iprot.readStructBegin()
25959 
    while True:
25960 
      (fname, ftype, fid) = iprot.readFieldBegin()
25961 
      if ftype == TType.STOP:
25962 
        break
25963 
      if fid == 1:
25964 
        if ftype == TType.I64:
25965 
          self.transactionId = iprot.readI64();
25966 
        else:
25967 
          iprot.skip(ftype)
25968 
      elif fid == -1:
25969 
        if ftype == TType.STRUCT:
25970 
          self.attribute = Attribute()
25971 
          self.attribute.read(iprot)
25972 
        else:
25973 
          iprot.skip(ftype)
25974 
      else:
25975 
        iprot.skip(ftype)
25976 
      iprot.readFieldEnd()
25977 
    iprot.readStructEnd()
25978 
 
25979 
  def write(self, oprot):
25980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25982 
      return
25983 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
25984 
    if self.attribute is not None:
25985 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
25986 
      self.attribute.write(oprot)
25987 
      oprot.writeFieldEnd()
25988 
    if self.transactionId is not None:
25989 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
25990 
      oprot.writeI64(self.transactionId)
25991 
      oprot.writeFieldEnd()
25992 
    oprot.writeFieldStop()
25993 
    oprot.writeStructEnd()
25994 
 
25995 
  def validate(self):
25996 
    return
25997 
 
25998 
 
25999 
  def __repr__(self):
26000 
    L = ['%s=%r' % (key, value)
26001 
      for key, value in self.__dict__.iteritems()]
26002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26003 
 
26004 
  def __eq__(self, other):
26005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26006 
 
26007 
  def __ne__(self, other):
26008 
    return not (self == other)
26009 
 
26010 
class setOrderAttributeForTransaction_result:
26011 
 
26012 
  thrift_spec = (
26013 
  )
26014 
 
26015 
  def read(self, iprot):
26016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26018 
      return
26019 
    iprot.readStructBegin()
26020 
    while True:
26021 
      (fname, ftype, fid) = iprot.readFieldBegin()
26022 
      if ftype == TType.STOP:
26023 
        break
26024 
      else:
26025 
        iprot.skip(ftype)
26026 
      iprot.readFieldEnd()
26027 
    iprot.readStructEnd()
26028 
 
26029 
  def write(self, oprot):
26030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26032 
      return
26033 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
26034 
    oprot.writeFieldStop()
26035 
    oprot.writeStructEnd()
26036 
 
26037 
  def validate(self):
26038 
    return
26039 
 
26040 
 
26041 
  def __repr__(self):
26042 
    L = ['%s=%r' % (key, value)
26043 
      for key, value in self.__dict__.iteritems()]
26044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26045 
 
26046 
  def __eq__(self, other):
26047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26048 
 
26049 
  def __ne__(self, other):
26050 
    return not (self == other)
5553 rajveer 26051 
 
26052 
class getReceivePendingOrders_args:
26053 
  """
26054 
  Attributes:
26055 
   - storeId
26056 
  """
26057 
 
26058 
  thrift_spec = (
26059 
    None, # 0
26060 
    (1, TType.I64, 'storeId', None, None, ), # 1
26061 
  )
26062 
 
26063 
  def __init__(self, storeId=None,):
26064 
    self.storeId = storeId
26065 
 
26066 
  def read(self, iprot):
26067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26069 
      return
26070 
    iprot.readStructBegin()
26071 
    while True:
26072 
      (fname, ftype, fid) = iprot.readFieldBegin()
26073 
      if ftype == TType.STOP:
26074 
        break
26075 
      if fid == 1:
26076 
        if ftype == TType.I64:
26077 
          self.storeId = iprot.readI64();
26078 
        else:
26079 
          iprot.skip(ftype)
26080 
      else:
26081 
        iprot.skip(ftype)
26082 
      iprot.readFieldEnd()
26083 
    iprot.readStructEnd()
26084 
 
26085 
  def write(self, oprot):
26086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26088 
      return
26089 
    oprot.writeStructBegin('getReceivePendingOrders_args')
26090 
    if self.storeId is not None:
26091 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26092 
      oprot.writeI64(self.storeId)
26093 
      oprot.writeFieldEnd()
26094 
    oprot.writeFieldStop()
26095 
    oprot.writeStructEnd()
26096 
 
26097 
  def validate(self):
26098 
    return
26099 
 
26100 
 
26101 
  def __repr__(self):
26102 
    L = ['%s=%r' % (key, value)
26103 
      for key, value in self.__dict__.iteritems()]
26104 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26105 
 
26106 
  def __eq__(self, other):
26107 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26108 
 
26109 
  def __ne__(self, other):
26110 
    return not (self == other)
26111 
 
26112 
class getReceivePendingOrders_result:
26113 
  """
26114 
  Attributes:
26115 
   - success
26116 
  """
26117 
 
26118 
  thrift_spec = (
26119 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26120 
  )
26121 
 
26122 
  def __init__(self, success=None,):
26123 
    self.success = success
26124 
 
26125 
  def read(self, iprot):
26126 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26127 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26128 
      return
26129 
    iprot.readStructBegin()
26130 
    while True:
26131 
      (fname, ftype, fid) = iprot.readFieldBegin()
26132 
      if ftype == TType.STOP:
26133 
        break
26134 
      if fid == 0:
26135 
        if ftype == TType.LIST:
26136 
          self.success = []
6188 rajveer 26137 
          (_etype638, _size635) = iprot.readListBegin()
26138 
          for _i639 in xrange(_size635):
26139 
            _elem640 = Order()
26140 
            _elem640.read(iprot)
26141 
            self.success.append(_elem640)
5553 rajveer 26142 
          iprot.readListEnd()
26143 
        else:
26144 
          iprot.skip(ftype)
26145 
      else:
26146 
        iprot.skip(ftype)
26147 
      iprot.readFieldEnd()
26148 
    iprot.readStructEnd()
26149 
 
26150 
  def write(self, oprot):
26151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26153 
      return
26154 
    oprot.writeStructBegin('getReceivePendingOrders_result')
26155 
    if self.success is not None:
26156 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26157 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26158 
      for iter641 in self.success:
26159 
        iter641.write(oprot)
5553 rajveer 26160 
      oprot.writeListEnd()
26161 
      oprot.writeFieldEnd()
26162 
    oprot.writeFieldStop()
26163 
    oprot.writeStructEnd()
26164 
 
26165 
  def validate(self):
26166 
    return
26167 
 
26168 
 
26169 
  def __repr__(self):
26170 
    L = ['%s=%r' % (key, value)
26171 
      for key, value in self.__dict__.iteritems()]
26172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26173 
 
26174 
  def __eq__(self, other):
26175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26176 
 
26177 
  def __ne__(self, other):
26178 
    return not (self == other)
26179 
 
26180 
class getReceivedAtStoreOrders_args:
26181 
  """
26182 
  Attributes:
26183 
   - storeId
26184 
  """
26185 
 
26186 
  thrift_spec = (
26187 
    None, # 0
26188 
    (1, TType.I64, 'storeId', None, None, ), # 1
26189 
  )
26190 
 
26191 
  def __init__(self, storeId=None,):
26192 
    self.storeId = storeId
26193 
 
26194 
  def read(self, iprot):
26195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26197 
      return
26198 
    iprot.readStructBegin()
26199 
    while True:
26200 
      (fname, ftype, fid) = iprot.readFieldBegin()
26201 
      if ftype == TType.STOP:
26202 
        break
26203 
      if fid == 1:
26204 
        if ftype == TType.I64:
26205 
          self.storeId = iprot.readI64();
26206 
        else:
26207 
          iprot.skip(ftype)
26208 
      else:
26209 
        iprot.skip(ftype)
26210 
      iprot.readFieldEnd()
26211 
    iprot.readStructEnd()
26212 
 
26213 
  def write(self, oprot):
26214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26216 
      return
26217 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
26218 
    if self.storeId is not None:
26219 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26220 
      oprot.writeI64(self.storeId)
26221 
      oprot.writeFieldEnd()
26222 
    oprot.writeFieldStop()
26223 
    oprot.writeStructEnd()
26224 
 
26225 
  def validate(self):
26226 
    return
26227 
 
26228 
 
26229 
  def __repr__(self):
26230 
    L = ['%s=%r' % (key, value)
26231 
      for key, value in self.__dict__.iteritems()]
26232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26233 
 
26234 
  def __eq__(self, other):
26235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26236 
 
26237 
  def __ne__(self, other):
26238 
    return not (self == other)
26239 
 
26240 
class getReceivedAtStoreOrders_result:
26241 
  """
26242 
  Attributes:
26243 
   - success
26244 
  """
26245 
 
26246 
  thrift_spec = (
26247 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26248 
  )
26249 
 
26250 
  def __init__(self, success=None,):
26251 
    self.success = success
26252 
 
26253 
  def read(self, iprot):
26254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26256 
      return
26257 
    iprot.readStructBegin()
26258 
    while True:
26259 
      (fname, ftype, fid) = iprot.readFieldBegin()
26260 
      if ftype == TType.STOP:
26261 
        break
26262 
      if fid == 0:
26263 
        if ftype == TType.LIST:
26264 
          self.success = []
6188 rajveer 26265 
          (_etype645, _size642) = iprot.readListBegin()
26266 
          for _i646 in xrange(_size642):
26267 
            _elem647 = Order()
26268 
            _elem647.read(iprot)
26269 
            self.success.append(_elem647)
5553 rajveer 26270 
          iprot.readListEnd()
26271 
        else:
26272 
          iprot.skip(ftype)
26273 
      else:
26274 
        iprot.skip(ftype)
26275 
      iprot.readFieldEnd()
26276 
    iprot.readStructEnd()
26277 
 
26278 
  def write(self, oprot):
26279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26281 
      return
26282 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
26283 
    if self.success is not None:
26284 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26285 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26286 
      for iter648 in self.success:
26287 
        iter648.write(oprot)
5553 rajveer 26288 
      oprot.writeListEnd()
26289 
      oprot.writeFieldEnd()
26290 
    oprot.writeFieldStop()
26291 
    oprot.writeStructEnd()
26292 
 
26293 
  def validate(self):
26294 
    return
26295 
 
26296 
 
26297 
  def __repr__(self):
26298 
    L = ['%s=%r' % (key, value)
26299 
      for key, value in self.__dict__.iteritems()]
26300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26301 
 
26302 
  def __eq__(self, other):
26303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26304 
 
26305 
  def __ne__(self, other):
26306 
    return not (self == other)
5593 mandeep.dh 26307 
 
5713 rajveer 26308 
class getOrdersCollectionAtStore_args:
26309 
  """
26310 
  Attributes:
26311 
   - storeId
26312 
   - fromDate
26313 
   - toDate
26314 
   - onlyCod
26315 
  """
26316 
 
26317 
  thrift_spec = (
26318 
    None, # 0
26319 
    (1, TType.I64, 'storeId', None, None, ), # 1
26320 
    (2, TType.I64, 'fromDate', None, None, ), # 2
26321 
    (3, TType.I64, 'toDate', None, None, ), # 3
26322 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
26323 
  )
26324 
 
26325 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
26326 
    self.storeId = storeId
26327 
    self.fromDate = fromDate
26328 
    self.toDate = toDate
26329 
    self.onlyCod = onlyCod
26330 
 
26331 
  def read(self, iprot):
26332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26334 
      return
26335 
    iprot.readStructBegin()
26336 
    while True:
26337 
      (fname, ftype, fid) = iprot.readFieldBegin()
26338 
      if ftype == TType.STOP:
26339 
        break
26340 
      if fid == 1:
26341 
        if ftype == TType.I64:
26342 
          self.storeId = iprot.readI64();
26343 
        else:
26344 
          iprot.skip(ftype)
26345 
      elif fid == 2:
26346 
        if ftype == TType.I64:
26347 
          self.fromDate = iprot.readI64();
26348 
        else:
26349 
          iprot.skip(ftype)
26350 
      elif fid == 3:
26351 
        if ftype == TType.I64:
26352 
          self.toDate = iprot.readI64();
26353 
        else:
26354 
          iprot.skip(ftype)
26355 
      elif fid == 4:
26356 
        if ftype == TType.BOOL:
26357 
          self.onlyCod = iprot.readBool();
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('getOrdersCollectionAtStore_args')
26370 
    if self.storeId is not None:
26371 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26372 
      oprot.writeI64(self.storeId)
26373 
      oprot.writeFieldEnd()
26374 
    if self.fromDate is not None:
26375 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
26376 
      oprot.writeI64(self.fromDate)
26377 
      oprot.writeFieldEnd()
26378 
    if self.toDate is not None:
26379 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
26380 
      oprot.writeI64(self.toDate)
26381 
      oprot.writeFieldEnd()
26382 
    if self.onlyCod is not None:
26383 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
26384 
      oprot.writeBool(self.onlyCod)
26385 
      oprot.writeFieldEnd()
26386 
    oprot.writeFieldStop()
26387 
    oprot.writeStructEnd()
26388 
 
26389 
  def validate(self):
26390 
    return
26391 
 
26392 
 
26393 
  def __repr__(self):
26394 
    L = ['%s=%r' % (key, value)
26395 
      for key, value in self.__dict__.iteritems()]
26396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26397 
 
26398 
  def __eq__(self, other):
26399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26400 
 
26401 
  def __ne__(self, other):
26402 
    return not (self == other)
26403 
 
26404 
class getOrdersCollectionAtStore_result:
26405 
  """
26406 
  Attributes:
26407 
   - success
26408 
  """
26409 
 
26410 
  thrift_spec = (
26411 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26412 
  )
26413 
 
26414 
  def __init__(self, success=None,):
26415 
    self.success = success
26416 
 
26417 
  def read(self, iprot):
26418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26420 
      return
26421 
    iprot.readStructBegin()
26422 
    while True:
26423 
      (fname, ftype, fid) = iprot.readFieldBegin()
26424 
      if ftype == TType.STOP:
26425 
        break
26426 
      if fid == 0:
26427 
        if ftype == TType.LIST:
26428 
          self.success = []
6188 rajveer 26429 
          (_etype652, _size649) = iprot.readListBegin()
26430 
          for _i653 in xrange(_size649):
26431 
            _elem654 = Order()
26432 
            _elem654.read(iprot)
26433 
            self.success.append(_elem654)
5713 rajveer 26434 
          iprot.readListEnd()
26435 
        else:
26436 
          iprot.skip(ftype)
26437 
      else:
26438 
        iprot.skip(ftype)
26439 
      iprot.readFieldEnd()
26440 
    iprot.readStructEnd()
26441 
 
26442 
  def write(self, oprot):
26443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26445 
      return
26446 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
26447 
    if self.success is not None:
26448 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26449 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26450 
      for iter655 in self.success:
26451 
        iter655.write(oprot)
5713 rajveer 26452 
      oprot.writeListEnd()
26453 
      oprot.writeFieldEnd()
26454 
    oprot.writeFieldStop()
26455 
    oprot.writeStructEnd()
26456 
 
26457 
  def validate(self):
26458 
    return
26459 
 
26460 
 
26461 
  def __repr__(self):
26462 
    L = ['%s=%r' % (key, value)
26463 
      for key, value in self.__dict__.iteritems()]
26464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26465 
 
26466 
  def __eq__(self, other):
26467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26468 
 
26469 
  def __ne__(self, other):
26470 
    return not (self == other)
26471 
 
5833 rajveer 26472 
class getOrderAttributeValue_args:
26473 
  """
26474 
  Attributes:
26475 
   - orderId
26476 
   - attributeName
26477 
  """
26478 
 
26479 
  thrift_spec = None
26480 
  def __init__(self, orderId=None, attributeName=None,):
26481 
    self.orderId = orderId
26482 
    self.attributeName = attributeName
26483 
 
26484 
  def read(self, iprot):
26485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26487 
      return
26488 
    iprot.readStructBegin()
26489 
    while True:
26490 
      (fname, ftype, fid) = iprot.readFieldBegin()
26491 
      if ftype == TType.STOP:
26492 
        break
26493 
      if fid == 1:
26494 
        if ftype == TType.I64:
26495 
          self.orderId = iprot.readI64();
26496 
        else:
26497 
          iprot.skip(ftype)
26498 
      elif fid == -1:
26499 
        if ftype == TType.STRING:
26500 
          self.attributeName = iprot.readString();
26501 
        else:
26502 
          iprot.skip(ftype)
26503 
      else:
26504 
        iprot.skip(ftype)
26505 
      iprot.readFieldEnd()
26506 
    iprot.readStructEnd()
26507 
 
26508 
  def write(self, oprot):
26509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26511 
      return
26512 
    oprot.writeStructBegin('getOrderAttributeValue_args')
26513 
    if self.attributeName is not None:
26514 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
26515 
      oprot.writeString(self.attributeName)
26516 
      oprot.writeFieldEnd()
26517 
    if self.orderId is not None:
26518 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26519 
      oprot.writeI64(self.orderId)
26520 
      oprot.writeFieldEnd()
26521 
    oprot.writeFieldStop()
26522 
    oprot.writeStructEnd()
26523 
 
26524 
  def validate(self):
26525 
    return
26526 
 
26527 
 
26528 
  def __repr__(self):
26529 
    L = ['%s=%r' % (key, value)
26530 
      for key, value in self.__dict__.iteritems()]
26531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26532 
 
26533 
  def __eq__(self, other):
26534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26535 
 
26536 
  def __ne__(self, other):
26537 
    return not (self == other)
26538 
 
26539 
class getOrderAttributeValue_result:
26540 
  """
26541 
  Attributes:
26542 
   - success
26543 
  """
26544 
 
26545 
  thrift_spec = (
26546 
    (0, TType.STRING, 'success', None, None, ), # 0
26547 
  )
26548 
 
26549 
  def __init__(self, success=None,):
26550 
    self.success = success
26551 
 
26552 
  def read(self, iprot):
26553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26555 
      return
26556 
    iprot.readStructBegin()
26557 
    while True:
26558 
      (fname, ftype, fid) = iprot.readFieldBegin()
26559 
      if ftype == TType.STOP:
26560 
        break
26561 
      if fid == 0:
26562 
        if ftype == TType.STRING:
26563 
          self.success = iprot.readString();
26564 
        else:
26565 
          iprot.skip(ftype)
26566 
      else:
26567 
        iprot.skip(ftype)
26568 
      iprot.readFieldEnd()
26569 
    iprot.readStructEnd()
26570 
 
26571 
  def write(self, oprot):
26572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26574 
      return
26575 
    oprot.writeStructBegin('getOrderAttributeValue_result')
26576 
    if self.success is not None:
26577 
      oprot.writeFieldBegin('success', TType.STRING, 0)
26578 
      oprot.writeString(self.success)
26579 
      oprot.writeFieldEnd()
26580 
    oprot.writeFieldStop()
26581 
    oprot.writeStructEnd()
26582 
 
26583 
  def validate(self):
26584 
    return
26585 
 
26586 
 
26587 
  def __repr__(self):
26588 
    L = ['%s=%r' % (key, value)
26589 
      for key, value in self.__dict__.iteritems()]
26590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26591 
 
26592 
  def __eq__(self, other):
26593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26594 
 
26595 
  def __ne__(self, other):
26596 
    return not (self == other)
26597 
 
6019 rajveer 26598 
class changeJacketNumber_args:
26599 
  """
26600 
  Attributes:
26601 
   - orderId
26602 
   - jacketNumber
26603 
  """
26604 
 
26605 
  thrift_spec = (
26606 
    None, # 0
26607 
    (1, TType.I64, 'orderId', None, None, ), # 1
26608 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
26609 
  )
26610 
 
26611 
  def __init__(self, orderId=None, jacketNumber=None,):
26612 
    self.orderId = orderId
26613 
    self.jacketNumber = jacketNumber
26614 
 
26615 
  def read(self, iprot):
26616 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26617 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26618 
      return
26619 
    iprot.readStructBegin()
26620 
    while True:
26621 
      (fname, ftype, fid) = iprot.readFieldBegin()
26622 
      if ftype == TType.STOP:
26623 
        break
26624 
      if fid == 1:
26625 
        if ftype == TType.I64:
26626 
          self.orderId = iprot.readI64();
26627 
        else:
26628 
          iprot.skip(ftype)
26629 
      elif fid == 2:
26630 
        if ftype == TType.I64:
26631 
          self.jacketNumber = iprot.readI64();
26632 
        else:
26633 
          iprot.skip(ftype)
26634 
      else:
26635 
        iprot.skip(ftype)
26636 
      iprot.readFieldEnd()
26637 
    iprot.readStructEnd()
26638 
 
26639 
  def write(self, oprot):
26640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26642 
      return
26643 
    oprot.writeStructBegin('changeJacketNumber_args')
26644 
    if self.orderId is not None:
26645 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26646 
      oprot.writeI64(self.orderId)
26647 
      oprot.writeFieldEnd()
26648 
    if self.jacketNumber is not None:
26649 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
26650 
      oprot.writeI64(self.jacketNumber)
26651 
      oprot.writeFieldEnd()
26652 
    oprot.writeFieldStop()
26653 
    oprot.writeStructEnd()
26654 
 
26655 
  def validate(self):
26656 
    return
26657 
 
26658 
 
26659 
  def __repr__(self):
26660 
    L = ['%s=%r' % (key, value)
26661 
      for key, value in self.__dict__.iteritems()]
26662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26663 
 
26664 
  def __eq__(self, other):
26665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26666 
 
26667 
  def __ne__(self, other):
26668 
    return not (self == other)
26669 
 
26670 
class changeJacketNumber_result:
26671 
  """
26672 
  Attributes:
26673 
   - success
26674 
  """
26675 
 
26676 
  thrift_spec = (
26677 
    (0, TType.BOOL, 'success', None, None, ), # 0
26678 
  )
26679 
 
26680 
  def __init__(self, success=None,):
26681 
    self.success = success
26682 
 
26683 
  def read(self, iprot):
26684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26686 
      return
26687 
    iprot.readStructBegin()
26688 
    while True:
26689 
      (fname, ftype, fid) = iprot.readFieldBegin()
26690 
      if ftype == TType.STOP:
26691 
        break
26692 
      if fid == 0:
26693 
        if ftype == TType.BOOL:
26694 
          self.success = iprot.readBool();
26695 
        else:
26696 
          iprot.skip(ftype)
26697 
      else:
26698 
        iprot.skip(ftype)
26699 
      iprot.readFieldEnd()
26700 
    iprot.readStructEnd()
26701 
 
26702 
  def write(self, oprot):
26703 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26704 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26705 
      return
26706 
    oprot.writeStructBegin('changeJacketNumber_result')
26707 
    if self.success is not None:
26708 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26709 
      oprot.writeBool(self.success)
26710 
      oprot.writeFieldEnd()
26711 
    oprot.writeFieldStop()
26712 
    oprot.writeStructEnd()
26713 
 
26714 
  def validate(self):
26715 
    return
26716 
 
26717 
 
26718 
  def __repr__(self):
26719 
    L = ['%s=%r' % (key, value)
26720 
      for key, value in self.__dict__.iteritems()]
26721 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26722 
 
26723 
  def __eq__(self, other):
26724 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26725 
 
26726 
  def __ne__(self, other):
26727 
    return not (self == other)
26728 
 
26729 
class markOrderAsRtoInTransit_args:
26730 
  """
26731 
  Attributes:
26732 
   - orderId
26733 
  """
26734 
 
26735 
  thrift_spec = (
26736 
    None, # 0
26737 
    (1, TType.I64, 'orderId', None, None, ), # 1
26738 
  )
26739 
 
26740 
  def __init__(self, orderId=None,):
26741 
    self.orderId = orderId
26742 
 
26743 
  def read(self, iprot):
26744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26746 
      return
26747 
    iprot.readStructBegin()
26748 
    while True:
26749 
      (fname, ftype, fid) = iprot.readFieldBegin()
26750 
      if ftype == TType.STOP:
26751 
        break
26752 
      if fid == 1:
26753 
        if ftype == TType.I64:
26754 
          self.orderId = iprot.readI64();
26755 
        else:
26756 
          iprot.skip(ftype)
26757 
      else:
26758 
        iprot.skip(ftype)
26759 
      iprot.readFieldEnd()
26760 
    iprot.readStructEnd()
26761 
 
26762 
  def write(self, oprot):
26763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26765 
      return
26766 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26767 
    if self.orderId is not None:
26768 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26769 
      oprot.writeI64(self.orderId)
26770 
      oprot.writeFieldEnd()
26771 
    oprot.writeFieldStop()
26772 
    oprot.writeStructEnd()
26773 
 
26774 
  def validate(self):
26775 
    return
26776 
 
26777 
 
26778 
  def __repr__(self):
26779 
    L = ['%s=%r' % (key, value)
26780 
      for key, value in self.__dict__.iteritems()]
26781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26782 
 
26783 
  def __eq__(self, other):
26784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26785 
 
26786 
  def __ne__(self, other):
26787 
    return not (self == other)
26788 
 
26789 
class markOrderAsRtoInTransit_result:
26790 
  """
26791 
  Attributes:
26792 
   - success
26793 
  """
26794 
 
26795 
  thrift_spec = (
26796 
    (0, TType.BOOL, 'success', None, None, ), # 0
26797 
  )
26798 
 
26799 
  def __init__(self, success=None,):
26800 
    self.success = success
26801 
 
26802 
  def read(self, iprot):
26803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26805 
      return
26806 
    iprot.readStructBegin()
26807 
    while True:
26808 
      (fname, ftype, fid) = iprot.readFieldBegin()
26809 
      if ftype == TType.STOP:
26810 
        break
26811 
      if fid == 0:
26812 
        if ftype == TType.BOOL:
26813 
          self.success = iprot.readBool();
26814 
        else:
26815 
          iprot.skip(ftype)
26816 
      else:
26817 
        iprot.skip(ftype)
26818 
      iprot.readFieldEnd()
26819 
    iprot.readStructEnd()
26820 
 
26821 
  def write(self, oprot):
26822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26824 
      return
26825 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
26826 
    if self.success is not None:
26827 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26828 
      oprot.writeBool(self.success)
26829 
      oprot.writeFieldEnd()
26830 
    oprot.writeFieldStop()
26831 
    oprot.writeStructEnd()
26832 
 
26833 
  def validate(self):
26834 
    return
26835 
 
26836 
 
26837 
  def __repr__(self):
26838 
    L = ['%s=%r' % (key, value)
26839 
      for key, value in self.__dict__.iteritems()]
26840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26841 
 
26842 
  def __eq__(self, other):
26843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26844 
 
26845 
  def __ne__(self, other):
26846 
    return not (self == other)
26847 
 
5593 mandeep.dh 26848 
class acceptOrderForItem_args:
26849 
  """
26850 
  Attributes:
26851 
   - itemId
26852 
   - quantity
26853 
   - fulfilmentWarehouseId
26854 
   - billingWarehouseId
26855 
  """
26856 
 
26857 
  thrift_spec = (
26858 
    None, # 0
26859 
    (1, TType.I64, 'itemId', None, None, ), # 1
26860 
    (2, TType.I64, 'quantity', None, None, ), # 2
26861 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
26862 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
26863 
  )
26864 
 
26865 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
26866 
    self.itemId = itemId
26867 
    self.quantity = quantity
26868 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
26869 
    self.billingWarehouseId = billingWarehouseId
26870 
 
26871 
  def read(self, iprot):
26872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26874 
      return
26875 
    iprot.readStructBegin()
26876 
    while True:
26877 
      (fname, ftype, fid) = iprot.readFieldBegin()
26878 
      if ftype == TType.STOP:
26879 
        break
26880 
      if fid == 1:
26881 
        if ftype == TType.I64:
26882 
          self.itemId = iprot.readI64();
26883 
        else:
26884 
          iprot.skip(ftype)
26885 
      elif fid == 2:
26886 
        if ftype == TType.I64:
26887 
          self.quantity = iprot.readI64();
26888 
        else:
26889 
          iprot.skip(ftype)
26890 
      elif fid == 3:
26891 
        if ftype == TType.I64:
26892 
          self.fulfilmentWarehouseId = iprot.readI64();
26893 
        else:
26894 
          iprot.skip(ftype)
26895 
      elif fid == 4:
26896 
        if ftype == TType.I64:
26897 
          self.billingWarehouseId = iprot.readI64();
26898 
        else:
26899 
          iprot.skip(ftype)
26900 
      else:
26901 
        iprot.skip(ftype)
26902 
      iprot.readFieldEnd()
26903 
    iprot.readStructEnd()
26904 
 
26905 
  def write(self, oprot):
26906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26908 
      return
26909 
    oprot.writeStructBegin('acceptOrderForItem_args')
26910 
    if self.itemId is not None:
26911 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26912 
      oprot.writeI64(self.itemId)
26913 
      oprot.writeFieldEnd()
26914 
    if self.quantity is not None:
26915 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
26916 
      oprot.writeI64(self.quantity)
26917 
      oprot.writeFieldEnd()
26918 
    if self.fulfilmentWarehouseId is not None:
26919 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26920 
      oprot.writeI64(self.fulfilmentWarehouseId)
26921 
      oprot.writeFieldEnd()
26922 
    if self.billingWarehouseId is not None:
26923 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26924 
      oprot.writeI64(self.billingWarehouseId)
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)
26943 
 
26944 
class acceptOrderForItem_result:
26945 
 
26946 
  thrift_spec = (
26947 
  )
26948 
 
26949 
  def read(self, iprot):
26950 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26951 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26952 
      return
26953 
    iprot.readStructBegin()
26954 
    while True:
26955 
      (fname, ftype, fid) = iprot.readFieldBegin()
26956 
      if ftype == TType.STOP:
26957 
        break
26958 
      else:
26959 
        iprot.skip(ftype)
26960 
      iprot.readFieldEnd()
26961 
    iprot.readStructEnd()
26962 
 
26963 
  def write(self, oprot):
26964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26966 
      return
26967 
    oprot.writeStructBegin('acceptOrderForItem_result')
26968 
    oprot.writeFieldStop()
26969 
    oprot.writeStructEnd()
26970 
 
26971 
  def validate(self):
26972 
    return
26973 
 
26974 
 
26975 
  def __repr__(self):
26976 
    L = ['%s=%r' % (key, value)
26977 
      for key, value in self.__dict__.iteritems()]
26978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26979 
 
26980 
  def __eq__(self, other):
26981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26982 
 
26983 
  def __ne__(self, other):
26984 
    return not (self == other)
6000 mandeep.dh 26985 
 
26986 
class createRechargeOrder_args:
26987 
  """
26988 
  Attributes:
26989 
   - rechargeOrder
26990 
  """
26991 
 
26992 
  thrift_spec = (
26993 
    None, # 0
26994 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
26995 
  )
26996 
 
26997 
  def __init__(self, rechargeOrder=None,):
26998 
    self.rechargeOrder = rechargeOrder
26999 
 
27000 
  def read(self, iprot):
27001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27003 
      return
27004 
    iprot.readStructBegin()
27005 
    while True:
27006 
      (fname, ftype, fid) = iprot.readFieldBegin()
27007 
      if ftype == TType.STOP:
27008 
        break
27009 
      if fid == 1:
27010 
        if ftype == TType.STRUCT:
27011 
          self.rechargeOrder = RechargeOrder()
27012 
          self.rechargeOrder.read(iprot)
27013 
        else:
27014 
          iprot.skip(ftype)
27015 
      else:
27016 
        iprot.skip(ftype)
27017 
      iprot.readFieldEnd()
27018 
    iprot.readStructEnd()
27019 
 
27020 
  def write(self, oprot):
27021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27023 
      return
27024 
    oprot.writeStructBegin('createRechargeOrder_args')
27025 
    if self.rechargeOrder is not None:
27026 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
27027 
      self.rechargeOrder.write(oprot)
27028 
      oprot.writeFieldEnd()
27029 
    oprot.writeFieldStop()
27030 
    oprot.writeStructEnd()
27031 
 
27032 
  def validate(self):
27033 
    return
27034 
 
27035 
 
27036 
  def __repr__(self):
27037 
    L = ['%s=%r' % (key, value)
27038 
      for key, value in self.__dict__.iteritems()]
27039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27040 
 
27041 
  def __eq__(self, other):
27042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27043 
 
27044 
  def __ne__(self, other):
27045 
    return not (self == other)
27046 
 
27047 
class createRechargeOrder_result:
27048 
  """
27049 
  Attributes:
27050 
   - success
27051 
   - ex
27052 
  """
27053 
 
27054 
  thrift_spec = (
27055 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27056 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27057 
  )
27058 
 
27059 
  def __init__(self, success=None, ex=None,):
27060 
    self.success = success
27061 
    self.ex = ex
27062 
 
27063 
  def read(self, iprot):
27064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27066 
      return
27067 
    iprot.readStructBegin()
27068 
    while True:
27069 
      (fname, ftype, fid) = iprot.readFieldBegin()
27070 
      if ftype == TType.STOP:
27071 
        break
27072 
      if fid == 0:
27073 
        if ftype == TType.STRUCT:
27074 
          self.success = RechargeOrder()
27075 
          self.success.read(iprot)
27076 
        else:
27077 
          iprot.skip(ftype)
27078 
      elif fid == 1:
27079 
        if ftype == TType.STRUCT:
27080 
          self.ex = TransactionServiceException()
27081 
          self.ex.read(iprot)
27082 
        else:
27083 
          iprot.skip(ftype)
27084 
      else:
27085 
        iprot.skip(ftype)
27086 
      iprot.readFieldEnd()
27087 
    iprot.readStructEnd()
27088 
 
27089 
  def write(self, oprot):
27090 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27091 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27092 
      return
27093 
    oprot.writeStructBegin('createRechargeOrder_result')
27094 
    if self.success is not None:
27095 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27096 
      self.success.write(oprot)
27097 
      oprot.writeFieldEnd()
27098 
    if self.ex is not None:
27099 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27100 
      self.ex.write(oprot)
27101 
      oprot.writeFieldEnd()
27102 
    oprot.writeFieldStop()
27103 
    oprot.writeStructEnd()
27104 
 
27105 
  def validate(self):
27106 
    return
27107 
 
27108 
 
27109 
  def __repr__(self):
27110 
    L = ['%s=%r' % (key, value)
27111 
      for key, value in self.__dict__.iteritems()]
27112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27113 
 
27114 
  def __eq__(self, other):
27115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27116 
 
27117 
  def __ne__(self, other):
27118 
    return not (self == other)
27119 
 
6031 rajveer 27120 
class getRechargeOrder_args:
27121 
  """
27122 
  Attributes:
27123 
   - rechargeRrderId
27124 
  """
27125 
 
27126 
  thrift_spec = (
27127 
    None, # 0
27128 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
27129 
  )
27130 
 
27131 
  def __init__(self, rechargeRrderId=None,):
27132 
    self.rechargeRrderId = rechargeRrderId
27133 
 
27134 
  def read(self, iprot):
27135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27137 
      return
27138 
    iprot.readStructBegin()
27139 
    while True:
27140 
      (fname, ftype, fid) = iprot.readFieldBegin()
27141 
      if ftype == TType.STOP:
27142 
        break
27143 
      if fid == 1:
27144 
        if ftype == TType.I64:
27145 
          self.rechargeRrderId = iprot.readI64();
27146 
        else:
27147 
          iprot.skip(ftype)
27148 
      else:
27149 
        iprot.skip(ftype)
27150 
      iprot.readFieldEnd()
27151 
    iprot.readStructEnd()
27152 
 
27153 
  def write(self, oprot):
27154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27156 
      return
27157 
    oprot.writeStructBegin('getRechargeOrder_args')
27158 
    if self.rechargeRrderId is not None:
27159 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
27160 
      oprot.writeI64(self.rechargeRrderId)
27161 
      oprot.writeFieldEnd()
27162 
    oprot.writeFieldStop()
27163 
    oprot.writeStructEnd()
27164 
 
27165 
  def validate(self):
27166 
    return
27167 
 
27168 
 
27169 
  def __repr__(self):
27170 
    L = ['%s=%r' % (key, value)
27171 
      for key, value in self.__dict__.iteritems()]
27172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27173 
 
27174 
  def __eq__(self, other):
27175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27176 
 
27177 
  def __ne__(self, other):
27178 
    return not (self == other)
27179 
 
27180 
class getRechargeOrder_result:
27181 
  """
27182 
  Attributes:
27183 
   - success
27184 
   - ex
27185 
  """
27186 
 
27187 
  thrift_spec = (
27188 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27189 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27190 
  )
27191 
 
27192 
  def __init__(self, success=None, ex=None,):
27193 
    self.success = success
27194 
    self.ex = ex
27195 
 
27196 
  def read(self, iprot):
27197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27199 
      return
27200 
    iprot.readStructBegin()
27201 
    while True:
27202 
      (fname, ftype, fid) = iprot.readFieldBegin()
27203 
      if ftype == TType.STOP:
27204 
        break
27205 
      if fid == 0:
27206 
        if ftype == TType.STRUCT:
27207 
          self.success = RechargeOrder()
27208 
          self.success.read(iprot)
27209 
        else:
27210 
          iprot.skip(ftype)
27211 
      elif fid == 1:
27212 
        if ftype == TType.STRUCT:
27213 
          self.ex = TransactionServiceException()
27214 
          self.ex.read(iprot)
27215 
        else:
27216 
          iprot.skip(ftype)
27217 
      else:
27218 
        iprot.skip(ftype)
27219 
      iprot.readFieldEnd()
27220 
    iprot.readStructEnd()
27221 
 
27222 
  def write(self, oprot):
27223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27225 
      return
27226 
    oprot.writeStructBegin('getRechargeOrder_result')
27227 
    if self.success is not None:
27228 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27229 
      self.success.write(oprot)
27230 
      oprot.writeFieldEnd()
27231 
    if self.ex is not None:
27232 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27233 
      self.ex.write(oprot)
27234 
      oprot.writeFieldEnd()
27235 
    oprot.writeFieldStop()
27236 
    oprot.writeStructEnd()
27237 
 
27238 
  def validate(self):
27239 
    return
27240 
 
27241 
 
27242 
  def __repr__(self):
27243 
    L = ['%s=%r' % (key, value)
27244 
      for key, value in self.__dict__.iteritems()]
27245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27246 
 
27247 
  def __eq__(self, other):
27248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27249 
 
27250 
  def __ne__(self, other):
27251 
    return not (self == other)
27252 
 
27253 
class getRechargeOrders_args:
27254 
  """
27255 
  Attributes:
27256 
   - userId
27257 
  """
27258 
 
27259 
  thrift_spec = (
27260 
    None, # 0
27261 
    (1, TType.I64, 'userId', None, None, ), # 1
27262 
  )
27263 
 
27264 
  def __init__(self, userId=None,):
27265 
    self.userId = userId
27266 
 
27267 
  def read(self, iprot):
27268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27270 
      return
27271 
    iprot.readStructBegin()
27272 
    while True:
27273 
      (fname, ftype, fid) = iprot.readFieldBegin()
27274 
      if ftype == TType.STOP:
27275 
        break
27276 
      if fid == 1:
27277 
        if ftype == TType.I64:
27278 
          self.userId = iprot.readI64();
27279 
        else:
27280 
          iprot.skip(ftype)
27281 
      else:
27282 
        iprot.skip(ftype)
27283 
      iprot.readFieldEnd()
27284 
    iprot.readStructEnd()
27285 
 
27286 
  def write(self, oprot):
27287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27289 
      return
27290 
    oprot.writeStructBegin('getRechargeOrders_args')
27291 
    if self.userId is not None:
27292 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27293 
      oprot.writeI64(self.userId)
27294 
      oprot.writeFieldEnd()
27295 
    oprot.writeFieldStop()
27296 
    oprot.writeStructEnd()
27297 
 
27298 
  def validate(self):
27299 
    return
27300 
 
27301 
 
27302 
  def __repr__(self):
27303 
    L = ['%s=%r' % (key, value)
27304 
      for key, value in self.__dict__.iteritems()]
27305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27306 
 
27307 
  def __eq__(self, other):
27308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27309 
 
27310 
  def __ne__(self, other):
27311 
    return not (self == other)
27312 
 
27313 
class getRechargeOrders_result:
27314 
  """
27315 
  Attributes:
27316 
   - success
27317 
  """
27318 
 
27319 
  thrift_spec = (
27320 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27321 
  )
27322 
 
27323 
  def __init__(self, success=None,):
27324 
    self.success = success
27325 
 
27326 
  def read(self, iprot):
27327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27329 
      return
27330 
    iprot.readStructBegin()
27331 
    while True:
27332 
      (fname, ftype, fid) = iprot.readFieldBegin()
27333 
      if ftype == TType.STOP:
27334 
        break
27335 
      if fid == 0:
27336 
        if ftype == TType.LIST:
27337 
          self.success = []
6188 rajveer 27338 
          (_etype659, _size656) = iprot.readListBegin()
27339 
          for _i660 in xrange(_size656):
27340 
            _elem661 = RechargeOrder()
27341 
            _elem661.read(iprot)
27342 
            self.success.append(_elem661)
6031 rajveer 27343 
          iprot.readListEnd()
27344 
        else:
27345 
          iprot.skip(ftype)
27346 
      else:
27347 
        iprot.skip(ftype)
27348 
      iprot.readFieldEnd()
27349 
    iprot.readStructEnd()
27350 
 
27351 
  def write(self, oprot):
27352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27354 
      return
27355 
    oprot.writeStructBegin('getRechargeOrders_result')
27356 
    if self.success is not None:
27357 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27358 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27359 
      for iter662 in self.success:
27360 
        iter662.write(oprot)
6031 rajveer 27361 
      oprot.writeListEnd()
27362 
      oprot.writeFieldEnd()
27363 
    oprot.writeFieldStop()
27364 
    oprot.writeStructEnd()
27365 
 
27366 
  def validate(self):
27367 
    return
27368 
 
27369 
 
27370 
  def __repr__(self):
27371 
    L = ['%s=%r' % (key, value)
27372 
      for key, value in self.__dict__.iteritems()]
27373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27374 
 
27375 
  def __eq__(self, other):
27376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27377 
 
27378 
  def __ne__(self, other):
27379 
    return not (self == other)
27380 
 
6000 mandeep.dh 27381 
class updateRechargeOrderStatus_args:
27382 
  """
27383 
  Attributes:
27384 
   - rechargeOrderId
27385 
   - rechargeOrderStatus
27386 
  """
27387 
 
27388 
  thrift_spec = (
27389 
    None, # 0
27390 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
27391 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
27392 
  )
27393 
 
27394 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
27395 
    self.rechargeOrderId = rechargeOrderId
27396 
    self.rechargeOrderStatus = rechargeOrderStatus
27397 
 
27398 
  def read(self, iprot):
27399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27401 
      return
27402 
    iprot.readStructBegin()
27403 
    while True:
27404 
      (fname, ftype, fid) = iprot.readFieldBegin()
27405 
      if ftype == TType.STOP:
27406 
        break
27407 
      if fid == 1:
27408 
        if ftype == TType.I64:
27409 
          self.rechargeOrderId = iprot.readI64();
27410 
        else:
27411 
          iprot.skip(ftype)
27412 
      elif fid == 2:
27413 
        if ftype == TType.I32:
27414 
          self.rechargeOrderStatus = iprot.readI32();
27415 
        else:
27416 
          iprot.skip(ftype)
27417 
      else:
27418 
        iprot.skip(ftype)
27419 
      iprot.readFieldEnd()
27420 
    iprot.readStructEnd()
27421 
 
27422 
  def write(self, oprot):
27423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27425 
      return
27426 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
27427 
    if self.rechargeOrderId is not None:
27428 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27429 
      oprot.writeI64(self.rechargeOrderId)
27430 
      oprot.writeFieldEnd()
27431 
    if self.rechargeOrderStatus is not None:
27432 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
27433 
      oprot.writeI32(self.rechargeOrderStatus)
27434 
      oprot.writeFieldEnd()
27435 
    oprot.writeFieldStop()
27436 
    oprot.writeStructEnd()
27437 
 
27438 
  def validate(self):
27439 
    return
27440 
 
27441 
 
27442 
  def __repr__(self):
27443 
    L = ['%s=%r' % (key, value)
27444 
      for key, value in self.__dict__.iteritems()]
27445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27446 
 
27447 
  def __eq__(self, other):
27448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27449 
 
27450 
  def __ne__(self, other):
27451 
    return not (self == other)
27452 
 
27453 
class updateRechargeOrderStatus_result:
27454 
  """
27455 
  Attributes:
6031 rajveer 27456 
   - success
6000 mandeep.dh 27457 
   - ex
27458 
  """
27459 
 
27460 
  thrift_spec = (
6031 rajveer 27461 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27462 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27463 
  )
27464 
 
6031 rajveer 27465 
  def __init__(self, success=None, ex=None,):
27466 
    self.success = success
6000 mandeep.dh 27467 
    self.ex = ex
27468 
 
27469 
  def read(self, iprot):
27470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27472 
      return
27473 
    iprot.readStructBegin()
27474 
    while True:
27475 
      (fname, ftype, fid) = iprot.readFieldBegin()
27476 
      if ftype == TType.STOP:
27477 
        break
6031 rajveer 27478 
      if fid == 0:
27479 
        if ftype == TType.BOOL:
27480 
          self.success = iprot.readBool();
27481 
        else:
27482 
          iprot.skip(ftype)
27483 
      elif fid == 1:
6000 mandeep.dh 27484 
        if ftype == TType.STRUCT:
27485 
          self.ex = TransactionServiceException()
27486 
          self.ex.read(iprot)
27487 
        else:
27488 
          iprot.skip(ftype)
27489 
      else:
27490 
        iprot.skip(ftype)
27491 
      iprot.readFieldEnd()
27492 
    iprot.readStructEnd()
27493 
 
27494 
  def write(self, oprot):
27495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27497 
      return
27498 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 27499 
    if self.success is not None:
27500 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27501 
      oprot.writeBool(self.success)
27502 
      oprot.writeFieldEnd()
6000 mandeep.dh 27503 
    if self.ex is not None:
27504 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27505 
      self.ex.write(oprot)
27506 
      oprot.writeFieldEnd()
27507 
    oprot.writeFieldStop()
27508 
    oprot.writeStructEnd()
27509 
 
27510 
  def validate(self):
27511 
    return
27512 
 
27513 
 
27514 
  def __repr__(self):
27515 
    L = ['%s=%r' % (key, value)
27516 
      for key, value in self.__dict__.iteritems()]
27517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27518 
 
27519 
  def __eq__(self, other):
27520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27521 
 
27522 
  def __ne__(self, other):
27523 
    return not (self == other)
27524 
 
27525 
class activateRechargeTxn_args:
27526 
  """
27527 
  Attributes:
6031 rajveer 27528 
   - rechargeOrderId
6000 mandeep.dh 27529 
  """
27530 
 
27531 
  thrift_spec = (
27532 
    None, # 0
6031 rajveer 27533 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 27534 
  )
27535 
 
6031 rajveer 27536 
  def __init__(self, rechargeOrderId=None,):
27537 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 27538 
 
27539 
  def read(self, iprot):
27540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27542 
      return
27543 
    iprot.readStructBegin()
27544 
    while True:
27545 
      (fname, ftype, fid) = iprot.readFieldBegin()
27546 
      if ftype == TType.STOP:
27547 
        break
27548 
      if fid == 1:
6031 rajveer 27549 
        if ftype == TType.I64:
27550 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 27551 
        else:
27552 
          iprot.skip(ftype)
27553 
      else:
27554 
        iprot.skip(ftype)
27555 
      iprot.readFieldEnd()
27556 
    iprot.readStructEnd()
27557 
 
27558 
  def write(self, oprot):
27559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27561 
      return
27562 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 27563 
    if self.rechargeOrderId is not None:
27564 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27565 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 27566 
      oprot.writeFieldEnd()
27567 
    oprot.writeFieldStop()
27568 
    oprot.writeStructEnd()
27569 
 
27570 
  def validate(self):
27571 
    return
27572 
 
27573 
 
27574 
  def __repr__(self):
27575 
    L = ['%s=%r' % (key, value)
27576 
      for key, value in self.__dict__.iteritems()]
27577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27578 
 
27579 
  def __eq__(self, other):
27580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27581 
 
27582 
  def __ne__(self, other):
27583 
    return not (self == other)
27584 
 
27585 
class activateRechargeTxn_result:
27586 
  """
27587 
  Attributes:
27588 
   - success
27589 
   - ex
27590 
  """
27591 
 
27592 
  thrift_spec = (
6031 rajveer 27593 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27594 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27595 
  )
27596 
 
27597 
  def __init__(self, success=None, ex=None,):
27598 
    self.success = success
27599 
    self.ex = ex
27600 
 
27601 
  def read(self, iprot):
27602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27604 
      return
27605 
    iprot.readStructBegin()
27606 
    while True:
27607 
      (fname, ftype, fid) = iprot.readFieldBegin()
27608 
      if ftype == TType.STOP:
27609 
        break
27610 
      if fid == 0:
6031 rajveer 27611 
        if ftype == TType.BOOL:
27612 
          self.success = iprot.readBool();
6000 mandeep.dh 27613 
        else:
27614 
          iprot.skip(ftype)
27615 
      elif fid == 1:
27616 
        if ftype == TType.STRUCT:
27617 
          self.ex = TransactionServiceException()
27618 
          self.ex.read(iprot)
27619 
        else:
27620 
          iprot.skip(ftype)
27621 
      else:
27622 
        iprot.skip(ftype)
27623 
      iprot.readFieldEnd()
27624 
    iprot.readStructEnd()
27625 
 
27626 
  def write(self, oprot):
27627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27629 
      return
27630 
    oprot.writeStructBegin('activateRechargeTxn_result')
27631 
    if self.success is not None:
6031 rajveer 27632 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27633 
      oprot.writeBool(self.success)
6000 mandeep.dh 27634 
      oprot.writeFieldEnd()
27635 
    if self.ex is not None:
27636 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27637 
      self.ex.write(oprot)
27638 
      oprot.writeFieldEnd()
27639 
    oprot.writeFieldStop()
27640 
    oprot.writeStructEnd()
27641 
 
27642 
  def validate(self):
27643 
    return
27644 
 
27645 
 
27646 
  def __repr__(self):
27647 
    L = ['%s=%r' % (key, value)
27648 
      for key, value in self.__dict__.iteritems()]
27649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27650 
 
27651 
  def __eq__(self, other):
27652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27653 
 
27654 
  def __ne__(self, other):
27655 
    return not (self == other)
27656 
 
6031 rajveer 27657 
class getUserWallet_args:
6000 mandeep.dh 27658 
  """
27659 
  Attributes:
6031 rajveer 27660 
   - userId
6000 mandeep.dh 27661 
  """
27662 
 
27663 
  thrift_spec = (
27664 
    None, # 0
6031 rajveer 27665 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27666 
  )
27667 
 
6031 rajveer 27668 
  def __init__(self, userId=None,):
27669 
    self.userId = userId
6000 mandeep.dh 27670 
 
27671 
  def read(self, iprot):
27672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27674 
      return
27675 
    iprot.readStructBegin()
27676 
    while True:
27677 
      (fname, ftype, fid) = iprot.readFieldBegin()
27678 
      if ftype == TType.STOP:
27679 
        break
27680 
      if fid == 1:
27681 
        if ftype == TType.I64:
6031 rajveer 27682 
          self.userId = iprot.readI64();
6000 mandeep.dh 27683 
        else:
27684 
          iprot.skip(ftype)
27685 
      else:
27686 
        iprot.skip(ftype)
27687 
      iprot.readFieldEnd()
27688 
    iprot.readStructEnd()
27689 
 
27690 
  def write(self, oprot):
27691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27693 
      return
6031 rajveer 27694 
    oprot.writeStructBegin('getUserWallet_args')
27695 
    if self.userId is not None:
27696 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27697 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27698 
      oprot.writeFieldEnd()
27699 
    oprot.writeFieldStop()
27700 
    oprot.writeStructEnd()
27701 
 
27702 
  def validate(self):
27703 
    return
27704 
 
27705 
 
27706 
  def __repr__(self):
27707 
    L = ['%s=%r' % (key, value)
27708 
      for key, value in self.__dict__.iteritems()]
27709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27710 
 
27711 
  def __eq__(self, other):
27712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27713 
 
27714 
  def __ne__(self, other):
27715 
    return not (self == other)
27716 
 
6031 rajveer 27717 
class getUserWallet_result:
6000 mandeep.dh 27718 
  """
27719 
  Attributes:
27720 
   - success
27721 
  """
27722 
 
27723 
  thrift_spec = (
6031 rajveer 27724 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 27725 
  )
27726 
 
27727 
  def __init__(self, success=None,):
27728 
    self.success = success
27729 
 
27730 
  def read(self, iprot):
27731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27733 
      return
27734 
    iprot.readStructBegin()
27735 
    while True:
27736 
      (fname, ftype, fid) = iprot.readFieldBegin()
27737 
      if ftype == TType.STOP:
27738 
        break
27739 
      if fid == 0:
6031 rajveer 27740 
        if ftype == TType.STRUCT:
27741 
          self.success = UserWallet()
27742 
          self.success.read(iprot)
6000 mandeep.dh 27743 
        else:
27744 
          iprot.skip(ftype)
27745 
      else:
27746 
        iprot.skip(ftype)
27747 
      iprot.readFieldEnd()
27748 
    iprot.readStructEnd()
27749 
 
27750 
  def write(self, oprot):
27751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27753 
      return
6031 rajveer 27754 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27755 
    if self.success is not None:
6031 rajveer 27756 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27757 
      self.success.write(oprot)
6000 mandeep.dh 27758 
      oprot.writeFieldEnd()
27759 
    oprot.writeFieldStop()
27760 
    oprot.writeStructEnd()
27761 
 
27762 
  def validate(self):
27763 
    return
27764 
 
27765 
 
27766 
  def __repr__(self):
27767 
    L = ['%s=%r' % (key, value)
27768 
      for key, value in self.__dict__.iteritems()]
27769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27770 
 
27771 
  def __eq__(self, other):
27772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27773 
 
27774 
  def __ne__(self, other):
27775 
    return not (self == other)
27776 
 
6031 rajveer 27777 
class getUserWalletHistory_args:
6000 mandeep.dh 27778 
  """
27779 
  Attributes:
6031 rajveer 27780 
   - userId
6000 mandeep.dh 27781 
  """
27782 
 
27783 
  thrift_spec = (
27784 
    None, # 0
6031 rajveer 27785 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27786 
  )
27787 
 
6031 rajveer 27788 
  def __init__(self, userId=None,):
27789 
    self.userId = userId
6000 mandeep.dh 27790 
 
27791 
  def read(self, iprot):
27792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27794 
      return
27795 
    iprot.readStructBegin()
27796 
    while True:
27797 
      (fname, ftype, fid) = iprot.readFieldBegin()
27798 
      if ftype == TType.STOP:
27799 
        break
27800 
      if fid == 1:
27801 
        if ftype == TType.I64:
6031 rajveer 27802 
          self.userId = iprot.readI64();
6000 mandeep.dh 27803 
        else:
27804 
          iprot.skip(ftype)
27805 
      else:
27806 
        iprot.skip(ftype)
27807 
      iprot.readFieldEnd()
27808 
    iprot.readStructEnd()
27809 
 
27810 
  def write(self, oprot):
27811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27813 
      return
6031 rajveer 27814 
    oprot.writeStructBegin('getUserWalletHistory_args')
27815 
    if self.userId is not None:
27816 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27817 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27818 
      oprot.writeFieldEnd()
27819 
    oprot.writeFieldStop()
27820 
    oprot.writeStructEnd()
27821 
 
27822 
  def validate(self):
27823 
    return
27824 
 
27825 
 
27826 
  def __repr__(self):
27827 
    L = ['%s=%r' % (key, value)
27828 
      for key, value in self.__dict__.iteritems()]
27829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27830 
 
27831 
  def __eq__(self, other):
27832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27833 
 
27834 
  def __ne__(self, other):
27835 
    return not (self == other)
27836 
 
6031 rajveer 27837 
class getUserWalletHistory_result:
6000 mandeep.dh 27838 
  """
27839 
  Attributes:
27840 
   - success
27841 
  """
27842 
 
27843 
  thrift_spec = (
6031 rajveer 27844 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 27845 
  )
27846 
 
27847 
  def __init__(self, success=None,):
27848 
    self.success = success
27849 
 
27850 
  def read(self, iprot):
27851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27853 
      return
27854 
    iprot.readStructBegin()
27855 
    while True:
27856 
      (fname, ftype, fid) = iprot.readFieldBegin()
27857 
      if ftype == TType.STOP:
27858 
        break
27859 
      if fid == 0:
27860 
        if ftype == TType.LIST:
27861 
          self.success = []
6188 rajveer 27862 
          (_etype666, _size663) = iprot.readListBegin()
27863 
          for _i667 in xrange(_size663):
27864 
            _elem668 = UserWalletHistory()
27865 
            _elem668.read(iprot)
27866 
            self.success.append(_elem668)
6000 mandeep.dh 27867 
          iprot.readListEnd()
27868 
        else:
27869 
          iprot.skip(ftype)
27870 
      else:
27871 
        iprot.skip(ftype)
27872 
      iprot.readFieldEnd()
27873 
    iprot.readStructEnd()
27874 
 
27875 
  def write(self, oprot):
27876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27878 
      return
6031 rajveer 27879 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 27880 
    if self.success is not None:
27881 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27882 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27883 
      for iter669 in self.success:
27884 
        iter669.write(oprot)
6000 mandeep.dh 27885 
      oprot.writeListEnd()
27886 
      oprot.writeFieldEnd()
27887 
    oprot.writeFieldStop()
27888 
    oprot.writeStructEnd()
27889 
 
27890 
  def validate(self):
27891 
    return
27892 
 
27893 
 
27894 
  def __repr__(self):
27895 
    L = ['%s=%r' % (key, value)
27896 
      for key, value in self.__dict__.iteritems()]
27897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27898 
 
27899 
  def __eq__(self, other):
27900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27901 
 
27902 
  def __ne__(self, other):
27903 
    return not (self == other)
6048 rajveer 27904 
 
6050 anupam.sin 27905 
class getRechargeOrdersForTransaction_args:
27906 
  """
27907 
  Attributes:
27908 
   - txnId
27909 
  """
27910 
 
27911 
  thrift_spec = (
27912 
    None, # 0
27913 
    (1, TType.I64, 'txnId', None, None, ), # 1
27914 
  )
27915 
 
27916 
  def __init__(self, txnId=None,):
27917 
    self.txnId = txnId
27918 
 
27919 
  def read(self, iprot):
27920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27922 
      return
27923 
    iprot.readStructBegin()
27924 
    while True:
27925 
      (fname, ftype, fid) = iprot.readFieldBegin()
27926 
      if ftype == TType.STOP:
27927 
        break
27928 
      if fid == 1:
27929 
        if ftype == TType.I64:
27930 
          self.txnId = iprot.readI64();
27931 
        else:
27932 
          iprot.skip(ftype)
27933 
      else:
27934 
        iprot.skip(ftype)
27935 
      iprot.readFieldEnd()
27936 
    iprot.readStructEnd()
27937 
 
27938 
  def write(self, oprot):
27939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27941 
      return
27942 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
27943 
    if self.txnId is not None:
27944 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
27945 
      oprot.writeI64(self.txnId)
27946 
      oprot.writeFieldEnd()
27947 
    oprot.writeFieldStop()
27948 
    oprot.writeStructEnd()
27949 
 
27950 
  def validate(self):
27951 
    return
27952 
 
27953 
 
27954 
  def __repr__(self):
27955 
    L = ['%s=%r' % (key, value)
27956 
      for key, value in self.__dict__.iteritems()]
27957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27958 
 
27959 
  def __eq__(self, other):
27960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27961 
 
27962 
  def __ne__(self, other):
27963 
    return not (self == other)
27964 
 
27965 
class getRechargeOrdersForTransaction_result:
27966 
  """
27967 
  Attributes:
27968 
   - success
27969 
   - ex
27970 
  """
27971 
 
27972 
  thrift_spec = (
27973 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27974 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27975 
  )
27976 
 
27977 
  def __init__(self, success=None, ex=None,):
27978 
    self.success = success
27979 
    self.ex = ex
27980 
 
27981 
  def read(self, iprot):
27982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27984 
      return
27985 
    iprot.readStructBegin()
27986 
    while True:
27987 
      (fname, ftype, fid) = iprot.readFieldBegin()
27988 
      if ftype == TType.STOP:
27989 
        break
27990 
      if fid == 0:
27991 
        if ftype == TType.STRUCT:
27992 
          self.success = RechargeOrder()
27993 
          self.success.read(iprot)
27994 
        else:
27995 
          iprot.skip(ftype)
27996 
      elif fid == 1:
27997 
        if ftype == TType.STRUCT:
27998 
          self.ex = TransactionServiceException()
27999 
          self.ex.read(iprot)
28000 
        else:
28001 
          iprot.skip(ftype)
28002 
      else:
28003 
        iprot.skip(ftype)
28004 
      iprot.readFieldEnd()
28005 
    iprot.readStructEnd()
28006 
 
28007 
  def write(self, oprot):
28008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28010 
      return
28011 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
28012 
    if self.success is not None:
28013 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28014 
      self.success.write(oprot)
28015 
      oprot.writeFieldEnd()
28016 
    if self.ex is not None:
28017 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28018 
      self.ex.write(oprot)
28019 
      oprot.writeFieldEnd()
28020 
    oprot.writeFieldStop()
28021 
    oprot.writeStructEnd()
28022 
 
28023 
  def validate(self):
28024 
    return
28025 
 
28026 
 
28027 
  def __repr__(self):
28028 
    L = ['%s=%r' % (key, value)
28029 
      for key, value in self.__dict__.iteritems()]
28030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28031 
 
28032 
  def __eq__(self, other):
28033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28034 
 
28035 
  def __ne__(self, other):
28036 
    return not (self == other)
28037 
 
6048 rajveer 28038 
class getServiceProviders_args:
28039 
  """
28040 
  Attributes:
28041 
   - rechargeType
6206 rajveer 28042 
   - onlyActive
6048 rajveer 28043 
  """
28044 
 
28045 
  thrift_spec = (
28046 
    None, # 0
28047 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 28048 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 28049 
  )
28050 
 
6206 rajveer 28051 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 28052 
    self.rechargeType = rechargeType
6206 rajveer 28053 
    self.onlyActive = onlyActive
6048 rajveer 28054 
 
28055 
  def read(self, iprot):
28056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28058 
      return
28059 
    iprot.readStructBegin()
28060 
    while True:
28061 
      (fname, ftype, fid) = iprot.readFieldBegin()
28062 
      if ftype == TType.STOP:
28063 
        break
28064 
      if fid == 1:
28065 
        if ftype == TType.I32:
28066 
          self.rechargeType = iprot.readI32();
28067 
        else:
28068 
          iprot.skip(ftype)
6206 rajveer 28069 
      elif fid == 2:
28070 
        if ftype == TType.BOOL:
28071 
          self.onlyActive = iprot.readBool();
28072 
        else:
28073 
          iprot.skip(ftype)
6048 rajveer 28074 
      else:
28075 
        iprot.skip(ftype)
28076 
      iprot.readFieldEnd()
28077 
    iprot.readStructEnd()
28078 
 
28079 
  def write(self, oprot):
28080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28082 
      return
28083 
    oprot.writeStructBegin('getServiceProviders_args')
28084 
    if self.rechargeType is not None:
28085 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28086 
      oprot.writeI32(self.rechargeType)
28087 
      oprot.writeFieldEnd()
6206 rajveer 28088 
    if self.onlyActive is not None:
28089 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
28090 
      oprot.writeBool(self.onlyActive)
28091 
      oprot.writeFieldEnd()
6048 rajveer 28092 
    oprot.writeFieldStop()
28093 
    oprot.writeStructEnd()
28094 
 
28095 
  def validate(self):
28096 
    return
28097 
 
28098 
 
28099 
  def __repr__(self):
28100 
    L = ['%s=%r' % (key, value)
28101 
      for key, value in self.__dict__.iteritems()]
28102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28103 
 
28104 
  def __eq__(self, other):
28105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28106 
 
28107 
  def __ne__(self, other):
28108 
    return not (self == other)
28109 
 
28110 
class getServiceProviders_result:
28111 
  """
28112 
  Attributes:
28113 
   - success
28114 
  """
28115 
 
28116 
  thrift_spec = (
28117 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
28118 
  )
28119 
 
28120 
  def __init__(self, success=None,):
28121 
    self.success = success
28122 
 
28123 
  def read(self, iprot):
28124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28126 
      return
28127 
    iprot.readStructBegin()
28128 
    while True:
28129 
      (fname, ftype, fid) = iprot.readFieldBegin()
28130 
      if ftype == TType.STOP:
28131 
        break
28132 
      if fid == 0:
28133 
        if ftype == TType.MAP:
28134 
          self.success = {}
6188 rajveer 28135 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
28136 
          for _i674 in xrange(_size670):
28137 
            _key675 = iprot.readI64();
28138 
            _val676 = iprot.readString();
28139 
            self.success[_key675] = _val676
6048 rajveer 28140 
          iprot.readMapEnd()
28141 
        else:
28142 
          iprot.skip(ftype)
28143 
      else:
28144 
        iprot.skip(ftype)
28145 
      iprot.readFieldEnd()
28146 
    iprot.readStructEnd()
28147 
 
28148 
  def write(self, oprot):
28149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28151 
      return
28152 
    oprot.writeStructBegin('getServiceProviders_result')
28153 
    if self.success is not None:
28154 
      oprot.writeFieldBegin('success', TType.MAP, 0)
28155 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 28156 
      for kiter677,viter678 in self.success.items():
28157 
        oprot.writeI64(kiter677)
28158 
        oprot.writeString(viter678)
6048 rajveer 28159 
      oprot.writeMapEnd()
28160 
      oprot.writeFieldEnd()
28161 
    oprot.writeFieldStop()
28162 
    oprot.writeStructEnd()
28163 
 
28164 
  def validate(self):
28165 
    return
28166 
 
28167 
 
28168 
  def __repr__(self):
28169 
    L = ['%s=%r' % (key, value)
28170 
      for key, value in self.__dict__.iteritems()]
28171 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28172 
 
28173 
  def __eq__(self, other):
28174 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28175 
 
28176 
  def __ne__(self, other):
28177 
    return not (self == other)
28178 
 
28179 
class getServiceProviderForDevice_args:
28180 
  """
28181 
  Attributes:
6049 rajveer 28182 
   - rechargeType
6048 rajveer 28183 
   - deviceNumber
28184 
  """
28185 
 
28186 
  thrift_spec = (
28187 
    None, # 0
6049 rajveer 28188 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28189 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 28190 
  )
28191 
 
6049 rajveer 28192 
  def __init__(self, rechargeType=None, deviceNumber=None,):
28193 
    self.rechargeType = rechargeType
6048 rajveer 28194 
    self.deviceNumber = deviceNumber
28195 
 
28196 
  def read(self, iprot):
28197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28199 
      return
28200 
    iprot.readStructBegin()
28201 
    while True:
28202 
      (fname, ftype, fid) = iprot.readFieldBegin()
28203 
      if ftype == TType.STOP:
28204 
        break
28205 
      if fid == 1:
6049 rajveer 28206 
        if ftype == TType.I32:
28207 
          self.rechargeType = iprot.readI32();
28208 
        else:
28209 
          iprot.skip(ftype)
28210 
      elif fid == 2:
6048 rajveer 28211 
        if ftype == TType.STRING:
28212 
          self.deviceNumber = iprot.readString();
28213 
        else:
28214 
          iprot.skip(ftype)
28215 
      else:
28216 
        iprot.skip(ftype)
28217 
      iprot.readFieldEnd()
28218 
    iprot.readStructEnd()
28219 
 
28220 
  def write(self, oprot):
28221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28223 
      return
28224 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 28225 
    if self.rechargeType is not None:
28226 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28227 
      oprot.writeI32(self.rechargeType)
28228 
      oprot.writeFieldEnd()
6048 rajveer 28229 
    if self.deviceNumber is not None:
6049 rajveer 28230 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 28231 
      oprot.writeString(self.deviceNumber)
28232 
      oprot.writeFieldEnd()
28233 
    oprot.writeFieldStop()
28234 
    oprot.writeStructEnd()
28235 
 
28236 
  def validate(self):
28237 
    return
28238 
 
28239 
 
28240 
  def __repr__(self):
28241 
    L = ['%s=%r' % (key, value)
28242 
      for key, value in self.__dict__.iteritems()]
28243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28244 
 
28245 
  def __eq__(self, other):
28246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28247 
 
28248 
  def __ne__(self, other):
28249 
    return not (self == other)
28250 
 
28251 
class getServiceProviderForDevice_result:
28252 
  """
28253 
  Attributes:
28254 
   - success
28255 
  """
28256 
 
28257 
  thrift_spec = (
6289 anupam.sin 28258 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 28259 
  )
28260 
 
28261 
  def __init__(self, success=None,):
28262 
    self.success = success
28263 
 
28264 
  def read(self, iprot):
28265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28267 
      return
28268 
    iprot.readStructBegin()
28269 
    while True:
28270 
      (fname, ftype, fid) = iprot.readFieldBegin()
28271 
      if ftype == TType.STOP:
28272 
        break
28273 
      if fid == 0:
6289 anupam.sin 28274 
        if ftype == TType.STRUCT:
28275 
          self.success = DeviceNumberInfo()
28276 
          self.success.read(iprot)
6048 rajveer 28277 
        else:
28278 
          iprot.skip(ftype)
28279 
      else:
28280 
        iprot.skip(ftype)
28281 
      iprot.readFieldEnd()
28282 
    iprot.readStructEnd()
28283 
 
28284 
  def write(self, oprot):
28285 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28286 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28287 
      return
28288 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
28289 
    if self.success is not None:
6289 anupam.sin 28290 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28291 
      self.success.write(oprot)
6048 rajveer 28292 
      oprot.writeFieldEnd()
28293 
    oprot.writeFieldStop()
28294 
    oprot.writeStructEnd()
28295 
 
28296 
  def validate(self):
28297 
    return
28298 
 
28299 
 
28300 
  def __repr__(self):
28301 
    L = ['%s=%r' % (key, value)
28302 
      for key, value in self.__dict__.iteritems()]
28303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28304 
 
28305 
  def __eq__(self, other):
28306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28307 
 
28308 
  def __ne__(self, other):
28309 
    return not (self == other)
6094 rajveer 28310 
 
6269 rajveer 28311 
class validateRecharge_args:
28312 
  """
28313 
  Attributes:
28314 
   - rechargeType
28315 
   - deviceNumber
6307 anupam.sin 28316 
   - userSelectedProviderId
6591 anupam.sin 28317 
   - clientAddress
6269 rajveer 28318 
  """
28319 
 
28320 
  thrift_spec = (
28321 
    None, # 0
28322 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28323 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 28324 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6591 anupam.sin 28325 
    (4, TType.STRING, 'clientAddress', None, None, ), # 4
6269 rajveer 28326 
  )
28327 
 
6591 anupam.sin 28328 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None, clientAddress=None,):
6269 rajveer 28329 
    self.rechargeType = rechargeType
28330 
    self.deviceNumber = deviceNumber
6307 anupam.sin 28331 
    self.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 28332 
    self.clientAddress = clientAddress
6269 rajveer 28333 
 
28334 
  def read(self, iprot):
28335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28337 
      return
28338 
    iprot.readStructBegin()
28339 
    while True:
28340 
      (fname, ftype, fid) = iprot.readFieldBegin()
28341 
      if ftype == TType.STOP:
28342 
        break
28343 
      if fid == 1:
28344 
        if ftype == TType.I32:
28345 
          self.rechargeType = iprot.readI32();
28346 
        else:
28347 
          iprot.skip(ftype)
28348 
      elif fid == 2:
28349 
        if ftype == TType.STRING:
28350 
          self.deviceNumber = iprot.readString();
28351 
        else:
28352 
          iprot.skip(ftype)
6307 anupam.sin 28353 
      elif fid == 3:
28354 
        if ftype == TType.I64:
28355 
          self.userSelectedProviderId = iprot.readI64();
28356 
        else:
28357 
          iprot.skip(ftype)
6591 anupam.sin 28358 
      elif fid == 4:
28359 
        if ftype == TType.STRING:
28360 
          self.clientAddress = iprot.readString();
28361 
        else:
28362 
          iprot.skip(ftype)
6269 rajveer 28363 
      else:
28364 
        iprot.skip(ftype)
28365 
      iprot.readFieldEnd()
28366 
    iprot.readStructEnd()
28367 
 
28368 
  def write(self, oprot):
28369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28371 
      return
28372 
    oprot.writeStructBegin('validateRecharge_args')
28373 
    if self.rechargeType is not None:
28374 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28375 
      oprot.writeI32(self.rechargeType)
28376 
      oprot.writeFieldEnd()
28377 
    if self.deviceNumber is not None:
28378 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
28379 
      oprot.writeString(self.deviceNumber)
28380 
      oprot.writeFieldEnd()
6307 anupam.sin 28381 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 28382 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 28383 
      oprot.writeI64(self.userSelectedProviderId)
28384 
      oprot.writeFieldEnd()
6591 anupam.sin 28385 
    if self.clientAddress is not None:
28386 
      oprot.writeFieldBegin('clientAddress', TType.STRING, 4)
28387 
      oprot.writeString(self.clientAddress)
28388 
      oprot.writeFieldEnd()
6269 rajveer 28389 
    oprot.writeFieldStop()
28390 
    oprot.writeStructEnd()
28391 
 
28392 
  def validate(self):
28393 
    return
28394 
 
28395 
 
28396 
  def __repr__(self):
28397 
    L = ['%s=%r' % (key, value)
28398 
      for key, value in self.__dict__.iteritems()]
28399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28400 
 
28401 
  def __eq__(self, other):
28402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28403 
 
28404 
  def __ne__(self, other):
28405 
    return not (self == other)
28406 
 
28407 
class validateRecharge_result:
28408 
  """
28409 
  Attributes:
28410 
   - success
28411 
  """
28412 
 
28413 
  thrift_spec = (
28414 
    (0, TType.STRING, 'success', None, None, ), # 0
28415 
  )
28416 
 
28417 
  def __init__(self, success=None,):
28418 
    self.success = success
28419 
 
28420 
  def read(self, iprot):
28421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28423 
      return
28424 
    iprot.readStructBegin()
28425 
    while True:
28426 
      (fname, ftype, fid) = iprot.readFieldBegin()
28427 
      if ftype == TType.STOP:
28428 
        break
28429 
      if fid == 0:
28430 
        if ftype == TType.STRING:
28431 
          self.success = iprot.readString();
28432 
        else:
28433 
          iprot.skip(ftype)
28434 
      else:
28435 
        iprot.skip(ftype)
28436 
      iprot.readFieldEnd()
28437 
    iprot.readStructEnd()
28438 
 
28439 
  def write(self, oprot):
28440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28442 
      return
28443 
    oprot.writeStructBegin('validateRecharge_result')
28444 
    if self.success is not None:
28445 
      oprot.writeFieldBegin('success', TType.STRING, 0)
28446 
      oprot.writeString(self.success)
28447 
      oprot.writeFieldEnd()
28448 
    oprot.writeFieldStop()
28449 
    oprot.writeStructEnd()
28450 
 
28451 
  def validate(self):
28452 
    return
28453 
 
28454 
 
28455 
  def __repr__(self):
28456 
    L = ['%s=%r' % (key, value)
28457 
      for key, value in self.__dict__.iteritems()]
28458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28459 
 
28460 
  def __eq__(self, other):
28461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28462 
 
28463 
  def __ne__(self, other):
28464 
    return not (self == other)
28465 
 
6094 rajveer 28466 
class getRechargeOrdersForDevice_args:
28467 
  """
28468 
  Attributes:
28469 
   - deviceNumber
28470 
  """
28471 
 
28472 
  thrift_spec = (
28473 
    None, # 0
28474 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
28475 
  )
28476 
 
28477 
  def __init__(self, deviceNumber=None,):
28478 
    self.deviceNumber = deviceNumber
28479 
 
28480 
  def read(self, iprot):
28481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28483 
      return
28484 
    iprot.readStructBegin()
28485 
    while True:
28486 
      (fname, ftype, fid) = iprot.readFieldBegin()
28487 
      if ftype == TType.STOP:
28488 
        break
28489 
      if fid == 1:
28490 
        if ftype == TType.STRING:
28491 
          self.deviceNumber = iprot.readString();
28492 
        else:
28493 
          iprot.skip(ftype)
28494 
      else:
28495 
        iprot.skip(ftype)
28496 
      iprot.readFieldEnd()
28497 
    iprot.readStructEnd()
28498 
 
28499 
  def write(self, oprot):
28500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28502 
      return
28503 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
28504 
    if self.deviceNumber is not None:
28505 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
28506 
      oprot.writeString(self.deviceNumber)
28507 
      oprot.writeFieldEnd()
28508 
    oprot.writeFieldStop()
28509 
    oprot.writeStructEnd()
28510 
 
28511 
  def validate(self):
28512 
    return
28513 
 
28514 
 
28515 
  def __repr__(self):
28516 
    L = ['%s=%r' % (key, value)
28517 
      for key, value in self.__dict__.iteritems()]
28518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28519 
 
28520 
  def __eq__(self, other):
28521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28522 
 
28523 
  def __ne__(self, other):
28524 
    return not (self == other)
28525 
 
28526 
class getRechargeOrdersForDevice_result:
28527 
  """
28528 
  Attributes:
28529 
   - success
28530 
  """
28531 
 
28532 
  thrift_spec = (
28533 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28534 
  )
28535 
 
28536 
  def __init__(self, success=None,):
28537 
    self.success = success
28538 
 
28539 
  def read(self, iprot):
28540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28542 
      return
28543 
    iprot.readStructBegin()
28544 
    while True:
28545 
      (fname, ftype, fid) = iprot.readFieldBegin()
28546 
      if ftype == TType.STOP:
28547 
        break
28548 
      if fid == 0:
28549 
        if ftype == TType.LIST:
28550 
          self.success = []
6188 rajveer 28551 
          (_etype682, _size679) = iprot.readListBegin()
28552 
          for _i683 in xrange(_size679):
28553 
            _elem684 = RechargeOrder()
28554 
            _elem684.read(iprot)
28555 
            self.success.append(_elem684)
6094 rajveer 28556 
          iprot.readListEnd()
28557 
        else:
28558 
          iprot.skip(ftype)
28559 
      else:
28560 
        iprot.skip(ftype)
28561 
      iprot.readFieldEnd()
28562 
    iprot.readStructEnd()
28563 
 
28564 
  def write(self, oprot):
28565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28567 
      return
28568 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
28569 
    if self.success is not None:
28570 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28571 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28572 
      for iter685 in self.success:
28573 
        iter685.write(oprot)
6094 rajveer 28574 
      oprot.writeListEnd()
28575 
      oprot.writeFieldEnd()
28576 
    oprot.writeFieldStop()
28577 
    oprot.writeStructEnd()
28578 
 
28579 
  def validate(self):
28580 
    return
28581 
 
28582 
 
28583 
  def __repr__(self):
28584 
    L = ['%s=%r' % (key, value)
28585 
      for key, value in self.__dict__.iteritems()]
28586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28587 
 
28588 
  def __eq__(self, other):
28589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28590 
 
28591 
  def __ne__(self, other):
28592 
    return not (self == other)
28593 
 
28594 
class addAmountToWallet_args:
28595 
  """
28596 
  Attributes:
28597 
   - userId
28598 
   - orderId
28599 
   - amount
28600 
  """
28601 
 
28602 
  thrift_spec = (
28603 
    None, # 0
28604 
    (1, TType.I64, 'userId', None, None, ), # 1
28605 
    (2, TType.I64, 'orderId', None, None, ), # 2
28606 
    (3, TType.I64, 'amount', None, None, ), # 3
28607 
  )
28608 
 
28609 
  def __init__(self, userId=None, orderId=None, amount=None,):
28610 
    self.userId = userId
28611 
    self.orderId = orderId
28612 
    self.amount = amount
28613 
 
28614 
  def read(self, iprot):
28615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28617 
      return
28618 
    iprot.readStructBegin()
28619 
    while True:
28620 
      (fname, ftype, fid) = iprot.readFieldBegin()
28621 
      if ftype == TType.STOP:
28622 
        break
28623 
      if fid == 1:
28624 
        if ftype == TType.I64:
28625 
          self.userId = iprot.readI64();
28626 
        else:
28627 
          iprot.skip(ftype)
28628 
      elif fid == 2:
28629 
        if ftype == TType.I64:
28630 
          self.orderId = iprot.readI64();
28631 
        else:
28632 
          iprot.skip(ftype)
28633 
      elif fid == 3:
28634 
        if ftype == TType.I64:
28635 
          self.amount = iprot.readI64();
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('addAmountToWallet_args')
28648 
    if self.userId is not None:
28649 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28650 
      oprot.writeI64(self.userId)
28651 
      oprot.writeFieldEnd()
28652 
    if self.orderId is not None:
28653 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
28654 
      oprot.writeI64(self.orderId)
28655 
      oprot.writeFieldEnd()
28656 
    if self.amount is not None:
28657 
      oprot.writeFieldBegin('amount', TType.I64, 3)
28658 
      oprot.writeI64(self.amount)
28659 
      oprot.writeFieldEnd()
28660 
    oprot.writeFieldStop()
28661 
    oprot.writeStructEnd()
28662 
 
28663 
  def validate(self):
28664 
    return
28665 
 
28666 
 
28667 
  def __repr__(self):
28668 
    L = ['%s=%r' % (key, value)
28669 
      for key, value in self.__dict__.iteritems()]
28670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28671 
 
28672 
  def __eq__(self, other):
28673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28674 
 
28675 
  def __ne__(self, other):
28676 
    return not (self == other)
28677 
 
28678 
class addAmountToWallet_result:
28679 
 
28680 
  thrift_spec = (
28681 
  )
28682 
 
28683 
  def read(self, iprot):
28684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28686 
      return
28687 
    iprot.readStructBegin()
28688 
    while True:
28689 
      (fname, ftype, fid) = iprot.readFieldBegin()
28690 
      if ftype == TType.STOP:
28691 
        break
28692 
      else:
28693 
        iprot.skip(ftype)
28694 
      iprot.readFieldEnd()
28695 
    iprot.readStructEnd()
28696 
 
28697 
  def write(self, oprot):
28698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28700 
      return
28701 
    oprot.writeStructBegin('addAmountToWallet_result')
28702 
    oprot.writeFieldStop()
28703 
    oprot.writeStructEnd()
28704 
 
28705 
  def validate(self):
28706 
    return
28707 
 
28708 
 
28709 
  def __repr__(self):
28710 
    L = ['%s=%r' % (key, value)
28711 
      for key, value in self.__dict__.iteritems()]
28712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28713 
 
28714 
  def __eq__(self, other):
28715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28716 
 
28717 
  def __ne__(self, other):
28718 
    return not (self == other)
6154 rajveer 28719 
 
6188 rajveer 28720 
class getRechargeStatistics_args:
28721 
 
28722 
  thrift_spec = (
28723 
  )
28724 
 
28725 
  def read(self, iprot):
28726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28728 
      return
28729 
    iprot.readStructBegin()
28730 
    while True:
28731 
      (fname, ftype, fid) = iprot.readFieldBegin()
28732 
      if ftype == TType.STOP:
28733 
        break
28734 
      else:
28735 
        iprot.skip(ftype)
28736 
      iprot.readFieldEnd()
28737 
    iprot.readStructEnd()
28738 
 
28739 
  def write(self, oprot):
28740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28742 
      return
28743 
    oprot.writeStructBegin('getRechargeStatistics_args')
28744 
    oprot.writeFieldStop()
28745 
    oprot.writeStructEnd()
28746 
 
28747 
  def validate(self):
28748 
    return
28749 
 
28750 
 
28751 
  def __repr__(self):
28752 
    L = ['%s=%r' % (key, value)
28753 
      for key, value in self.__dict__.iteritems()]
28754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28755 
 
28756 
  def __eq__(self, other):
28757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28758 
 
28759 
  def __ne__(self, other):
28760 
    return not (self == other)
28761 
 
28762 
class getRechargeStatistics_result:
28763 
  """
28764 
  Attributes:
28765 
   - success
28766 
  """
28767 
 
28768 
  thrift_spec = (
28769 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
28770 
  )
28771 
 
28772 
  def __init__(self, success=None,):
28773 
    self.success = success
28774 
 
28775 
  def read(self, iprot):
28776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28778 
      return
28779 
    iprot.readStructBegin()
28780 
    while True:
28781 
      (fname, ftype, fid) = iprot.readFieldBegin()
28782 
      if ftype == TType.STOP:
28783 
        break
28784 
      if fid == 0:
28785 
        if ftype == TType.STRUCT:
28786 
          self.success = RechargeStatistics()
28787 
          self.success.read(iprot)
28788 
        else:
28789 
          iprot.skip(ftype)
28790 
      else:
28791 
        iprot.skip(ftype)
28792 
      iprot.readFieldEnd()
28793 
    iprot.readStructEnd()
28794 
 
28795 
  def write(self, oprot):
28796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28798 
      return
28799 
    oprot.writeStructBegin('getRechargeStatistics_result')
28800 
    if self.success is not None:
28801 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28802 
      self.success.write(oprot)
28803 
      oprot.writeFieldEnd()
28804 
    oprot.writeFieldStop()
28805 
    oprot.writeStructEnd()
28806 
 
28807 
  def validate(self):
28808 
    return
28809 
 
28810 
 
28811 
  def __repr__(self):
28812 
    L = ['%s=%r' % (key, value)
28813 
      for key, value in self.__dict__.iteritems()]
28814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28815 
 
28816 
  def __eq__(self, other):
28817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28818 
 
28819 
  def __ne__(self, other):
28820 
    return not (self == other)
28821 
 
6154 rajveer 28822 
class getRechargeOrdersForStatus_args:
28823 
  """
28824 
  Attributes:
28825 
   - status
28826 
  """
28827 
 
28828 
  thrift_spec = (
28829 
    None, # 0
28830 
    (1, TType.I64, 'status', None, None, ), # 1
28831 
  )
28832 
 
28833 
  def __init__(self, status=None,):
28834 
    self.status = status
28835 
 
28836 
  def read(self, iprot):
28837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28839 
      return
28840 
    iprot.readStructBegin()
28841 
    while True:
28842 
      (fname, ftype, fid) = iprot.readFieldBegin()
28843 
      if ftype == TType.STOP:
28844 
        break
28845 
      if fid == 1:
28846 
        if ftype == TType.I64:
28847 
          self.status = iprot.readI64();
28848 
        else:
28849 
          iprot.skip(ftype)
28850 
      else:
28851 
        iprot.skip(ftype)
28852 
      iprot.readFieldEnd()
28853 
    iprot.readStructEnd()
28854 
 
28855 
  def write(self, oprot):
28856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28858 
      return
28859 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
28860 
    if self.status is not None:
28861 
      oprot.writeFieldBegin('status', TType.I64, 1)
28862 
      oprot.writeI64(self.status)
28863 
      oprot.writeFieldEnd()
28864 
    oprot.writeFieldStop()
28865 
    oprot.writeStructEnd()
28866 
 
28867 
  def validate(self):
28868 
    return
28869 
 
28870 
 
28871 
  def __repr__(self):
28872 
    L = ['%s=%r' % (key, value)
28873 
      for key, value in self.__dict__.iteritems()]
28874 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28875 
 
28876 
  def __eq__(self, other):
28877 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28878 
 
28879 
  def __ne__(self, other):
28880 
    return not (self == other)
28881 
 
28882 
class getRechargeOrdersForStatus_result:
28883 
  """
28884 
  Attributes:
28885 
   - success
28886 
  """
28887 
 
28888 
  thrift_spec = (
28889 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28890 
  )
28891 
 
28892 
  def __init__(self, success=None,):
28893 
    self.success = success
28894 
 
28895 
  def read(self, iprot):
28896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28898 
      return
28899 
    iprot.readStructBegin()
28900 
    while True:
28901 
      (fname, ftype, fid) = iprot.readFieldBegin()
28902 
      if ftype == TType.STOP:
28903 
        break
28904 
      if fid == 0:
28905 
        if ftype == TType.LIST:
28906 
          self.success = []
6188 rajveer 28907 
          (_etype689, _size686) = iprot.readListBegin()
28908 
          for _i690 in xrange(_size686):
28909 
            _elem691 = RechargeOrder()
28910 
            _elem691.read(iprot)
28911 
            self.success.append(_elem691)
6154 rajveer 28912 
          iprot.readListEnd()
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('getRechargeOrdersForStatus_result')
28925 
    if self.success is not None:
28926 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28927 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28928 
      for iter692 in self.success:
28929 
        iter692.write(oprot)
6154 rajveer 28930 
      oprot.writeListEnd()
28931 
      oprot.writeFieldEnd()
28932 
    oprot.writeFieldStop()
28933 
    oprot.writeStructEnd()
28934 
 
28935 
  def validate(self):
28936 
    return
28937 
 
28938 
 
28939 
  def __repr__(self):
28940 
    L = ['%s=%r' % (key, value)
28941 
      for key, value in self.__dict__.iteritems()]
28942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28943 
 
28944 
  def __eq__(self, other):
28945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28946 
 
28947 
  def __ne__(self, other):
28948 
    return not (self == other)
6159 rajveer 28949 
 
28950 
class getPlansForOperator_args:
28951 
  """
28952 
  Attributes:
28953 
   - operatorId
28954 
  """
28955 
 
28956 
  thrift_spec = (
28957 
    None, # 0
28958 
    (1, TType.I64, 'operatorId', None, None, ), # 1
28959 
  )
28960 
 
28961 
  def __init__(self, operatorId=None,):
28962 
    self.operatorId = operatorId
28963 
 
28964 
  def read(self, iprot):
28965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28967 
      return
28968 
    iprot.readStructBegin()
28969 
    while True:
28970 
      (fname, ftype, fid) = iprot.readFieldBegin()
28971 
      if ftype == TType.STOP:
28972 
        break
28973 
      if fid == 1:
28974 
        if ftype == TType.I64:
28975 
          self.operatorId = iprot.readI64();
28976 
        else:
28977 
          iprot.skip(ftype)
28978 
      else:
28979 
        iprot.skip(ftype)
28980 
      iprot.readFieldEnd()
28981 
    iprot.readStructEnd()
28982 
 
28983 
  def write(self, oprot):
28984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28986 
      return
28987 
    oprot.writeStructBegin('getPlansForOperator_args')
28988 
    if self.operatorId is not None:
28989 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28990 
      oprot.writeI64(self.operatorId)
28991 
      oprot.writeFieldEnd()
28992 
    oprot.writeFieldStop()
28993 
    oprot.writeStructEnd()
28994 
 
28995 
  def validate(self):
28996 
    return
28997 
 
28998 
 
28999 
  def __repr__(self):
29000 
    L = ['%s=%r' % (key, value)
29001 
      for key, value in self.__dict__.iteritems()]
29002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29003 
 
29004 
  def __eq__(self, other):
29005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29006 
 
29007 
  def __ne__(self, other):
29008 
    return not (self == other)
29009 
 
29010 
class getPlansForOperator_result:
29011 
  """
29012 
  Attributes:
29013 
   - success
29014 
  """
29015 
 
29016 
  thrift_spec = (
29017 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
29018 
  )
29019 
 
29020 
  def __init__(self, success=None,):
29021 
    self.success = success
29022 
 
29023 
  def read(self, iprot):
29024 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29025 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29026 
      return
29027 
    iprot.readStructBegin()
29028 
    while True:
29029 
      (fname, ftype, fid) = iprot.readFieldBegin()
29030 
      if ftype == TType.STOP:
29031 
        break
29032 
      if fid == 0:
29033 
        if ftype == TType.LIST:
29034 
          self.success = []
6188 rajveer 29035 
          (_etype696, _size693) = iprot.readListBegin()
29036 
          for _i697 in xrange(_size693):
29037 
            _elem698 = RechargePlan()
29038 
            _elem698.read(iprot)
29039 
            self.success.append(_elem698)
6159 rajveer 29040 
          iprot.readListEnd()
29041 
        else:
29042 
          iprot.skip(ftype)
29043 
      else:
29044 
        iprot.skip(ftype)
29045 
      iprot.readFieldEnd()
29046 
    iprot.readStructEnd()
29047 
 
29048 
  def write(self, oprot):
29049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29051 
      return
29052 
    oprot.writeStructBegin('getPlansForOperator_result')
29053 
    if self.success is not None:
29054 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29055 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 29056 
      for iter699 in self.success:
29057 
        iter699.write(oprot)
6159 rajveer 29058 
      oprot.writeListEnd()
29059 
      oprot.writeFieldEnd()
29060 
    oprot.writeFieldStop()
29061 
    oprot.writeStructEnd()
29062 
 
29063 
  def validate(self):
29064 
    return
29065 
 
29066 
 
29067 
  def __repr__(self):
29068 
    L = ['%s=%r' % (key, value)
29069 
      for key, value in self.__dict__.iteritems()]
29070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29071 
 
29072 
  def __eq__(self, other):
29073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29074 
 
29075 
  def __ne__(self, other):
29076 
    return not (self == other)
6289 anupam.sin 29077 
 
29078 
class getRechargeDenominations_args:
29079 
  """
29080 
  Attributes:
29081 
   - operatorId
6307 anupam.sin 29082 
   - circleCode
6289 anupam.sin 29083 
   - denominationType
29084 
  """
29085 
 
29086 
  thrift_spec = (
29087 
    None, # 0
29088 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 29089 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 29090 
    (3, TType.I32, 'denominationType', None, None, ), # 3
29091 
  )
29092 
 
6307 anupam.sin 29093 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 29094 
    self.operatorId = operatorId
6307 anupam.sin 29095 
    self.circleCode = circleCode
6289 anupam.sin 29096 
    self.denominationType = denominationType
29097 
 
29098 
  def read(self, iprot):
29099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29101 
      return
29102 
    iprot.readStructBegin()
29103 
    while True:
29104 
      (fname, ftype, fid) = iprot.readFieldBegin()
29105 
      if ftype == TType.STOP:
29106 
        break
29107 
      if fid == 1:
29108 
        if ftype == TType.I64:
29109 
          self.operatorId = iprot.readI64();
29110 
        else:
29111 
          iprot.skip(ftype)
29112 
      elif fid == 2:
29113 
        if ftype == TType.STRING:
6307 anupam.sin 29114 
          self.circleCode = iprot.readString();
6289 anupam.sin 29115 
        else:
29116 
          iprot.skip(ftype)
29117 
      elif fid == 3:
29118 
        if ftype == TType.I32:
29119 
          self.denominationType = iprot.readI32();
29120 
        else:
29121 
          iprot.skip(ftype)
29122 
      else:
29123 
        iprot.skip(ftype)
29124 
      iprot.readFieldEnd()
29125 
    iprot.readStructEnd()
29126 
 
29127 
  def write(self, oprot):
29128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29130 
      return
29131 
    oprot.writeStructBegin('getRechargeDenominations_args')
29132 
    if self.operatorId is not None:
29133 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29134 
      oprot.writeI64(self.operatorId)
29135 
      oprot.writeFieldEnd()
6307 anupam.sin 29136 
    if self.circleCode is not None:
29137 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
29138 
      oprot.writeString(self.circleCode)
6289 anupam.sin 29139 
      oprot.writeFieldEnd()
29140 
    if self.denominationType is not None:
29141 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
29142 
      oprot.writeI32(self.denominationType)
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 getRechargeDenominations_result:
29163 
  """
29164 
  Attributes:
29165 
   - success
29166 
   - ex
29167 
  """
29168 
 
29169 
  thrift_spec = (
29170 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
29171 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29172 
  )
29173 
 
29174 
  def __init__(self, success=None, ex=None,):
29175 
    self.success = success
29176 
    self.ex = ex
29177 
 
29178 
  def read(self, iprot):
29179 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29180 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29181 
      return
29182 
    iprot.readStructBegin()
29183 
    while True:
29184 
      (fname, ftype, fid) = iprot.readFieldBegin()
29185 
      if ftype == TType.STOP:
29186 
        break
29187 
      if fid == 0:
29188 
        if ftype == TType.LIST:
29189 
          self.success = []
29190 
          (_etype703, _size700) = iprot.readListBegin()
29191 
          for _i704 in xrange(_size700):
29192 
            _elem705 = RechargeDenomination()
29193 
            _elem705.read(iprot)
29194 
            self.success.append(_elem705)
29195 
          iprot.readListEnd()
29196 
        else:
29197 
          iprot.skip(ftype)
29198 
      elif fid == 1:
29199 
        if ftype == TType.STRUCT:
29200 
          self.ex = TransactionServiceException()
29201 
          self.ex.read(iprot)
29202 
        else:
29203 
          iprot.skip(ftype)
29204 
      else:
29205 
        iprot.skip(ftype)
29206 
      iprot.readFieldEnd()
29207 
    iprot.readStructEnd()
29208 
 
29209 
  def write(self, oprot):
29210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29212 
      return
29213 
    oprot.writeStructBegin('getRechargeDenominations_result')
29214 
    if self.success is not None:
29215 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29216 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29217 
      for iter706 in self.success:
29218 
        iter706.write(oprot)
29219 
      oprot.writeListEnd()
29220 
      oprot.writeFieldEnd()
29221 
    if self.ex is not None:
29222 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29223 
      self.ex.write(oprot)
29224 
      oprot.writeFieldEnd()
29225 
    oprot.writeFieldStop()
29226 
    oprot.writeStructEnd()
29227 
 
29228 
  def validate(self):
29229 
    return
29230 
 
29231 
 
29232 
  def __repr__(self):
29233 
    L = ['%s=%r' % (key, value)
29234 
      for key, value in self.__dict__.iteritems()]
29235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29236 
 
29237 
  def __eq__(self, other):
29238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29239 
 
29240 
  def __ne__(self, other):
29241 
    return not (self == other)
6371 rajveer 29242 
 
29243 
class updateAvailabilityStatus_args:
29244 
  """
29245 
  Attributes:
29246 
   - operatorId
29247 
   - circleId
29248 
   - isAvailable
29249 
  """
29250 
 
29251 
  thrift_spec = (
29252 
    None, # 0
29253 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29254 
    (2, TType.I64, 'circleId', None, None, ), # 2
29255 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
29256 
  )
29257 
 
29258 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
29259 
    self.operatorId = operatorId
29260 
    self.circleId = circleId
29261 
    self.isAvailable = isAvailable
29262 
 
29263 
  def read(self, iprot):
29264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29266 
      return
29267 
    iprot.readStructBegin()
29268 
    while True:
29269 
      (fname, ftype, fid) = iprot.readFieldBegin()
29270 
      if ftype == TType.STOP:
29271 
        break
29272 
      if fid == 1:
29273 
        if ftype == TType.I64:
29274 
          self.operatorId = iprot.readI64();
29275 
        else:
29276 
          iprot.skip(ftype)
29277 
      elif fid == 2:
29278 
        if ftype == TType.I64:
29279 
          self.circleId = iprot.readI64();
29280 
        else:
29281 
          iprot.skip(ftype)
29282 
      elif fid == 3:
29283 
        if ftype == TType.BOOL:
29284 
          self.isAvailable = iprot.readBool();
29285 
        else:
29286 
          iprot.skip(ftype)
29287 
      else:
29288 
        iprot.skip(ftype)
29289 
      iprot.readFieldEnd()
29290 
    iprot.readStructEnd()
29291 
 
29292 
  def write(self, oprot):
29293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29295 
      return
29296 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
29297 
    if self.operatorId is not None:
29298 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29299 
      oprot.writeI64(self.operatorId)
29300 
      oprot.writeFieldEnd()
29301 
    if self.circleId is not None:
29302 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
29303 
      oprot.writeI64(self.circleId)
29304 
      oprot.writeFieldEnd()
29305 
    if self.isAvailable is not None:
29306 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
29307 
      oprot.writeBool(self.isAvailable)
29308 
      oprot.writeFieldEnd()
29309 
    oprot.writeFieldStop()
29310 
    oprot.writeStructEnd()
29311 
 
29312 
  def validate(self):
29313 
    return
29314 
 
29315 
 
29316 
  def __repr__(self):
29317 
    L = ['%s=%r' % (key, value)
29318 
      for key, value in self.__dict__.iteritems()]
29319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29320 
 
29321 
  def __eq__(self, other):
29322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29323 
 
29324 
  def __ne__(self, other):
29325 
    return not (self == other)
29326 
 
29327 
class updateAvailabilityStatus_result:
29328 
 
29329 
  thrift_spec = (
29330 
  )
29331 
 
29332 
  def read(self, iprot):
29333 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29334 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29335 
      return
29336 
    iprot.readStructBegin()
29337 
    while True:
29338 
      (fname, ftype, fid) = iprot.readFieldBegin()
29339 
      if ftype == TType.STOP:
29340 
        break
29341 
      else:
29342 
        iprot.skip(ftype)
29343 
      iprot.readFieldEnd()
29344 
    iprot.readStructEnd()
29345 
 
29346 
  def write(self, oprot):
29347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29349 
      return
29350 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
29351 
    oprot.writeFieldStop()
29352 
    oprot.writeStructEnd()
29353 
 
29354 
  def validate(self):
29355 
    return
29356 
 
29357 
 
29358 
  def __repr__(self):
29359 
    L = ['%s=%r' % (key, value)
29360 
      for key, value in self.__dict__.iteritems()]
29361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29362 
 
29363 
  def __eq__(self, other):
29364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29365 
 
29366 
  def __ne__(self, other):
29367 
    return not (self == other)
6389 rajveer 29368 
 
29369 
class getAvailableEmiSchemes_args:
29370 
 
29371 
  thrift_spec = (
29372 
  )
29373 
 
29374 
  def read(self, iprot):
29375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29377 
      return
29378 
    iprot.readStructBegin()
29379 
    while True:
29380 
      (fname, ftype, fid) = iprot.readFieldBegin()
29381 
      if ftype == TType.STOP:
29382 
        break
29383 
      else:
29384 
        iprot.skip(ftype)
29385 
      iprot.readFieldEnd()
29386 
    iprot.readStructEnd()
29387 
 
29388 
  def write(self, oprot):
29389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29391 
      return
29392 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
29393 
    oprot.writeFieldStop()
29394 
    oprot.writeStructEnd()
29395 
 
29396 
  def validate(self):
29397 
    return
29398 
 
29399 
 
29400 
  def __repr__(self):
29401 
    L = ['%s=%r' % (key, value)
29402 
      for key, value in self.__dict__.iteritems()]
29403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29404 
 
29405 
  def __eq__(self, other):
29406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29407 
 
29408 
  def __ne__(self, other):
29409 
    return not (self == other)
29410 
 
29411 
class getAvailableEmiSchemes_result:
29412 
  """
29413 
  Attributes:
29414 
   - success
29415 
  """
29416 
 
29417 
  thrift_spec = (
29418 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
29419 
  )
29420 
 
29421 
  def __init__(self, success=None,):
29422 
    self.success = success
29423 
 
29424 
  def read(self, iprot):
29425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29427 
      return
29428 
    iprot.readStructBegin()
29429 
    while True:
29430 
      (fname, ftype, fid) = iprot.readFieldBegin()
29431 
      if ftype == TType.STOP:
29432 
        break
29433 
      if fid == 0:
29434 
        if ftype == TType.LIST:
29435 
          self.success = []
29436 
          (_etype710, _size707) = iprot.readListBegin()
29437 
          for _i711 in xrange(_size707):
29438 
            _elem712 = EmiScheme()
29439 
            _elem712.read(iprot)
29440 
            self.success.append(_elem712)
29441 
          iprot.readListEnd()
29442 
        else:
29443 
          iprot.skip(ftype)
29444 
      else:
29445 
        iprot.skip(ftype)
29446 
      iprot.readFieldEnd()
29447 
    iprot.readStructEnd()
29448 
 
29449 
  def write(self, oprot):
29450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29452 
      return
29453 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
29454 
    if self.success is not None:
29455 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29456 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29457 
      for iter713 in self.success:
29458 
        iter713.write(oprot)
29459 
      oprot.writeListEnd()
29460 
      oprot.writeFieldEnd()
29461 
    oprot.writeFieldStop()
29462 
    oprot.writeStructEnd()
29463 
 
29464 
  def validate(self):
29465 
    return
29466 
 
29467 
 
29468 
  def __repr__(self):
29469 
    L = ['%s=%r' % (key, value)
29470 
      for key, value in self.__dict__.iteritems()]
29471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29472 
 
29473 
  def __eq__(self, other):
29474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29475 
 
29476 
  def __ne__(self, other):
29477 
    return not (self == other)
29478 
 
29479 
class getMiscCharges_args:
29480 
  """
29481 
  Attributes:
29482 
   - transactionId
29483 
  """
29484 
 
29485 
  thrift_spec = (
29486 
    None, # 0
29487 
    (1, TType.I64, 'transactionId', None, None, ), # 1
29488 
  )
29489 
 
29490 
  def __init__(self, transactionId=None,):
29491 
    self.transactionId = transactionId
29492 
 
29493 
  def read(self, iprot):
29494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29496 
      return
29497 
    iprot.readStructBegin()
29498 
    while True:
29499 
      (fname, ftype, fid) = iprot.readFieldBegin()
29500 
      if ftype == TType.STOP:
29501 
        break
29502 
      if fid == 1:
29503 
        if ftype == TType.I64:
29504 
          self.transactionId = iprot.readI64();
29505 
        else:
29506 
          iprot.skip(ftype)
29507 
      else:
29508 
        iprot.skip(ftype)
29509 
      iprot.readFieldEnd()
29510 
    iprot.readStructEnd()
29511 
 
29512 
  def write(self, oprot):
29513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29515 
      return
29516 
    oprot.writeStructBegin('getMiscCharges_args')
29517 
    if self.transactionId is not None:
29518 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
29519 
      oprot.writeI64(self.transactionId)
29520 
      oprot.writeFieldEnd()
29521 
    oprot.writeFieldStop()
29522 
    oprot.writeStructEnd()
29523 
 
29524 
  def validate(self):
29525 
    return
29526 
 
29527 
 
29528 
  def __repr__(self):
29529 
    L = ['%s=%r' % (key, value)
29530 
      for key, value in self.__dict__.iteritems()]
29531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29532 
 
29533 
  def __eq__(self, other):
29534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29535 
 
29536 
  def __ne__(self, other):
29537 
    return not (self == other)
29538 
 
29539 
class getMiscCharges_result:
29540 
  """
29541 
  Attributes:
29542 
   - success
29543 
  """
29544 
 
29545 
  thrift_spec = (
6412 rajveer 29546 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 29547 
  )
29548 
 
29549 
  def __init__(self, success=None,):
29550 
    self.success = success
29551 
 
29552 
  def read(self, iprot):
29553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29555 
      return
29556 
    iprot.readStructBegin()
29557 
    while True:
29558 
      (fname, ftype, fid) = iprot.readFieldBegin()
29559 
      if ftype == TType.STOP:
29560 
        break
29561 
      if fid == 0:
29562 
        if ftype == TType.MAP:
29563 
          self.success = {}
29564 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
29565 
          for _i718 in xrange(_size714):
29566 
            _key719 = iprot.readI64();
6412 rajveer 29567 
            _val720 = iprot.readDouble();
6389 rajveer 29568 
            self.success[_key719] = _val720
29569 
          iprot.readMapEnd()
29570 
        else:
29571 
          iprot.skip(ftype)
29572 
      else:
29573 
        iprot.skip(ftype)
29574 
      iprot.readFieldEnd()
29575 
    iprot.readStructEnd()
29576 
 
29577 
  def write(self, oprot):
29578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29580 
      return
29581 
    oprot.writeStructBegin('getMiscCharges_result')
29582 
    if self.success is not None:
29583 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 29584 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 29585 
      for kiter721,viter722 in self.success.items():
29586 
        oprot.writeI64(kiter721)
6412 rajveer 29587 
        oprot.writeDouble(viter722)
6389 rajveer 29588 
      oprot.writeMapEnd()
29589 
      oprot.writeFieldEnd()
29590 
    oprot.writeFieldStop()
29591 
    oprot.writeStructEnd()
29592 
 
29593 
  def validate(self):
29594 
    return
29595 
 
29596 
 
29597 
  def __repr__(self):
29598 
    L = ['%s=%r' % (key, value)
29599 
      for key, value in self.__dict__.iteritems()]
29600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29601 
 
29602 
  def __eq__(self, other):
29603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29604 
 
29605 
  def __ne__(self, other):
29606 
    return not (self == other)
6507 anupam.sin 29607 
 
29608 
class refundRechargeOrder_args:
29609 
  """
29610 
  Attributes:
29611 
   - rechargeOrderId
29612 
  """
29613 
 
29614 
  thrift_spec = (
29615 
    None, # 0
29616 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
29617 
  )
29618 
 
29619 
  def __init__(self, rechargeOrderId=None,):
29620 
    self.rechargeOrderId = rechargeOrderId
29621 
 
29622 
  def read(self, iprot):
29623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29625 
      return
29626 
    iprot.readStructBegin()
29627 
    while True:
29628 
      (fname, ftype, fid) = iprot.readFieldBegin()
29629 
      if ftype == TType.STOP:
29630 
        break
29631 
      if fid == 1:
29632 
        if ftype == TType.I64:
29633 
          self.rechargeOrderId = iprot.readI64();
29634 
        else:
29635 
          iprot.skip(ftype)
29636 
      else:
29637 
        iprot.skip(ftype)
29638 
      iprot.readFieldEnd()
29639 
    iprot.readStructEnd()
29640 
 
29641 
  def write(self, oprot):
29642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29644 
      return
29645 
    oprot.writeStructBegin('refundRechargeOrder_args')
29646 
    if self.rechargeOrderId is not None:
29647 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
29648 
      oprot.writeI64(self.rechargeOrderId)
29649 
      oprot.writeFieldEnd()
29650 
    oprot.writeFieldStop()
29651 
    oprot.writeStructEnd()
29652 
 
29653 
  def validate(self):
29654 
    return
29655 
 
29656 
 
29657 
  def __repr__(self):
29658 
    L = ['%s=%r' % (key, value)
29659 
      for key, value in self.__dict__.iteritems()]
29660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29661 
 
29662 
  def __eq__(self, other):
29663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29664 
 
29665 
  def __ne__(self, other):
29666 
    return not (self == other)
29667 
 
29668 
class refundRechargeOrder_result:
29669 
  """
29670 
  Attributes:
29671 
   - success
29672 
   - ex
29673 
  """
29674 
 
29675 
  thrift_spec = (
29676 
    (0, TType.BOOL, 'success', None, None, ), # 0
29677 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29678 
  )
29679 
 
29680 
  def __init__(self, success=None, ex=None,):
29681 
    self.success = success
29682 
    self.ex = ex
29683 
 
29684 
  def read(self, iprot):
29685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29687 
      return
29688 
    iprot.readStructBegin()
29689 
    while True:
29690 
      (fname, ftype, fid) = iprot.readFieldBegin()
29691 
      if ftype == TType.STOP:
29692 
        break
29693 
      if fid == 0:
29694 
        if ftype == TType.BOOL:
29695 
          self.success = iprot.readBool();
29696 
        else:
29697 
          iprot.skip(ftype)
29698 
      elif fid == 1:
29699 
        if ftype == TType.STRUCT:
29700 
          self.ex = TransactionServiceException()
29701 
          self.ex.read(iprot)
29702 
        else:
29703 
          iprot.skip(ftype)
29704 
      else:
29705 
        iprot.skip(ftype)
29706 
      iprot.readFieldEnd()
29707 
    iprot.readStructEnd()
29708 
 
29709 
  def write(self, oprot):
29710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29712 
      return
29713 
    oprot.writeStructBegin('refundRechargeOrder_result')
29714 
    if self.success is not None:
29715 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
29716 
      oprot.writeBool(self.success)
29717 
      oprot.writeFieldEnd()
29718 
    if self.ex is not None:
29719 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29720 
      self.ex.write(oprot)
29721 
      oprot.writeFieldEnd()
29722 
    oprot.writeFieldStop()
29723 
    oprot.writeStructEnd()
29724 
 
29725 
  def validate(self):
29726 
    return
29727 
 
29728 
 
29729 
  def __repr__(self):
29730 
    L = ['%s=%r' % (key, value)
29731 
      for key, value in self.__dict__.iteritems()]
29732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29733 
 
29734 
  def __eq__(self, other):
29735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29736 
 
29737 
  def __ne__(self, other):
29738 
    return not (self == other)
6821 amar.kumar 29739 
 
29740 
class getPhysicalOrders_args:
29741 
  """
29742 
  Attributes:
29743 
   - fromDate
29744 
   - toDate
29745 
  """
29746 
 
29747 
  thrift_spec = (
29748 
    None, # 0
29749 
    (1, TType.I64, 'fromDate', None, None, ), # 1
29750 
    (2, TType.I64, 'toDate', None, None, ), # 2
29751 
  )
29752 
 
29753 
  def __init__(self, fromDate=None, toDate=None,):
29754 
    self.fromDate = fromDate
29755 
    self.toDate = toDate
29756 
 
29757 
  def read(self, iprot):
29758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29760 
      return
29761 
    iprot.readStructBegin()
29762 
    while True:
29763 
      (fname, ftype, fid) = iprot.readFieldBegin()
29764 
      if ftype == TType.STOP:
29765 
        break
29766 
      if fid == 1:
29767 
        if ftype == TType.I64:
29768 
          self.fromDate = iprot.readI64();
29769 
        else:
29770 
          iprot.skip(ftype)
29771 
      elif fid == 2:
29772 
        if ftype == TType.I64:
29773 
          self.toDate = iprot.readI64();
29774 
        else:
29775 
          iprot.skip(ftype)
29776 
      else:
29777 
        iprot.skip(ftype)
29778 
      iprot.readFieldEnd()
29779 
    iprot.readStructEnd()
29780 
 
29781 
  def write(self, oprot):
29782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29784 
      return
29785 
    oprot.writeStructBegin('getPhysicalOrders_args')
29786 
    if self.fromDate is not None:
29787 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
29788 
      oprot.writeI64(self.fromDate)
29789 
      oprot.writeFieldEnd()
29790 
    if self.toDate is not None:
29791 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
29792 
      oprot.writeI64(self.toDate)
29793 
      oprot.writeFieldEnd()
29794 
    oprot.writeFieldStop()
29795 
    oprot.writeStructEnd()
29796 
 
29797 
  def validate(self):
29798 
    return
29799 
 
29800 
 
29801 
  def __repr__(self):
29802 
    L = ['%s=%r' % (key, value)
29803 
      for key, value in self.__dict__.iteritems()]
29804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29805 
 
29806 
  def __eq__(self, other):
29807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29808 
 
29809 
  def __ne__(self, other):
29810 
    return not (self == other)
29811 
 
29812 
class getPhysicalOrders_result:
29813 
  """
29814 
  Attributes:
29815 
   - success
29816 
  """
29817 
 
29818 
  thrift_spec = (
29819 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
29820 
  )
29821 
 
29822 
  def __init__(self, success=None,):
29823 
    self.success = success
29824 
 
29825 
  def read(self, iprot):
29826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29828 
      return
29829 
    iprot.readStructBegin()
29830 
    while True:
29831 
      (fname, ftype, fid) = iprot.readFieldBegin()
29832 
      if ftype == TType.STOP:
29833 
        break
29834 
      if fid == 0:
29835 
        if ftype == TType.LIST:
29836 
          self.success = []
29837 
          (_etype726, _size723) = iprot.readListBegin()
29838 
          for _i727 in xrange(_size723):
29839 
            _elem728 = Order()
29840 
            _elem728.read(iprot)
29841 
            self.success.append(_elem728)
29842 
          iprot.readListEnd()
29843 
        else:
29844 
          iprot.skip(ftype)
29845 
      else:
29846 
        iprot.skip(ftype)
29847 
      iprot.readFieldEnd()
29848 
    iprot.readStructEnd()
29849 
 
29850 
  def write(self, oprot):
29851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29853 
      return
29854 
    oprot.writeStructBegin('getPhysicalOrders_result')
29855 
    if self.success is not None:
29856 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29857 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29858 
      for iter729 in self.success:
29859 
        iter729.write(oprot)
29860 
      oprot.writeListEnd()
29861 
      oprot.writeFieldEnd()
29862 
    oprot.writeFieldStop()
29863 
    oprot.writeStructEnd()
29864 
 
29865 
  def validate(self):
29866 
    return
29867 
 
29868 
 
29869 
  def __repr__(self):
29870 
    L = ['%s=%r' % (key, value)
29871 
      for key, value in self.__dict__.iteritems()]
29872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29873 
 
29874 
  def __eq__(self, other):
29875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29876 
 
29877 
  def __ne__(self, other):
29878 
    return not (self == other)
6906 rajveer 29879 
 
29880 
class getDocument_args:
29881 
  """
29882 
  Attributes:
29883 
   - docType
29884 
   - docSource
29885 
  """
29886 
 
29887 
  thrift_spec = (
29888 
    None, # 0
29889 
    (1, TType.I64, 'docType', None, None, ), # 1
29890 
    (2, TType.I64, 'docSource', None, None, ), # 2
29891 
  )
29892 
 
29893 
  def __init__(self, docType=None, docSource=None,):
29894 
    self.docType = docType
29895 
    self.docSource = docSource
29896 
 
29897 
  def read(self, iprot):
29898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29900 
      return
29901 
    iprot.readStructBegin()
29902 
    while True:
29903 
      (fname, ftype, fid) = iprot.readFieldBegin()
29904 
      if ftype == TType.STOP:
29905 
        break
29906 
      if fid == 1:
29907 
        if ftype == TType.I64:
29908 
          self.docType = iprot.readI64();
29909 
        else:
29910 
          iprot.skip(ftype)
29911 
      elif fid == 2:
29912 
        if ftype == TType.I64:
29913 
          self.docSource = iprot.readI64();
29914 
        else:
29915 
          iprot.skip(ftype)
29916 
      else:
29917 
        iprot.skip(ftype)
29918 
      iprot.readFieldEnd()
29919 
    iprot.readStructEnd()
29920 
 
29921 
  def write(self, oprot):
29922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29924 
      return
29925 
    oprot.writeStructBegin('getDocument_args')
29926 
    if self.docType is not None:
29927 
      oprot.writeFieldBegin('docType', TType.I64, 1)
29928 
      oprot.writeI64(self.docType)
29929 
      oprot.writeFieldEnd()
29930 
    if self.docSource is not None:
29931 
      oprot.writeFieldBegin('docSource', TType.I64, 2)
29932 
      oprot.writeI64(self.docSource)
29933 
      oprot.writeFieldEnd()
29934 
    oprot.writeFieldStop()
29935 
    oprot.writeStructEnd()
29936 
 
29937 
  def validate(self):
29938 
    return
29939 
 
29940 
 
29941 
  def __repr__(self):
29942 
    L = ['%s=%r' % (key, value)
29943 
      for key, value in self.__dict__.iteritems()]
29944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29945 
 
29946 
  def __eq__(self, other):
29947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29948 
 
29949 
  def __ne__(self, other):
29950 
    return not (self == other)
29951 
 
29952 
class getDocument_result:
29953 
  """
29954 
  Attributes:
29955 
   - success
29956 
  """
29957 
 
29958 
  thrift_spec = (
29959 
    (0, TType.STRING, 'success', None, None, ), # 0
29960 
  )
29961 
 
29962 
  def __init__(self, success=None,):
29963 
    self.success = success
29964 
 
29965 
  def read(self, iprot):
29966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29968 
      return
29969 
    iprot.readStructBegin()
29970 
    while True:
29971 
      (fname, ftype, fid) = iprot.readFieldBegin()
29972 
      if ftype == TType.STOP:
29973 
        break
29974 
      if fid == 0:
29975 
        if ftype == TType.STRING:
29976 
          self.success = iprot.readString();
29977 
        else:
29978 
          iprot.skip(ftype)
29979 
      else:
29980 
        iprot.skip(ftype)
29981 
      iprot.readFieldEnd()
29982 
    iprot.readStructEnd()
29983 
 
29984 
  def write(self, oprot):
29985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29987 
      return
29988 
    oprot.writeStructBegin('getDocument_result')
29989 
    if self.success is not None:
29990 
      oprot.writeFieldBegin('success', TType.STRING, 0)
29991 
      oprot.writeString(self.success)
29992 
      oprot.writeFieldEnd()
29993 
    oprot.writeFieldStop()
29994 
    oprot.writeStructEnd()
29995 
 
29996 
  def validate(self):
29997 
    return
29998 
 
29999 
 
30000 
  def __repr__(self):
30001 
    L = ['%s=%r' % (key, value)
30002 
      for key, value in self.__dict__.iteritems()]
30003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30004 
 
30005 
  def __eq__(self, other):
30006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30007 
 
30008 
  def __ne__(self, other):
30009 
    return not (self == other)
6985 anupam.sin 30010 
 
30011 
class changeShippingAddress_args:
30012 
  """
30013 
  Attributes:
30014 
   - orderId
30015 
   - line1
30016 
   - line2
30017 
   - city
30018 
   - state
30019 
   - pin
30020 
  """
30021 
 
30022 
  thrift_spec = (
30023 
    None, # 0
30024 
    (1, TType.I64, 'orderId', None, None, ), # 1
30025 
    (2, TType.STRING, 'line1', None, None, ), # 2
30026 
    (3, TType.STRING, 'line2', None, None, ), # 3
30027 
    (4, TType.STRING, 'city', None, None, ), # 4
30028 
    (5, TType.STRING, 'state', None, None, ), # 5
30029 
    (6, TType.STRING, 'pin', None, None, ), # 6
30030 
  )
30031 
 
30032 
  def __init__(self, orderId=None, line1=None, line2=None, city=None, state=None, pin=None,):
30033 
    self.orderId = orderId
30034 
    self.line1 = line1
30035 
    self.line2 = line2
30036 
    self.city = city
30037 
    self.state = state
30038 
    self.pin = pin
30039 
 
30040 
  def read(self, iprot):
30041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30043 
      return
30044 
    iprot.readStructBegin()
30045 
    while True:
30046 
      (fname, ftype, fid) = iprot.readFieldBegin()
30047 
      if ftype == TType.STOP:
30048 
        break
30049 
      if fid == 1:
30050 
        if ftype == TType.I64:
30051 
          self.orderId = iprot.readI64();
30052 
        else:
30053 
          iprot.skip(ftype)
30054 
      elif fid == 2:
30055 
        if ftype == TType.STRING:
30056 
          self.line1 = iprot.readString();
30057 
        else:
30058 
          iprot.skip(ftype)
30059 
      elif fid == 3:
30060 
        if ftype == TType.STRING:
30061 
          self.line2 = iprot.readString();
30062 
        else:
30063 
          iprot.skip(ftype)
30064 
      elif fid == 4:
30065 
        if ftype == TType.STRING:
30066 
          self.city = iprot.readString();
30067 
        else:
30068 
          iprot.skip(ftype)
30069 
      elif fid == 5:
30070 
        if ftype == TType.STRING:
30071 
          self.state = iprot.readString();
30072 
        else:
30073 
          iprot.skip(ftype)
30074 
      elif fid == 6:
30075 
        if ftype == TType.STRING:
30076 
          self.pin = iprot.readString();
30077 
        else:
30078 
          iprot.skip(ftype)
30079 
      else:
30080 
        iprot.skip(ftype)
30081 
      iprot.readFieldEnd()
30082 
    iprot.readStructEnd()
30083 
 
30084 
  def write(self, oprot):
30085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30087 
      return
30088 
    oprot.writeStructBegin('changeShippingAddress_args')
30089 
    if self.orderId is not None:
30090 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30091 
      oprot.writeI64(self.orderId)
30092 
      oprot.writeFieldEnd()
30093 
    if self.line1 is not None:
30094 
      oprot.writeFieldBegin('line1', TType.STRING, 2)
30095 
      oprot.writeString(self.line1)
30096 
      oprot.writeFieldEnd()
30097 
    if self.line2 is not None:
30098 
      oprot.writeFieldBegin('line2', TType.STRING, 3)
30099 
      oprot.writeString(self.line2)
30100 
      oprot.writeFieldEnd()
30101 
    if self.city is not None:
30102 
      oprot.writeFieldBegin('city', TType.STRING, 4)
30103 
      oprot.writeString(self.city)
30104 
      oprot.writeFieldEnd()
30105 
    if self.state is not None:
30106 
      oprot.writeFieldBegin('state', TType.STRING, 5)
30107 
      oprot.writeString(self.state)
30108 
      oprot.writeFieldEnd()
30109 
    if self.pin is not None:
30110 
      oprot.writeFieldBegin('pin', TType.STRING, 6)
30111 
      oprot.writeString(self.pin)
30112 
      oprot.writeFieldEnd()
30113 
    oprot.writeFieldStop()
30114 
    oprot.writeStructEnd()
30115 
 
30116 
  def validate(self):
30117 
    return
30118 
 
30119 
 
30120 
  def __repr__(self):
30121 
    L = ['%s=%r' % (key, value)
30122 
      for key, value in self.__dict__.iteritems()]
30123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30124 
 
30125 
  def __eq__(self, other):
30126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30127 
 
30128 
  def __ne__(self, other):
30129 
    return not (self == other)
30130 
 
30131 
class changeShippingAddress_result:
30132 
  """
30133 
  Attributes:
30134 
   - success
30135 
  """
30136 
 
30137 
  thrift_spec = (
30138 
    (0, TType.BOOL, 'success', None, None, ), # 0
30139 
  )
30140 
 
30141 
  def __init__(self, success=None,):
30142 
    self.success = success
30143 
 
30144 
  def read(self, iprot):
30145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30147 
      return
30148 
    iprot.readStructBegin()
30149 
    while True:
30150 
      (fname, ftype, fid) = iprot.readFieldBegin()
30151 
      if ftype == TType.STOP:
30152 
        break
30153 
      if fid == 0:
30154 
        if ftype == TType.BOOL:
30155 
          self.success = iprot.readBool();
30156 
        else:
30157 
          iprot.skip(ftype)
30158 
      else:
30159 
        iprot.skip(ftype)
30160 
      iprot.readFieldEnd()
30161 
    iprot.readStructEnd()
30162 
 
30163 
  def write(self, oprot):
30164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30166 
      return
30167 
    oprot.writeStructBegin('changeShippingAddress_result')
30168 
    if self.success is not None:
30169 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30170 
      oprot.writeBool(self.success)
30171 
      oprot.writeFieldEnd()
30172 
    oprot.writeFieldStop()
30173 
    oprot.writeStructEnd()
30174 
 
30175 
  def validate(self):
30176 
    return
30177 
 
30178 
 
30179 
  def __repr__(self):
30180 
    L = ['%s=%r' % (key, value)
30181 
      for key, value in self.__dict__.iteritems()]
30182 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30183 
 
30184 
  def __eq__(self, other):
30185 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30186 
 
30187 
  def __ne__(self, other):
30188 
    return not (self == other)
6988 rajveer 30189 
 
30190 
class retrieveInvoice_args:
30191 
  """
30192 
  Attributes:
30193 
   - orderId
30194 
  """
30195 
 
30196 
  thrift_spec = (
30197 
    None, # 0
30198 
    (1, TType.I64, 'orderId', None, None, ), # 1
30199 
  )
30200 
 
30201 
  def __init__(self, orderId=None,):
30202 
    self.orderId = orderId
30203 
 
30204 
  def read(self, iprot):
30205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30207 
      return
30208 
    iprot.readStructBegin()
30209 
    while True:
30210 
      (fname, ftype, fid) = iprot.readFieldBegin()
30211 
      if ftype == TType.STOP:
30212 
        break
30213 
      if fid == 1:
30214 
        if ftype == TType.I64:
30215 
          self.orderId = iprot.readI64();
30216 
        else:
30217 
          iprot.skip(ftype)
30218 
      else:
30219 
        iprot.skip(ftype)
30220 
      iprot.readFieldEnd()
30221 
    iprot.readStructEnd()
30222 
 
30223 
  def write(self, oprot):
30224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30226 
      return
30227 
    oprot.writeStructBegin('retrieveInvoice_args')
30228 
    if self.orderId is not None:
30229 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
30230 
      oprot.writeI64(self.orderId)
30231 
      oprot.writeFieldEnd()
30232 
    oprot.writeFieldStop()
30233 
    oprot.writeStructEnd()
30234 
 
30235 
  def validate(self):
30236 
    return
30237 
 
30238 
 
30239 
  def __repr__(self):
30240 
    L = ['%s=%r' % (key, value)
30241 
      for key, value in self.__dict__.iteritems()]
30242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30243 
 
30244 
  def __eq__(self, other):
30245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30246 
 
30247 
  def __ne__(self, other):
30248 
    return not (self == other)
30249 
 
30250 
class retrieveInvoice_result:
30251 
  """
30252 
  Attributes:
30253 
   - success
30254 
  """
30255 
 
30256 
  thrift_spec = (
30257 
    (0, TType.STRING, 'success', None, None, ), # 0
30258 
  )
30259 
 
30260 
  def __init__(self, success=None,):
30261 
    self.success = success
30262 
 
30263 
  def read(self, iprot):
30264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30266 
      return
30267 
    iprot.readStructBegin()
30268 
    while True:
30269 
      (fname, ftype, fid) = iprot.readFieldBegin()
30270 
      if ftype == TType.STOP:
30271 
        break
30272 
      if fid == 0:
30273 
        if ftype == TType.STRING:
30274 
          self.success = iprot.readString();
30275 
        else:
30276 
          iprot.skip(ftype)
30277 
      else:
30278 
        iprot.skip(ftype)
30279 
      iprot.readFieldEnd()
30280 
    iprot.readStructEnd()
30281 
 
30282 
  def write(self, oprot):
30283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30285 
      return
30286 
    oprot.writeStructBegin('retrieveInvoice_result')
30287 
    if self.success is not None:
30288 
      oprot.writeFieldBegin('success', TType.STRING, 0)
30289 
      oprot.writeString(self.success)
30290 
      oprot.writeFieldEnd()
30291 
    oprot.writeFieldStop()
30292 
    oprot.writeStructEnd()
30293 
 
30294 
  def validate(self):
30295 
    return
30296 
 
30297 
 
30298 
  def __repr__(self):
30299 
    L = ['%s=%r' % (key, value)
30300 
      for key, value in self.__dict__.iteritems()]
30301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30302 
 
30303 
  def __eq__(self, other):
30304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30305 
 
30306 
  def __ne__(self, other):
30307 
    return not (self == other)
7026 rajveer 30308 
 
30309 
class receiveUpdatesForRedExpress_args:
30310 
  """
30311 
  Attributes:
30312 
   - awbNumber
30313 
  """
30314 
 
30315 
  thrift_spec = (
30316 
    None, # 0
30317 
    (1, TType.STRING, 'awbNumber', None, None, ), # 1
30318 
  )
30319 
 
30320 
  def __init__(self, awbNumber=None,):
30321 
    self.awbNumber = awbNumber
30322 
 
30323 
  def read(self, iprot):
30324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30326 
      return
30327 
    iprot.readStructBegin()
30328 
    while True:
30329 
      (fname, ftype, fid) = iprot.readFieldBegin()
30330 
      if ftype == TType.STOP:
30331 
        break
30332 
      if fid == 1:
30333 
        if ftype == TType.STRING:
30334 
          self.awbNumber = iprot.readString();
30335 
        else:
30336 
          iprot.skip(ftype)
30337 
      else:
30338 
        iprot.skip(ftype)
30339 
      iprot.readFieldEnd()
30340 
    iprot.readStructEnd()
30341 
 
30342 
  def write(self, oprot):
30343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30345 
      return
30346 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_args')
30347 
    if self.awbNumber is not None:
30348 
      oprot.writeFieldBegin('awbNumber', TType.STRING, 1)
30349 
      oprot.writeString(self.awbNumber)
30350 
      oprot.writeFieldEnd()
30351 
    oprot.writeFieldStop()
30352 
    oprot.writeStructEnd()
30353 
 
30354 
  def validate(self):
30355 
    return
30356 
 
30357 
 
30358 
  def __repr__(self):
30359 
    L = ['%s=%r' % (key, value)
30360 
      for key, value in self.__dict__.iteritems()]
30361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30362 
 
30363 
  def __eq__(self, other):
30364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30365 
 
30366 
  def __ne__(self, other):
30367 
    return not (self == other)
30368 
 
30369 
class receiveUpdatesForRedExpress_result:
30370 
  """
30371 
  Attributes:
30372 
   - success
30373 
  """
30374 
 
30375 
  thrift_spec = (
30376 
    (0, TType.LIST, 'success', (TType.STRING,None), None, ), # 0
30377 
  )
30378 
 
30379 
  def __init__(self, success=None,):
30380 
    self.success = success
30381 
 
30382 
  def read(self, iprot):
30383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30385 
      return
30386 
    iprot.readStructBegin()
30387 
    while True:
30388 
      (fname, ftype, fid) = iprot.readFieldBegin()
30389 
      if ftype == TType.STOP:
30390 
        break
30391 
      if fid == 0:
30392 
        if ftype == TType.LIST:
30393 
          self.success = []
30394 
          (_etype733, _size730) = iprot.readListBegin()
30395 
          for _i734 in xrange(_size730):
30396 
            _elem735 = iprot.readString();
30397 
            self.success.append(_elem735)
30398 
          iprot.readListEnd()
30399 
        else:
30400 
          iprot.skip(ftype)
30401 
      else:
30402 
        iprot.skip(ftype)
30403 
      iprot.readFieldEnd()
30404 
    iprot.readStructEnd()
30405 
 
30406 
  def write(self, oprot):
30407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30409 
      return
30410 
    oprot.writeStructBegin('receiveUpdatesForRedExpress_result')
30411 
    if self.success is not None:
30412 
      oprot.writeFieldBegin('success', TType.LIST, 0)
30413 
      oprot.writeListBegin(TType.STRING, len(self.success))
30414 
      for iter736 in self.success:
30415 
        oprot.writeString(iter736)
30416 
      oprot.writeListEnd()
30417 
      oprot.writeFieldEnd()
30418 
    oprot.writeFieldStop()
30419 
    oprot.writeStructEnd()
30420 
 
30421 
  def validate(self):
30422 
    return
30423 
 
30424 
 
30425 
  def __repr__(self):
30426 
    L = ['%s=%r' % (key, value)
30427 
      for key, value in self.__dict__.iteritems()]
30428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30429 
 
30430 
  def __eq__(self, other):
30431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30432 
 
30433 
  def __ne__(self, other):
30434 
    return not (self == other)