Subversion Repositories SmartDukaan

Rev

Rev 6591 | Rev 6821 | 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 
 
6507 anupam.sin 1447 
 
3376 rajveer 1448 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1449 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1450 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1451 
 
1452 
  def createTransaction(self, transaction):
1453 
    """
1454 
    Parameters:
1455 
     - transaction
1456 
    """
1457 
    self.send_createTransaction(transaction)
132 ashish 1458 
    return self.recv_createTransaction()
94 ashish 1459 
 
1460 
  def send_createTransaction(self, transaction):
1461 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1462 
    args = createTransaction_args()
1463 
    args.transaction = transaction
1464 
    args.write(self._oprot)
1465 
    self._oprot.writeMessageEnd()
1466 
    self._oprot.trans.flush()
1467 
 
1468 
  def recv_createTransaction(self, ):
1469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1470 
    if mtype == TMessageType.EXCEPTION:
1471 
      x = TApplicationException()
1472 
      x.read(self._iprot)
1473 
      self._iprot.readMessageEnd()
1474 
      raise x
1475 
    result = createTransaction_result()
1476 
    result.read(self._iprot)
1477 
    self._iprot.readMessageEnd()
3431 rajveer 1478 
    if result.success is not None:
132 ashish 1479 
      return result.success
3431 rajveer 1480 
    if result.ex is not None:
94 ashish 1481 
      raise result.ex
132 ashish 1482 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1483 
 
1484 
  def getTransaction(self, id):
1485 
    """
1486 
    Parameters:
1487 
     - id
1488 
    """
1489 
    self.send_getTransaction(id)
1490 
    return self.recv_getTransaction()
1491 
 
1492 
  def send_getTransaction(self, id):
1493 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1494 
    args = getTransaction_args()
1495 
    args.id = id
1496 
    args.write(self._oprot)
1497 
    self._oprot.writeMessageEnd()
1498 
    self._oprot.trans.flush()
1499 
 
1500 
  def recv_getTransaction(self, ):
1501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1502 
    if mtype == TMessageType.EXCEPTION:
1503 
      x = TApplicationException()
1504 
      x.read(self._iprot)
1505 
      self._iprot.readMessageEnd()
1506 
      raise x
1507 
    result = getTransaction_result()
1508 
    result.read(self._iprot)
1509 
    self._iprot.readMessageEnd()
3431 rajveer 1510 
    if result.success is not None:
94 ashish 1511 
      return result.success
3431 rajveer 1512 
    if result.ex is not None:
94 ashish 1513 
      raise result.ex
1514 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1515 
 
1516 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1517 
    """
1518 
    Parameters:
1519 
     - customerId
1520 
     - from_date
1521 
     - to_date
1522 
     - status
1523 
    """
1524 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1525 
    return self.recv_getTransactionsForCustomer()
1526 
 
1527 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1528 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1529 
    args = getTransactionsForCustomer_args()
1530 
    args.customerId = customerId
1531 
    args.from_date = from_date
1532 
    args.to_date = to_date
1533 
    args.status = status
1534 
    args.write(self._oprot)
1535 
    self._oprot.writeMessageEnd()
1536 
    self._oprot.trans.flush()
1537 
 
1538 
  def recv_getTransactionsForCustomer(self, ):
1539 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1540 
    if mtype == TMessageType.EXCEPTION:
1541 
      x = TApplicationException()
1542 
      x.read(self._iprot)
1543 
      self._iprot.readMessageEnd()
1544 
      raise x
1545 
    result = getTransactionsForCustomer_result()
1546 
    result.read(self._iprot)
1547 
    self._iprot.readMessageEnd()
3431 rajveer 1548 
    if result.success is not None:
94 ashish 1549 
      return result.success
3431 rajveer 1550 
    if result.ex is not None:
94 ashish 1551 
      raise result.ex
1552 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1553 
 
132 ashish 1554 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1555 
    """
1556 
    Parameters:
1557 
     - shoppingCartId
1558 
    """
1559 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1560 
    return self.recv_getTransactionsForShoppingCartId()
1561 
 
1562 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1563 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1564 
    args = getTransactionsForShoppingCartId_args()
1565 
    args.shoppingCartId = shoppingCartId
1566 
    args.write(self._oprot)
1567 
    self._oprot.writeMessageEnd()
1568 
    self._oprot.trans.flush()
1569 
 
1570 
  def recv_getTransactionsForShoppingCartId(self, ):
1571 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1572 
    if mtype == TMessageType.EXCEPTION:
1573 
      x = TApplicationException()
1574 
      x.read(self._iprot)
1575 
      self._iprot.readMessageEnd()
1576 
      raise x
1577 
    result = getTransactionsForShoppingCartId_result()
1578 
    result.read(self._iprot)
1579 
    self._iprot.readMessageEnd()
3431 rajveer 1580 
    if result.success is not None:
132 ashish 1581 
      return result.success
3431 rajveer 1582 
    if result.ex is not None:
132 ashish 1583 
      raise result.ex
1584 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1585 
 
94 ashish 1586 
  def getTransactionStatus(self, transactionId):
1587 
    """
1588 
    Parameters:
1589 
     - transactionId
1590 
    """
1591 
    self.send_getTransactionStatus(transactionId)
1592 
    return self.recv_getTransactionStatus()
1593 
 
1594 
  def send_getTransactionStatus(self, transactionId):
1595 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1596 
    args = getTransactionStatus_args()
1597 
    args.transactionId = transactionId
1598 
    args.write(self._oprot)
1599 
    self._oprot.writeMessageEnd()
1600 
    self._oprot.trans.flush()
1601 
 
1602 
  def recv_getTransactionStatus(self, ):
1603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1604 
    if mtype == TMessageType.EXCEPTION:
1605 
      x = TApplicationException()
1606 
      x.read(self._iprot)
1607 
      self._iprot.readMessageEnd()
1608 
      raise x
1609 
    result = getTransactionStatus_result()
1610 
    result.read(self._iprot)
1611 
    self._iprot.readMessageEnd()
3431 rajveer 1612 
    if result.success is not None:
94 ashish 1613 
      return result.success
3431 rajveer 1614 
    if result.ex is not None:
94 ashish 1615 
      raise result.ex
1616 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1617 
 
5527 anupam.sin 1618 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1619 
    """
1620 
    Parameters:
1621 
     - transactionId
1622 
     - status
1623 
     - description
5527 anupam.sin 1624 
     - pickUp
1625 
     - orderType
94 ashish 1626 
    """
5527 anupam.sin 1627 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1628 
    return self.recv_changeTransactionStatus()
1629 
 
5527 anupam.sin 1630 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1631 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1632 
    args = changeTransactionStatus_args()
1633 
    args.transactionId = transactionId
1634 
    args.status = status
1635 
    args.description = description
5527 anupam.sin 1636 
    args.pickUp = pickUp
1637 
    args.orderType = orderType
94 ashish 1638 
    args.write(self._oprot)
1639 
    self._oprot.writeMessageEnd()
1640 
    self._oprot.trans.flush()
1641 
 
1642 
  def recv_changeTransactionStatus(self, ):
1643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1644 
    if mtype == TMessageType.EXCEPTION:
1645 
      x = TApplicationException()
1646 
      x.read(self._iprot)
1647 
      self._iprot.readMessageEnd()
1648 
      raise x
1649 
    result = changeTransactionStatus_result()
1650 
    result.read(self._iprot)
1651 
    self._iprot.readMessageEnd()
3431 rajveer 1652 
    if result.success is not None:
94 ashish 1653 
      return result.success
3431 rajveer 1654 
    if result.ex is not None:
94 ashish 1655 
      raise result.ex
1656 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1657 
 
1398 varun.gupt 1658 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1659 
    """
1660 
    Parameters:
1661 
     - transactionId
1662 
    """
1398 varun.gupt 1663 
    self.send_enqueueTransactionInfoEmail(transactionId)
1664 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1665 
 
1398 varun.gupt 1666 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1667 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1668 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1669 
    args.transactionId = transactionId
1670 
    args.write(self._oprot)
1671 
    self._oprot.writeMessageEnd()
1672 
    self._oprot.trans.flush()
1673 
 
1398 varun.gupt 1674 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1675 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1676 
    if mtype == TMessageType.EXCEPTION:
1677 
      x = TApplicationException()
1678 
      x.read(self._iprot)
1679 
      self._iprot.readMessageEnd()
1680 
      raise x
1398 varun.gupt 1681 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1682 
    result.read(self._iprot)
1683 
    self._iprot.readMessageEnd()
3431 rajveer 1684 
    if result.success is not None:
1382 varun.gupt 1685 
      return result.success
3431 rajveer 1686 
    if result.ex is not None:
1382 varun.gupt 1687 
      raise result.ex
1398 varun.gupt 1688 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1689 
 
4801 anupam.sin 1690 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1691 
    """
1692 
    Parameters:
4801 anupam.sin 1693 
     - statuses
483 rajveer 1694 
     - from_date
1695 
     - to_date
1696 
     - warehouse_id
94 ashish 1697 
    """
4801 anupam.sin 1698 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1699 
    return self.recv_getAllOrders()
94 ashish 1700 
 
4801 anupam.sin 1701 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1702 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1703 
    args = getAllOrders_args()
4801 anupam.sin 1704 
    args.statuses = statuses
483 rajveer 1705 
    args.from_date = from_date
1706 
    args.to_date = to_date
1707 
    args.warehouse_id = warehouse_id
94 ashish 1708 
    args.write(self._oprot)
1709 
    self._oprot.writeMessageEnd()
1710 
    self._oprot.trans.flush()
1711 
 
483 rajveer 1712 
  def recv_getAllOrders(self, ):
94 ashish 1713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1714 
    if mtype == TMessageType.EXCEPTION:
1715 
      x = TApplicationException()
1716 
      x.read(self._iprot)
1717 
      self._iprot.readMessageEnd()
1718 
      raise x
483 rajveer 1719 
    result = getAllOrders_result()
94 ashish 1720 
    result.read(self._iprot)
1721 
    self._iprot.readMessageEnd()
3431 rajveer 1722 
    if result.success is not None:
94 ashish 1723 
      return result.success
3431 rajveer 1724 
    if result.ex is not None:
94 ashish 1725 
      raise result.ex
483 rajveer 1726 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1727 
 
4133 chandransh 1728 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1729 
    """
1730 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1731 
    Pass the status as null and the limit as 0 to ignore them.
1732 
 
1733 
    Parameters:
1734 
     - statuses
1735 
     - offset
1736 
     - limit
1737 
     - warehouse_id
1738 
    """
1739 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1740 
    return self.recv_getOrdersInBatch()
1741 
 
1742 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1743 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1744 
    args = getOrdersInBatch_args()
1745 
    args.statuses = statuses
1746 
    args.offset = offset
1747 
    args.limit = limit
1748 
    args.warehouse_id = warehouse_id
1749 
    args.write(self._oprot)
1750 
    self._oprot.writeMessageEnd()
1751 
    self._oprot.trans.flush()
1752 
 
1753 
  def recv_getOrdersInBatch(self, ):
1754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1755 
    if mtype == TMessageType.EXCEPTION:
1756 
      x = TApplicationException()
1757 
      x.read(self._iprot)
1758 
      self._iprot.readMessageEnd()
1759 
      raise x
1760 
    result = getOrdersInBatch_result()
1761 
    result.read(self._iprot)
1762 
    self._iprot.readMessageEnd()
1763 
    if result.success is not None:
1764 
      return result.success
1765 
    if result.ex is not None:
1766 
      raise result.ex
1767 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1768 
 
1769 
  def getOrderCount(self, statuses, warehouseId):
1770 
    """
1771 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1772 
 
1773 
    Parameters:
1774 
     - statuses
1775 
     - warehouseId
1776 
    """
1777 
    self.send_getOrderCount(statuses, warehouseId)
1778 
    return self.recv_getOrderCount()
1779 
 
1780 
  def send_getOrderCount(self, statuses, warehouseId):
1781 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1782 
    args = getOrderCount_args()
1783 
    args.statuses = statuses
1784 
    args.warehouseId = warehouseId
1785 
    args.write(self._oprot)
1786 
    self._oprot.writeMessageEnd()
1787 
    self._oprot.trans.flush()
1788 
 
1789 
  def recv_getOrderCount(self, ):
1790 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1791 
    if mtype == TMessageType.EXCEPTION:
1792 
      x = TApplicationException()
1793 
      x.read(self._iprot)
1794 
      self._iprot.readMessageEnd()
1795 
      raise x
1796 
    result = getOrderCount_result()
1797 
    result.read(self._iprot)
1798 
    self._iprot.readMessageEnd()
1799 
    if result.success is not None:
1800 
      return result.success
1801 
    if result.ex is not None:
1802 
      raise result.ex
1803 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1804 
 
999 varun.gupt 1805 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1806 
    """
1132 chandransh 1807 
    Returns orders within a range of their billing dates
3431 rajveer 1808 
 
999 varun.gupt 1809 
    Parameters:
1810 
     - status
1811 
     - start_billing_date
1812 
     - end_billing_date
1813 
     - warehouse_id
1814 
    """
1815 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1816 
    return self.recv_getOrdersByBillingDate()
1817 
 
1818 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1819 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1820 
    args = getOrdersByBillingDate_args()
1821 
    args.status = status
1822 
    args.start_billing_date = start_billing_date
1823 
    args.end_billing_date = end_billing_date
1824 
    args.warehouse_id = warehouse_id
1825 
    args.write(self._oprot)
1826 
    self._oprot.writeMessageEnd()
1827 
    self._oprot.trans.flush()
1828 
 
1829 
  def recv_getOrdersByBillingDate(self, ):
1830 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1831 
    if mtype == TMessageType.EXCEPTION:
1832 
      x = TApplicationException()
1833 
      x.read(self._iprot)
1834 
      self._iprot.readMessageEnd()
1835 
      raise x
1836 
    result = getOrdersByBillingDate_result()
1837 
    result.read(self._iprot)
1838 
    self._iprot.readMessageEnd()
3431 rajveer 1839 
    if result.success is not None:
999 varun.gupt 1840 
      return result.success
3431 rajveer 1841 
    if result.ex is not None:
999 varun.gupt 1842 
      raise result.ex
1843 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1844 
 
3451 chandransh 1845 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1846 
    """
1847 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1848 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1849 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1850 
 
3427 chandransh 1851 
    Parameters:
1852 
     - fromShippingDate
1853 
     - toShippingDate
1854 
     - providerId
1855 
     - warehouseId
3451 chandransh 1856 
     - cod
3427 chandransh 1857 
    """
3451 chandransh 1858 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1859 
    return self.recv_getOrdersByShippingDate()
1860 
 
3451 chandransh 1861 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1862 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1863 
    args = getOrdersByShippingDate_args()
1864 
    args.fromShippingDate = fromShippingDate
1865 
    args.toShippingDate = toShippingDate
1866 
    args.providerId = providerId
1867 
    args.warehouseId = warehouseId
3451 chandransh 1868 
    args.cod = cod
3427 chandransh 1869 
    args.write(self._oprot)
1870 
    self._oprot.writeMessageEnd()
1871 
    self._oprot.trans.flush()
1872 
 
1873 
  def recv_getOrdersByShippingDate(self, ):
1874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1875 
    if mtype == TMessageType.EXCEPTION:
1876 
      x = TApplicationException()
1877 
      x.read(self._iprot)
1878 
      self._iprot.readMessageEnd()
1879 
      raise x
1880 
    result = getOrdersByShippingDate_result()
1881 
    result.read(self._iprot)
1882 
    self._iprot.readMessageEnd()
3431 rajveer 1883 
    if result.success is not None:
3427 chandransh 1884 
      return result.success
3431 rajveer 1885 
    if result.ex is not None:
3427 chandransh 1886 
      raise result.ex
1887 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1888 
 
1382 varun.gupt 1889 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1890 
    """
1891 
    Returns order ids for orders which can be returned
3431 rajveer 1892 
 
1382 varun.gupt 1893 
    Parameters:
1894 
     - customer_id
1895 
     - limit
1896 
    """
1897 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1898 
    return self.recv_getReturnableOrdersForCustomer()
1899 
 
1900 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1901 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1902 
    args = getReturnableOrdersForCustomer_args()
1903 
    args.customer_id = customer_id
1904 
    args.limit = limit
1905 
    args.write(self._oprot)
1906 
    self._oprot.writeMessageEnd()
1907 
    self._oprot.trans.flush()
1908 
 
1909 
  def recv_getReturnableOrdersForCustomer(self, ):
1910 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1911 
    if mtype == TMessageType.EXCEPTION:
1912 
      x = TApplicationException()
1913 
      x.read(self._iprot)
1914 
      self._iprot.readMessageEnd()
1915 
      raise x
1916 
    result = getReturnableOrdersForCustomer_result()
1917 
    result.read(self._iprot)
1918 
    self._iprot.readMessageEnd()
3431 rajveer 1919 
    if result.success is not None:
1382 varun.gupt 1920 
      return result.success
3431 rajveer 1921 
    if result.ex is not None:
1382 varun.gupt 1922 
      raise result.ex
1923 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1924 
 
1925 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1926 
    """
1927 
    Returns order ids for orders which can be cancelled
3431 rajveer 1928 
 
1382 varun.gupt 1929 
    Parameters:
1930 
     - customer_id
1931 
     - limit
1932 
    """
1933 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1934 
    return self.recv_getCancellableOrdersForCustomer()
1935 
 
1936 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1937 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1938 
    args = getCancellableOrdersForCustomer_args()
1939 
    args.customer_id = customer_id
1940 
    args.limit = limit
1941 
    args.write(self._oprot)
1942 
    self._oprot.writeMessageEnd()
1943 
    self._oprot.trans.flush()
1944 
 
1945 
  def recv_getCancellableOrdersForCustomer(self, ):
1946 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1947 
    if mtype == TMessageType.EXCEPTION:
1948 
      x = TApplicationException()
1949 
      x.read(self._iprot)
1950 
      self._iprot.readMessageEnd()
1951 
      raise x
1952 
    result = getCancellableOrdersForCustomer_result()
1953 
    result.read(self._iprot)
1954 
    self._iprot.readMessageEnd()
3431 rajveer 1955 
    if result.success is not None:
1382 varun.gupt 1956 
      return result.success
3431 rajveer 1957 
    if result.ex is not None:
1382 varun.gupt 1958 
      raise result.ex
1959 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1960 
 
483 rajveer 1961 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1962 
    """
1963 
    Parameters:
483 rajveer 1964 
     - orderId
1965 
     - status
1966 
     - description
94 ashish 1967 
    """
483 rajveer 1968 
    self.send_changeOrderStatus(orderId, status, description)
1969 
    return self.recv_changeOrderStatus()
94 ashish 1970 
 
483 rajveer 1971 
  def send_changeOrderStatus(self, orderId, status, description):
1972 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1973 
    args = changeOrderStatus_args()
1974 
    args.orderId = orderId
1975 
    args.status = status
1976 
    args.description = description
94 ashish 1977 
    args.write(self._oprot)
1978 
    self._oprot.writeMessageEnd()
1979 
    self._oprot.trans.flush()
1980 
 
483 rajveer 1981 
  def recv_changeOrderStatus(self, ):
94 ashish 1982 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1983 
    if mtype == TMessageType.EXCEPTION:
1984 
      x = TApplicationException()
1985 
      x.read(self._iprot)
1986 
      self._iprot.readMessageEnd()
1987 
      raise x
483 rajveer 1988 
    result = changeOrderStatus_result()
94 ashish 1989 
    result.read(self._iprot)
1990 
    self._iprot.readMessageEnd()
3431 rajveer 1991 
    if result.success is not None:
94 ashish 1992 
      return result.success
3431 rajveer 1993 
    if result.ex is not None:
94 ashish 1994 
      raise result.ex
483 rajveer 1995 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 1996 
 
1528 ankur.sing 1997 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 1998 
    """
1528 ankur.sing 1999 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
2000 
    only user who owns the transaction can view its order details.
3431 rajveer 2001 
 
94 ashish 2002 
    Parameters:
2003 
     - transactionId
1528 ankur.sing 2004 
     - customerId
94 ashish 2005 
    """
1528 ankur.sing 2006 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2007 
    return self.recv_getOrdersForTransaction()
94 ashish 2008 
 
1528 ankur.sing 2009 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2010 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2011 
    args = getOrdersForTransaction_args()
94 ashish 2012 
    args.transactionId = transactionId
1528 ankur.sing 2013 
    args.customerId = customerId
94 ashish 2014 
    args.write(self._oprot)
2015 
    self._oprot.writeMessageEnd()
2016 
    self._oprot.trans.flush()
2017 
 
483 rajveer 2018 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2020 
    if mtype == TMessageType.EXCEPTION:
2021 
      x = TApplicationException()
2022 
      x.read(self._iprot)
2023 
      self._iprot.readMessageEnd()
2024 
      raise x
483 rajveer 2025 
    result = getOrdersForTransaction_result()
94 ashish 2026 
    result.read(self._iprot)
2027 
    self._iprot.readMessageEnd()
3431 rajveer 2028 
    if result.success is not None:
94 ashish 2029 
      return result.success
3431 rajveer 2030 
    if result.ex is not None:
94 ashish 2031 
      raise result.ex
483 rajveer 2032 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2033 
 
3014 chandransh 2034 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2035 
    """
3014 chandransh 2036 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2037 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2038 
 
94 ashish 2039 
    Parameters:
483 rajveer 2040 
     - customerId
2041 
     - from_date
2042 
     - to_date
3014 chandransh 2043 
     - statuses
94 ashish 2044 
    """
3014 chandransh 2045 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2046 
    return self.recv_getOrdersForCustomer()
94 ashish 2047 
 
3014 chandransh 2048 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2049 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2050 
    args = getOrdersForCustomer_args()
2051 
    args.customerId = customerId
2052 
    args.from_date = from_date
2053 
    args.to_date = to_date
3014 chandransh 2054 
    args.statuses = statuses
94 ashish 2055 
    args.write(self._oprot)
2056 
    self._oprot.writeMessageEnd()
2057 
    self._oprot.trans.flush()
2058 
 
483 rajveer 2059 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2060 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2061 
    if mtype == TMessageType.EXCEPTION:
2062 
      x = TApplicationException()
2063 
      x.read(self._iprot)
2064 
      self._iprot.readMessageEnd()
2065 
      raise x
483 rajveer 2066 
    result = getOrdersForCustomer_result()
94 ashish 2067 
    result.read(self._iprot)
2068 
    self._iprot.readMessageEnd()
3431 rajveer 2069 
    if result.success is not None:
94 ashish 2070 
      return result.success
3431 rajveer 2071 
    if result.ex is not None:
94 ashish 2072 
      raise result.ex
483 rajveer 2073 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2074 
 
483 rajveer 2075 
  def createOrder(self, order):
94 ashish 2076 
    """
2077 
    Parameters:
483 rajveer 2078 
     - order
94 ashish 2079 
    """
483 rajveer 2080 
    self.send_createOrder(order)
2081 
    return self.recv_createOrder()
94 ashish 2082 
 
483 rajveer 2083 
  def send_createOrder(self, order):
2084 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2085 
    args = createOrder_args()
2086 
    args.order = order
94 ashish 2087 
    args.write(self._oprot)
2088 
    self._oprot.writeMessageEnd()
2089 
    self._oprot.trans.flush()
2090 
 
483 rajveer 2091 
  def recv_createOrder(self, ):
94 ashish 2092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2093 
    if mtype == TMessageType.EXCEPTION:
2094 
      x = TApplicationException()
2095 
      x.read(self._iprot)
2096 
      self._iprot.readMessageEnd()
2097 
      raise x
483 rajveer 2098 
    result = createOrder_result()
94 ashish 2099 
    result.read(self._iprot)
2100 
    self._iprot.readMessageEnd()
3431 rajveer 2101 
    if result.success is not None:
94 ashish 2102 
      return result.success
3431 rajveer 2103 
    if result.ex is not None:
94 ashish 2104 
      raise result.ex
483 rajveer 2105 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2106 
 
483 rajveer 2107 
  def getOrder(self, id):
94 ashish 2108 
    """
2109 
    Parameters:
483 rajveer 2110 
     - id
94 ashish 2111 
    """
483 rajveer 2112 
    self.send_getOrder(id)
2113 
    return self.recv_getOrder()
94 ashish 2114 
 
483 rajveer 2115 
  def send_getOrder(self, id):
2116 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2117 
    args = getOrder_args()
2118 
    args.id = id
94 ashish 2119 
    args.write(self._oprot)
2120 
    self._oprot.writeMessageEnd()
2121 
    self._oprot.trans.flush()
2122 
 
483 rajveer 2123 
  def recv_getOrder(self, ):
94 ashish 2124 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2125 
    if mtype == TMessageType.EXCEPTION:
2126 
      x = TApplicationException()
2127 
      x.read(self._iprot)
2128 
      self._iprot.readMessageEnd()
2129 
      raise x
483 rajveer 2130 
    result = getOrder_result()
94 ashish 2131 
    result.read(self._iprot)
2132 
    self._iprot.readMessageEnd()
3431 rajveer 2133 
    if result.success is not None:
94 ashish 2134 
      return result.success
3431 rajveer 2135 
    if result.ex is not None:
94 ashish 2136 
      raise result.ex
483 rajveer 2137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2138 
 
483 rajveer 2139 
  def getLineItemsForOrder(self, orderId):
94 ashish 2140 
    """
2141 
    Parameters:
483 rajveer 2142 
     - orderId
94 ashish 2143 
    """
483 rajveer 2144 
    self.send_getLineItemsForOrder(orderId)
2145 
    return self.recv_getLineItemsForOrder()
94 ashish 2146 
 
483 rajveer 2147 
  def send_getLineItemsForOrder(self, orderId):
2148 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2149 
    args = getLineItemsForOrder_args()
2150 
    args.orderId = orderId
94 ashish 2151 
    args.write(self._oprot)
2152 
    self._oprot.writeMessageEnd()
2153 
    self._oprot.trans.flush()
2154 
 
483 rajveer 2155 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2156 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2157 
    if mtype == TMessageType.EXCEPTION:
2158 
      x = TApplicationException()
2159 
      x.read(self._iprot)
2160 
      self._iprot.readMessageEnd()
2161 
      raise x
483 rajveer 2162 
    result = getLineItemsForOrder_result()
94 ashish 2163 
    result.read(self._iprot)
2164 
    self._iprot.readMessageEnd()
3431 rajveer 2165 
    if result.success is not None:
94 ashish 2166 
      return result.success
3431 rajveer 2167 
    if result.ex is not None:
94 ashish 2168 
      raise result.ex
483 rajveer 2169 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2170 
 
4999 phani.kuma 2171 
  def getOrderList(self, order_ids):
2172 
    """
2173 
    Parameters:
2174 
     - order_ids
2175 
    """
2176 
    self.send_getOrderList(order_ids)
2177 
    return self.recv_getOrderList()
2178 
 
2179 
  def send_getOrderList(self, order_ids):
2180 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2181 
    args = getOrderList_args()
2182 
    args.order_ids = order_ids
2183 
    args.write(self._oprot)
2184 
    self._oprot.writeMessageEnd()
2185 
    self._oprot.trans.flush()
2186 
 
2187 
  def recv_getOrderList(self, ):
2188 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2189 
    if mtype == TMessageType.EXCEPTION:
2190 
      x = TApplicationException()
2191 
      x.read(self._iprot)
2192 
      self._iprot.readMessageEnd()
2193 
      raise x
2194 
    result = getOrderList_result()
2195 
    result.read(self._iprot)
2196 
    self._iprot.readMessageEnd()
2197 
    if result.success is not None:
2198 
      return result.success
2199 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2200 
 
5386 phani.kuma 2201 
  def getOrderListForVendor(self, order_ids, vendorId):
2202 
    """
2203 
    Parameters:
2204 
     - order_ids
2205 
     - vendorId
2206 
    """
2207 
    self.send_getOrderListForVendor(order_ids, vendorId)
2208 
    return self.recv_getOrderListForVendor()
2209 
 
2210 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2211 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2212 
    args = getOrderListForVendor_args()
2213 
    args.order_ids = order_ids
2214 
    args.vendorId = vendorId
2215 
    args.write(self._oprot)
2216 
    self._oprot.writeMessageEnd()
2217 
    self._oprot.trans.flush()
2218 
 
2219 
  def recv_getOrderListForVendor(self, ):
2220 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2221 
    if mtype == TMessageType.EXCEPTION:
2222 
      x = TApplicationException()
2223 
      x.read(self._iprot)
2224 
      self._iprot.readMessageEnd()
2225 
      raise x
2226 
    result = getOrderListForVendor_result()
2227 
    result.read(self._iprot)
2228 
    self._iprot.readMessageEnd()
2229 
    if result.success is not None:
2230 
      return result.success
2231 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2232 
 
1528 ankur.sing 2233 
  def getOrderForCustomer(self, orderId, customerId):
2234 
    """
2235 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2236 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2237 
 
1528 ankur.sing 2238 
    Parameters:
2239 
     - orderId
2240 
     - customerId
2241 
    """
2242 
    self.send_getOrderForCustomer(orderId, customerId)
2243 
    return self.recv_getOrderForCustomer()
2244 
 
2245 
  def send_getOrderForCustomer(self, orderId, customerId):
2246 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2247 
    args = getOrderForCustomer_args()
2248 
    args.orderId = orderId
2249 
    args.customerId = customerId
2250 
    args.write(self._oprot)
2251 
    self._oprot.writeMessageEnd()
2252 
    self._oprot.trans.flush()
2253 
 
2254 
  def recv_getOrderForCustomer(self, ):
2255 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2256 
    if mtype == TMessageType.EXCEPTION:
2257 
      x = TApplicationException()
2258 
      x.read(self._iprot)
2259 
      self._iprot.readMessageEnd()
2260 
      raise x
2261 
    result = getOrderForCustomer_result()
2262 
    result.read(self._iprot)
2263 
    self._iprot.readMessageEnd()
3431 rajveer 2264 
    if result.success is not None:
1528 ankur.sing 2265 
      return result.success
3431 rajveer 2266 
    if result.ex is not None:
1528 ankur.sing 2267 
      raise result.ex
2268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2269 
 
4444 rajveer 2270 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2271 
    """
2272 
    Parameters:
4394 rajveer 2273 
     - type
4444 rajveer 2274 
     - warehouseId
4394 rajveer 2275 
     - status
2276 
     - timestamp
3064 chandransh 2277 
    """
4444 rajveer 2278 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2279 
    return self.recv_getAlerts()
2280 
 
4444 rajveer 2281 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2282 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2283 
    args = getAlerts_args()
4394 rajveer 2284 
    args.type = type
4444 rajveer 2285 
    args.warehouseId = warehouseId
4394 rajveer 2286 
    args.status = status
2287 
    args.timestamp = timestamp
3064 chandransh 2288 
    args.write(self._oprot)
2289 
    self._oprot.writeMessageEnd()
2290 
    self._oprot.trans.flush()
2291 
 
2292 
  def recv_getAlerts(self, ):
2293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2294 
    if mtype == TMessageType.EXCEPTION:
2295 
      x = TApplicationException()
2296 
      x.read(self._iprot)
2297 
      self._iprot.readMessageEnd()
2298 
      raise x
2299 
    result = getAlerts_result()
2300 
    result.read(self._iprot)
2301 
    self._iprot.readMessageEnd()
3431 rajveer 2302 
    if result.success is not None:
3064 chandransh 2303 
      return result.success
2304 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2305 
 
4444 rajveer 2306 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2307 
    """
2308 
    Parameters:
2309 
     - type
4444 rajveer 2310 
     - warehouseId
4394 rajveer 2311 
     - description
3064 chandransh 2312 
    """
4444 rajveer 2313 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2314 
    self.recv_addAlert()
3064 chandransh 2315 
 
4444 rajveer 2316 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2317 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2318 
    args = addAlert_args()
3064 chandransh 2319 
    args.type = type
4444 rajveer 2320 
    args.warehouseId = warehouseId
4394 rajveer 2321 
    args.description = description
3064 chandransh 2322 
    args.write(self._oprot)
2323 
    self._oprot.writeMessageEnd()
2324 
    self._oprot.trans.flush()
2325 
 
4394 rajveer 2326 
  def recv_addAlert(self, ):
3064 chandransh 2327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2328 
    if mtype == TMessageType.EXCEPTION:
2329 
      x = TApplicationException()
2330 
      x.read(self._iprot)
2331 
      self._iprot.readMessageEnd()
2332 
      raise x
4394 rajveer 2333 
    result = addAlert_result()
3064 chandransh 2334 
    result.read(self._iprot)
2335 
    self._iprot.readMessageEnd()
2336 
    return
2337 
 
4444 rajveer 2338 
  def markAlertsAsSeen(self, warehouseId):
2339 
    """
2340 
    Parameters:
2341 
     - warehouseId
2342 
    """
2343 
    self.send_markAlertsAsSeen(warehouseId)
2344 
    self.recv_markAlertsAsSeen()
2345 
 
2346 
  def send_markAlertsAsSeen(self, warehouseId):
2347 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2348 
    args = markAlertsAsSeen_args()
2349 
    args.warehouseId = warehouseId
2350 
    args.write(self._oprot)
2351 
    self._oprot.writeMessageEnd()
2352 
    self._oprot.trans.flush()
2353 
 
2354 
  def recv_markAlertsAsSeen(self, ):
2355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2356 
    if mtype == TMessageType.EXCEPTION:
2357 
      x = TApplicationException()
2358 
      x.read(self._iprot)
2359 
      self._iprot.readMessageEnd()
2360 
      raise x
2361 
    result = markAlertsAsSeen_result()
2362 
    result.read(self._iprot)
2363 
    self._iprot.readMessageEnd()
2364 
    return
2365 
 
3064 chandransh 2366 
  def getValidOrderCount(self, ):
2367 
    """
2368 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2369 
    """
2370 
    self.send_getValidOrderCount()
2371 
    return self.recv_getValidOrderCount()
2372 
 
2373 
  def send_getValidOrderCount(self, ):
2374 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2375 
    args = getValidOrderCount_args()
2376 
    args.write(self._oprot)
2377 
    self._oprot.writeMessageEnd()
2378 
    self._oprot.trans.flush()
2379 
 
2380 
  def recv_getValidOrderCount(self, ):
2381 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2382 
    if mtype == TMessageType.EXCEPTION:
2383 
      x = TApplicationException()
2384 
      x.read(self._iprot)
2385 
      self._iprot.readMessageEnd()
2386 
      raise x
2387 
    result = getValidOrderCount_result()
2388 
    result.read(self._iprot)
2389 
    self._iprot.readMessageEnd()
3431 rajveer 2390 
    if result.success is not None:
3064 chandransh 2391 
      return result.success
2392 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2393 
 
2394 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2395 
    """
2396 
    Returns the number of distinct customers who have done successful transactions
2397 
    """
2398 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2399 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2400 
 
2401 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2402 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2403 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2404 
    args.write(self._oprot)
2405 
    self._oprot.writeMessageEnd()
2406 
    self._oprot.trans.flush()
2407 
 
2408 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2409 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2410 
    if mtype == TMessageType.EXCEPTION:
2411 
      x = TApplicationException()
2412 
      x.read(self._iprot)
2413 
      self._iprot.readMessageEnd()
2414 
      raise x
2415 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2416 
    result.read(self._iprot)
2417 
    self._iprot.readMessageEnd()
3431 rajveer 2418 
    if result.success is not None:
3064 chandransh 2419 
      return result.success
2420 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2421 
 
2422 
  def getValidOrdersAmountRange(self, ):
2423 
    """
2424 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2425 
    List contains two values, first minimum amount and second maximum amount.
2426 
    """
2427 
    self.send_getValidOrdersAmountRange()
2428 
    return self.recv_getValidOrdersAmountRange()
2429 
 
2430 
  def send_getValidOrdersAmountRange(self, ):
2431 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2432 
    args = getValidOrdersAmountRange_args()
2433 
    args.write(self._oprot)
2434 
    self._oprot.writeMessageEnd()
2435 
    self._oprot.trans.flush()
2436 
 
2437 
  def recv_getValidOrdersAmountRange(self, ):
2438 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2439 
    if mtype == TMessageType.EXCEPTION:
2440 
      x = TApplicationException()
2441 
      x.read(self._iprot)
2442 
      self._iprot.readMessageEnd()
2443 
      raise x
2444 
    result = getValidOrdersAmountRange_result()
2445 
    result.read(self._iprot)
2446 
    self._iprot.readMessageEnd()
3431 rajveer 2447 
    if result.success is not None:
3064 chandransh 2448 
      return result.success
2449 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2450 
 
5874 rajveer 2451 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2452 
    """
2453 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2454 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2455 
 
3064 chandransh 2456 
    Parameters:
2457 
     - limit
5874 rajveer 2458 
     - onlyStore
3064 chandransh 2459 
    """
5874 rajveer 2460 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2461 
    return self.recv_getValidOrders()
2462 
 
5874 rajveer 2463 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2464 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2465 
    args = getValidOrders_args()
2466 
    args.limit = limit
5874 rajveer 2467 
    args.onlyStore = onlyStore
3064 chandransh 2468 
    args.write(self._oprot)
2469 
    self._oprot.writeMessageEnd()
2470 
    self._oprot.trans.flush()
2471 
 
2472 
  def recv_getValidOrders(self, ):
2473 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2474 
    if mtype == TMessageType.EXCEPTION:
2475 
      x = TApplicationException()
2476 
      x.read(self._iprot)
2477 
      self._iprot.readMessageEnd()
2478 
      raise x
2479 
    result = getValidOrders_result()
2480 
    result.read(self._iprot)
2481 
    self._iprot.readMessageEnd()
3431 rajveer 2482 
    if result.success is not None:
3064 chandransh 2483 
      return result.success
2484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2485 
 
1220 chandransh 2486 
  def batchOrders(self, warehouseId):
2487 
    """
2488 
    Create a batch of all the pending orders for the given warehouse.
2489 
    The returned list is orderd by created_timestamp.
2490 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2491 
 
1220 chandransh 2492 
    Parameters:
2493 
     - warehouseId
2494 
    """
2495 
    self.send_batchOrders(warehouseId)
2496 
    return self.recv_batchOrders()
2497 
 
2498 
  def send_batchOrders(self, warehouseId):
2499 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2500 
    args = batchOrders_args()
2501 
    args.warehouseId = warehouseId
2502 
    args.write(self._oprot)
2503 
    self._oprot.writeMessageEnd()
2504 
    self._oprot.trans.flush()
2505 
 
2506 
  def recv_batchOrders(self, ):
2507 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2508 
    if mtype == TMessageType.EXCEPTION:
2509 
      x = TApplicationException()
2510 
      x.read(self._iprot)
2511 
      self._iprot.readMessageEnd()
2512 
      raise x
2513 
    result = batchOrders_result()
2514 
    result.read(self._iprot)
2515 
    self._iprot.readMessageEnd()
3431 rajveer 2516 
    if result.success is not None:
1220 chandransh 2517 
      return result.success
3431 rajveer 2518 
    if result.ex is not None:
1220 chandransh 2519 
      raise result.ex
2520 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2521 
 
1208 chandransh 2522 
  def markOrderAsOutOfStock(self, orderId):
2523 
    """
2524 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2525 
 
1208 chandransh 2526 
    Parameters:
2527 
     - orderId
2528 
    """
2529 
    self.send_markOrderAsOutOfStock(orderId)
2530 
    return self.recv_markOrderAsOutOfStock()
2531 
 
2532 
  def send_markOrderAsOutOfStock(self, orderId):
2533 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2534 
    args = markOrderAsOutOfStock_args()
2535 
    args.orderId = orderId
2536 
    args.write(self._oprot)
2537 
    self._oprot.writeMessageEnd()
2538 
    self._oprot.trans.flush()
2539 
 
2540 
  def recv_markOrderAsOutOfStock(self, ):
2541 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2542 
    if mtype == TMessageType.EXCEPTION:
2543 
      x = TApplicationException()
2544 
      x.read(self._iprot)
2545 
      self._iprot.readMessageEnd()
2546 
      raise x
2547 
    result = markOrderAsOutOfStock_result()
2548 
    result.read(self._iprot)
2549 
    self._iprot.readMessageEnd()
3431 rajveer 2550 
    if result.success is not None:
1208 chandransh 2551 
      return result.success
3431 rajveer 2552 
    if result.ex is not None:
1208 chandransh 2553 
      raise result.ex
2554 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2555 
 
3064 chandransh 2556 
  def verifyOrder(self, orderId):
759 chandransh 2557 
    """
3064 chandransh 2558 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2559 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2560 
    used for all other orders as well.
2561 
    Throws an exception if no such order exists.
3431 rajveer 2562 
 
759 chandransh 2563 
    Parameters:
3064 chandransh 2564 
     - orderId
759 chandransh 2565 
    """
3064 chandransh 2566 
    self.send_verifyOrder(orderId)
2567 
    return self.recv_verifyOrder()
759 chandransh 2568 
 
3064 chandransh 2569 
  def send_verifyOrder(self, orderId):
2570 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2571 
    args = verifyOrder_args()
2572 
    args.orderId = orderId
759 chandransh 2573 
    args.write(self._oprot)
2574 
    self._oprot.writeMessageEnd()
2575 
    self._oprot.trans.flush()
2576 
 
3064 chandransh 2577 
  def recv_verifyOrder(self, ):
759 chandransh 2578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2579 
    if mtype == TMessageType.EXCEPTION:
2580 
      x = TApplicationException()
2581 
      x.read(self._iprot)
2582 
      self._iprot.readMessageEnd()
2583 
      raise x
3064 chandransh 2584 
    result = verifyOrder_result()
759 chandransh 2585 
    result.read(self._iprot)
2586 
    self._iprot.readMessageEnd()
3431 rajveer 2587 
    if result.success is not None:
759 chandransh 2588 
      return result.success
3431 rajveer 2589 
    if result.ex is not None:
759 chandransh 2590 
      raise result.ex
3064 chandransh 2591 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2592 
 
3064 chandransh 2593 
  def acceptOrder(self, orderId):
1113 chandransh 2594 
    """
3064 chandransh 2595 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2596 
    given order is not a COD order, it also captures the payment if the same has
2597 
    not been captured.
2598 
    Throws an exception if no such order exists.
3431 rajveer 2599 
 
1113 chandransh 2600 
    Parameters:
3064 chandransh 2601 
     - orderId
1113 chandransh 2602 
    """
3064 chandransh 2603 
    self.send_acceptOrder(orderId)
2604 
    return self.recv_acceptOrder()
1113 chandransh 2605 
 
3064 chandransh 2606 
  def send_acceptOrder(self, orderId):
2607 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2608 
    args = acceptOrder_args()
2609 
    args.orderId = orderId
1113 chandransh 2610 
    args.write(self._oprot)
2611 
    self._oprot.writeMessageEnd()
2612 
    self._oprot.trans.flush()
2613 
 
3064 chandransh 2614 
  def recv_acceptOrder(self, ):
1113 chandransh 2615 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2616 
    if mtype == TMessageType.EXCEPTION:
2617 
      x = TApplicationException()
2618 
      x.read(self._iprot)
2619 
      self._iprot.readMessageEnd()
2620 
      raise x
3064 chandransh 2621 
    result = acceptOrder_result()
1113 chandransh 2622 
    result.read(self._iprot)
2623 
    self._iprot.readMessageEnd()
3431 rajveer 2624 
    if result.success is not None:
1113 chandransh 2625 
      return result.success
3431 rajveer 2626 
    if result.ex is not None:
1113 chandransh 2627 
      raise result.ex
3064 chandransh 2628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2629 
 
5110 mandeep.dh 2630 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2631 
    """
3064 chandransh 2632 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2633 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2634 
    the IMEI no. if a -1 is supplied.
2635 
    Also, it generates an invoice number for the order, marks the order as
2636 
    BILLED and sets the billing timestamp.
2637 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2638 
 
1135 chandransh 2639 
    Parameters:
3064 chandransh 2640 
     - orderId
2641 
     - invoice_number
4658 mandeep.dh 2642 
     - serialNumber
4283 anupam.sin 2643 
     - itemNumber
3064 chandransh 2644 
     - billed_by
4264 rajveer 2645 
     - jacketNumber
4283 anupam.sin 2646 
     - billingType
5110 mandeep.dh 2647 
     - fulfilmentWarehouseId
4763 rajveer 2648 
     - authorize
1135 chandransh 2649 
    """
5110 mandeep.dh 2650 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2651 
    return self.recv_addBillingDetails()
1135 chandransh 2652 
 
5110 mandeep.dh 2653 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2654 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2655 
    args = addBillingDetails_args()
2656 
    args.orderId = orderId
2657 
    args.invoice_number = invoice_number
4658 mandeep.dh 2658 
    args.serialNumber = serialNumber
4283 anupam.sin 2659 
    args.itemNumber = itemNumber
3064 chandransh 2660 
    args.billed_by = billed_by
4264 rajveer 2661 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2662 
    args.billingType = billingType
5110 mandeep.dh 2663 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2664 
    args.authorize = authorize
1135 chandransh 2665 
    args.write(self._oprot)
2666 
    self._oprot.writeMessageEnd()
2667 
    self._oprot.trans.flush()
2668 
 
3064 chandransh 2669 
  def recv_addBillingDetails(self, ):
1135 chandransh 2670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2671 
    if mtype == TMessageType.EXCEPTION:
2672 
      x = TApplicationException()
2673 
      x.read(self._iprot)
2674 
      self._iprot.readMessageEnd()
2675 
      raise x
3064 chandransh 2676 
    result = addBillingDetails_result()
1135 chandransh 2677 
    result.read(self._iprot)
2678 
    self._iprot.readMessageEnd()
3431 rajveer 2679 
    if result.success is not None:
3064 chandransh 2680 
      return result.success
3431 rajveer 2681 
    if result.ex is not None:
1135 chandransh 2682 
      raise result.ex
3064 chandransh 2683 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2684 
 
6756 amar.kumar 2685 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2686 
    """
2687 
    Add the invoice number to the order.
2688 
 
2689 
    Parameters:
2690 
     - orderId
2691 
     - invoiceNumber
4763 rajveer 2692 
     - color
6756 amar.kumar 2693 
     - serialNumber
2694 
     - itemNumber
4579 rajveer 2695 
    """
6756 amar.kumar 2696 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color, serialNumber, itemNumber)
4579 rajveer 2697 
    self.recv_addInvoiceNumber()
2698 
 
6756 amar.kumar 2699 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2700 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2701 
    args = addInvoiceNumber_args()
2702 
    args.orderId = orderId
2703 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2704 
    args.color = color
6756 amar.kumar 2705 
    args.serialNumber = serialNumber
2706 
    args.itemNumber = itemNumber
4579 rajveer 2707 
    args.write(self._oprot)
2708 
    self._oprot.writeMessageEnd()
2709 
    self._oprot.trans.flush()
2710 
 
2711 
  def recv_addInvoiceNumber(self, ):
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
2718 
    result = addInvoiceNumber_result()
2719 
    result.read(self._iprot)
2720 
    self._iprot.readMessageEnd()
2721 
    if result.ex is not None:
2722 
      raise result.ex
2723 
    return
2724 
 
4910 phani.kuma 2725 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2726 
    """
3064 chandransh 2727 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2728 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2729 
 
1408 ankur.sing 2730 
    Parameters:
3064 chandransh 2731 
     - warehouseId
1408 ankur.sing 2732 
     - providerId
3064 chandransh 2733 
     - cod
4910 phani.kuma 2734 
     - orderIds
1408 ankur.sing 2735 
    """
4910 phani.kuma 2736 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2737 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2738 
 
4910 phani.kuma 2739 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2740 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2741 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2742 
    args.warehouseId = warehouseId
1408 ankur.sing 2743 
    args.providerId = providerId
3064 chandransh 2744 
    args.cod = cod
4910 phani.kuma 2745 
    args.orderIds = orderIds
1408 ankur.sing 2746 
    args.write(self._oprot)
2747 
    self._oprot.writeMessageEnd()
2748 
    self._oprot.trans.flush()
2749 
 
4910 phani.kuma 2750 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2751 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2752 
    if mtype == TMessageType.EXCEPTION:
2753 
      x = TApplicationException()
2754 
      x.read(self._iprot)
2755 
      self._iprot.readMessageEnd()
2756 
      raise x
4910 phani.kuma 2757 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2758 
    result.read(self._iprot)
2759 
    self._iprot.readMessageEnd()
3431 rajveer 2760 
    if result.success is not None:
1408 ankur.sing 2761 
      return result.success
3431 rajveer 2762 
    if result.ex is not None:
3064 chandransh 2763 
      raise result.ex
4910 phani.kuma 2764 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2765 
 
5713 rajveer 2766 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2767 
    """
2768 
    Parameters:
2769 
     - providerId
2770 
     - orderIds
5713 rajveer 2771 
     - awbs
5676 rajveer 2772 
    """
5713 rajveer 2773 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2774 
    return self.recv_markOrdersAsReturnedFromStore()
2775 
 
5713 rajveer 2776 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2777 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2778 
    args = markOrdersAsReturnedFromStore_args()
2779 
    args.providerId = providerId
2780 
    args.orderIds = orderIds
5713 rajveer 2781 
    args.awbs = awbs
5676 rajveer 2782 
    args.write(self._oprot)
2783 
    self._oprot.writeMessageEnd()
2784 
    self._oprot.trans.flush()
2785 
 
2786 
  def recv_markOrdersAsReturnedFromStore(self, ):
2787 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2788 
    if mtype == TMessageType.EXCEPTION:
2789 
      x = TApplicationException()
2790 
      x.read(self._iprot)
2791 
      self._iprot.readMessageEnd()
2792 
      raise x
2793 
    result = markOrdersAsReturnedFromStore_result()
2794 
    result.read(self._iprot)
2795 
    self._iprot.readMessageEnd()
2796 
    if result.success is not None:
2797 
      return result.success
2798 
    if result.ex is not None:
2799 
      raise result.ex
2800 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2801 
 
4910 phani.kuma 2802 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2803 
    """
4910 phani.kuma 2804 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2805 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2806 
 
2807 
    Parameters:
2808 
     - providerId
4910 phani.kuma 2809 
     - pickupDetails
4410 rajveer 2810 
    """
4910 phani.kuma 2811 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2812 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2813 
 
4910 phani.kuma 2814 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2815 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2816 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2817 
    args.providerId = providerId
4910 phani.kuma 2818 
    args.pickupDetails = pickupDetails
4410 rajveer 2819 
    args.write(self._oprot)
2820 
    self._oprot.writeMessageEnd()
2821 
    self._oprot.trans.flush()
2822 
 
4910 phani.kuma 2823 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2824 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2825 
    if mtype == TMessageType.EXCEPTION:
2826 
      x = TApplicationException()
2827 
      x.read(self._iprot)
2828 
      self._iprot.readMessageEnd()
2829 
      raise x
4910 phani.kuma 2830 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2831 
    result.read(self._iprot)
2832 
    self._iprot.readMessageEnd()
2833 
    if result.ex is not None:
2834 
      raise result.ex
4910 phani.kuma 2835 
    return
4410 rajveer 2836 
 
4910 phani.kuma 2837 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2838 
    """
3064 chandransh 2839 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2840 
 
94 ashish 2841 
    Parameters:
3064 chandransh 2842 
     - providerId
304 ashish 2843 
    """
4910 phani.kuma 2844 
    self.send_getOrdersNotPickedUp(providerId)
2845 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2846 
 
4910 phani.kuma 2847 
  def send_getOrdersNotPickedUp(self, providerId):
2848 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2849 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2850 
    args.providerId = providerId
304 ashish 2851 
    args.write(self._oprot)
2852 
    self._oprot.writeMessageEnd()
2853 
    self._oprot.trans.flush()
2854 
 
4910 phani.kuma 2855 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2856 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2857 
    if mtype == TMessageType.EXCEPTION:
2858 
      x = TApplicationException()
2859 
      x.read(self._iprot)
2860 
      self._iprot.readMessageEnd()
2861 
      raise x
4910 phani.kuma 2862 
    result = getOrdersNotPickedUp_result()
304 ashish 2863 
    result.read(self._iprot)
2864 
    self._iprot.readMessageEnd()
3431 rajveer 2865 
    if result.success is not None:
304 ashish 2866 
      return result.success
4910 phani.kuma 2867 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2868 
 
3064 chandransh 2869 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2870 
    """
3064 chandransh 2871 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2872 
    the name of the receiver.
2873 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2874 
 
304 ashish 2875 
    Parameters:
3064 chandransh 2876 
     - providerId
2877 
     - deliveredOrders
304 ashish 2878 
    """
3064 chandransh 2879 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2880 
    self.recv_markOrdersAsDelivered()
304 ashish 2881 
 
3064 chandransh 2882 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2883 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2884 
    args = markOrdersAsDelivered_args()
2885 
    args.providerId = providerId
2886 
    args.deliveredOrders = deliveredOrders
304 ashish 2887 
    args.write(self._oprot)
2888 
    self._oprot.writeMessageEnd()
2889 
    self._oprot.trans.flush()
2890 
 
3064 chandransh 2891 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2893 
    if mtype == TMessageType.EXCEPTION:
2894 
      x = TApplicationException()
2895 
      x.read(self._iprot)
2896 
      self._iprot.readMessageEnd()
2897 
      raise x
3064 chandransh 2898 
    result = markOrdersAsDelivered_result()
304 ashish 2899 
    result.read(self._iprot)
2900 
    self._iprot.readMessageEnd()
3431 rajveer 2901 
    if result.ex is not None:
3064 chandransh 2902 
      raise result.ex
304 ashish 2903 
    return
2904 
 
4910 phani.kuma 2905 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2906 
    """
4910 phani.kuma 2907 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2908 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2909 
 
3064 chandransh 2910 
    Parameters:
2911 
     - providerId
2912 
     - returnedOrders
1596 ankur.sing 2913 
    """
4910 phani.kuma 2914 
    self.send_markAsRTOrders(providerId, returnedOrders)
2915 
    self.recv_markAsRTOrders()
304 ashish 2916 
 
4910 phani.kuma 2917 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2918 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2919 
    args = markAsRTOrders_args()
3064 chandransh 2920 
    args.providerId = providerId
2921 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2922 
    args.write(self._oprot)
2923 
    self._oprot.writeMessageEnd()
2924 
    self._oprot.trans.flush()
2925 
 
4910 phani.kuma 2926 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2928 
    if mtype == TMessageType.EXCEPTION:
2929 
      x = TApplicationException()
2930 
      x.read(self._iprot)
2931 
      self._iprot.readMessageEnd()
2932 
      raise x
4910 phani.kuma 2933 
    result = markAsRTOrders_result()
1596 ankur.sing 2934 
    result.read(self._iprot)
2935 
    self._iprot.readMessageEnd()
3431 rajveer 2936 
    if result.ex is not None:
3064 chandransh 2937 
      raise result.ex
2938 
    return
1596 ankur.sing 2939 
 
4910 phani.kuma 2940 
  def getRTOrders(self, providerId):
2941 
    """
2942 
    Returns a list of orders that were returned by courier.
2943 
 
2944 
    Parameters:
2945 
     - providerId
2946 
    """
2947 
    self.send_getRTOrders(providerId)
2948 
    return self.recv_getRTOrders()
2949 
 
2950 
  def send_getRTOrders(self, providerId):
2951 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2952 
    args = getRTOrders_args()
2953 
    args.providerId = providerId
2954 
    args.write(self._oprot)
2955 
    self._oprot.writeMessageEnd()
2956 
    self._oprot.trans.flush()
2957 
 
2958 
  def recv_getRTOrders(self, ):
2959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2960 
    if mtype == TMessageType.EXCEPTION:
2961 
      x = TApplicationException()
2962 
      x.read(self._iprot)
2963 
      self._iprot.readMessageEnd()
2964 
      raise x
2965 
    result = getRTOrders_result()
2966 
    result.read(self._iprot)
2967 
    self._iprot.readMessageEnd()
2968 
    if result.success is not None:
2969 
      return result.success
2970 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2971 
 
3064 chandransh 2972 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2973 
    """
3064 chandransh 2974 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2975 
 
3064 chandransh 2976 
    Parameters:
2977 
     - providerId
2978 
     - undeliveredOrders
1627 ankur.sing 2979 
    """
3064 chandransh 2980 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2981 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2982 
 
3064 chandransh 2983 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
2984 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
2985 
    args = updateNonDeliveryReason_args()
2986 
    args.providerId = providerId
2987 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 2988 
    args.write(self._oprot)
2989 
    self._oprot.writeMessageEnd()
2990 
    self._oprot.trans.flush()
2991 
 
3064 chandransh 2992 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 2993 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2994 
    if mtype == TMessageType.EXCEPTION:
2995 
      x = TApplicationException()
2996 
      x.read(self._iprot)
2997 
      self._iprot.readMessageEnd()
2998 
      raise x
3064 chandransh 2999 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 3000 
    result.read(self._iprot)
3001 
    self._iprot.readMessageEnd()
4910 phani.kuma 3002 
    if result.ex is not None:
3003 
      raise result.ex
3004 
    return
3005 
 
3006 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3007 
    """
3008 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3009 
 
3010 
    Parameters:
3011 
     - providerId
3012 
    """
3013 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3014 
    return self.recv_getNonDeliveredOrdersbyCourier()
3015 
 
3016 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3017 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3018 
    args = getNonDeliveredOrdersbyCourier_args()
3019 
    args.providerId = providerId
3020 
    args.write(self._oprot)
3021 
    self._oprot.writeMessageEnd()
3022 
    self._oprot.trans.flush()
3023 
 
3024 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3026 
    if mtype == TMessageType.EXCEPTION:
3027 
      x = TApplicationException()
3028 
      x.read(self._iprot)
3029 
      self._iprot.readMessageEnd()
3030 
      raise x
3031 
    result = getNonDeliveredOrdersbyCourier_result()
3032 
    result.read(self._iprot)
3033 
    self._iprot.readMessageEnd()
4581 phani.kuma 3034 
    if result.success is not None:
3035 
      return result.success
4910 phani.kuma 3036 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3037 
 
3038 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3039 
    """
3040 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3041 
 
3042 
    Parameters:
3043 
     - providerId
3044 
     - local_connected_orders
3045 
    """
3046 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3047 
    self.recv_markOrdersAsLocalConnected()
3048 
 
3049 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3050 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3051 
    args = markOrdersAsLocalConnected_args()
3052 
    args.providerId = providerId
3053 
    args.local_connected_orders = local_connected_orders
3054 
    args.write(self._oprot)
3055 
    self._oprot.writeMessageEnd()
3056 
    self._oprot.trans.flush()
3057 
 
3058 
  def recv_markOrdersAsLocalConnected(self, ):
3059 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3060 
    if mtype == TMessageType.EXCEPTION:
3061 
      x = TApplicationException()
3062 
      x.read(self._iprot)
3063 
      self._iprot.readMessageEnd()
3064 
      raise x
3065 
    result = markOrdersAsLocalConnected_result()
3066 
    result.read(self._iprot)
3067 
    self._iprot.readMessageEnd()
3431 rajveer 3068 
    if result.ex is not None:
3064 chandransh 3069 
      raise result.ex
4910 phani.kuma 3070 
    return
1627 ankur.sing 3071 
 
4910 phani.kuma 3072 
  def getOrdersNotLocalConnected(self, providerId):
3073 
    """
3074 
    Returns a list of orders that were picked up or shipped but pending local connection.
3075 
 
3076 
    Parameters:
3077 
     - providerId
3078 
    """
3079 
    self.send_getOrdersNotLocalConnected(providerId)
3080 
    return self.recv_getOrdersNotLocalConnected()
3081 
 
3082 
  def send_getOrdersNotLocalConnected(self, providerId):
3083 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3084 
    args = getOrdersNotLocalConnected_args()
3085 
    args.providerId = providerId
3086 
    args.write(self._oprot)
3087 
    self._oprot.writeMessageEnd()
3088 
    self._oprot.trans.flush()
3089 
 
3090 
  def recv_getOrdersNotLocalConnected(self, ):
3091 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3092 
    if mtype == TMessageType.EXCEPTION:
3093 
      x = TApplicationException()
3094 
      x.read(self._iprot)
3095 
      self._iprot.readMessageEnd()
3096 
      raise x
3097 
    result = getOrdersNotLocalConnected_result()
3098 
    result.read(self._iprot)
3099 
    self._iprot.readMessageEnd()
3100 
    if result.success is not None:
3101 
      return result.success
3102 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3103 
 
3104 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3105 
    """
3106 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3107 
 
3108 
    Parameters:
3109 
     - providerId
3110 
     - destination_city_reached_orders
3111 
    """
3112 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3113 
    self.recv_markOrdersAsDestinationCityReached()
3114 
 
3115 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3116 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3117 
    args = markOrdersAsDestinationCityReached_args()
3118 
    args.providerId = providerId
3119 
    args.destination_city_reached_orders = destination_city_reached_orders
3120 
    args.write(self._oprot)
3121 
    self._oprot.writeMessageEnd()
3122 
    self._oprot.trans.flush()
3123 
 
3124 
  def recv_markOrdersAsDestinationCityReached(self, ):
3125 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3126 
    if mtype == TMessageType.EXCEPTION:
3127 
      x = TApplicationException()
3128 
      x.read(self._iprot)
3129 
      self._iprot.readMessageEnd()
3130 
      raise x
3131 
    result = markOrdersAsDestinationCityReached_result()
3132 
    result.read(self._iprot)
3133 
    self._iprot.readMessageEnd()
3134 
    if result.ex is not None:
3135 
      raise result.ex
3136 
    return
3137 
 
3138 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3139 
    """
3140 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3141 
 
3142 
    Parameters:
3143 
     - providerId
3144 
     - first_atdl_orders
3145 
    """
3146 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3147 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3148 
 
3149 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3150 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3151 
    args = markOrdersAsFirstDeliveryAttempted_args()
3152 
    args.providerId = providerId
3153 
    args.first_atdl_orders = first_atdl_orders
3154 
    args.write(self._oprot)
3155 
    self._oprot.writeMessageEnd()
3156 
    self._oprot.trans.flush()
3157 
 
3158 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3159 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3160 
    if mtype == TMessageType.EXCEPTION:
3161 
      x = TApplicationException()
3162 
      x.read(self._iprot)
3163 
      self._iprot.readMessageEnd()
3164 
      raise x
3165 
    result = markOrdersAsFirstDeliveryAttempted_result()
3166 
    result.read(self._iprot)
3167 
    self._iprot.readMessageEnd()
3168 
    if result.ex is not None:
3169 
      raise result.ex
3170 
    return
3171 
 
3064 chandransh 3172 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3173 
    """
3064 chandransh 3174 
    Returns the list of orders whose delivery time has passed but have not been
3175 
    delivered yet for the given provider and warehouse. To get a complete list of
3176 
    undelivered orders, pass them as -1.
3177 
    Returns an empty list if no such orders exist.
3431 rajveer 3178 
 
1886 ankur.sing 3179 
    Parameters:
3064 chandransh 3180 
     - providerId
3181 
     - warehouseId
1886 ankur.sing 3182 
    """
3064 chandransh 3183 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3184 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3185 
 
3064 chandransh 3186 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3187 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3188 
    args = getUndeliveredOrders_args()
3189 
    args.providerId = providerId
3190 
    args.warehouseId = warehouseId
1886 ankur.sing 3191 
    args.write(self._oprot)
3192 
    self._oprot.writeMessageEnd()
3193 
    self._oprot.trans.flush()
3194 
 
3064 chandransh 3195 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3196 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3197 
    if mtype == TMessageType.EXCEPTION:
3198 
      x = TApplicationException()
3199 
      x.read(self._iprot)
3200 
      self._iprot.readMessageEnd()
3201 
      raise x
3064 chandransh 3202 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3203 
    result.read(self._iprot)
3204 
    self._iprot.readMessageEnd()
3431 rajveer 3205 
    if result.success is not None:
1886 ankur.sing 3206 
      return result.success
3064 chandransh 3207 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3208 
 
4783 phani.kuma 3209 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3210 
    """
3211 
    Returns the list of orders whose expected delivery date has passed but have not been
3212 
    delivered yet.
3213 
    Returns an empty list if no such orders exist.
3214 
    """
3215 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3216 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3217 
 
3218 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3219 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3220 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3221 
    args.write(self._oprot)
3222 
    self._oprot.writeMessageEnd()
3223 
    self._oprot.trans.flush()
3224 
 
3225 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3226 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3227 
    if mtype == TMessageType.EXCEPTION:
3228 
      x = TApplicationException()
3229 
      x.read(self._iprot)
3230 
      self._iprot.readMessageEnd()
3231 
      raise x
3232 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3233 
    result.read(self._iprot)
3234 
    self._iprot.readMessageEnd()
3235 
    if result.success is not None:
3236 
      return result.success
3237 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3238 
 
2536 chandransh 3239 
  def toggleDOAFlag(self, orderId):
3240 
    """
3241 
    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.
3242 
    Returns the final flag status.
3243 
    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 3244 
 
2536 chandransh 3245 
    Parameters:
3246 
     - orderId
3247 
    """
3248 
    self.send_toggleDOAFlag(orderId)
3249 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3250 
 
2536 chandransh 3251 
  def send_toggleDOAFlag(self, orderId):
3252 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3253 
    args = toggleDOAFlag_args()
3254 
    args.orderId = orderId
3255 
    args.write(self._oprot)
3256 
    self._oprot.writeMessageEnd()
3257 
    self._oprot.trans.flush()
3258 
 
3259 
  def recv_toggleDOAFlag(self, ):
3260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3261 
    if mtype == TMessageType.EXCEPTION:
3262 
      x = TApplicationException()
3263 
      x.read(self._iprot)
3264 
      self._iprot.readMessageEnd()
3265 
      raise x
3266 
    result = toggleDOAFlag_result()
3267 
    result.read(self._iprot)
3268 
    self._iprot.readMessageEnd()
3431 rajveer 3269 
    if result.success is not None:
2536 chandransh 3270 
      return result.success
3431 rajveer 3271 
    if result.ex is not None:
2536 chandransh 3272 
      raise result.ex
3273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3274 
 
4712 rajveer 3275 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3276 
    """
3277 
    Parameters:
3278 
     - orderId
3279 
     - deliveryTimestamp
3280 
     - receiver
3281 
    """
3282 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3283 
    self.recv_markOrderAsDelivered()
3284 
 
3285 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3286 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3287 
    args = markOrderAsDelivered_args()
3288 
    args.orderId = orderId
3289 
    args.deliveryTimestamp = deliveryTimestamp
3290 
    args.receiver = receiver
3291 
    args.write(self._oprot)
3292 
    self._oprot.writeMessageEnd()
3293 
    self._oprot.trans.flush()
3294 
 
3295 
  def recv_markOrderAsDelivered(self, ):
3296 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3297 
    if mtype == TMessageType.EXCEPTION:
3298 
      x = TApplicationException()
3299 
      x.read(self._iprot)
3300 
      self._iprot.readMessageEnd()
3301 
      raise x
3302 
    result = markOrderAsDelivered_result()
3303 
    result.read(self._iprot)
3304 
    self._iprot.readMessageEnd()
3305 
    if result.ex is not None:
3306 
      raise result.ex
3307 
    return
3308 
 
5553 rajveer 3309 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3310 
    """
3311 
    Parameters:
3312 
     - orderId
3313 
     - deliveryTimestamp
3314 
    """
3315 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3316 
    self.recv_markOrderAsReceivedAtStore()
3317 
 
3318 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3319 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3320 
    args = markOrderAsReceivedAtStore_args()
3321 
    args.orderId = orderId
3322 
    args.deliveryTimestamp = deliveryTimestamp
3323 
    args.write(self._oprot)
3324 
    self._oprot.writeMessageEnd()
3325 
    self._oprot.trans.flush()
3326 
 
3327 
  def recv_markOrderAsReceivedAtStore(self, ):
3328 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3329 
    if mtype == TMessageType.EXCEPTION:
3330 
      x = TApplicationException()
3331 
      x.read(self._iprot)
3332 
      self._iprot.readMessageEnd()
3333 
      raise x
3334 
    result = markOrderAsReceivedAtStore_result()
3335 
    result.read(self._iprot)
3336 
    self._iprot.readMessageEnd()
3337 
    if result.ex is not None:
3338 
      raise result.ex
3339 
    return
3340 
 
4454 rajveer 3341 
  def markOrderDoaRequestReceived(self, orderId):
3342 
    """
3343 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3344 
 
3345 
    Parameters:
3346 
     - orderId
3347 
    """
3348 
    self.send_markOrderDoaRequestReceived(orderId)
3349 
    return self.recv_markOrderDoaRequestReceived()
3350 
 
3351 
  def send_markOrderDoaRequestReceived(self, orderId):
3352 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3353 
    args = markOrderDoaRequestReceived_args()
3354 
    args.orderId = orderId
3355 
    args.write(self._oprot)
3356 
    self._oprot.writeMessageEnd()
3357 
    self._oprot.trans.flush()
3358 
 
3359 
  def recv_markOrderDoaRequestReceived(self, ):
3360 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3361 
    if mtype == TMessageType.EXCEPTION:
3362 
      x = TApplicationException()
3363 
      x.read(self._iprot)
3364 
      self._iprot.readMessageEnd()
3365 
      raise x
3366 
    result = markOrderDoaRequestReceived_result()
3367 
    result.read(self._iprot)
3368 
    self._iprot.readMessageEnd()
3369 
    if result.success is not None:
3370 
      return result.success
3371 
    if result.ex is not None:
3372 
      raise result.ex
3373 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3374 
 
3375 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3376 
    """
3377 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3378 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3379 
 
3380 
    Parameters:
3381 
     - orderId
3382 
     - isAuthorized
3383 
    """
3384 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3385 
    return self.recv_markOrderDoaRequestAuthorized()
3386 
 
3387 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3388 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3389 
    args = markOrderDoaRequestAuthorized_args()
3390 
    args.orderId = orderId
3391 
    args.isAuthorized = isAuthorized
3392 
    args.write(self._oprot)
3393 
    self._oprot.writeMessageEnd()
3394 
    self._oprot.trans.flush()
3395 
 
3396 
  def recv_markOrderDoaRequestAuthorized(self, ):
3397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3398 
    if mtype == TMessageType.EXCEPTION:
3399 
      x = TApplicationException()
3400 
      x.read(self._iprot)
3401 
      self._iprot.readMessageEnd()
3402 
      raise x
3403 
    result = markOrderDoaRequestAuthorized_result()
3404 
    result.read(self._iprot)
3405 
    self._iprot.readMessageEnd()
3406 
    if result.success is not None:
3407 
      return result.success
3408 
    if result.ex is not None:
3409 
      raise result.ex
3410 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3411 
 
4488 rajveer 3412 
  def markOrderReturnRequestReceived(self, orderId):
3413 
    """
3414 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3415 
 
3416 
    Parameters:
3417 
     - orderId
3418 
    """
3419 
    self.send_markOrderReturnRequestReceived(orderId)
3420 
    return self.recv_markOrderReturnRequestReceived()
3421 
 
3422 
  def send_markOrderReturnRequestReceived(self, orderId):
3423 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3424 
    args = markOrderReturnRequestReceived_args()
3425 
    args.orderId = orderId
3426 
    args.write(self._oprot)
3427 
    self._oprot.writeMessageEnd()
3428 
    self._oprot.trans.flush()
3429 
 
3430 
  def recv_markOrderReturnRequestReceived(self, ):
3431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3432 
    if mtype == TMessageType.EXCEPTION:
3433 
      x = TApplicationException()
3434 
      x.read(self._iprot)
3435 
      self._iprot.readMessageEnd()
3436 
      raise x
3437 
    result = markOrderReturnRequestReceived_result()
3438 
    result.read(self._iprot)
3439 
    self._iprot.readMessageEnd()
3440 
    if result.success is not None:
3441 
      return result.success
3442 
    if result.ex is not None:
3443 
      raise result.ex
3444 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3445 
 
3446 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3447 
    """
3448 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3449 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3450 
 
3451 
    Parameters:
3452 
     - orderId
3453 
     - isAuthorized
3454 
    """
3455 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3456 
    return self.recv_markOrderReturnRequestAuthorized()
3457 
 
3458 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3459 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3460 
    args = markOrderReturnRequestAuthorized_args()
3461 
    args.orderId = orderId
3462 
    args.isAuthorized = isAuthorized
3463 
    args.write(self._oprot)
3464 
    self._oprot.writeMessageEnd()
3465 
    self._oprot.trans.flush()
3466 
 
3467 
  def recv_markOrderReturnRequestAuthorized(self, ):
3468 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3469 
    if mtype == TMessageType.EXCEPTION:
3470 
      x = TApplicationException()
3471 
      x.read(self._iprot)
3472 
      self._iprot.readMessageEnd()
3473 
      raise x
3474 
    result = markOrderReturnRequestAuthorized_result()
3475 
    result.read(self._iprot)
3476 
    self._iprot.readMessageEnd()
3477 
    if result.success is not None:
3478 
      return result.success
3479 
    if result.ex is not None:
3480 
      raise result.ex
3481 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3482 
 
4579 rajveer 3483 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3484 
    """
3485 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3486 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3487 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3488 
    For any other status, it returns false.
3489 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3490 
 
2536 chandransh 3491 
    Parameters:
3492 
     - orderId
4579 rajveer 3493 
     - providerId
2536 chandransh 3494 
    """
4579 rajveer 3495 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3496 
    return self.recv_requestPickupNumber()
3497 
 
4579 rajveer 3498 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3499 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3500 
    args = requestPickupNumber_args()
3501 
    args.orderId = orderId
4579 rajveer 3502 
    args.providerId = providerId
2536 chandransh 3503 
    args.write(self._oprot)
3504 
    self._oprot.writeMessageEnd()
3505 
    self._oprot.trans.flush()
3506 
 
3507 
  def recv_requestPickupNumber(self, ):
3508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3509 
    if mtype == TMessageType.EXCEPTION:
3510 
      x = TApplicationException()
3511 
      x.read(self._iprot)
3512 
      self._iprot.readMessageEnd()
3513 
      raise x
3514 
    result = requestPickupNumber_result()
3515 
    result.read(self._iprot)
3516 
    self._iprot.readMessageEnd()
3431 rajveer 3517 
    if result.success is not None:
2536 chandransh 3518 
      return result.success
3431 rajveer 3519 
    if result.ex is not None:
2536 chandransh 3520 
      raise result.ex
3521 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3522 
 
4602 rajveer 3523 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3524 
    """
4452 rajveer 3525 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3526 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3527 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3528 
    	3. Returns true
2591 chandransh 3529 
    If the order is in any other status, it returns false.
2536 chandransh 3530 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3531 
 
2536 chandransh 3532 
    Parameters:
3533 
     - orderId
3534 
     - pickupNumber
4602 rajveer 3535 
     - providerId
2536 chandransh 3536 
    """
4602 rajveer 3537 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3538 
    return self.recv_authorizePickup()
3539 
 
4602 rajveer 3540 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3541 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3542 
    args = authorizePickup_args()
3543 
    args.orderId = orderId
3544 
    args.pickupNumber = pickupNumber
4602 rajveer 3545 
    args.providerId = providerId
2536 chandransh 3546 
    args.write(self._oprot)
3547 
    self._oprot.writeMessageEnd()
3548 
    self._oprot.trans.flush()
3549 
 
3550 
  def recv_authorizePickup(self, ):
3551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3552 
    if mtype == TMessageType.EXCEPTION:
3553 
      x = TApplicationException()
3554 
      x.read(self._iprot)
3555 
      self._iprot.readMessageEnd()
3556 
      raise x
3557 
    result = authorizePickup_result()
3558 
    result.read(self._iprot)
3559 
    self._iprot.readMessageEnd()
3431 rajveer 3560 
    if result.success is not None:
2536 chandransh 3561 
      return result.success
3431 rajveer 3562 
    if result.ex is not None:
2536 chandransh 3563 
      raise result.ex
3564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3565 
 
2764 chandransh 3566 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3567 
    """
3568 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3569 
 
2764 chandransh 3570 
    Parameters:
3571 
     - providerId
3572 
     - pickupDetails
3573 
    """
3574 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3575 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3576 
 
3577 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3578 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3579 
    args = markDoasAsPickedUp_args()
3580 
    args.providerId = providerId
3581 
    args.pickupDetails = pickupDetails
3582 
    args.write(self._oprot)
3583 
    self._oprot.writeMessageEnd()
3584 
    self._oprot.trans.flush()
3585 
 
3586 
  def recv_markDoasAsPickedUp(self, ):
3587 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3588 
    if mtype == TMessageType.EXCEPTION:
3589 
      x = TApplicationException()
3590 
      x.read(self._iprot)
3591 
      self._iprot.readMessageEnd()
3592 
      raise x
3593 
    result = markDoasAsPickedUp_result()
3594 
    result.read(self._iprot)
3595 
    self._iprot.readMessageEnd()
4910 phani.kuma 3596 
    return
3597 
 
3598 
  def getDoasNotPickedUp(self, providerId):
3599 
    """
3600 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3601 
 
3602 
    Parameters:
3603 
     - providerId
3604 
    """
3605 
    self.send_getDoasNotPickedUp(providerId)
3606 
    return self.recv_getDoasNotPickedUp()
3607 
 
3608 
  def send_getDoasNotPickedUp(self, providerId):
3609 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3610 
    args = getDoasNotPickedUp_args()
3611 
    args.providerId = providerId
3612 
    args.write(self._oprot)
3613 
    self._oprot.writeMessageEnd()
3614 
    self._oprot.trans.flush()
3615 
 
3616 
  def recv_getDoasNotPickedUp(self, ):
3617 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3618 
    if mtype == TMessageType.EXCEPTION:
3619 
      x = TApplicationException()
3620 
      x.read(self._iprot)
3621 
      self._iprot.readMessageEnd()
3622 
      raise x
3623 
    result = getDoasNotPickedUp_result()
3624 
    result.read(self._iprot)
3625 
    self._iprot.readMessageEnd()
3431 rajveer 3626 
    if result.success is not None:
2764 chandransh 3627 
      return result.success
4910 phani.kuma 3628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3629 
 
4741 phani.kuma 3630 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3631 
    """
3632 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3633 
 
3634 
    Parameters:
3635 
     - providerId
3636 
     - pickupDetails
3637 
    """
3638 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3639 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3640 
 
3641 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3642 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3643 
    args = markReturnOrdersAsPickedUp_args()
3644 
    args.providerId = providerId
3645 
    args.pickupDetails = pickupDetails
3646 
    args.write(self._oprot)
3647 
    self._oprot.writeMessageEnd()
3648 
    self._oprot.trans.flush()
3649 
 
3650 
  def recv_markReturnOrdersAsPickedUp(self, ):
3651 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3652 
    if mtype == TMessageType.EXCEPTION:
3653 
      x = TApplicationException()
3654 
      x.read(self._iprot)
3655 
      self._iprot.readMessageEnd()
3656 
      raise x
3657 
    result = markReturnOrdersAsPickedUp_result()
3658 
    result.read(self._iprot)
3659 
    self._iprot.readMessageEnd()
4910 phani.kuma 3660 
    return
3661 
 
3662 
  def getReturnOrdersNotPickedUp(self, providerId):
3663 
    """
3664 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3665 
 
3666 
    Parameters:
3667 
     - providerId
3668 
    """
3669 
    self.send_getReturnOrdersNotPickedUp(providerId)
3670 
    return self.recv_getReturnOrdersNotPickedUp()
3671 
 
3672 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3673 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3674 
    args = getReturnOrdersNotPickedUp_args()
3675 
    args.providerId = providerId
3676 
    args.write(self._oprot)
3677 
    self._oprot.writeMessageEnd()
3678 
    self._oprot.trans.flush()
3679 
 
3680 
  def recv_getReturnOrdersNotPickedUp(self, ):
3681 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3682 
    if mtype == TMessageType.EXCEPTION:
3683 
      x = TApplicationException()
3684 
      x.read(self._iprot)
3685 
      self._iprot.readMessageEnd()
3686 
      raise x
3687 
    result = getReturnOrdersNotPickedUp_result()
3688 
    result.read(self._iprot)
3689 
    self._iprot.readMessageEnd()
4741 phani.kuma 3690 
    if result.success is not None:
3691 
      return result.success
4910 phani.kuma 3692 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3693 
 
4479 rajveer 3694 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3695 
    """
4452 rajveer 3696 
    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 3697 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3698 
    If the order is in any other state, it returns false.
3699 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3700 
 
2591 chandransh 3701 
    Parameters:
3702 
     - orderId
4479 rajveer 3703 
     - receiveCondition
2591 chandransh 3704 
    """
4479 rajveer 3705 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3706 
    return self.recv_receiveReturn()
2536 chandransh 3707 
 
4479 rajveer 3708 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3709 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3710 
    args = receiveReturn_args()
2591 chandransh 3711 
    args.orderId = orderId
4479 rajveer 3712 
    args.receiveCondition = receiveCondition
2591 chandransh 3713 
    args.write(self._oprot)
3714 
    self._oprot.writeMessageEnd()
3715 
    self._oprot.trans.flush()
3716 
 
2616 chandransh 3717 
  def recv_receiveReturn(self, ):
2591 chandransh 3718 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3719 
    if mtype == TMessageType.EXCEPTION:
3720 
      x = TApplicationException()
3721 
      x.read(self._iprot)
3722 
      self._iprot.readMessageEnd()
3723 
      raise x
2616 chandransh 3724 
    result = receiveReturn_result()
2591 chandransh 3725 
    result.read(self._iprot)
3726 
    self._iprot.readMessageEnd()
3431 rajveer 3727 
    if result.success is not None:
2591 chandransh 3728 
      return result.success
3431 rajveer 3729 
    if result.ex is not None:
2591 chandransh 3730 
      raise result.ex
2616 chandransh 3731 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3732 
 
3733 
  def validateDoa(self, orderId, isValid):
3734 
    """
4452 rajveer 3735 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3736 
    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 3737 
    If the order is in any other state, it returns false.
3738 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3739 
 
2591 chandransh 3740 
    Parameters:
3741 
     - orderId
3742 
     - isValid
3743 
    """
3744 
    self.send_validateDoa(orderId, isValid)
3745 
    return self.recv_validateDoa()
3746 
 
3747 
  def send_validateDoa(self, orderId, isValid):
3748 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3749 
    args = validateDoa_args()
3750 
    args.orderId = orderId
3751 
    args.isValid = isValid
3752 
    args.write(self._oprot)
3753 
    self._oprot.writeMessageEnd()
3754 
    self._oprot.trans.flush()
3755 
 
3756 
  def recv_validateDoa(self, ):
3757 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3758 
    if mtype == TMessageType.EXCEPTION:
3759 
      x = TApplicationException()
3760 
      x.read(self._iprot)
3761 
      self._iprot.readMessageEnd()
3762 
      raise x
3763 
    result = validateDoa_result()
3764 
    result.read(self._iprot)
3765 
    self._iprot.readMessageEnd()
3431 rajveer 3766 
    if result.success is not None:
2591 chandransh 3767 
      return result.success
3431 rajveer 3768 
    if result.ex is not None:
2591 chandransh 3769 
      raise result.ex
3770 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3771 
 
4495 rajveer 3772 
  def validateReturnProduct(self, orderId, isUsable):
3773 
    """
3774 
    Parameters:
3775 
     - orderId
3776 
     - isUsable
3777 
    """
3778 
    self.send_validateReturnProduct(orderId, isUsable)
3779 
    return self.recv_validateReturnProduct()
3780 
 
3781 
  def send_validateReturnProduct(self, orderId, isUsable):
3782 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3783 
    args = validateReturnProduct_args()
3784 
    args.orderId = orderId
3785 
    args.isUsable = isUsable
3786 
    args.write(self._oprot)
3787 
    self._oprot.writeMessageEnd()
3788 
    self._oprot.trans.flush()
3789 
 
3790 
  def recv_validateReturnProduct(self, ):
3791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3792 
    if mtype == TMessageType.EXCEPTION:
3793 
      x = TApplicationException()
3794 
      x.read(self._iprot)
3795 
      self._iprot.readMessageEnd()
3796 
      raise x
3797 
    result = validateReturnProduct_result()
3798 
    result.read(self._iprot)
3799 
    self._iprot.readMessageEnd()
3800 
    if result.success is not None:
3801 
      return result.success
3802 
    if result.ex is not None:
3803 
      raise result.ex
3804 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3805 
 
2616 chandransh 3806 
  def reshipOrder(self, orderId):
3807 
    """
4484 rajveer 3808 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3809 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3810 
    	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 3811 
 
3812 
    If the order is in DOA_CERT_VALID state, it does the following:
3813 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3814 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3815 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3816 
 
2616 chandransh 3817 
    Returns the id of the newly created order.
3431 rajveer 3818 
 
2616 chandransh 3819 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3820 
 
2616 chandransh 3821 
    Parameters:
3822 
     - orderId
3823 
    """
3824 
    self.send_reshipOrder(orderId)
3825 
    return self.recv_reshipOrder()
2591 chandransh 3826 
 
2616 chandransh 3827 
  def send_reshipOrder(self, orderId):
3828 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3829 
    args = reshipOrder_args()
3830 
    args.orderId = orderId
3831 
    args.write(self._oprot)
3832 
    self._oprot.writeMessageEnd()
3833 
    self._oprot.trans.flush()
3834 
 
3835 
  def recv_reshipOrder(self, ):
3836 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3837 
    if mtype == TMessageType.EXCEPTION:
3838 
      x = TApplicationException()
3839 
      x.read(self._iprot)
3840 
      self._iprot.readMessageEnd()
3841 
      raise x
3842 
    result = reshipOrder_result()
3843 
    result.read(self._iprot)
3844 
    self._iprot.readMessageEnd()
3431 rajveer 3845 
    if result.success is not None:
2616 chandransh 3846 
      return result.success
3431 rajveer 3847 
    if result.ex is not None:
2616 chandransh 3848 
      raise result.ex
3849 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3850 
 
3226 chandransh 3851 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3852 
    """
4484 rajveer 3853 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3854 
    	1. Creates a refund request for batch processing.
3855 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3856 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3857 
 
2616 chandransh 3858 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3859 
    	1. Creates a refund request for batch processing.
3226 chandransh 3860 
    	2. Cancels the reservation of the item in the warehouse.
3861 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3862 
 
3226 chandransh 3863 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3864 
    	1. Cancels the reservation of the item in the warehouse.
3865 
    	2. Marks the current order as CANCELED.
3866 
 
3867 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3868 
 
2616 chandransh 3869 
    Returns True if it is successful, False otherwise.
3431 rajveer 3870 
 
2616 chandransh 3871 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3872 
 
2616 chandransh 3873 
    Parameters:
3874 
     - orderId
3226 chandransh 3875 
     - refundedBy
3876 
     - reason
2616 chandransh 3877 
    """
3226 chandransh 3878 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3879 
    return self.recv_refundOrder()
3880 
 
3226 chandransh 3881 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3882 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3883 
    args = refundOrder_args()
3884 
    args.orderId = orderId
3226 chandransh 3885 
    args.refundedBy = refundedBy
3886 
    args.reason = reason
2616 chandransh 3887 
    args.write(self._oprot)
3888 
    self._oprot.writeMessageEnd()
3889 
    self._oprot.trans.flush()
3890 
 
3891 
  def recv_refundOrder(self, ):
3892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3893 
    if mtype == TMessageType.EXCEPTION:
3894 
      x = TApplicationException()
3895 
      x.read(self._iprot)
3896 
      self._iprot.readMessageEnd()
3897 
      raise x
3898 
    result = refundOrder_result()
3899 
    result.read(self._iprot)
3900 
    self._iprot.readMessageEnd()
3431 rajveer 3901 
    if result.success is not None:
2616 chandransh 3902 
      return result.success
3431 rajveer 3903 
    if result.ex is not None:
2616 chandransh 3904 
      raise result.ex
3905 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3906 
 
2690 chandransh 3907 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3908 
    """
3909 
    Get all return orders created between the from and to dates for the given warehouse.
3910 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3911 
 
2690 chandransh 3912 
    Parameters:
3913 
     - warehouseId
3914 
     - fromDate
3915 
     - toDate
3916 
    """
3917 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3918 
    return self.recv_getReturnOrders()
2616 chandransh 3919 
 
2690 chandransh 3920 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3921 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3922 
    args = getReturnOrders_args()
3923 
    args.warehouseId = warehouseId
3924 
    args.fromDate = fromDate
3925 
    args.toDate = toDate
3926 
    args.write(self._oprot)
3927 
    self._oprot.writeMessageEnd()
3928 
    self._oprot.trans.flush()
3929 
 
3930 
  def recv_getReturnOrders(self, ):
3931 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3932 
    if mtype == TMessageType.EXCEPTION:
3933 
      x = TApplicationException()
3934 
      x.read(self._iprot)
3935 
      self._iprot.readMessageEnd()
3936 
      raise x
3937 
    result = getReturnOrders_result()
3938 
    result.read(self._iprot)
3939 
    self._iprot.readMessageEnd()
3431 rajveer 3940 
    if result.success is not None:
2690 chandransh 3941 
      return result.success
3942 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3943 
 
5481 phani.kuma 3944 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3945 
    """
3946 
    Get all return orders created between the from and to dates.
3947 
 
3948 
    Parameters:
3949 
     - onlyNotProcessed
3950 
     - fromDate
3951 
     - toDate
3952 
    """
3953 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3954 
    return self.recv_getAllReturnOrders()
3955 
 
3956 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3957 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3958 
    args = getAllReturnOrders_args()
3959 
    args.onlyNotProcessed = onlyNotProcessed
3960 
    args.fromDate = fromDate
3961 
    args.toDate = toDate
3962 
    args.write(self._oprot)
3963 
    self._oprot.writeMessageEnd()
3964 
    self._oprot.trans.flush()
3965 
 
3966 
  def recv_getAllReturnOrders(self, ):
3967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3968 
    if mtype == TMessageType.EXCEPTION:
3969 
      x = TApplicationException()
3970 
      x.read(self._iprot)
3971 
      self._iprot.readMessageEnd()
3972 
      raise x
3973 
    result = getAllReturnOrders_result()
3974 
    result.read(self._iprot)
3975 
    self._iprot.readMessageEnd()
3976 
    if result.success is not None:
3977 
      return result.success
3978 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3979 
 
2700 chandransh 3980 
  def getReturnOrder(self, id):
3981 
    """
3982 
    Returns the ReturnOrder corresponding to the given id.
3983 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 3984 
 
2700 chandransh 3985 
    Parameters:
3986 
     - id
3987 
    """
3988 
    self.send_getReturnOrder(id)
3989 
    return self.recv_getReturnOrder()
3990 
 
3991 
  def send_getReturnOrder(self, id):
3992 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
3993 
    args = getReturnOrder_args()
3994 
    args.id = id
3995 
    args.write(self._oprot)
3996 
    self._oprot.writeMessageEnd()
3997 
    self._oprot.trans.flush()
3998 
 
3999 
  def recv_getReturnOrder(self, ):
4000 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4001 
    if mtype == TMessageType.EXCEPTION:
4002 
      x = TApplicationException()
4003 
      x.read(self._iprot)
4004 
      self._iprot.readMessageEnd()
4005 
      raise x
4006 
    result = getReturnOrder_result()
4007 
    result.read(self._iprot)
4008 
    self._iprot.readMessageEnd()
3431 rajveer 4009 
    if result.success is not None:
2700 chandransh 4010 
      return result.success
3431 rajveer 4011 
    if result.ex is not None:
2700 chandransh 4012 
      raise result.ex
4013 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4014 
 
2690 chandransh 4015 
  def processReturn(self, returnOrderId):
4016 
    """
4017 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4018 
 
2690 chandransh 4019 
    Parameters:
4020 
     - returnOrderId
4021 
    """
4022 
    self.send_processReturn(returnOrderId)
4023 
    self.recv_processReturn()
4024 
 
4025 
  def send_processReturn(self, returnOrderId):
4026 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4027 
    args = processReturn_args()
4028 
    args.returnOrderId = returnOrderId
4029 
    args.write(self._oprot)
4030 
    self._oprot.writeMessageEnd()
4031 
    self._oprot.trans.flush()
4032 
 
4033 
  def recv_processReturn(self, ):
4034 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4035 
    if mtype == TMessageType.EXCEPTION:
4036 
      x = TApplicationException()
4037 
      x.read(self._iprot)
4038 
      self._iprot.readMessageEnd()
4039 
      raise x
4040 
    result = processReturn_result()
4041 
    result.read(self._iprot)
4042 
    self._iprot.readMessageEnd()
3431 rajveer 4043 
    if result.ex is not None:
2690 chandransh 4044 
      raise result.ex
4045 
    return
4046 
 
3451 chandransh 4047 
  def updateWeight(self, orderId, weight):
4048 
    """
4049 
    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 4050 
 
3451 chandransh 4051 
    Parameters:
4052 
     - orderId
4053 
     - weight
4054 
    """
4055 
    self.send_updateWeight(orderId, weight)
4056 
    return self.recv_updateWeight()
4057 
 
4058 
  def send_updateWeight(self, orderId, weight):
4059 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4060 
    args = updateWeight_args()
4061 
    args.orderId = orderId
4062 
    args.weight = weight
4063 
    args.write(self._oprot)
4064 
    self._oprot.writeMessageEnd()
4065 
    self._oprot.trans.flush()
4066 
 
4067 
  def recv_updateWeight(self, ):
4068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4069 
    if mtype == TMessageType.EXCEPTION:
4070 
      x = TApplicationException()
4071 
      x.read(self._iprot)
4072 
      self._iprot.readMessageEnd()
4073 
      raise x
4074 
    result = updateWeight_result()
4075 
    result.read(self._iprot)
4076 
    self._iprot.readMessageEnd()
4077 
    if result.success is not None:
4078 
      return result.success
4079 
    if result.ex is not None:
4080 
      raise result.ex
4081 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4082 
 
3469 chandransh 4083 
  def changeItem(self, orderId, itemId):
4084 
    """
4085 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4086 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4087 
 
3469 chandransh 4088 
    Parameters:
4089 
     - orderId
4090 
     - itemId
4091 
    """
4092 
    self.send_changeItem(orderId, itemId)
4093 
    return self.recv_changeItem()
4094 
 
4095 
  def send_changeItem(self, orderId, itemId):
4096 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4097 
    args = changeItem_args()
4098 
    args.orderId = orderId
4099 
    args.itemId = itemId
4100 
    args.write(self._oprot)
4101 
    self._oprot.writeMessageEnd()
4102 
    self._oprot.trans.flush()
4103 
 
4104 
  def recv_changeItem(self, ):
4105 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4106 
    if mtype == TMessageType.EXCEPTION:
4107 
      x = TApplicationException()
4108 
      x.read(self._iprot)
4109 
      self._iprot.readMessageEnd()
4110 
      raise x
4111 
    result = changeItem_result()
4112 
    result.read(self._iprot)
4113 
    self._iprot.readMessageEnd()
4114 
    if result.success is not None:
4115 
      return result.success
4116 
    if result.ex is not None:
4117 
      raise result.ex
4118 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4119 
 
4120 
  def shiftToWarehouse(self, orderId, warehouseId):
4121 
    """
4122 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4123 
 
4124 
    Parameters:
4125 
     - orderId
4126 
     - warehouseId
4127 
    """
4128 
    self.send_shiftToWarehouse(orderId, warehouseId)
4129 
    return self.recv_shiftToWarehouse()
4130 
 
4131 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4132 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4133 
    args = shiftToWarehouse_args()
4134 
    args.orderId = orderId
4135 
    args.warehouseId = warehouseId
4136 
    args.write(self._oprot)
4137 
    self._oprot.writeMessageEnd()
4138 
    self._oprot.trans.flush()
4139 
 
4140 
  def recv_shiftToWarehouse(self, ):
4141 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4142 
    if mtype == TMessageType.EXCEPTION:
4143 
      x = TApplicationException()
4144 
      x.read(self._iprot)
4145 
      self._iprot.readMessageEnd()
4146 
      raise x
4147 
    result = shiftToWarehouse_result()
4148 
    result.read(self._iprot)
4149 
    self._iprot.readMessageEnd()
4150 
    if result.success is not None:
4151 
      return result.success
4152 
    if result.ex is not None:
4153 
      raise result.ex
4154 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4155 
 
4647 rajveer 4156 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4157 
    """
4158 
    Adds the given delay reason to the given order.
3986 chandransh 4159 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4160 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4161 
 
3553 chandransh 4162 
    Parameters:
4163 
     - orderId
4164 
     - delayReason
3986 chandransh 4165 
     - furtherDelay
4647 rajveer 4166 
     - delayReasonText
3553 chandransh 4167 
    """
4647 rajveer 4168 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4169 
    return self.recv_addDelayReason()
4170 
 
4647 rajveer 4171 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4172 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4173 
    args = addDelayReason_args()
4174 
    args.orderId = orderId
4175 
    args.delayReason = delayReason
3986 chandransh 4176 
    args.furtherDelay = furtherDelay
4647 rajveer 4177 
    args.delayReasonText = delayReasonText
3553 chandransh 4178 
    args.write(self._oprot)
4179 
    self._oprot.writeMessageEnd()
4180 
    self._oprot.trans.flush()
4181 
 
4182 
  def recv_addDelayReason(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 = addDelayReason_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, "addDelayReason failed: unknown result");
4197 
 
3956 chandransh 4198 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4199 
    """
4200 
    Marks the COD orders with given AWB nos. as having been processed.
4201 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4202 
 
3956 chandransh 4203 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4204 
    1. There is no order corresponding to an AWB number.
4205 
    2. The captured amount for a payment exceeds the total payment.
4206 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4207 
 
4208 
    Parameters:
4209 
     - collectedAmountMap
4210 
     - xferBy
4211 
     - xferTxnId
4212 
     - xferDate
4213 
    """
4214 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4215 
    return self.recv_reconcileCodCollection()
4216 
 
4217 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4218 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4219 
    args = reconcileCodCollection_args()
4220 
    args.collectedAmountMap = collectedAmountMap
4221 
    args.xferBy = xferBy
4222 
    args.xferTxnId = xferTxnId
4223 
    args.xferDate = xferDate
4224 
    args.write(self._oprot)
4225 
    self._oprot.writeMessageEnd()
4226 
    self._oprot.trans.flush()
4227 
 
4228 
  def recv_reconcileCodCollection(self, ):
4229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4230 
    if mtype == TMessageType.EXCEPTION:
4231 
      x = TApplicationException()
4232 
      x.read(self._iprot)
4233 
      self._iprot.readMessageEnd()
4234 
      raise x
4235 
    result = reconcileCodCollection_result()
4236 
    result.read(self._iprot)
4237 
    self._iprot.readMessageEnd()
4238 
    if result.success is not None:
4239 
      return result.success
4240 
    if result.ex is not None:
4241 
      raise result.ex
4242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4243 
 
4008 mandeep.dh 4244 
  def getTransactionsRequiringExtraProcessing(self, category):
4245 
    """
4065 mandeep.dh 4246 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4247 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4248 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4249 
 
4008 mandeep.dh 4250 
    Parameters:
4251 
     - category
4252 
    """
4253 
    self.send_getTransactionsRequiringExtraProcessing(category)
4254 
    return self.recv_getTransactionsRequiringExtraProcessing()
4255 
 
4256 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4257 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4258 
    args = getTransactionsRequiringExtraProcessing_args()
4259 
    args.category = category
4260 
    args.write(self._oprot)
4261 
    self._oprot.writeMessageEnd()
4262 
    self._oprot.trans.flush()
4263 
 
4264 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4265 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4266 
    if mtype == TMessageType.EXCEPTION:
4267 
      x = TApplicationException()
4268 
      x.read(self._iprot)
4269 
      self._iprot.readMessageEnd()
4270 
      raise x
4271 
    result = getTransactionsRequiringExtraProcessing_result()
4272 
    result.read(self._iprot)
4273 
    self._iprot.readMessageEnd()
4274 
    if result.success is not None:
4275 
      return result.success
4276 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4277 
 
4278 
  def markTransactionAsProcessed(self, transactionId, category):
4279 
    """
4280 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4281 
    It essentially deletes the transaction id record for a particular
4282 
    processing type category (if present) from DB.
4283 
    This is currently used by CRM application.
4008 mandeep.dh 4284 
 
4285 
    Parameters:
4286 
     - transactionId
4287 
     - category
4288 
    """
4289 
    self.send_markTransactionAsProcessed(transactionId, category)
4290 
    self.recv_markTransactionAsProcessed()
4291 
 
4292 
  def send_markTransactionAsProcessed(self, transactionId, category):
4293 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4294 
    args = markTransactionAsProcessed_args()
4295 
    args.transactionId = transactionId
4296 
    args.category = category
4297 
    args.write(self._oprot)
4298 
    self._oprot.writeMessageEnd()
4299 
    self._oprot.trans.flush()
4300 
 
4301 
  def recv_markTransactionAsProcessed(self, ):
4302 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4303 
    if mtype == TMessageType.EXCEPTION:
4304 
      x = TApplicationException()
4305 
      x.read(self._iprot)
4306 
      self._iprot.readMessageEnd()
4307 
      raise x
4308 
    result = markTransactionAsProcessed_result()
4309 
    result.read(self._iprot)
4310 
    self._iprot.readMessageEnd()
4311 
    return
4312 
 
4018 chandransh 4313 
  def getItemWiseRiskyOrdersCount(self, ):
4314 
    """
4315 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4316 
    is defined as one whose shipping date is about to expire.
4317 
    """
4318 
    self.send_getItemWiseRiskyOrdersCount()
4319 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4320 
 
4018 chandransh 4321 
  def send_getItemWiseRiskyOrdersCount(self, ):
4322 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4323 
    args = getItemWiseRiskyOrdersCount_args()
4324 
    args.write(self._oprot)
4325 
    self._oprot.writeMessageEnd()
4326 
    self._oprot.trans.flush()
4327 
 
4328 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4330 
    if mtype == TMessageType.EXCEPTION:
4331 
      x = TApplicationException()
4332 
      x.read(self._iprot)
4333 
      self._iprot.readMessageEnd()
4334 
      raise x
4335 
    result = getItemWiseRiskyOrdersCount_result()
4336 
    result.read(self._iprot)
4337 
    self._iprot.readMessageEnd()
4338 
    if result.success is not None:
4339 
      return result.success
4340 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4341 
 
4295 varun.gupt 4342 
  def getOrdersForItemIds(self, itemIds):
4343 
    """
4344 
    Returns a list of all orders which have items with given id
4345 
 
4346 
    Parameters:
4347 
     - itemIds
4348 
    """
4349 
    self.send_getOrdersForItemIds(itemIds)
4350 
    return self.recv_getOrdersForItemIds()
4351 
 
4352 
  def send_getOrdersForItemIds(self, itemIds):
4353 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4354 
    args = getOrdersForItemIds_args()
4355 
    args.itemIds = itemIds
4356 
    args.write(self._oprot)
4357 
    self._oprot.writeMessageEnd()
4358 
    self._oprot.trans.flush()
4359 
 
4360 
  def recv_getOrdersForItemIds(self, ):
4361 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4362 
    if mtype == TMessageType.EXCEPTION:
4363 
      x = TApplicationException()
4364 
      x.read(self._iprot)
4365 
      self._iprot.readMessageEnd()
4366 
      raise x
4367 
    result = getOrdersForItemIds_result()
4368 
    result.read(self._iprot)
4369 
    self._iprot.readMessageEnd()
4370 
    if result.success is not None:
4371 
      return result.success
4372 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4373 
 
4247 rajveer 4374 
  def markOrderCancellationRequestReceived(self, orderId):
4375 
    """
4376 
    Mark order as cancellation request received. If customer sends request of cancellation of
4377 
    a particular order, this method will be called. It will just change status of the order
4378 
    depending on its current status. It also records the previous status, so that we can move
4379 
    back to that status if cancellation request is denied.
4018 chandransh 4380 
 
4247 rajveer 4381 
    Parameters:
4382 
     - orderId
4383 
    """
4384 
    self.send_markOrderCancellationRequestReceived(orderId)
4385 
    self.recv_markOrderCancellationRequestReceived()
4386 
 
4387 
  def send_markOrderCancellationRequestReceived(self, orderId):
4388 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4389 
    args = markOrderCancellationRequestReceived_args()
4390 
    args.orderId = orderId
4391 
    args.write(self._oprot)
4392 
    self._oprot.writeMessageEnd()
4393 
    self._oprot.trans.flush()
4394 
 
4395 
  def recv_markOrderCancellationRequestReceived(self, ):
4396 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4397 
    if mtype == TMessageType.EXCEPTION:
4398 
      x = TApplicationException()
4399 
      x.read(self._iprot)
4400 
      self._iprot.readMessageEnd()
4401 
      raise x
4402 
    result = markOrderCancellationRequestReceived_result()
4403 
    result.read(self._iprot)
4404 
    self._iprot.readMessageEnd()
4405 
    if result.ex is not None:
4406 
      raise result.ex
4407 
    return
4408 
 
4409 
  def markOrderCancellationRequestConfirmed(self, orderId):
4410 
    """
4411 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4412 
    cancellation request confirmed. After this OM will be able to cancel the order.
4413 
 
4414 
    Parameters:
4415 
     - orderId
4416 
    """
4417 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4418 
    self.recv_markOrderCancellationRequestConfirmed()
4419 
 
4420 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4421 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4422 
    args = markOrderCancellationRequestConfirmed_args()
4423 
    args.orderId = orderId
4424 
    args.write(self._oprot)
4425 
    self._oprot.writeMessageEnd()
4426 
    self._oprot.trans.flush()
4427 
 
4428 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4429 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4430 
    if mtype == TMessageType.EXCEPTION:
4431 
      x = TApplicationException()
4432 
      x.read(self._iprot)
4433 
      self._iprot.readMessageEnd()
4434 
      raise x
4435 
    result = markOrderCancellationRequestConfirmed_result()
4436 
    result.read(self._iprot)
4437 
    self._iprot.readMessageEnd()
4438 
    if result.ex is not None:
4439 
      raise result.ex
4440 
    return
4441 
 
4442 
  def markOrderCancellationRequestDenied(self, orderId):
4443 
    """
4444 
    If we decide to not to cancel order, we will move the order ro previous status.
4445 
 
4446 
    Parameters:
4447 
     - orderId
4448 
    """
4449 
    self.send_markOrderCancellationRequestDenied(orderId)
4450 
    self.recv_markOrderCancellationRequestDenied()
4451 
 
4452 
  def send_markOrderCancellationRequestDenied(self, orderId):
4453 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4454 
    args = markOrderCancellationRequestDenied_args()
4455 
    args.orderId = orderId
4456 
    args.write(self._oprot)
4457 
    self._oprot.writeMessageEnd()
4458 
    self._oprot.trans.flush()
4459 
 
4460 
  def recv_markOrderCancellationRequestDenied(self, ):
4461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4462 
    if mtype == TMessageType.EXCEPTION:
4463 
      x = TApplicationException()
4464 
      x.read(self._iprot)
4465 
      self._iprot.readMessageEnd()
4466 
      raise x
4467 
    result = markOrderCancellationRequestDenied_result()
4468 
    result.read(self._iprot)
4469 
    self._iprot.readMessageEnd()
4470 
    if result.ex is not None:
4471 
      raise result.ex
4472 
    return
4473 
 
4258 rajveer 4474 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4475 
    """
4258 rajveer 4476 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4477 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4478 
 
4479 
    Parameters:
4258 rajveer 4480 
     - transactionId
4247 rajveer 4481 
    """
4258 rajveer 4482 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4483 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4484 
 
4258 rajveer 4485 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4486 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4487 
    args = markTransactionAsPaymentFlagRemoved_args()
4488 
    args.transactionId = transactionId
4247 rajveer 4489 
    args.write(self._oprot)
4490 
    self._oprot.writeMessageEnd()
4491 
    self._oprot.trans.flush()
4492 
 
4258 rajveer 4493 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4495 
    if mtype == TMessageType.EXCEPTION:
4496 
      x = TApplicationException()
4497 
      x.read(self._iprot)
4498 
      self._iprot.readMessageEnd()
4499 
      raise x
4258 rajveer 4500 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4501 
    result.read(self._iprot)
4502 
    self._iprot.readMessageEnd()
4503 
    if result.ex is not None:
4504 
      raise result.ex
4505 
    return
4506 
 
4259 anupam.sin 4507 
  def refundTransaction(self, transactionId, refundedBy, reason):
4508 
    """
4509 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4510 
    need to be cancelled
4247 rajveer 4511 
 
4259 anupam.sin 4512 
    Parameters:
4513 
     - transactionId
4514 
     - refundedBy
4515 
     - reason
4516 
    """
4517 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4518 
    self.recv_refundTransaction()
4519 
 
4520 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4521 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4522 
    args = refundTransaction_args()
4523 
    args.transactionId = transactionId
4524 
    args.refundedBy = refundedBy
4525 
    args.reason = reason
4526 
    args.write(self._oprot)
4527 
    self._oprot.writeMessageEnd()
4528 
    self._oprot.trans.flush()
4529 
 
4530 
  def recv_refundTransaction(self, ):
4531 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4532 
    if mtype == TMessageType.EXCEPTION:
4533 
      x = TApplicationException()
4534 
      x.read(self._iprot)
4535 
      self._iprot.readMessageEnd()
4536 
      raise x
4537 
    result = refundTransaction_result()
4538 
    result.read(self._iprot)
4539 
    self._iprot.readMessageEnd()
4540 
    if result.ex is not None:
4541 
      raise result.ex
4542 
    return
4543 
 
4324 mandeep.dh 4544 
  def updateShipmentAddress(self, orderId, addressId):
4545 
    """
4546 
    Updates shipment address of an order. Delivery and shipping date estimates
4547 
    etc. are also updated here.
4548 
 
4549 
    Throws TransactionServiceException in case address change is not
4550 
    possible due to certain reasons such as new pincode in address is
4551 
    not serviceable etc.
4552 
 
4553 
    Parameters:
4554 
     - orderId
4555 
     - addressId
4556 
    """
4557 
    self.send_updateShipmentAddress(orderId, addressId)
4558 
    self.recv_updateShipmentAddress()
4559 
 
4560 
  def send_updateShipmentAddress(self, orderId, addressId):
4561 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4562 
    args = updateShipmentAddress_args()
4563 
    args.orderId = orderId
4564 
    args.addressId = addressId
4565 
    args.write(self._oprot)
4566 
    self._oprot.writeMessageEnd()
4567 
    self._oprot.trans.flush()
4568 
 
4569 
  def recv_updateShipmentAddress(self, ):
4570 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4571 
    if mtype == TMessageType.EXCEPTION:
4572 
      x = TApplicationException()
4573 
      x.read(self._iprot)
4574 
      self._iprot.readMessageEnd()
4575 
      raise x
4576 
    result = updateShipmentAddress_result()
4577 
    result.read(self._iprot)
4578 
    self._iprot.readMessageEnd()
4579 
    if result.ex is not None:
4580 
      raise result.ex
4581 
    return
4582 
 
4285 rajveer 4583 
  def acceptOrdersForItemId(self, itemId, inventory):
4584 
    """
4585 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4586 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4587 
 
4285 rajveer 4588 
    Parameters:
4589 
     - itemId
4590 
     - inventory
4591 
    """
4592 
    self.send_acceptOrdersForItemId(itemId, inventory)
4593 
    return self.recv_acceptOrdersForItemId()
4594 
 
4595 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4596 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4597 
    args = acceptOrdersForItemId_args()
4598 
    args.itemId = itemId
4599 
    args.inventory = inventory
4600 
    args.write(self._oprot)
4601 
    self._oprot.writeMessageEnd()
4602 
    self._oprot.trans.flush()
4603 
 
4604 
  def recv_acceptOrdersForItemId(self, ):
4605 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4606 
    if mtype == TMessageType.EXCEPTION:
4607 
      x = TApplicationException()
4608 
      x.read(self._iprot)
4609 
      self._iprot.readMessageEnd()
4610 
      raise x
4611 
    result = acceptOrdersForItemId_result()
4612 
    result.read(self._iprot)
4613 
    self._iprot.readMessageEnd()
4614 
    if result.success is not None:
4615 
      return result.success
4616 
    if result.ex is not None:
4617 
      raise result.ex
4618 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4619 
 
4369 rajveer 4620 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4621 
    """
4622 
    Parameters:
4623 
     - vendorId
4624 
     - itemId
4625 
     - quantity
4626 
     - estimate
4369 rajveer 4627 
     - isReminder
4303 rajveer 4628 
    """
4369 rajveer 4629 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4630 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4631 
 
4369 rajveer 4632 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4633 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4634 
    args = markOrdersAsPORaised_args()
4635 
    args.vendorId = vendorId
4636 
    args.itemId = itemId
4637 
    args.quantity = quantity
4638 
    args.estimate = estimate
4369 rajveer 4639 
    args.isReminder = isReminder
4303 rajveer 4640 
    args.write(self._oprot)
4641 
    self._oprot.writeMessageEnd()
4642 
    self._oprot.trans.flush()
4643 
 
4644 
  def recv_markOrdersAsPORaised(self, ):
4645 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4646 
    if mtype == TMessageType.EXCEPTION:
4647 
      x = TApplicationException()
4648 
      x.read(self._iprot)
4649 
      self._iprot.readMessageEnd()
4650 
      raise x
4651 
    result = markOrdersAsPORaised_result()
4652 
    result.read(self._iprot)
4653 
    self._iprot.readMessageEnd()
4654 
    if result.ex is not None:
4655 
      raise result.ex
4656 
    return
4657 
 
4369 rajveer 4658 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4659 
    """
4660 
    Parameters:
4661 
     - vendorId
4662 
     - itemId
4663 
     - quantity
4664 
     - estimate
4369 rajveer 4665 
     - isReminder
4303 rajveer 4666 
    """
4369 rajveer 4667 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4668 
    self.recv_markOrdersAsReversalInitiated()
4669 
 
4369 rajveer 4670 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4671 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4672 
    args = markOrdersAsReversalInitiated_args()
4673 
    args.vendorId = vendorId
4674 
    args.itemId = itemId
4675 
    args.quantity = quantity
4676 
    args.estimate = estimate
4369 rajveer 4677 
    args.isReminder = isReminder
4303 rajveer 4678 
    args.write(self._oprot)
4679 
    self._oprot.writeMessageEnd()
4680 
    self._oprot.trans.flush()
4681 
 
4682 
  def recv_markOrdersAsReversalInitiated(self, ):
4683 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4684 
    if mtype == TMessageType.EXCEPTION:
4685 
      x = TApplicationException()
4686 
      x.read(self._iprot)
4687 
      self._iprot.readMessageEnd()
4688 
      raise x
4689 
    result = markOrdersAsReversalInitiated_result()
4690 
    result.read(self._iprot)
4691 
    self._iprot.readMessageEnd()
4692 
    if result.ex is not None:
4693 
      raise result.ex
4694 
    return
4695 
 
4369 rajveer 4696 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4697 
    """
4698 
    Parameters:
4699 
     - vendorId
4700 
     - itemId
4701 
     - quantity
4702 
     - estimate
4369 rajveer 4703 
     - isReminder
4303 rajveer 4704 
    """
4369 rajveer 4705 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4706 
    self.recv_markOrdersAsNotAvailabke()
4707 
 
4369 rajveer 4708 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4709 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4710 
    args = markOrdersAsNotAvailabke_args()
4711 
    args.vendorId = vendorId
4712 
    args.itemId = itemId
4713 
    args.quantity = quantity
4714 
    args.estimate = estimate
4369 rajveer 4715 
    args.isReminder = isReminder
4303 rajveer 4716 
    args.write(self._oprot)
4717 
    self._oprot.writeMessageEnd()
4718 
    self._oprot.trans.flush()
4719 
 
4720 
  def recv_markOrdersAsNotAvailabke(self, ):
4721 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4722 
    if mtype == TMessageType.EXCEPTION:
4723 
      x = TApplicationException()
4724 
      x.read(self._iprot)
4725 
      self._iprot.readMessageEnd()
4726 
      raise x
4727 
    result = markOrdersAsNotAvailabke_result()
4728 
    result.read(self._iprot)
4729 
    self._iprot.readMessageEnd()
4730 
    if result.ex is not None:
4731 
      raise result.ex
4732 
    return
4733 
 
4369 rajveer 4734 
  def markOrdersAsTimeout(self, vendorId):
4735 
    """
4736 
    Parameters:
4737 
     - vendorId
4738 
    """
4739 
    self.send_markOrdersAsTimeout(vendorId)
4740 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4741 
 
4369 rajveer 4742 
  def send_markOrdersAsTimeout(self, vendorId):
4743 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4744 
    args = markOrdersAsTimeout_args()
4745 
    args.vendorId = vendorId
4746 
    args.write(self._oprot)
4747 
    self._oprot.writeMessageEnd()
4748 
    self._oprot.trans.flush()
4749 
 
4750 
  def recv_markOrdersAsTimeout(self, ):
4751 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4752 
    if mtype == TMessageType.EXCEPTION:
4753 
      x = TApplicationException()
4754 
      x.read(self._iprot)
4755 
      self._iprot.readMessageEnd()
4756 
      raise x
4757 
    result = markOrdersAsTimeout_result()
4758 
    result.read(self._iprot)
4759 
    self._iprot.readMessageEnd()
4760 
    if result.success is not None:
4761 
      return result.success
4762 
    if result.ex is not None:
4763 
      raise result.ex
4764 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4765 
 
4662 rajveer 4766 
  def markOrderAsLostInTransit(self, orderId):
4767 
    """
4768 
    Mark order as LOST_IN_TRANSIT
4769 
 
4770 
    Parameters:
4771 
     - orderId
4772 
    """
4773 
    self.send_markOrderAsLostInTransit(orderId)
4774 
    return self.recv_markOrderAsLostInTransit()
4775 
 
4776 
  def send_markOrderAsLostInTransit(self, orderId):
4777 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4778 
    args = markOrderAsLostInTransit_args()
4779 
    args.orderId = orderId
4780 
    args.write(self._oprot)
4781 
    self._oprot.writeMessageEnd()
4782 
    self._oprot.trans.flush()
4783 
 
4784 
  def recv_markOrderAsLostInTransit(self, ):
4785 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4786 
    if mtype == TMessageType.EXCEPTION:
4787 
      x = TApplicationException()
4788 
      x.read(self._iprot)
4789 
      self._iprot.readMessageEnd()
4790 
      raise x
4791 
    result = markOrderAsLostInTransit_result()
4792 
    result.read(self._iprot)
4793 
    self._iprot.readMessageEnd()
4794 
    if result.success is not None:
4795 
      return result.success
4796 
    if result.ex is not None:
4797 
      raise result.ex
4798 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4799 
 
4386 anupam.sin 4800 
  def getOrderForAwb(self, awb):
4801 
    """
4802 
    Returns the order corresponding to an AWB number
4369 rajveer 4803 
 
4386 anupam.sin 4804 
    Parameters:
4805 
     - awb
4806 
    """
4807 
    self.send_getOrderForAwb(awb)
4808 
    return self.recv_getOrderForAwb()
4809 
 
4810 
  def send_getOrderForAwb(self, awb):
4811 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4812 
    args = getOrderForAwb_args()
4813 
    args.awb = awb
4814 
    args.write(self._oprot)
4815 
    self._oprot.writeMessageEnd()
4816 
    self._oprot.trans.flush()
4817 
 
4818 
  def recv_getOrderForAwb(self, ):
4819 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4820 
    if mtype == TMessageType.EXCEPTION:
4821 
      x = TApplicationException()
4822 
      x.read(self._iprot)
4823 
      self._iprot.readMessageEnd()
4824 
      raise x
4825 
    result = getOrderForAwb_result()
4826 
    result.read(self._iprot)
4827 
    self._iprot.readMessageEnd()
4828 
    if result.success is not None:
4829 
      return result.success
4830 
    if result.ex is not None:
4831 
      raise result.ex
4832 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4833 
 
4910 phani.kuma 4834 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4835 
    """
4910 phani.kuma 4836 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4837 
 
4506 phani.kuma 4838 
    Parameters:
4839 
     - logistics_provider_id
4910 phani.kuma 4840 
     - order_status_list
4506 phani.kuma 4841 
    """
4910 phani.kuma 4842 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4843 
    return self.recv_getOrdersForProviderForStatus()
4844 
 
4910 phani.kuma 4845 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4846 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4847 
    args = getOrdersForProviderForStatus_args()
4848 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4849 
    args.order_status_list = order_status_list
4506 phani.kuma 4850 
    args.write(self._oprot)
4851 
    self._oprot.writeMessageEnd()
4852 
    self._oprot.trans.flush()
4853 
 
4854 
  def recv_getOrdersForProviderForStatus(self, ):
4855 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4856 
    if mtype == TMessageType.EXCEPTION:
4857 
      x = TApplicationException()
4858 
      x.read(self._iprot)
4859 
      self._iprot.readMessageEnd()
4860 
      raise x
4861 
    result = getOrdersForProviderForStatus_result()
4862 
    result.read(self._iprot)
4863 
    self._iprot.readMessageEnd()
4864 
    if result.success is not None:
4865 
      return result.success
4866 
    if result.ex is not None:
4867 
      raise result.ex
4868 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4869 
 
4600 varun.gupt 4870 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4871 
    """
4872 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4873 
 
4600 varun.gupt 4874 
    Parameters:
4875 
     - vendorId
4876 
     - billingDateFrom
4877 
     - billingDateTo
4878 
    """
4879 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4880 
    return self.recv_getBilledOrdersForVendor()
4881 
 
4882 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4883 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4884 
    args = getBilledOrdersForVendor_args()
4885 
    args.vendorId = vendorId
4886 
    args.billingDateFrom = billingDateFrom
4887 
    args.billingDateTo = billingDateTo
4888 
    args.write(self._oprot)
4889 
    self._oprot.writeMessageEnd()
4890 
    self._oprot.trans.flush()
4891 
 
4892 
  def recv_getBilledOrdersForVendor(self, ):
4893 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4894 
    if mtype == TMessageType.EXCEPTION:
4895 
      x = TApplicationException()
4896 
      x.read(self._iprot)
4897 
      self._iprot.readMessageEnd()
4898 
      raise x
4899 
    result = getBilledOrdersForVendor_result()
4900 
    result.read(self._iprot)
4901 
    self._iprot.readMessageEnd()
4902 
    if result.success is not None:
4903 
      return result.success
4904 
    if result.ex is not None:
4905 
      raise result.ex
4906 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4907 
 
4607 rajveer 4908 
  def getSlippedSippingDateOrders(self, ):
4909 
    self.send_getSlippedSippingDateOrders()
4910 
    return self.recv_getSlippedSippingDateOrders()
4911 
 
4912 
  def send_getSlippedSippingDateOrders(self, ):
4913 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4914 
    args = getSlippedSippingDateOrders_args()
4915 
    args.write(self._oprot)
4916 
    self._oprot.writeMessageEnd()
4917 
    self._oprot.trans.flush()
4918 
 
4919 
  def recv_getSlippedSippingDateOrders(self, ):
4920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4921 
    if mtype == TMessageType.EXCEPTION:
4922 
      x = TApplicationException()
4923 
      x.read(self._iprot)
4924 
      self._iprot.readMessageEnd()
4925 
      raise x
4926 
    result = getSlippedSippingDateOrders_result()
4927 
    result.read(self._iprot)
4928 
    self._iprot.readMessageEnd()
4929 
    if result.success is not None:
4930 
      return result.success
4931 
    if result.ex is not None:
4932 
      raise result.ex
4933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4934 
 
4709 rajveer 4935 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4936 
    """
4937 
    Parameters:
4938 
     - cancelDateFrom
4939 
     - cancelDateTo
4940 
    """
4941 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4942 
    return self.recv_getCancelledOrders()
4943 
 
4944 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4945 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4946 
    args = getCancelledOrders_args()
4947 
    args.cancelDateFrom = cancelDateFrom
4948 
    args.cancelDateTo = cancelDateTo
4949 
    args.write(self._oprot)
4950 
    self._oprot.writeMessageEnd()
4951 
    self._oprot.trans.flush()
4952 
 
4953 
  def recv_getCancelledOrders(self, ):
4954 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4955 
    if mtype == TMessageType.EXCEPTION:
4956 
      x = TApplicationException()
4957 
      x.read(self._iprot)
4958 
      self._iprot.readMessageEnd()
4959 
      raise x
4960 
    result = getCancelledOrders_result()
4961 
    result.read(self._iprot)
4962 
    self._iprot.readMessageEnd()
4963 
    if result.success is not None:
4964 
      return result.success
4965 
    if result.ex is not None:
4966 
      raise result.ex
4967 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4968 
 
4600 varun.gupt 4969 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4970 
    """
4971 
    Parameters:
4972 
     - mapAWBAndAmount
4973 
    """
4974 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4975 
    self.recv_saveBluedartSettlements()
4976 
 
4977 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4978 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4979 
    args = saveBluedartSettlements_args()
4980 
    args.mapAWBAndAmount = mapAWBAndAmount
4981 
    args.write(self._oprot)
4982 
    self._oprot.writeMessageEnd()
4983 
    self._oprot.trans.flush()
4984 
 
4985 
  def recv_saveBluedartSettlements(self, ):
4986 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4987 
    if mtype == TMessageType.EXCEPTION:
4988 
      x = TApplicationException()
4989 
      x.read(self._iprot)
4990 
      self._iprot.readMessageEnd()
4991 
      raise x
4992 
    result = saveBluedartSettlements_result()
4993 
    result.read(self._iprot)
4994 
    self._iprot.readMessageEnd()
4995 
    if result.ex is not None:
4996 
      raise result.ex
4997 
    return
4998 
 
4905 varun.gupt 4999 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5000 
    """
5001 
    Parameters:
5002 
     - settlementDate
5003 
     - paymentGatewayId
4905 varun.gupt 5004 
     - referenceId
4600 varun.gupt 5005 
     - serviceTax
5006 
     - otherCharges
5007 
     - netCollection
5008 
    """
4905 varun.gupt 5009 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5010 
    self.recv_savePaymentSettlements()
5011 
 
4905 varun.gupt 5012 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5013 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5014 
    args = savePaymentSettlements_args()
5015 
    args.settlementDate = settlementDate
5016 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5017 
    args.referenceId = referenceId
4600 varun.gupt 5018 
    args.serviceTax = serviceTax
5019 
    args.otherCharges = otherCharges
5020 
    args.netCollection = netCollection
5021 
    args.write(self._oprot)
5022 
    self._oprot.writeMessageEnd()
5023 
    self._oprot.trans.flush()
5024 
 
5025 
  def recv_savePaymentSettlements(self, ):
5026 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5027 
    if mtype == TMessageType.EXCEPTION:
5028 
      x = TApplicationException()
5029 
      x.read(self._iprot)
5030 
      self._iprot.readMessageEnd()
5031 
      raise x
5032 
    result = savePaymentSettlements_result()
5033 
    result.read(self._iprot)
5034 
    self._iprot.readMessageEnd()
5035 
    if result.ex is not None:
5036 
      raise result.ex
5037 
    return
5038 
 
5039 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5040 
    """
5041 
    Parameters:
5042 
     - settlementId
5043 
     - settlementDate
5044 
     - transactionDateFrom
5045 
     - transactionDateTo
5046 
     - amount
5047 
    """
5048 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5049 
    self.recv_saveEBSSettlementSummary()
5050 
 
5051 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5052 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5053 
    args = saveEBSSettlementSummary_args()
5054 
    args.settlementId = settlementId
5055 
    args.settlementDate = settlementDate
5056 
    args.transactionDateFrom = transactionDateFrom
5057 
    args.transactionDateTo = transactionDateTo
5058 
    args.amount = amount
5059 
    args.write(self._oprot)
5060 
    self._oprot.writeMessageEnd()
5061 
    self._oprot.trans.flush()
5062 
 
5063 
  def recv_saveEBSSettlementSummary(self, ):
5064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5065 
    if mtype == TMessageType.EXCEPTION:
5066 
      x = TApplicationException()
5067 
      x.read(self._iprot)
5068 
      self._iprot.readMessageEnd()
5069 
      raise x
5070 
    result = saveEBSSettlementSummary_result()
5071 
    result.read(self._iprot)
5072 
    self._iprot.readMessageEnd()
5073 
    if result.ex is not None:
5074 
      raise result.ex
5075 
    return
5076 
 
5386 phani.kuma 5077 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5078 
    """
5079 
    Parameters:
5189 varun.gupt 5080 
     - referenceId
5081 
     - isRefund
4600 varun.gupt 5082 
    """
5386 phani.kuma 5083 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5084 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5085 
 
5386 phani.kuma 5086 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5087 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5088 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5089 
    args.referenceId = referenceId
5090 
    args.isRefund = isRefund
4600 varun.gupt 5091 
    args.write(self._oprot)
5092 
    self._oprot.writeMessageEnd()
5093 
    self._oprot.trans.flush()
5094 
 
5386 phani.kuma 5095 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5097 
    if mtype == TMessageType.EXCEPTION:
5098 
      x = TApplicationException()
5099 
      x.read(self._iprot)
5100 
      self._iprot.readMessageEnd()
5101 
      raise x
5386 phani.kuma 5102 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5103 
    result.read(self._iprot)
5104 
    self._iprot.readMessageEnd()
5105 
    if result.success is not None:
5106 
      return result.success
5107 
    if result.ex is not None:
5108 
      raise result.ex
5386 phani.kuma 5109 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5110 
 
5386 phani.kuma 5111 
  def getSettlementForCod(self, orderId, isRefund):
5112 
    """
5113 
    Parameters:
5114 
     - orderId
5115 
     - isRefund
5116 
    """
5117 
    self.send_getSettlementForCod(orderId, isRefund)
5118 
    return self.recv_getSettlementForCod()
5119 
 
5120 
  def send_getSettlementForCod(self, orderId, isRefund):
5121 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5122 
    args = getSettlementForCod_args()
5123 
    args.orderId = orderId
5124 
    args.isRefund = isRefund
5125 
    args.write(self._oprot)
5126 
    self._oprot.writeMessageEnd()
5127 
    self._oprot.trans.flush()
5128 
 
5129 
  def recv_getSettlementForCod(self, ):
5130 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5131 
    if mtype == TMessageType.EXCEPTION:
5132 
      x = TApplicationException()
5133 
      x.read(self._iprot)
5134 
      self._iprot.readMessageEnd()
5135 
      raise x
5136 
    result = getSettlementForCod_result()
5137 
    result.read(self._iprot)
5138 
    self._iprot.readMessageEnd()
5139 
    if result.success is not None:
5140 
      return result.success
5141 
    if result.ex is not None:
5142 
      raise result.ex
5143 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5144 
 
4600 varun.gupt 5145 
  def getEBSSettlementSummaries(self, ):
5146 
    self.send_getEBSSettlementSummaries()
5147 
    return self.recv_getEBSSettlementSummaries()
5148 
 
5149 
  def send_getEBSSettlementSummaries(self, ):
5150 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5151 
    args = getEBSSettlementSummaries_args()
5152 
    args.write(self._oprot)
5153 
    self._oprot.writeMessageEnd()
5154 
    self._oprot.trans.flush()
5155 
 
5156 
  def recv_getEBSSettlementSummaries(self, ):
5157 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5158 
    if mtype == TMessageType.EXCEPTION:
5159 
      x = TApplicationException()
5160 
      x.read(self._iprot)
5161 
      self._iprot.readMessageEnd()
5162 
      raise x
5163 
    result = getEBSSettlementSummaries_result()
5164 
    result.read(self._iprot)
5165 
    self._iprot.readMessageEnd()
5166 
    if result.success is not None:
5167 
      return result.success
5168 
    if result.ex is not None:
5169 
      raise result.ex
5170 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5171 
 
5172 
  def markEBSSettlementUploaded(self, settlementId):
5173 
    """
5174 
    Parameters:
5175 
     - settlementId
5176 
    """
5177 
    self.send_markEBSSettlementUploaded(settlementId)
5178 
    self.recv_markEBSSettlementUploaded()
5179 
 
5180 
  def send_markEBSSettlementUploaded(self, settlementId):
5181 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5182 
    args = markEBSSettlementUploaded_args()
5183 
    args.settlementId = settlementId
5184 
    args.write(self._oprot)
5185 
    self._oprot.writeMessageEnd()
5186 
    self._oprot.trans.flush()
5187 
 
5188 
  def recv_markEBSSettlementUploaded(self, ):
5189 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5190 
    if mtype == TMessageType.EXCEPTION:
5191 
      x = TApplicationException()
5192 
      x.read(self._iprot)
5193 
      self._iprot.readMessageEnd()
5194 
      raise x
5195 
    result = markEBSSettlementUploaded_result()
5196 
    result.read(self._iprot)
5197 
    self._iprot.readMessageEnd()
5198 
    if result.ex is not None:
5199 
      raise result.ex
5200 
    return
5201 
 
5202 
  def getEBSSettlementDate(self, settlementId):
5203 
    """
5204 
    Parameters:
5205 
     - settlementId
5206 
    """
5207 
    self.send_getEBSSettlementDate(settlementId)
5208 
    return self.recv_getEBSSettlementDate()
5209 
 
5210 
  def send_getEBSSettlementDate(self, settlementId):
5211 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5212 
    args = getEBSSettlementDate_args()
5213 
    args.settlementId = settlementId
5214 
    args.write(self._oprot)
5215 
    self._oprot.writeMessageEnd()
5216 
    self._oprot.trans.flush()
5217 
 
5218 
  def recv_getEBSSettlementDate(self, ):
5219 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5220 
    if mtype == TMessageType.EXCEPTION:
5221 
      x = TApplicationException()
5222 
      x.read(self._iprot)
5223 
      self._iprot.readMessageEnd()
5224 
      raise x
5225 
    result = getEBSSettlementDate_result()
5226 
    result.read(self._iprot)
5227 
    self._iprot.readMessageEnd()
5228 
    if result.success is not None:
5229 
      return result.success
5230 
    if result.ex is not None:
5231 
      raise result.ex
5232 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5233 
 
4715 varun.gupt 5234 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5235 
    """
5236 
    Parameters:
5237 
     - settlementDateFrom
5238 
     - settlementDateTo
5239 
     - isRefund
5240 
    """
5241 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5242 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5243 
 
4715 varun.gupt 5244 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5245 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5246 
    args = getSettlementsByDate_args()
5247 
    args.settlementDateFrom = settlementDateFrom
5248 
    args.settlementDateTo = settlementDateTo
5249 
    args.isRefund = isRefund
5250 
    args.write(self._oprot)
5251 
    self._oprot.writeMessageEnd()
5252 
    self._oprot.trans.flush()
5253 
 
5254 
  def recv_getSettlementsByDate(self, ):
5255 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5256 
    if mtype == TMessageType.EXCEPTION:
5257 
      x = TApplicationException()
5258 
      x.read(self._iprot)
5259 
      self._iprot.readMessageEnd()
5260 
      raise x
5261 
    result = getSettlementsByDate_result()
5262 
    result.read(self._iprot)
5263 
    self._iprot.readMessageEnd()
5264 
    if result.success is not None:
5265 
      return result.success
5266 
    if result.ex is not None:
5267 
      raise result.ex
5268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5269 
 
5270 
  def getReshippedOrderIds(self, orderIds):
5271 
    """
5272 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5273 
 
5274 
    Parameters:
5275 
     - orderIds
5276 
    """
5277 
    self.send_getReshippedOrderIds(orderIds)
5278 
    return self.recv_getReshippedOrderIds()
5279 
 
5280 
  def send_getReshippedOrderIds(self, orderIds):
5281 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5282 
    args = getReshippedOrderIds_args()
5283 
    args.orderIds = orderIds
5284 
    args.write(self._oprot)
5285 
    self._oprot.writeMessageEnd()
5286 
    self._oprot.trans.flush()
5287 
 
5288 
  def recv_getReshippedOrderIds(self, ):
5289 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5290 
    if mtype == TMessageType.EXCEPTION:
5291 
      x = TApplicationException()
5292 
      x.read(self._iprot)
5293 
      self._iprot.readMessageEnd()
5294 
      raise x
5295 
    result = getReshippedOrderIds_result()
5296 
    result.read(self._iprot)
5297 
    self._iprot.readMessageEnd()
5298 
    if result.success is not None:
5299 
      return result.success
5300 
    if result.ex is not None:
5301 
      raise result.ex
5302 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5303 
 
5481 phani.kuma 5304 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5305 
    """
5306 
    Parameters:
5307 
     - vendorId
5481 phani.kuma 5308 
     - onlyVendorNotPaid
5309 
     - billingDateFrom
5310 
     - billingDateTo
4875 varun.gupt 5311 
    """
5481 phani.kuma 5312 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5313 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5314 
 
5481 phani.kuma 5315 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5316 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5317 
    args = getBilledOrders_args()
4875 varun.gupt 5318 
    args.vendorId = vendorId
5481 phani.kuma 5319 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5320 
    args.billingDateFrom = billingDateFrom
5321 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5322 
    args.write(self._oprot)
5323 
    self._oprot.writeMessageEnd()
5324 
    self._oprot.trans.flush()
5325 
 
5481 phani.kuma 5326 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5327 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5328 
    if mtype == TMessageType.EXCEPTION:
5329 
      x = TApplicationException()
5330 
      x.read(self._iprot)
5331 
      self._iprot.readMessageEnd()
5332 
      raise x
5481 phani.kuma 5333 
    result = getBilledOrders_result()
4875 varun.gupt 5334 
    result.read(self._iprot)
5335 
    self._iprot.readMessageEnd()
5336 
    if result.success is not None:
5337 
      return result.success
5338 
    if result.ex is not None:
5339 
      raise result.ex
5481 phani.kuma 5340 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5341 
 
5031 varun.gupt 5342 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5343 
    """
5344 
    Parameters:
5345 
     - startDate
5346 
     - endDate
5347 
    """
5348 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5349 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5350 
 
5031 varun.gupt 5351 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5352 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5353 
    args = getStatusDistributionOfOrders_args()
5354 
    args.startDate = startDate
5355 
    args.endDate = endDate
5356 
    args.write(self._oprot)
5357 
    self._oprot.writeMessageEnd()
5358 
    self._oprot.trans.flush()
5359 
 
5360 
  def recv_getStatusDistributionOfOrders(self, ):
5361 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5362 
    if mtype == TMessageType.EXCEPTION:
5363 
      x = TApplicationException()
5364 
      x.read(self._iprot)
5365 
      self._iprot.readMessageEnd()
5366 
      raise x
5367 
    result = getStatusDistributionOfOrders_result()
5368 
    result.read(self._iprot)
5369 
    self._iprot.readMessageEnd()
5370 
    if result.success is not None:
5371 
      return result.success
5372 
    if result.ex is not None:
5373 
      raise result.ex
5374 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5375 
 
5067 varun.gupt 5376 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5377 
    """
5378 
    Parameters:
5379 
     - status
5380 
     - startDatetime
5381 
     - endDatetime
5382 
    """
5383 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5384 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5385 
 
5067 varun.gupt 5386 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5387 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5388 
    args = getOrderIdsForStatus_args()
5389 
    args.status = status
5390 
    args.startDatetime = startDatetime
5391 
    args.endDatetime = endDatetime
5392 
    args.write(self._oprot)
5393 
    self._oprot.writeMessageEnd()
5394 
    self._oprot.trans.flush()
5395 
 
5396 
  def recv_getOrderIdsForStatus(self, ):
5397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5398 
    if mtype == TMessageType.EXCEPTION:
5399 
      x = TApplicationException()
5400 
      x.read(self._iprot)
5401 
      self._iprot.readMessageEnd()
5402 
      raise x
5403 
    result = getOrderIdsForStatus_result()
5404 
    result.read(self._iprot)
5405 
    self._iprot.readMessageEnd()
5406 
    if result.success is not None:
5407 
      return result.success
5408 
    if result.ex is not None:
5409 
      raise result.ex
5410 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5411 
 
5348 anupam.sin 5412 
  def updateCODAgent(self, agent, orderId):
5413 
    """
5414 
    Updates the agent who handled the COD verification call
5415 
 
5416 
    Parameters:
5417 
     - agent
5418 
     - orderId
5419 
    """
5420 
    self.send_updateCODAgent(agent, orderId)
5421 
    self.recv_updateCODAgent()
5422 
 
5423 
  def send_updateCODAgent(self, agent, orderId):
5424 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5425 
    args = updateCODAgent_args()
5426 
    args.agent = agent
5427 
    args.orderId = orderId
5428 
    args.write(self._oprot)
5429 
    self._oprot.writeMessageEnd()
5430 
    self._oprot.trans.flush()
5431 
 
5432 
  def recv_updateCODAgent(self, ):
5433 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5434 
    if mtype == TMessageType.EXCEPTION:
5435 
      x = TApplicationException()
5436 
      x.read(self._iprot)
5437 
      self._iprot.readMessageEnd()
5438 
      raise x
5439 
    result = updateCODAgent_result()
5440 
    result.read(self._iprot)
5441 
    self._iprot.readMessageEnd()
5442 
    if result.ex is not None:
5443 
      raise result.ex
5444 
    return
5445 
 
5099 varun.gupt 5446 
  def updateOrderAsPaidToVendor(self, orderId):
5447 
    """
5448 
    Parameters:
5449 
     - orderId
5450 
    """
5451 
    self.send_updateOrderAsPaidToVendor(orderId)
5452 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5453 
 
5099 varun.gupt 5454 
  def send_updateOrderAsPaidToVendor(self, orderId):
5455 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5456 
    args = updateOrderAsPaidToVendor_args()
5457 
    args.orderId = orderId
5458 
    args.write(self._oprot)
5459 
    self._oprot.writeMessageEnd()
5460 
    self._oprot.trans.flush()
5461 
 
5462 
  def recv_updateOrderAsPaidToVendor(self, ):
5463 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5464 
    if mtype == TMessageType.EXCEPTION:
5465 
      x = TApplicationException()
5466 
      x.read(self._iprot)
5467 
      self._iprot.readMessageEnd()
5468 
      raise x
5469 
    result = updateOrderAsPaidToVendor_result()
5470 
    result.read(self._iprot)
5471 
    self._iprot.readMessageEnd()
5472 
    if result.ex is not None:
5473 
      raise result.ex
5474 
    return
5475 
 
5386 phani.kuma 5476 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5477 
    """
5478 
    Parameters:
5479 
     - orderId
5480 
    """
5481 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5482 
    self.recv_updateOrderOnlyAsPaidToVendor()
5483 
 
5484 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5485 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5486 
    args = updateOrderOnlyAsPaidToVendor_args()
5487 
    args.orderId = orderId
5488 
    args.write(self._oprot)
5489 
    self._oprot.writeMessageEnd()
5490 
    self._oprot.trans.flush()
5491 
 
5492 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5493 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5494 
    if mtype == TMessageType.EXCEPTION:
5495 
      x = TApplicationException()
5496 
      x.read(self._iprot)
5497 
      self._iprot.readMessageEnd()
5498 
      raise x
5499 
    result = updateOrderOnlyAsPaidToVendor_result()
5500 
    result.read(self._iprot)
5501 
    self._iprot.readMessageEnd()
5502 
    if result.ex is not None:
5503 
      raise result.ex
5504 
    return
5505 
 
5208 varun.gupt 5506 
  def getRefundedOrdersMarkedPaid(self, ):
5507 
    self.send_getRefundedOrdersMarkedPaid()
5508 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5509 
 
5208 varun.gupt 5510 
  def send_getRefundedOrdersMarkedPaid(self, ):
5511 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5512 
    args = getRefundedOrdersMarkedPaid_args()
5513 
    args.write(self._oprot)
5514 
    self._oprot.writeMessageEnd()
5515 
    self._oprot.trans.flush()
5516 
 
5517 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5518 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5519 
    if mtype == TMessageType.EXCEPTION:
5520 
      x = TApplicationException()
5521 
      x.read(self._iprot)
5522 
      self._iprot.readMessageEnd()
5523 
      raise x
5524 
    result = getRefundedOrdersMarkedPaid_result()
5525 
    result.read(self._iprot)
5526 
    self._iprot.readMessageEnd()
5527 
    if result.success is not None:
5528 
      return result.success
5529 
    if result.ex is not None:
5530 
      raise result.ex
5531 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5532 
 
5447 anupam.sin 5533 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5534 
    """
5535 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5536 
 
5447 anupam.sin 5537 
 
5538 
    Parameters:
5539 
     - minOrderId
5540 
     - maxOrderId
5541 
    """
5542 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5543 
    return self.recv_getAllVerificationAgents()
5544 
 
5545 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5546 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5547 
    args = getAllVerificationAgents_args()
5548 
    args.minOrderId = minOrderId
5549 
    args.maxOrderId = maxOrderId
5550 
    args.write(self._oprot)
5551 
    self._oprot.writeMessageEnd()
5552 
    self._oprot.trans.flush()
5553 
 
5554 
  def recv_getAllVerificationAgents(self, ):
5555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5556 
    if mtype == TMessageType.EXCEPTION:
5557 
      x = TApplicationException()
5558 
      x.read(self._iprot)
5559 
      self._iprot.readMessageEnd()
5560 
      raise x
5561 
    result = getAllVerificationAgents_result()
5562 
    result.read(self._iprot)
5563 
    self._iprot.readMessageEnd()
5564 
    if result.success is not None:
5565 
      return result.success
5566 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5567 
 
5527 anupam.sin 5568 
  def getAllAttributesForOrderId(self, orderId):
5569 
    """
5570 
    gets all attributes for a given orderId
5447 anupam.sin 5571 
 
5527 anupam.sin 5572 
    Parameters:
5573 
     - orderId
5574 
    """
5575 
    self.send_getAllAttributesForOrderId(orderId)
5576 
    return self.recv_getAllAttributesForOrderId()
5577 
 
5578 
  def send_getAllAttributesForOrderId(self, orderId):
5579 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5580 
    args = getAllAttributesForOrderId_args()
5581 
    args.orderId = orderId
5582 
    args.write(self._oprot)
5583 
    self._oprot.writeMessageEnd()
5584 
    self._oprot.trans.flush()
5585 
 
5586 
  def recv_getAllAttributesForOrderId(self, ):
5587 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5588 
    if mtype == TMessageType.EXCEPTION:
5589 
      x = TApplicationException()
5590 
      x.read(self._iprot)
5591 
      self._iprot.readMessageEnd()
5592 
      raise x
5593 
    result = getAllAttributesForOrderId_result()
5594 
    result.read(self._iprot)
5595 
    self._iprot.readMessageEnd()
5596 
    if result.success is not None:
5597 
      return result.success
5598 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5599 
 
5676 rajveer 5600 
  def setOrderAttributes(self, orderId, attributes):
5601 
    """
5602 
    sets attributes for an order
5603 
 
5604 
    Parameters:
5605 
     - orderId
5606 
     - attributes
5607 
    """
5608 
    self.send_setOrderAttributes(orderId, attributes)
5609 
    self.recv_setOrderAttributes()
5610 
 
5611 
  def send_setOrderAttributes(self, orderId, attributes):
5612 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5613 
    args = setOrderAttributes_args()
5614 
    args.orderId = orderId
5615 
    args.attributes = attributes
5616 
    args.write(self._oprot)
5617 
    self._oprot.writeMessageEnd()
5618 
    self._oprot.trans.flush()
5619 
 
5620 
  def recv_setOrderAttributes(self, ):
5621 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5622 
    if mtype == TMessageType.EXCEPTION:
5623 
      x = TApplicationException()
5624 
      x.read(self._iprot)
5625 
      self._iprot.readMessageEnd()
5626 
      raise x
5627 
    result = setOrderAttributes_result()
5628 
    result.read(self._iprot)
5629 
    self._iprot.readMessageEnd()
5630 
    return
5631 
 
5527 anupam.sin 5632 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5633 
    """
5634 
    sets attributes for all orders in a transaction
5635 
 
5636 
    Parameters:
5637 
     - transactionId
5638 
     - attribute
5639 
    """
5640 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5641 
    self.recv_setOrderAttributeForTransaction()
5642 
 
5643 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5644 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5645 
    args = setOrderAttributeForTransaction_args()
5646 
    args.transactionId = transactionId
5647 
    args.attribute = attribute
5648 
    args.write(self._oprot)
5649 
    self._oprot.writeMessageEnd()
5650 
    self._oprot.trans.flush()
5651 
 
5652 
  def recv_setOrderAttributeForTransaction(self, ):
5653 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5654 
    if mtype == TMessageType.EXCEPTION:
5655 
      x = TApplicationException()
5656 
      x.read(self._iprot)
5657 
      self._iprot.readMessageEnd()
5658 
      raise x
5659 
    result = setOrderAttributeForTransaction_result()
5660 
    result.read(self._iprot)
5661 
    self._iprot.readMessageEnd()
5662 
    return
5663 
 
5553 rajveer 5664 
  def getReceivePendingOrders(self, storeId):
5665 
    """
5666 
    Parameters:
5667 
     - storeId
5668 
    """
5669 
    self.send_getReceivePendingOrders(storeId)
5670 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5671 
 
5553 rajveer 5672 
  def send_getReceivePendingOrders(self, storeId):
5673 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5674 
    args = getReceivePendingOrders_args()
5675 
    args.storeId = storeId
5676 
    args.write(self._oprot)
5677 
    self._oprot.writeMessageEnd()
5678 
    self._oprot.trans.flush()
5679 
 
5680 
  def recv_getReceivePendingOrders(self, ):
5681 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5682 
    if mtype == TMessageType.EXCEPTION:
5683 
      x = TApplicationException()
5684 
      x.read(self._iprot)
5685 
      self._iprot.readMessageEnd()
5686 
      raise x
5687 
    result = getReceivePendingOrders_result()
5688 
    result.read(self._iprot)
5689 
    self._iprot.readMessageEnd()
5690 
    if result.success is not None:
5691 
      return result.success
5692 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5693 
 
5694 
  def getReceivedAtStoreOrders(self, storeId):
5695 
    """
5696 
    Parameters:
5697 
     - storeId
5698 
    """
5699 
    self.send_getReceivedAtStoreOrders(storeId)
5700 
    return self.recv_getReceivedAtStoreOrders()
5701 
 
5702 
  def send_getReceivedAtStoreOrders(self, storeId):
5703 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5704 
    args = getReceivedAtStoreOrders_args()
5705 
    args.storeId = storeId
5706 
    args.write(self._oprot)
5707 
    self._oprot.writeMessageEnd()
5708 
    self._oprot.trans.flush()
5709 
 
5710 
  def recv_getReceivedAtStoreOrders(self, ):
5711 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5712 
    if mtype == TMessageType.EXCEPTION:
5713 
      x = TApplicationException()
5714 
      x.read(self._iprot)
5715 
      self._iprot.readMessageEnd()
5716 
      raise x
5717 
    result = getReceivedAtStoreOrders_result()
5718 
    result.read(self._iprot)
5719 
    self._iprot.readMessageEnd()
5720 
    if result.success is not None:
5721 
      return result.success
5722 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5723 
 
5713 rajveer 5724 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5725 
    """
5726 
    Parameters:
5727 
     - storeId
5728 
     - fromDate
5729 
     - toDate
5730 
     - onlyCod
5731 
    """
5732 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5733 
    return self.recv_getOrdersCollectionAtStore()
5734 
 
5735 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5736 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5737 
    args = getOrdersCollectionAtStore_args()
5738 
    args.storeId = storeId
5739 
    args.fromDate = fromDate
5740 
    args.toDate = toDate
5741 
    args.onlyCod = onlyCod
5742 
    args.write(self._oprot)
5743 
    self._oprot.writeMessageEnd()
5744 
    self._oprot.trans.flush()
5745 
 
5746 
  def recv_getOrdersCollectionAtStore(self, ):
5747 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5748 
    if mtype == TMessageType.EXCEPTION:
5749 
      x = TApplicationException()
5750 
      x.read(self._iprot)
5751 
      self._iprot.readMessageEnd()
5752 
      raise x
5753 
    result = getOrdersCollectionAtStore_result()
5754 
    result.read(self._iprot)
5755 
    self._iprot.readMessageEnd()
5756 
    if result.success is not None:
5757 
      return result.success
5758 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5759 
 
5833 rajveer 5760 
  def getOrderAttributeValue(self, orderId, attributeName):
5761 
    """
5762 
    Parameters:
5763 
     - orderId
5764 
     - attributeName
5765 
    """
5766 
    self.send_getOrderAttributeValue(orderId, attributeName)
5767 
    return self.recv_getOrderAttributeValue()
5768 
 
5769 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5770 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5771 
    args = getOrderAttributeValue_args()
5772 
    args.orderId = orderId
5773 
    args.attributeName = attributeName
5774 
    args.write(self._oprot)
5775 
    self._oprot.writeMessageEnd()
5776 
    self._oprot.trans.flush()
5777 
 
5778 
  def recv_getOrderAttributeValue(self, ):
5779 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5780 
    if mtype == TMessageType.EXCEPTION:
5781 
      x = TApplicationException()
5782 
      x.read(self._iprot)
5783 
      self._iprot.readMessageEnd()
5784 
      raise x
5785 
    result = getOrderAttributeValue_result()
5786 
    result.read(self._iprot)
5787 
    self._iprot.readMessageEnd()
5788 
    if result.success is not None:
5789 
      return result.success
5790 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5791 
 
6019 rajveer 5792 
  def changeJacketNumber(self, orderId, jacketNumber):
5793 
    """
5794 
    Parameters:
5795 
     - orderId
5796 
     - jacketNumber
5797 
    """
5798 
    self.send_changeJacketNumber(orderId, jacketNumber)
5799 
    return self.recv_changeJacketNumber()
5800 
 
5801 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5802 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5803 
    args = changeJacketNumber_args()
5804 
    args.orderId = orderId
5805 
    args.jacketNumber = jacketNumber
5806 
    args.write(self._oprot)
5807 
    self._oprot.writeMessageEnd()
5808 
    self._oprot.trans.flush()
5809 
 
5810 
  def recv_changeJacketNumber(self, ):
5811 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5812 
    if mtype == TMessageType.EXCEPTION:
5813 
      x = TApplicationException()
5814 
      x.read(self._iprot)
5815 
      self._iprot.readMessageEnd()
5816 
      raise x
5817 
    result = changeJacketNumber_result()
5818 
    result.read(self._iprot)
5819 
    self._iprot.readMessageEnd()
5820 
    if result.success is not None:
5821 
      return result.success
5822 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5823 
 
5824 
  def markOrderAsRtoInTransit(self, orderId):
5825 
    """
5826 
    Parameters:
5827 
     - orderId
5828 
    """
5829 
    self.send_markOrderAsRtoInTransit(orderId)
5830 
    return self.recv_markOrderAsRtoInTransit()
5831 
 
5832 
  def send_markOrderAsRtoInTransit(self, orderId):
5833 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5834 
    args = markOrderAsRtoInTransit_args()
5835 
    args.orderId = orderId
5836 
    args.write(self._oprot)
5837 
    self._oprot.writeMessageEnd()
5838 
    self._oprot.trans.flush()
5839 
 
5840 
  def recv_markOrderAsRtoInTransit(self, ):
5841 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5842 
    if mtype == TMessageType.EXCEPTION:
5843 
      x = TApplicationException()
5844 
      x.read(self._iprot)
5845 
      self._iprot.readMessageEnd()
5846 
      raise x
5847 
    result = markOrderAsRtoInTransit_result()
5848 
    result.read(self._iprot)
5849 
    self._iprot.readMessageEnd()
5850 
    if result.success is not None:
5851 
      return result.success
5852 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5853 
 
5593 mandeep.dh 5854 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5855 
    """
5856 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5857 
    invoked while scanning IN of items.
5553 rajveer 5858 
 
5593 mandeep.dh 5859 
    Parameters:
5860 
     - itemId
5861 
     - quantity
5862 
     - fulfilmentWarehouseId
5863 
     - billingWarehouseId
5864 
    """
5865 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5866 
    self.recv_acceptOrderForItem()
5867 
 
5868 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5869 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5870 
    args = acceptOrderForItem_args()
5871 
    args.itemId = itemId
5872 
    args.quantity = quantity
5873 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5874 
    args.billingWarehouseId = billingWarehouseId
5875 
    args.write(self._oprot)
5876 
    self._oprot.writeMessageEnd()
5877 
    self._oprot.trans.flush()
5878 
 
5879 
  def recv_acceptOrderForItem(self, ):
5880 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5881 
    if mtype == TMessageType.EXCEPTION:
5882 
      x = TApplicationException()
5883 
      x.read(self._iprot)
5884 
      self._iprot.readMessageEnd()
5885 
      raise x
5886 
    result = acceptOrderForItem_result()
5887 
    result.read(self._iprot)
5888 
    self._iprot.readMessageEnd()
5889 
    return
5890 
 
6000 mandeep.dh 5891 
  def createRechargeOrder(self, rechargeOrder):
5892 
    """
5893 
    Parameters:
5894 
     - rechargeOrder
5895 
    """
5896 
    self.send_createRechargeOrder(rechargeOrder)
5897 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5898 
 
6000 mandeep.dh 5899 
  def send_createRechargeOrder(self, rechargeOrder):
5900 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5901 
    args = createRechargeOrder_args()
5902 
    args.rechargeOrder = rechargeOrder
5903 
    args.write(self._oprot)
5904 
    self._oprot.writeMessageEnd()
5905 
    self._oprot.trans.flush()
5906 
 
5907 
  def recv_createRechargeOrder(self, ):
5908 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5909 
    if mtype == TMessageType.EXCEPTION:
5910 
      x = TApplicationException()
5911 
      x.read(self._iprot)
5912 
      self._iprot.readMessageEnd()
5913 
      raise x
5914 
    result = createRechargeOrder_result()
5915 
    result.read(self._iprot)
5916 
    self._iprot.readMessageEnd()
5917 
    if result.success is not None:
5918 
      return result.success
5919 
    if result.ex is not None:
5920 
      raise result.ex
5921 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5922 
 
6031 rajveer 5923 
  def getRechargeOrder(self, rechargeRrderId):
5924 
    """
5925 
    Parameters:
5926 
     - rechargeRrderId
5927 
    """
5928 
    self.send_getRechargeOrder(rechargeRrderId)
5929 
    return self.recv_getRechargeOrder()
5930 
 
5931 
  def send_getRechargeOrder(self, rechargeRrderId):
5932 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5933 
    args = getRechargeOrder_args()
5934 
    args.rechargeRrderId = rechargeRrderId
5935 
    args.write(self._oprot)
5936 
    self._oprot.writeMessageEnd()
5937 
    self._oprot.trans.flush()
5938 
 
5939 
  def recv_getRechargeOrder(self, ):
5940 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5941 
    if mtype == TMessageType.EXCEPTION:
5942 
      x = TApplicationException()
5943 
      x.read(self._iprot)
5944 
      self._iprot.readMessageEnd()
5945 
      raise x
5946 
    result = getRechargeOrder_result()
5947 
    result.read(self._iprot)
5948 
    self._iprot.readMessageEnd()
5949 
    if result.success is not None:
5950 
      return result.success
5951 
    if result.ex is not None:
5952 
      raise result.ex
5953 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
5954 
 
5955 
  def getRechargeOrders(self, userId):
5956 
    """
5957 
    Parameters:
5958 
     - userId
5959 
    """
5960 
    self.send_getRechargeOrders(userId)
5961 
    return self.recv_getRechargeOrders()
5962 
 
5963 
  def send_getRechargeOrders(self, userId):
5964 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
5965 
    args = getRechargeOrders_args()
5966 
    args.userId = userId
5967 
    args.write(self._oprot)
5968 
    self._oprot.writeMessageEnd()
5969 
    self._oprot.trans.flush()
5970 
 
5971 
  def recv_getRechargeOrders(self, ):
5972 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5973 
    if mtype == TMessageType.EXCEPTION:
5974 
      x = TApplicationException()
5975 
      x.read(self._iprot)
5976 
      self._iprot.readMessageEnd()
5977 
      raise x
5978 
    result = getRechargeOrders_result()
5979 
    result.read(self._iprot)
5980 
    self._iprot.readMessageEnd()
5981 
    if result.success is not None:
5982 
      return result.success
5983 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
5984 
 
6000 mandeep.dh 5985 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5986 
    """
5987 
    Parameters:
5988 
     - rechargeOrderId
5989 
     - rechargeOrderStatus
5990 
    """
5991 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 5992 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 5993 
 
5994 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
5995 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
5996 
    args = updateRechargeOrderStatus_args()
5997 
    args.rechargeOrderId = rechargeOrderId
5998 
    args.rechargeOrderStatus = rechargeOrderStatus
5999 
    args.write(self._oprot)
6000 
    self._oprot.writeMessageEnd()
6001 
    self._oprot.trans.flush()
6002 
 
6003 
  def recv_updateRechargeOrderStatus(self, ):
6004 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6005 
    if mtype == TMessageType.EXCEPTION:
6006 
      x = TApplicationException()
6007 
      x.read(self._iprot)
6008 
      self._iprot.readMessageEnd()
6009 
      raise x
6010 
    result = updateRechargeOrderStatus_result()
6011 
    result.read(self._iprot)
6012 
    self._iprot.readMessageEnd()
6031 rajveer 6013 
    if result.success is not None:
6014 
      return result.success
6000 mandeep.dh 6015 
    if result.ex is not None:
6016 
      raise result.ex
6031 rajveer 6017 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6018 
 
6031 rajveer 6019 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6020 
    """
6021 
    Parameters:
6031 rajveer 6022 
     - rechargeOrderId
6000 mandeep.dh 6023 
    """
6031 rajveer 6024 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6025 
    return self.recv_activateRechargeTxn()
6026 
 
6031 rajveer 6027 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6028 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6029 
    args = activateRechargeTxn_args()
6031 rajveer 6030 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6031 
    args.write(self._oprot)
6032 
    self._oprot.writeMessageEnd()
6033 
    self._oprot.trans.flush()
6034 
 
6035 
  def recv_activateRechargeTxn(self, ):
6036 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6037 
    if mtype == TMessageType.EXCEPTION:
6038 
      x = TApplicationException()
6039 
      x.read(self._iprot)
6040 
      self._iprot.readMessageEnd()
6041 
      raise x
6042 
    result = activateRechargeTxn_result()
6043 
    result.read(self._iprot)
6044 
    self._iprot.readMessageEnd()
6045 
    if result.success is not None:
6046 
      return result.success
6047 
    if result.ex is not None:
6048 
      raise result.ex
6049 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6050 
 
6031 rajveer 6051 
  def getUserWallet(self, userId):
6000 mandeep.dh 6052 
    """
6053 
    Parameters:
6031 rajveer 6054 
     - userId
6000 mandeep.dh 6055 
    """
6031 rajveer 6056 
    self.send_getUserWallet(userId)
6057 
    return self.recv_getUserWallet()
6000 mandeep.dh 6058 
 
6031 rajveer 6059 
  def send_getUserWallet(self, userId):
6060 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6061 
    args = getUserWallet_args()
6062 
    args.userId = userId
6000 mandeep.dh 6063 
    args.write(self._oprot)
6064 
    self._oprot.writeMessageEnd()
6065 
    self._oprot.trans.flush()
6066 
 
6031 rajveer 6067 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6068 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6069 
    if mtype == TMessageType.EXCEPTION:
6070 
      x = TApplicationException()
6071 
      x.read(self._iprot)
6072 
      self._iprot.readMessageEnd()
6073 
      raise x
6031 rajveer 6074 
    result = getUserWallet_result()
6000 mandeep.dh 6075 
    result.read(self._iprot)
6076 
    self._iprot.readMessageEnd()
6077 
    if result.success is not None:
6078 
      return result.success
6031 rajveer 6079 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6080 
 
6031 rajveer 6081 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6082 
    """
6083 
    Parameters:
6031 rajveer 6084 
     - userId
6000 mandeep.dh 6085 
    """
6031 rajveer 6086 
    self.send_getUserWalletHistory(userId)
6087 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6088 
 
6031 rajveer 6089 
  def send_getUserWalletHistory(self, userId):
6090 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6091 
    args = getUserWalletHistory_args()
6092 
    args.userId = userId
6000 mandeep.dh 6093 
    args.write(self._oprot)
6094 
    self._oprot.writeMessageEnd()
6095 
    self._oprot.trans.flush()
6096 
 
6031 rajveer 6097 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6098 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6099 
    if mtype == TMessageType.EXCEPTION:
6100 
      x = TApplicationException()
6101 
      x.read(self._iprot)
6102 
      self._iprot.readMessageEnd()
6103 
      raise x
6031 rajveer 6104 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6105 
    result.read(self._iprot)
6106 
    self._iprot.readMessageEnd()
6107 
    if result.success is not None:
6108 
      return result.success
6031 rajveer 6109 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6110 
 
6050 anupam.sin 6111 
  def getRechargeOrdersForTransaction(self, txnId):
6112 
    """
6113 
    Returns a recharge order for a given transactionId
6114 
 
6115 
    Parameters:
6116 
     - txnId
6117 
    """
6118 
    self.send_getRechargeOrdersForTransaction(txnId)
6119 
    return self.recv_getRechargeOrdersForTransaction()
6120 
 
6121 
  def send_getRechargeOrdersForTransaction(self, txnId):
6122 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6123 
    args = getRechargeOrdersForTransaction_args()
6124 
    args.txnId = txnId
6125 
    args.write(self._oprot)
6126 
    self._oprot.writeMessageEnd()
6127 
    self._oprot.trans.flush()
6128 
 
6129 
  def recv_getRechargeOrdersForTransaction(self, ):
6130 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6131 
    if mtype == TMessageType.EXCEPTION:
6132 
      x = TApplicationException()
6133 
      x.read(self._iprot)
6134 
      self._iprot.readMessageEnd()
6135 
      raise x
6136 
    result = getRechargeOrdersForTransaction_result()
6137 
    result.read(self._iprot)
6138 
    self._iprot.readMessageEnd()
6139 
    if result.success is not None:
6140 
      return result.success
6141 
    if result.ex is not None:
6142 
      raise result.ex
6143 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6144 
 
6206 rajveer 6145 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6146 
    """
6147 
    Parameters:
6148 
     - rechargeType
6206 rajveer 6149 
     - onlyActive
6048 rajveer 6150 
    """
6206 rajveer 6151 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6152 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6153 
 
6206 rajveer 6154 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6155 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6156 
    args = getServiceProviders_args()
6157 
    args.rechargeType = rechargeType
6206 rajveer 6158 
    args.onlyActive = onlyActive
6048 rajveer 6159 
    args.write(self._oprot)
6160 
    self._oprot.writeMessageEnd()
6161 
    self._oprot.trans.flush()
6162 
 
6163 
  def recv_getServiceProviders(self, ):
6164 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6165 
    if mtype == TMessageType.EXCEPTION:
6166 
      x = TApplicationException()
6167 
      x.read(self._iprot)
6168 
      self._iprot.readMessageEnd()
6169 
      raise x
6170 
    result = getServiceProviders_result()
6171 
    result.read(self._iprot)
6172 
    self._iprot.readMessageEnd()
6173 
    if result.success is not None:
6174 
      return result.success
6175 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6176 
 
6049 rajveer 6177 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6178 
    """
6179 
    Parameters:
6049 rajveer 6180 
     - rechargeType
6048 rajveer 6181 
     - deviceNumber
6182 
    """
6049 rajveer 6183 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6184 
    return self.recv_getServiceProviderForDevice()
6185 
 
6049 rajveer 6186 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6187 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6188 
    args = getServiceProviderForDevice_args()
6049 rajveer 6189 
    args.rechargeType = rechargeType
6048 rajveer 6190 
    args.deviceNumber = deviceNumber
6191 
    args.write(self._oprot)
6192 
    self._oprot.writeMessageEnd()
6193 
    self._oprot.trans.flush()
6194 
 
6195 
  def recv_getServiceProviderForDevice(self, ):
6196 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6197 
    if mtype == TMessageType.EXCEPTION:
6198 
      x = TApplicationException()
6199 
      x.read(self._iprot)
6200 
      self._iprot.readMessageEnd()
6201 
      raise x
6202 
    result = getServiceProviderForDevice_result()
6203 
    result.read(self._iprot)
6204 
    self._iprot.readMessageEnd()
6205 
    if result.success is not None:
6206 
      return result.success
6207 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6208 
 
6591 anupam.sin 6209 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6210 
    """
6211 
    Parameters:
6212 
     - rechargeType
6213 
     - deviceNumber
6307 anupam.sin 6214 
     - userSelectedProviderId
6591 anupam.sin 6215 
     - clientAddress
6269 rajveer 6216 
    """
6591 anupam.sin 6217 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId, clientAddress)
6269 rajveer 6218 
    return self.recv_validateRecharge()
6219 
 
6591 anupam.sin 6220 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6221 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6222 
    args = validateRecharge_args()
6223 
    args.rechargeType = rechargeType
6224 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6225 
    args.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 6226 
    args.clientAddress = clientAddress
6269 rajveer 6227 
    args.write(self._oprot)
6228 
    self._oprot.writeMessageEnd()
6229 
    self._oprot.trans.flush()
6230 
 
6231 
  def recv_validateRecharge(self, ):
6232 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6233 
    if mtype == TMessageType.EXCEPTION:
6234 
      x = TApplicationException()
6235 
      x.read(self._iprot)
6236 
      self._iprot.readMessageEnd()
6237 
      raise x
6238 
    result = validateRecharge_result()
6239 
    result.read(self._iprot)
6240 
    self._iprot.readMessageEnd()
6241 
    if result.success is not None:
6242 
      return result.success
6243 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6244 
 
6094 rajveer 6245 
  def getRechargeOrdersForDevice(self, deviceNumber):
6246 
    """
6247 
    Parameters:
6248 
     - deviceNumber
6249 
    """
6250 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6251 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6252 
 
6094 rajveer 6253 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6254 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6255 
    args = getRechargeOrdersForDevice_args()
6256 
    args.deviceNumber = deviceNumber
6257 
    args.write(self._oprot)
6258 
    self._oprot.writeMessageEnd()
6259 
    self._oprot.trans.flush()
6260 
 
6261 
  def recv_getRechargeOrdersForDevice(self, ):
6262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6263 
    if mtype == TMessageType.EXCEPTION:
6264 
      x = TApplicationException()
6265 
      x.read(self._iprot)
6266 
      self._iprot.readMessageEnd()
6267 
      raise x
6268 
    result = getRechargeOrdersForDevice_result()
6269 
    result.read(self._iprot)
6270 
    self._iprot.readMessageEnd()
6271 
    if result.success is not None:
6272 
      return result.success
6273 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6274 
 
6275 
  def addAmountToWallet(self, userId, orderId, amount):
6276 
    """
6277 
    Parameters:
6278 
     - userId
6279 
     - orderId
6280 
     - amount
6281 
    """
6282 
    self.send_addAmountToWallet(userId, orderId, amount)
6283 
    self.recv_addAmountToWallet()
6284 
 
6285 
  def send_addAmountToWallet(self, userId, orderId, amount):
6286 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6287 
    args = addAmountToWallet_args()
6288 
    args.userId = userId
6289 
    args.orderId = orderId
6290 
    args.amount = amount
6291 
    args.write(self._oprot)
6292 
    self._oprot.writeMessageEnd()
6293 
    self._oprot.trans.flush()
6294 
 
6295 
  def recv_addAmountToWallet(self, ):
6296 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6297 
    if mtype == TMessageType.EXCEPTION:
6298 
      x = TApplicationException()
6299 
      x.read(self._iprot)
6300 
      self._iprot.readMessageEnd()
6301 
      raise x
6302 
    result = addAmountToWallet_result()
6303 
    result.read(self._iprot)
6304 
    self._iprot.readMessageEnd()
6305 
    return
6306 
 
6188 rajveer 6307 
  def getRechargeStatistics(self, ):
6308 
    self.send_getRechargeStatistics()
6309 
    return self.recv_getRechargeStatistics()
6310 
 
6311 
  def send_getRechargeStatistics(self, ):
6312 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6313 
    args = getRechargeStatistics_args()
6314 
    args.write(self._oprot)
6315 
    self._oprot.writeMessageEnd()
6316 
    self._oprot.trans.flush()
6317 
 
6318 
  def recv_getRechargeStatistics(self, ):
6319 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6320 
    if mtype == TMessageType.EXCEPTION:
6321 
      x = TApplicationException()
6322 
      x.read(self._iprot)
6323 
      self._iprot.readMessageEnd()
6324 
      raise x
6325 
    result = getRechargeStatistics_result()
6326 
    result.read(self._iprot)
6327 
    self._iprot.readMessageEnd()
6328 
    if result.success is not None:
6329 
      return result.success
6330 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6331 
 
6154 rajveer 6332 
  def getRechargeOrdersForStatus(self, status):
6333 
    """
6334 
    Parameters:
6335 
     - status
6336 
    """
6337 
    self.send_getRechargeOrdersForStatus(status)
6338 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6339 
 
6154 rajveer 6340 
  def send_getRechargeOrdersForStatus(self, status):
6341 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6342 
    args = getRechargeOrdersForStatus_args()
6343 
    args.status = status
6344 
    args.write(self._oprot)
6345 
    self._oprot.writeMessageEnd()
6346 
    self._oprot.trans.flush()
6347 
 
6348 
  def recv_getRechargeOrdersForStatus(self, ):
6349 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6350 
    if mtype == TMessageType.EXCEPTION:
6351 
      x = TApplicationException()
6352 
      x.read(self._iprot)
6353 
      self._iprot.readMessageEnd()
6354 
      raise x
6355 
    result = getRechargeOrdersForStatus_result()
6356 
    result.read(self._iprot)
6357 
    self._iprot.readMessageEnd()
6358 
    if result.success is not None:
6359 
      return result.success
6360 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6361 
 
6159 rajveer 6362 
  def getPlansForOperator(self, operatorId):
6363 
    """
6364 
    Parameters:
6365 
     - operatorId
6366 
    """
6367 
    self.send_getPlansForOperator(operatorId)
6368 
    return self.recv_getPlansForOperator()
6154 rajveer 6369 
 
6159 rajveer 6370 
  def send_getPlansForOperator(self, operatorId):
6371 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6372 
    args = getPlansForOperator_args()
6373 
    args.operatorId = operatorId
6374 
    args.write(self._oprot)
6375 
    self._oprot.writeMessageEnd()
6376 
    self._oprot.trans.flush()
6377 
 
6378 
  def recv_getPlansForOperator(self, ):
6379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6380 
    if mtype == TMessageType.EXCEPTION:
6381 
      x = TApplicationException()
6382 
      x.read(self._iprot)
6383 
      self._iprot.readMessageEnd()
6384 
      raise x
6385 
    result = getPlansForOperator_result()
6386 
    result.read(self._iprot)
6387 
    self._iprot.readMessageEnd()
6388 
    if result.success is not None:
6389 
      return result.success
6390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6391 
 
6307 anupam.sin 6392 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6393 
    """
6394 
    Returns denominations for a given operator and circle
6159 rajveer 6395 
 
6289 anupam.sin 6396 
    Parameters:
6397 
     - operatorId
6307 anupam.sin 6398 
     - circleCode
6289 anupam.sin 6399 
     - denominationType
6400 
    """
6307 anupam.sin 6401 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6402 
    return self.recv_getRechargeDenominations()
6403 
 
6307 anupam.sin 6404 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6405 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6406 
    args = getRechargeDenominations_args()
6407 
    args.operatorId = operatorId
6307 anupam.sin 6408 
    args.circleCode = circleCode
6289 anupam.sin 6409 
    args.denominationType = denominationType
6410 
    args.write(self._oprot)
6411 
    self._oprot.writeMessageEnd()
6412 
    self._oprot.trans.flush()
6413 
 
6414 
  def recv_getRechargeDenominations(self, ):
6415 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6416 
    if mtype == TMessageType.EXCEPTION:
6417 
      x = TApplicationException()
6418 
      x.read(self._iprot)
6419 
      self._iprot.readMessageEnd()
6420 
      raise x
6421 
    result = getRechargeDenominations_result()
6422 
    result.read(self._iprot)
6423 
    self._iprot.readMessageEnd()
6424 
    if result.success is not None:
6425 
      return result.success
6426 
    if result.ex is not None:
6427 
      raise result.ex
6428 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6429 
 
6371 rajveer 6430 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6431 
    """
6432 
    Parameters:
6433 
     - operatorId
6434 
     - circleId
6435 
     - isAvailable
6436 
    """
6437 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6438 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6439 
 
6371 rajveer 6440 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6441 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6442 
    args = updateAvailabilityStatus_args()
6443 
    args.operatorId = operatorId
6444 
    args.circleId = circleId
6445 
    args.isAvailable = isAvailable
6446 
    args.write(self._oprot)
6447 
    self._oprot.writeMessageEnd()
6448 
    self._oprot.trans.flush()
6449 
 
6450 
  def recv_updateAvailabilityStatus(self, ):
6451 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6452 
    if mtype == TMessageType.EXCEPTION:
6453 
      x = TApplicationException()
6454 
      x.read(self._iprot)
6455 
      self._iprot.readMessageEnd()
6456 
      raise x
6457 
    result = updateAvailabilityStatus_result()
6458 
    result.read(self._iprot)
6459 
    self._iprot.readMessageEnd()
6460 
    return
6461 
 
6389 rajveer 6462 
  def getAvailableEmiSchemes(self, ):
6463 
    self.send_getAvailableEmiSchemes()
6464 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6465 
 
6389 rajveer 6466 
  def send_getAvailableEmiSchemes(self, ):
6467 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6468 
    args = getAvailableEmiSchemes_args()
6469 
    args.write(self._oprot)
6470 
    self._oprot.writeMessageEnd()
6471 
    self._oprot.trans.flush()
6472 
 
6473 
  def recv_getAvailableEmiSchemes(self, ):
6474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6475 
    if mtype == TMessageType.EXCEPTION:
6476 
      x = TApplicationException()
6477 
      x.read(self._iprot)
6478 
      self._iprot.readMessageEnd()
6479 
      raise x
6480 
    result = getAvailableEmiSchemes_result()
6481 
    result.read(self._iprot)
6482 
    self._iprot.readMessageEnd()
6483 
    if result.success is not None:
6484 
      return result.success
6485 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6486 
 
6487 
  def getMiscCharges(self, transactionId):
6488 
    """
6489 
    Parameters:
6490 
     - transactionId
6491 
    """
6492 
    self.send_getMiscCharges(transactionId)
6493 
    return self.recv_getMiscCharges()
6494 
 
6495 
  def send_getMiscCharges(self, transactionId):
6496 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6497 
    args = getMiscCharges_args()
6498 
    args.transactionId = transactionId
6499 
    args.write(self._oprot)
6500 
    self._oprot.writeMessageEnd()
6501 
    self._oprot.trans.flush()
6502 
 
6503 
  def recv_getMiscCharges(self, ):
6504 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6505 
    if mtype == TMessageType.EXCEPTION:
6506 
      x = TApplicationException()
6507 
      x.read(self._iprot)
6508 
      self._iprot.readMessageEnd()
6509 
      raise x
6510 
    result = getMiscCharges_result()
6511 
    result.read(self._iprot)
6512 
    self._iprot.readMessageEnd()
6513 
    if result.success is not None:
6514 
      return result.success
6515 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6516 
 
6507 anupam.sin 6517 
  def refundRechargeOrder(self, rechargeOrderId):
6518 
    """
6519 
    Parameters:
6520 
     - rechargeOrderId
6521 
    """
6522 
    self.send_refundRechargeOrder(rechargeOrderId)
6523 
    return self.recv_refundRechargeOrder()
6389 rajveer 6524 
 
6507 anupam.sin 6525 
  def send_refundRechargeOrder(self, rechargeOrderId):
6526 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6527 
    args = refundRechargeOrder_args()
6528 
    args.rechargeOrderId = rechargeOrderId
6529 
    args.write(self._oprot)
6530 
    self._oprot.writeMessageEnd()
6531 
    self._oprot.trans.flush()
6532 
 
6533 
  def recv_refundRechargeOrder(self, ):
6534 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6535 
    if mtype == TMessageType.EXCEPTION:
6536 
      x = TApplicationException()
6537 
      x.read(self._iprot)
6538 
      self._iprot.readMessageEnd()
6539 
      raise x
6540 
    result = refundRechargeOrder_result()
6541 
    result.read(self._iprot)
6542 
    self._iprot.readMessageEnd()
6543 
    if result.success is not None:
6544 
      return result.success
6545 
    if result.ex is not None:
6546 
      raise result.ex
6547 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6548 
 
6549 
 
3376 rajveer 6550 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6551 
  def __init__(self, handler):
3376 rajveer 6552 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6553 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6554 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6555 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6556 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6557 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6558 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6559 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6560 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6561 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6562 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6563 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6564 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6565 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6566 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6567 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6568 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6569 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6570 
    self._processMap["createOrder"] = Processor.process_createOrder
6571 
    self._processMap["getOrder"] = Processor.process_getOrder
6572 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6573 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6574 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6575 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6576 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6577 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6578 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6579 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6580 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6581 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6582 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6583 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6584 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6585 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6586 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6587 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6588 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6589 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6590 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6591 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6592 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6593 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6594 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6595 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6596 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6597 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6598 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6599 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6600 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6601 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6602 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6603 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6604 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6605 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6606 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6607 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6608 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6609 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6610 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6611 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6612 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6613 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6614 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6615 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6616 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6617 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6618 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6619 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6620 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6621 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6622 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6623 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6624 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6625 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6626 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6627 
    self._processMap["changeItem"] = Processor.process_changeItem
6628 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6629 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6630 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6631 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6632 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6633 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6634 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6635 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6636 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6637 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6638 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6639 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6640 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6641 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6642 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6643 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6644 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6645 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6646 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6647 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6648 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6649 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6650 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6651 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6652 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6653 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6654 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6655 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6656 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6657 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6658 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6659 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6660 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6661 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6662 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6663 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6664 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6665 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6666 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6667 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6668 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6669 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6670 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6671 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6672 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6673 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6674 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6675 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6676 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6677 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6678 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6679 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6680 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6681 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6682 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6683 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6684 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6685 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6686 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 6687 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 6688 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6689 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 6690 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 6691 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
6692 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 6693 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 6694 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 6695 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 6696 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 6697 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 6698 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
6699 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 6700 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
94 ashish 6701 
 
6702 
  def process(self, iprot, oprot):
6703 
    (name, type, seqid) = iprot.readMessageBegin()
6704 
    if name not in self._processMap:
6705 
      iprot.skip(TType.STRUCT)
6706 
      iprot.readMessageEnd()
6707 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6708 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6709 
      x.write(oprot)
6710 
      oprot.writeMessageEnd()
6711 
      oprot.trans.flush()
6712 
      return
6713 
    else:
6714 
      self._processMap[name](self, seqid, iprot, oprot)
6715 
    return True
6716 
 
6717 
  def process_createTransaction(self, seqid, iprot, oprot):
6718 
    args = createTransaction_args()
6719 
    args.read(iprot)
6720 
    iprot.readMessageEnd()
6721 
    result = createTransaction_result()
6722 
    try:
132 ashish 6723 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6724 
    except TransactionServiceException, ex:
6725 
      result.ex = ex
6726 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6727 
    result.write(oprot)
6728 
    oprot.writeMessageEnd()
6729 
    oprot.trans.flush()
6730 
 
6731 
  def process_getTransaction(self, seqid, iprot, oprot):
6732 
    args = getTransaction_args()
6733 
    args.read(iprot)
6734 
    iprot.readMessageEnd()
6735 
    result = getTransaction_result()
6736 
    try:
6737 
      result.success = self._handler.getTransaction(args.id)
6738 
    except TransactionServiceException, ex:
6739 
      result.ex = ex
6740 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6741 
    result.write(oprot)
6742 
    oprot.writeMessageEnd()
6743 
    oprot.trans.flush()
6744 
 
6745 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6746 
    args = getTransactionsForCustomer_args()
6747 
    args.read(iprot)
6748 
    iprot.readMessageEnd()
6749 
    result = getTransactionsForCustomer_result()
6750 
    try:
6751 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6752 
    except TransactionServiceException, ex:
6753 
      result.ex = ex
6754 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6755 
    result.write(oprot)
6756 
    oprot.writeMessageEnd()
6757 
    oprot.trans.flush()
6758 
 
132 ashish 6759 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6760 
    args = getTransactionsForShoppingCartId_args()
6761 
    args.read(iprot)
6762 
    iprot.readMessageEnd()
6763 
    result = getTransactionsForShoppingCartId_result()
6764 
    try:
6765 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6766 
    except TransactionServiceException, ex:
6767 
      result.ex = ex
6768 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6769 
    result.write(oprot)
6770 
    oprot.writeMessageEnd()
6771 
    oprot.trans.flush()
6772 
 
94 ashish 6773 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6774 
    args = getTransactionStatus_args()
6775 
    args.read(iprot)
6776 
    iprot.readMessageEnd()
6777 
    result = getTransactionStatus_result()
6778 
    try:
6779 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6780 
    except TransactionServiceException, ex:
6781 
      result.ex = ex
6782 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6783 
    result.write(oprot)
6784 
    oprot.writeMessageEnd()
6785 
    oprot.trans.flush()
6786 
 
6787 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6788 
    args = changeTransactionStatus_args()
6789 
    args.read(iprot)
6790 
    iprot.readMessageEnd()
6791 
    result = changeTransactionStatus_result()
6792 
    try:
5527 anupam.sin 6793 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6794 
    except TransactionServiceException, ex:
6795 
      result.ex = ex
6796 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6797 
    result.write(oprot)
6798 
    oprot.writeMessageEnd()
6799 
    oprot.trans.flush()
6800 
 
1398 varun.gupt 6801 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6802 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6803 
    args.read(iprot)
6804 
    iprot.readMessageEnd()
1398 varun.gupt 6805 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6806 
    try:
1398 varun.gupt 6807 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6808 
    except TransactionServiceException, ex:
6809 
      result.ex = ex
1398 varun.gupt 6810 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6811 
    result.write(oprot)
6812 
    oprot.writeMessageEnd()
6813 
    oprot.trans.flush()
6814 
 
483 rajveer 6815 
  def process_getAllOrders(self, seqid, iprot, oprot):
6816 
    args = getAllOrders_args()
94 ashish 6817 
    args.read(iprot)
6818 
    iprot.readMessageEnd()
483 rajveer 6819 
    result = getAllOrders_result()
94 ashish 6820 
    try:
4801 anupam.sin 6821 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6822 
    except TransactionServiceException, ex:
6823 
      result.ex = ex
483 rajveer 6824 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6825 
    result.write(oprot)
6826 
    oprot.writeMessageEnd()
6827 
    oprot.trans.flush()
6828 
 
4133 chandransh 6829 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
6830 
    args = getOrdersInBatch_args()
6831 
    args.read(iprot)
6832 
    iprot.readMessageEnd()
6833 
    result = getOrdersInBatch_result()
6834 
    try:
6835 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
6836 
    except TransactionServiceException, ex:
6837 
      result.ex = ex
6838 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
6839 
    result.write(oprot)
6840 
    oprot.writeMessageEnd()
6841 
    oprot.trans.flush()
6842 
 
6843 
  def process_getOrderCount(self, seqid, iprot, oprot):
6844 
    args = getOrderCount_args()
6845 
    args.read(iprot)
6846 
    iprot.readMessageEnd()
6847 
    result = getOrderCount_result()
6848 
    try:
6849 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
6850 
    except TransactionServiceException, ex:
6851 
      result.ex = ex
6852 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
6853 
    result.write(oprot)
6854 
    oprot.writeMessageEnd()
6855 
    oprot.trans.flush()
6856 
 
999 varun.gupt 6857 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
6858 
    args = getOrdersByBillingDate_args()
6859 
    args.read(iprot)
6860 
    iprot.readMessageEnd()
6861 
    result = getOrdersByBillingDate_result()
6862 
    try:
6863 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
6864 
    except TransactionServiceException, ex:
6865 
      result.ex = ex
6866 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
6867 
    result.write(oprot)
6868 
    oprot.writeMessageEnd()
6869 
    oprot.trans.flush()
6870 
 
3427 chandransh 6871 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
6872 
    args = getOrdersByShippingDate_args()
6873 
    args.read(iprot)
6874 
    iprot.readMessageEnd()
6875 
    result = getOrdersByShippingDate_result()
6876 
    try:
3451 chandransh 6877 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 6878 
    except TransactionServiceException, ex:
6879 
      result.ex = ex
6880 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
6881 
    result.write(oprot)
6882 
    oprot.writeMessageEnd()
6883 
    oprot.trans.flush()
6884 
 
1382 varun.gupt 6885 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
6886 
    args = getReturnableOrdersForCustomer_args()
6887 
    args.read(iprot)
6888 
    iprot.readMessageEnd()
6889 
    result = getReturnableOrdersForCustomer_result()
6890 
    try:
6891 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
6892 
    except TransactionServiceException, ex:
6893 
      result.ex = ex
6894 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
6895 
    result.write(oprot)
6896 
    oprot.writeMessageEnd()
6897 
    oprot.trans.flush()
6898 
 
6899 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
6900 
    args = getCancellableOrdersForCustomer_args()
6901 
    args.read(iprot)
6902 
    iprot.readMessageEnd()
6903 
    result = getCancellableOrdersForCustomer_result()
6904 
    try:
6905 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
6906 
    except TransactionServiceException, ex:
6907 
      result.ex = ex
6908 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
6909 
    result.write(oprot)
6910 
    oprot.writeMessageEnd()
6911 
    oprot.trans.flush()
6912 
 
483 rajveer 6913 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
6914 
    args = changeOrderStatus_args()
94 ashish 6915 
    args.read(iprot)
6916 
    iprot.readMessageEnd()
483 rajveer 6917 
    result = changeOrderStatus_result()
94 ashish 6918 
    try:
483 rajveer 6919 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 6920 
    except TransactionServiceException, ex:
6921 
      result.ex = ex
483 rajveer 6922 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 6923 
    result.write(oprot)
6924 
    oprot.writeMessageEnd()
6925 
    oprot.trans.flush()
6926 
 
483 rajveer 6927 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
6928 
    args = getOrdersForTransaction_args()
94 ashish 6929 
    args.read(iprot)
6930 
    iprot.readMessageEnd()
483 rajveer 6931 
    result = getOrdersForTransaction_result()
94 ashish 6932 
    try:
1528 ankur.sing 6933 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 6934 
    except TransactionServiceException, ex:
6935 
      result.ex = ex
483 rajveer 6936 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 6937 
    result.write(oprot)
6938 
    oprot.writeMessageEnd()
6939 
    oprot.trans.flush()
6940 
 
483 rajveer 6941 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
6942 
    args = getOrdersForCustomer_args()
94 ashish 6943 
    args.read(iprot)
6944 
    iprot.readMessageEnd()
483 rajveer 6945 
    result = getOrdersForCustomer_result()
94 ashish 6946 
    try:
3014 chandransh 6947 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 6948 
    except TransactionServiceException, ex:
6949 
      result.ex = ex
483 rajveer 6950 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 6951 
    result.write(oprot)
6952 
    oprot.writeMessageEnd()
6953 
    oprot.trans.flush()
6954 
 
483 rajveer 6955 
  def process_createOrder(self, seqid, iprot, oprot):
6956 
    args = createOrder_args()
94 ashish 6957 
    args.read(iprot)
6958 
    iprot.readMessageEnd()
483 rajveer 6959 
    result = createOrder_result()
94 ashish 6960 
    try:
483 rajveer 6961 
      result.success = self._handler.createOrder(args.order)
94 ashish 6962 
    except TransactionServiceException, ex:
6963 
      result.ex = ex
483 rajveer 6964 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 6965 
    result.write(oprot)
6966 
    oprot.writeMessageEnd()
6967 
    oprot.trans.flush()
6968 
 
483 rajveer 6969 
  def process_getOrder(self, seqid, iprot, oprot):
6970 
    args = getOrder_args()
94 ashish 6971 
    args.read(iprot)
6972 
    iprot.readMessageEnd()
483 rajveer 6973 
    result = getOrder_result()
94 ashish 6974 
    try:
483 rajveer 6975 
      result.success = self._handler.getOrder(args.id)
94 ashish 6976 
    except TransactionServiceException, ex:
6977 
      result.ex = ex
483 rajveer 6978 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 6979 
    result.write(oprot)
6980 
    oprot.writeMessageEnd()
6981 
    oprot.trans.flush()
6982 
 
483 rajveer 6983 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
6984 
    args = getLineItemsForOrder_args()
94 ashish 6985 
    args.read(iprot)
6986 
    iprot.readMessageEnd()
483 rajveer 6987 
    result = getLineItemsForOrder_result()
94 ashish 6988 
    try:
483 rajveer 6989 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 6990 
    except TransactionServiceException, ex:
6991 
      result.ex = ex
483 rajveer 6992 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 6993 
    result.write(oprot)
6994 
    oprot.writeMessageEnd()
6995 
    oprot.trans.flush()
6996 
 
4999 phani.kuma 6997 
  def process_getOrderList(self, seqid, iprot, oprot):
6998 
    args = getOrderList_args()
6999 
    args.read(iprot)
7000 
    iprot.readMessageEnd()
7001 
    result = getOrderList_result()
7002 
    result.success = self._handler.getOrderList(args.order_ids)
7003 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
7004 
    result.write(oprot)
7005 
    oprot.writeMessageEnd()
7006 
    oprot.trans.flush()
7007 
 
5386 phani.kuma 7008 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
7009 
    args = getOrderListForVendor_args()
7010 
    args.read(iprot)
7011 
    iprot.readMessageEnd()
7012 
    result = getOrderListForVendor_result()
7013 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
7014 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
7015 
    result.write(oprot)
7016 
    oprot.writeMessageEnd()
7017 
    oprot.trans.flush()
7018 
 
1528 ankur.sing 7019 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
7020 
    args = getOrderForCustomer_args()
7021 
    args.read(iprot)
7022 
    iprot.readMessageEnd()
7023 
    result = getOrderForCustomer_result()
7024 
    try:
7025 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
7026 
    except TransactionServiceException, ex:
7027 
      result.ex = ex
7028 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
7029 
    result.write(oprot)
7030 
    oprot.writeMessageEnd()
7031 
    oprot.trans.flush()
7032 
 
3064 chandransh 7033 
  def process_getAlerts(self, seqid, iprot, oprot):
7034 
    args = getAlerts_args()
7035 
    args.read(iprot)
7036 
    iprot.readMessageEnd()
7037 
    result = getAlerts_result()
4444 rajveer 7038 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 7039 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
7040 
    result.write(oprot)
7041 
    oprot.writeMessageEnd()
7042 
    oprot.trans.flush()
7043 
 
4394 rajveer 7044 
  def process_addAlert(self, seqid, iprot, oprot):
7045 
    args = addAlert_args()
3064 chandransh 7046 
    args.read(iprot)
7047 
    iprot.readMessageEnd()
4394 rajveer 7048 
    result = addAlert_result()
4444 rajveer 7049 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 7050 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 7051 
    result.write(oprot)
7052 
    oprot.writeMessageEnd()
7053 
    oprot.trans.flush()
7054 
 
4444 rajveer 7055 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
7056 
    args = markAlertsAsSeen_args()
7057 
    args.read(iprot)
7058 
    iprot.readMessageEnd()
7059 
    result = markAlertsAsSeen_result()
7060 
    self._handler.markAlertsAsSeen(args.warehouseId)
7061 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
7062 
    result.write(oprot)
7063 
    oprot.writeMessageEnd()
7064 
    oprot.trans.flush()
7065 
 
3064 chandransh 7066 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
7067 
    args = getValidOrderCount_args()
7068 
    args.read(iprot)
7069 
    iprot.readMessageEnd()
7070 
    result = getValidOrderCount_result()
7071 
    result.success = self._handler.getValidOrderCount()
7072 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
7073 
    result.write(oprot)
7074 
    oprot.writeMessageEnd()
7075 
    oprot.trans.flush()
7076 
 
7077 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
7078 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
7079 
    args.read(iprot)
7080 
    iprot.readMessageEnd()
7081 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
7082 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
7083 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
7084 
    result.write(oprot)
7085 
    oprot.writeMessageEnd()
7086 
    oprot.trans.flush()
7087 
 
7088 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
7089 
    args = getValidOrdersAmountRange_args()
7090 
    args.read(iprot)
7091 
    iprot.readMessageEnd()
7092 
    result = getValidOrdersAmountRange_result()
7093 
    result.success = self._handler.getValidOrdersAmountRange()
7094 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
7095 
    result.write(oprot)
7096 
    oprot.writeMessageEnd()
7097 
    oprot.trans.flush()
7098 
 
7099 
  def process_getValidOrders(self, seqid, iprot, oprot):
7100 
    args = getValidOrders_args()
7101 
    args.read(iprot)
7102 
    iprot.readMessageEnd()
7103 
    result = getValidOrders_result()
5874 rajveer 7104 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 7105 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
7106 
    result.write(oprot)
7107 
    oprot.writeMessageEnd()
7108 
    oprot.trans.flush()
7109 
 
1220 chandransh 7110 
  def process_batchOrders(self, seqid, iprot, oprot):
7111 
    args = batchOrders_args()
7112 
    args.read(iprot)
7113 
    iprot.readMessageEnd()
7114 
    result = batchOrders_result()
7115 
    try:
7116 
      result.success = self._handler.batchOrders(args.warehouseId)
7117 
    except TransactionServiceException, ex:
7118 
      result.ex = ex
7119 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
7120 
    result.write(oprot)
7121 
    oprot.writeMessageEnd()
7122 
    oprot.trans.flush()
7123 
 
1208 chandransh 7124 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
7125 
    args = markOrderAsOutOfStock_args()
7126 
    args.read(iprot)
7127 
    iprot.readMessageEnd()
7128 
    result = markOrderAsOutOfStock_result()
7129 
    try:
7130 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
7131 
    except TransactionServiceException, ex:
7132 
      result.ex = ex
7133 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
7134 
    result.write(oprot)
7135 
    oprot.writeMessageEnd()
7136 
    oprot.trans.flush()
7137 
 
3064 chandransh 7138 
  def process_verifyOrder(self, seqid, iprot, oprot):
7139 
    args = verifyOrder_args()
759 chandransh 7140 
    args.read(iprot)
7141 
    iprot.readMessageEnd()
3064 chandransh 7142 
    result = verifyOrder_result()
759 chandransh 7143 
    try:
3064 chandransh 7144 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 7145 
    except TransactionServiceException, ex:
7146 
      result.ex = ex
3064 chandransh 7147 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 7148 
    result.write(oprot)
7149 
    oprot.writeMessageEnd()
7150 
    oprot.trans.flush()
7151 
 
3064 chandransh 7152 
  def process_acceptOrder(self, seqid, iprot, oprot):
7153 
    args = acceptOrder_args()
1113 chandransh 7154 
    args.read(iprot)
7155 
    iprot.readMessageEnd()
3064 chandransh 7156 
    result = acceptOrder_result()
1113 chandransh 7157 
    try:
3064 chandransh 7158 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7159 
    except TransactionServiceException, ex:
7160 
      result.ex = ex
3064 chandransh 7161 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7162 
    result.write(oprot)
7163 
    oprot.writeMessageEnd()
7164 
    oprot.trans.flush()
7165 
 
3064 chandransh 7166 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7167 
    args = addBillingDetails_args()
1135 chandransh 7168 
    args.read(iprot)
7169 
    iprot.readMessageEnd()
3064 chandransh 7170 
    result = addBillingDetails_result()
1135 chandransh 7171 
    try:
5110 mandeep.dh 7172 
      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 7173 
    except TransactionServiceException, ex:
7174 
      result.ex = ex
3064 chandransh 7175 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7176 
    result.write(oprot)
7177 
    oprot.writeMessageEnd()
7178 
    oprot.trans.flush()
7179 
 
4579 rajveer 7180 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7181 
    args = addInvoiceNumber_args()
7182 
    args.read(iprot)
7183 
    iprot.readMessageEnd()
7184 
    result = addInvoiceNumber_result()
7185 
    try:
6756 amar.kumar 7186 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color, args.serialNumber, args.itemNumber)
4579 rajveer 7187 
    except TransactionServiceException, ex:
7188 
      result.ex = ex
7189 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7190 
    result.write(oprot)
7191 
    oprot.writeMessageEnd()
7192 
    oprot.trans.flush()
7193 
 
4410 rajveer 7194 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7195 
    args = markOrdersAsShippedFromWarehouse_args()
7196 
    args.read(iprot)
7197 
    iprot.readMessageEnd()
7198 
    result = markOrdersAsShippedFromWarehouse_result()
7199 
    try:
4789 rajveer 7200 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7201 
    except TransactionServiceException, ex:
7202 
      result.ex = ex
7203 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7204 
    result.write(oprot)
7205 
    oprot.writeMessageEnd()
7206 
    oprot.trans.flush()
7207 
 
5676 rajveer 7208 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7209 
    args = markOrdersAsReturnedFromStore_args()
7210 
    args.read(iprot)
7211 
    iprot.readMessageEnd()
7212 
    result = markOrdersAsReturnedFromStore_result()
7213 
    try:
5713 rajveer 7214 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7215 
    except TransactionServiceException, ex:
7216 
      result.ex = ex
7217 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7218 
    result.write(oprot)
7219 
    oprot.writeMessageEnd()
7220 
    oprot.trans.flush()
7221 
 
3064 chandransh 7222 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7223 
    args = markOrdersAsPickedUp_args()
304 ashish 7224 
    args.read(iprot)
7225 
    iprot.readMessageEnd()
3064 chandransh 7226 
    result = markOrdersAsPickedUp_result()
7227 
    try:
4910 phani.kuma 7228 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7229 
    except TransactionServiceException, ex:
7230 
      result.ex = ex
7231 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7232 
    result.write(oprot)
7233 
    oprot.writeMessageEnd()
7234 
    oprot.trans.flush()
94 ashish 7235 
 
4910 phani.kuma 7236 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7237 
    args = getOrdersNotPickedUp_args()
7238 
    args.read(iprot)
7239 
    iprot.readMessageEnd()
7240 
    result = getOrdersNotPickedUp_result()
7241 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7242 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7243 
    result.write(oprot)
7244 
    oprot.writeMessageEnd()
7245 
    oprot.trans.flush()
7246 
 
3064 chandransh 7247 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7248 
    args = markOrdersAsDelivered_args()
304 ashish 7249 
    args.read(iprot)
7250 
    iprot.readMessageEnd()
3064 chandransh 7251 
    result = markOrdersAsDelivered_result()
7252 
    try:
7253 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7254 
    except TransactionServiceException, ex:
7255 
      result.ex = ex
7256 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7257 
    result.write(oprot)
7258 
    oprot.writeMessageEnd()
7259 
    oprot.trans.flush()
7260 
 
4910 phani.kuma 7261 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7262 
    args = markAsRTOrders_args()
1596 ankur.sing 7263 
    args.read(iprot)
7264 
    iprot.readMessageEnd()
4910 phani.kuma 7265 
    result = markAsRTOrders_result()
3064 chandransh 7266 
    try:
4910 phani.kuma 7267 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7268 
    except TransactionServiceException, ex:
7269 
      result.ex = ex
4910 phani.kuma 7270 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7271 
    result.write(oprot)
7272 
    oprot.writeMessageEnd()
7273 
    oprot.trans.flush()
304 ashish 7274 
 
4910 phani.kuma 7275 
  def process_getRTOrders(self, seqid, iprot, oprot):
7276 
    args = getRTOrders_args()
7277 
    args.read(iprot)
7278 
    iprot.readMessageEnd()
7279 
    result = getRTOrders_result()
7280 
    result.success = self._handler.getRTOrders(args.providerId)
7281 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7282 
    result.write(oprot)
7283 
    oprot.writeMessageEnd()
7284 
    oprot.trans.flush()
7285 
 
3064 chandransh 7286 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7287 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7288 
    args.read(iprot)
7289 
    iprot.readMessageEnd()
3064 chandransh 7290 
    result = updateNonDeliveryReason_result()
7291 
    try:
4910 phani.kuma 7292 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7293 
    except TransactionServiceException, ex:
7294 
      result.ex = ex
7295 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7296 
    result.write(oprot)
7297 
    oprot.writeMessageEnd()
7298 
    oprot.trans.flush()
1596 ankur.sing 7299 
 
4910 phani.kuma 7300 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7301 
    args = getNonDeliveredOrdersbyCourier_args()
7302 
    args.read(iprot)
7303 
    iprot.readMessageEnd()
7304 
    result = getNonDeliveredOrdersbyCourier_result()
7305 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7306 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7307 
    result.write(oprot)
7308 
    oprot.writeMessageEnd()
7309 
    oprot.trans.flush()
7310 
 
7311 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7312 
    args = markOrdersAsLocalConnected_args()
7313 
    args.read(iprot)
7314 
    iprot.readMessageEnd()
7315 
    result = markOrdersAsLocalConnected_result()
7316 
    try:
7317 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7318 
    except TransactionServiceException, ex:
7319 
      result.ex = ex
7320 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7321 
    result.write(oprot)
7322 
    oprot.writeMessageEnd()
7323 
    oprot.trans.flush()
7324 
 
7325 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7326 
    args = getOrdersNotLocalConnected_args()
7327 
    args.read(iprot)
7328 
    iprot.readMessageEnd()
7329 
    result = getOrdersNotLocalConnected_result()
7330 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7331 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7332 
    result.write(oprot)
7333 
    oprot.writeMessageEnd()
7334 
    oprot.trans.flush()
7335 
 
7336 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7337 
    args = markOrdersAsDestinationCityReached_args()
7338 
    args.read(iprot)
7339 
    iprot.readMessageEnd()
7340 
    result = markOrdersAsDestinationCityReached_result()
7341 
    try:
7342 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7343 
    except TransactionServiceException, ex:
7344 
      result.ex = ex
7345 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7346 
    result.write(oprot)
7347 
    oprot.writeMessageEnd()
7348 
    oprot.trans.flush()
7349 
 
7350 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7351 
    args = markOrdersAsFirstDeliveryAttempted_args()
7352 
    args.read(iprot)
7353 
    iprot.readMessageEnd()
7354 
    result = markOrdersAsFirstDeliveryAttempted_result()
7355 
    try:
7356 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7357 
    except TransactionServiceException, ex:
7358 
      result.ex = ex
7359 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7360 
    result.write(oprot)
7361 
    oprot.writeMessageEnd()
7362 
    oprot.trans.flush()
7363 
 
3064 chandransh 7364 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7365 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7366 
    args.read(iprot)
7367 
    iprot.readMessageEnd()
3064 chandransh 7368 
    result = getUndeliveredOrders_result()
7369 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7370 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7371 
    result.write(oprot)
7372 
    oprot.writeMessageEnd()
7373 
    oprot.trans.flush()
7374 
 
4783 phani.kuma 7375 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7376 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7377 
    args.read(iprot)
7378 
    iprot.readMessageEnd()
7379 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7380 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7381 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7382 
    result.write(oprot)
7383 
    oprot.writeMessageEnd()
7384 
    oprot.trans.flush()
7385 
 
2536 chandransh 7386 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7387 
    args = toggleDOAFlag_args()
7388 
    args.read(iprot)
7389 
    iprot.readMessageEnd()
7390 
    result = toggleDOAFlag_result()
7391 
    try:
7392 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7393 
    except TransactionServiceException, ex:
7394 
      result.ex = ex
7395 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7396 
    result.write(oprot)
7397 
    oprot.writeMessageEnd()
7398 
    oprot.trans.flush()
1886 ankur.sing 7399 
 
4712 rajveer 7400 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7401 
    args = markOrderAsDelivered_args()
7402 
    args.read(iprot)
7403 
    iprot.readMessageEnd()
7404 
    result = markOrderAsDelivered_result()
7405 
    try:
7406 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7407 
    except TransactionServiceException, ex:
7408 
      result.ex = ex
7409 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7410 
    result.write(oprot)
7411 
    oprot.writeMessageEnd()
7412 
    oprot.trans.flush()
7413 
 
5553 rajveer 7414 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7415 
    args = markOrderAsReceivedAtStore_args()
7416 
    args.read(iprot)
7417 
    iprot.readMessageEnd()
7418 
    result = markOrderAsReceivedAtStore_result()
7419 
    try:
7420 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7421 
    except TransactionServiceException, ex:
7422 
      result.ex = ex
7423 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7424 
    result.write(oprot)
7425 
    oprot.writeMessageEnd()
7426 
    oprot.trans.flush()
7427 
 
4454 rajveer 7428 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7429 
    args = markOrderDoaRequestReceived_args()
7430 
    args.read(iprot)
7431 
    iprot.readMessageEnd()
7432 
    result = markOrderDoaRequestReceived_result()
7433 
    try:
7434 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7435 
    except TransactionServiceException, ex:
7436 
      result.ex = ex
7437 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7438 
    result.write(oprot)
7439 
    oprot.writeMessageEnd()
7440 
    oprot.trans.flush()
7441 
 
7442 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7443 
    args = markOrderDoaRequestAuthorized_args()
7444 
    args.read(iprot)
7445 
    iprot.readMessageEnd()
7446 
    result = markOrderDoaRequestAuthorized_result()
7447 
    try:
7448 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7449 
    except TransactionServiceException, ex:
7450 
      result.ex = ex
7451 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7452 
    result.write(oprot)
7453 
    oprot.writeMessageEnd()
7454 
    oprot.trans.flush()
7455 
 
4488 rajveer 7456 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7457 
    args = markOrderReturnRequestReceived_args()
7458 
    args.read(iprot)
7459 
    iprot.readMessageEnd()
7460 
    result = markOrderReturnRequestReceived_result()
7461 
    try:
7462 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7463 
    except TransactionServiceException, ex:
7464 
      result.ex = ex
7465 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7466 
    result.write(oprot)
7467 
    oprot.writeMessageEnd()
7468 
    oprot.trans.flush()
7469 
 
7470 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7471 
    args = markOrderReturnRequestAuthorized_args()
7472 
    args.read(iprot)
7473 
    iprot.readMessageEnd()
7474 
    result = markOrderReturnRequestAuthorized_result()
7475 
    try:
7476 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7477 
    except TransactionServiceException, ex:
7478 
      result.ex = ex
7479 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7480 
    result.write(oprot)
7481 
    oprot.writeMessageEnd()
7482 
    oprot.trans.flush()
7483 
 
2536 chandransh 7484 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7485 
    args = requestPickupNumber_args()
7486 
    args.read(iprot)
7487 
    iprot.readMessageEnd()
7488 
    result = requestPickupNumber_result()
7489 
    try:
4579 rajveer 7490 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7491 
    except TransactionServiceException, ex:
7492 
      result.ex = ex
7493 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7494 
    result.write(oprot)
7495 
    oprot.writeMessageEnd()
7496 
    oprot.trans.flush()
7497 
 
7498 
  def process_authorizePickup(self, seqid, iprot, oprot):
7499 
    args = authorizePickup_args()
7500 
    args.read(iprot)
7501 
    iprot.readMessageEnd()
7502 
    result = authorizePickup_result()
7503 
    try:
4602 rajveer 7504 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7505 
    except TransactionServiceException, ex:
7506 
      result.ex = ex
7507 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7508 
    result.write(oprot)
7509 
    oprot.writeMessageEnd()
7510 
    oprot.trans.flush()
7511 
 
2764 chandransh 7512 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7513 
    args = markDoasAsPickedUp_args()
7514 
    args.read(iprot)
7515 
    iprot.readMessageEnd()
7516 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7517 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7518 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7519 
    result.write(oprot)
7520 
    oprot.writeMessageEnd()
7521 
    oprot.trans.flush()
7522 
 
4910 phani.kuma 7523 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7524 
    args = getDoasNotPickedUp_args()
7525 
    args.read(iprot)
7526 
    iprot.readMessageEnd()
7527 
    result = getDoasNotPickedUp_result()
7528 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7529 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7530 
    result.write(oprot)
7531 
    oprot.writeMessageEnd()
7532 
    oprot.trans.flush()
7533 
 
4741 phani.kuma 7534 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7535 
    args = markReturnOrdersAsPickedUp_args()
7536 
    args.read(iprot)
7537 
    iprot.readMessageEnd()
7538 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7539 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7540 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7541 
    result.write(oprot)
7542 
    oprot.writeMessageEnd()
7543 
    oprot.trans.flush()
7544 
 
4910 phani.kuma 7545 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7546 
    args = getReturnOrdersNotPickedUp_args()
7547 
    args.read(iprot)
7548 
    iprot.readMessageEnd()
7549 
    result = getReturnOrdersNotPickedUp_result()
7550 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7551 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7552 
    result.write(oprot)
7553 
    oprot.writeMessageEnd()
7554 
    oprot.trans.flush()
7555 
 
2616 chandransh 7556 
  def process_receiveReturn(self, seqid, iprot, oprot):
7557 
    args = receiveReturn_args()
2591 chandransh 7558 
    args.read(iprot)
7559 
    iprot.readMessageEnd()
2616 chandransh 7560 
    result = receiveReturn_result()
2591 chandransh 7561 
    try:
4479 rajveer 7562 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7563 
    except TransactionServiceException, ex:
7564 
      result.ex = ex
2616 chandransh 7565 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7566 
    result.write(oprot)
7567 
    oprot.writeMessageEnd()
7568 
    oprot.trans.flush()
2536 chandransh 7569 
 
2591 chandransh 7570 
  def process_validateDoa(self, seqid, iprot, oprot):
7571 
    args = validateDoa_args()
7572 
    args.read(iprot)
7573 
    iprot.readMessageEnd()
7574 
    result = validateDoa_result()
7575 
    try:
7576 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7577 
    except TransactionServiceException, ex:
7578 
      result.ex = ex
7579 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7580 
    result.write(oprot)
7581 
    oprot.writeMessageEnd()
7582 
    oprot.trans.flush()
7583 
 
4495 rajveer 7584 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7585 
    args = validateReturnProduct_args()
7586 
    args.read(iprot)
7587 
    iprot.readMessageEnd()
7588 
    result = validateReturnProduct_result()
7589 
    try:
7590 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7591 
    except TransactionServiceException, ex:
7592 
      result.ex = ex
7593 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7594 
    result.write(oprot)
7595 
    oprot.writeMessageEnd()
7596 
    oprot.trans.flush()
7597 
 
2616 chandransh 7598 
  def process_reshipOrder(self, seqid, iprot, oprot):
7599 
    args = reshipOrder_args()
7600 
    args.read(iprot)
7601 
    iprot.readMessageEnd()
7602 
    result = reshipOrder_result()
7603 
    try:
7604 
      result.success = self._handler.reshipOrder(args.orderId)
7605 
    except TransactionServiceException, ex:
7606 
      result.ex = ex
7607 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7608 
    result.write(oprot)
7609 
    oprot.writeMessageEnd()
7610 
    oprot.trans.flush()
2591 chandransh 7611 
 
2616 chandransh 7612 
  def process_refundOrder(self, seqid, iprot, oprot):
7613 
    args = refundOrder_args()
7614 
    args.read(iprot)
7615 
    iprot.readMessageEnd()
7616 
    result = refundOrder_result()
7617 
    try:
3226 chandransh 7618 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7619 
    except TransactionServiceException, ex:
7620 
      result.ex = ex
7621 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7622 
    result.write(oprot)
7623 
    oprot.writeMessageEnd()
7624 
    oprot.trans.flush()
7625 
 
2690 chandransh 7626 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7627 
    args = getReturnOrders_args()
7628 
    args.read(iprot)
7629 
    iprot.readMessageEnd()
7630 
    result = getReturnOrders_result()
7631 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7632 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7633 
    result.write(oprot)
7634 
    oprot.writeMessageEnd()
7635 
    oprot.trans.flush()
2616 chandransh 7636 
 
5481 phani.kuma 7637 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7638 
    args = getAllReturnOrders_args()
7639 
    args.read(iprot)
7640 
    iprot.readMessageEnd()
7641 
    result = getAllReturnOrders_result()
7642 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7643 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7644 
    result.write(oprot)
7645 
    oprot.writeMessageEnd()
7646 
    oprot.trans.flush()
7647 
 
2700 chandransh 7648 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7649 
    args = getReturnOrder_args()
7650 
    args.read(iprot)
7651 
    iprot.readMessageEnd()
7652 
    result = getReturnOrder_result()
7653 
    try:
7654 
      result.success = self._handler.getReturnOrder(args.id)
7655 
    except TransactionServiceException, ex:
7656 
      result.ex = ex
7657 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7658 
    result.write(oprot)
7659 
    oprot.writeMessageEnd()
7660 
    oprot.trans.flush()
7661 
 
2690 chandransh 7662 
  def process_processReturn(self, seqid, iprot, oprot):
7663 
    args = processReturn_args()
7664 
    args.read(iprot)
7665 
    iprot.readMessageEnd()
7666 
    result = processReturn_result()
7667 
    try:
7668 
      self._handler.processReturn(args.returnOrderId)
7669 
    except TransactionServiceException, ex:
7670 
      result.ex = ex
7671 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7672 
    result.write(oprot)
7673 
    oprot.writeMessageEnd()
7674 
    oprot.trans.flush()
7675 
 
3451 chandransh 7676 
  def process_updateWeight(self, seqid, iprot, oprot):
7677 
    args = updateWeight_args()
7678 
    args.read(iprot)
7679 
    iprot.readMessageEnd()
7680 
    result = updateWeight_result()
7681 
    try:
7682 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7683 
    except TransactionServiceException, ex:
7684 
      result.ex = ex
7685 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7686 
    result.write(oprot)
7687 
    oprot.writeMessageEnd()
7688 
    oprot.trans.flush()
2819 chandransh 7689 
 
3469 chandransh 7690 
  def process_changeItem(self, seqid, iprot, oprot):
7691 
    args = changeItem_args()
7692 
    args.read(iprot)
7693 
    iprot.readMessageEnd()
7694 
    result = changeItem_result()
7695 
    try:
7696 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7697 
    except TransactionServiceException, ex:
7698 
      result.ex = ex
7699 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7700 
    result.write(oprot)
7701 
    oprot.writeMessageEnd()
7702 
    oprot.trans.flush()
3451 chandransh 7703 
 
3469 chandransh 7704 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7705 
    args = shiftToWarehouse_args()
7706 
    args.read(iprot)
7707 
    iprot.readMessageEnd()
7708 
    result = shiftToWarehouse_result()
7709 
    try:
7710 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7711 
    except TransactionServiceException, ex:
7712 
      result.ex = ex
7713 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7714 
    result.write(oprot)
7715 
    oprot.writeMessageEnd()
7716 
    oprot.trans.flush()
7717 
 
3553 chandransh 7718 
  def process_addDelayReason(self, seqid, iprot, oprot):
7719 
    args = addDelayReason_args()
7720 
    args.read(iprot)
7721 
    iprot.readMessageEnd()
7722 
    result = addDelayReason_result()
7723 
    try:
4647 rajveer 7724 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7725 
    except TransactionServiceException, ex:
7726 
      result.ex = ex
7727 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7728 
    result.write(oprot)
7729 
    oprot.writeMessageEnd()
7730 
    oprot.trans.flush()
3469 chandransh 7731 
 
3956 chandransh 7732 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7733 
    args = reconcileCodCollection_args()
7734 
    args.read(iprot)
7735 
    iprot.readMessageEnd()
7736 
    result = reconcileCodCollection_result()
7737 
    try:
7738 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7739 
    except TransactionServiceException, ex:
7740 
      result.ex = ex
7741 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7742 
    result.write(oprot)
7743 
    oprot.writeMessageEnd()
7744 
    oprot.trans.flush()
3553 chandransh 7745 
 
4008 mandeep.dh 7746 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7747 
    args = getTransactionsRequiringExtraProcessing_args()
7748 
    args.read(iprot)
7749 
    iprot.readMessageEnd()
7750 
    result = getTransactionsRequiringExtraProcessing_result()
7751 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7752 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7753 
    result.write(oprot)
7754 
    oprot.writeMessageEnd()
7755 
    oprot.trans.flush()
3956 chandransh 7756 
 
4008 mandeep.dh 7757 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7758 
    args = markTransactionAsProcessed_args()
7759 
    args.read(iprot)
7760 
    iprot.readMessageEnd()
7761 
    result = markTransactionAsProcessed_result()
7762 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7763 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7764 
    result.write(oprot)
7765 
    oprot.writeMessageEnd()
7766 
    oprot.trans.flush()
7767 
 
4018 chandransh 7768 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7769 
    args = getItemWiseRiskyOrdersCount_args()
7770 
    args.read(iprot)
7771 
    iprot.readMessageEnd()
7772 
    result = getItemWiseRiskyOrdersCount_result()
7773 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7774 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7775 
    result.write(oprot)
7776 
    oprot.writeMessageEnd()
7777 
    oprot.trans.flush()
4008 mandeep.dh 7778 
 
4295 varun.gupt 7779 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7780 
    args = getOrdersForItemIds_args()
7781 
    args.read(iprot)
7782 
    iprot.readMessageEnd()
7783 
    result = getOrdersForItemIds_result()
7784 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7785 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7786 
    result.write(oprot)
7787 
    oprot.writeMessageEnd()
7788 
    oprot.trans.flush()
7789 
 
4247 rajveer 7790 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7791 
    args = markOrderCancellationRequestReceived_args()
7792 
    args.read(iprot)
7793 
    iprot.readMessageEnd()
7794 
    result = markOrderCancellationRequestReceived_result()
7795 
    try:
7796 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7797 
    except TransactionServiceException, ex:
7798 
      result.ex = ex
7799 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7800 
    result.write(oprot)
7801 
    oprot.writeMessageEnd()
7802 
    oprot.trans.flush()
4018 chandransh 7803 
 
4247 rajveer 7804 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7805 
    args = markOrderCancellationRequestConfirmed_args()
7806 
    args.read(iprot)
7807 
    iprot.readMessageEnd()
7808 
    result = markOrderCancellationRequestConfirmed_result()
7809 
    try:
7810 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7811 
    except TransactionServiceException, ex:
7812 
      result.ex = ex
7813 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7814 
    result.write(oprot)
7815 
    oprot.writeMessageEnd()
7816 
    oprot.trans.flush()
7817 
 
7818 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7819 
    args = markOrderCancellationRequestDenied_args()
7820 
    args.read(iprot)
7821 
    iprot.readMessageEnd()
7822 
    result = markOrderCancellationRequestDenied_result()
7823 
    try:
7824 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7825 
    except TransactionServiceException, ex:
7826 
      result.ex = ex
7827 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
7828 
    result.write(oprot)
7829 
    oprot.writeMessageEnd()
7830 
    oprot.trans.flush()
7831 
 
4258 rajveer 7832 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
7833 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 7834 
    args.read(iprot)
7835 
    iprot.readMessageEnd()
4258 rajveer 7836 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 7837 
    try:
4258 rajveer 7838 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 7839 
    except TransactionServiceException, ex:
7840 
      result.ex = ex
4258 rajveer 7841 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 7842 
    result.write(oprot)
7843 
    oprot.writeMessageEnd()
7844 
    oprot.trans.flush()
7845 
 
4259 anupam.sin 7846 
  def process_refundTransaction(self, seqid, iprot, oprot):
7847 
    args = refundTransaction_args()
7848 
    args.read(iprot)
7849 
    iprot.readMessageEnd()
7850 
    result = refundTransaction_result()
7851 
    try:
7852 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
7853 
    except TransactionServiceException, ex:
7854 
      result.ex = ex
7855 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
7856 
    result.write(oprot)
7857 
    oprot.writeMessageEnd()
7858 
    oprot.trans.flush()
4247 rajveer 7859 
 
4324 mandeep.dh 7860 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
7861 
    args = updateShipmentAddress_args()
7862 
    args.read(iprot)
7863 
    iprot.readMessageEnd()
7864 
    result = updateShipmentAddress_result()
7865 
    try:
7866 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
7867 
    except TransactionServiceException, ex:
7868 
      result.ex = ex
7869 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
7870 
    result.write(oprot)
7871 
    oprot.writeMessageEnd()
7872 
    oprot.trans.flush()
7873 
 
4285 rajveer 7874 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
7875 
    args = acceptOrdersForItemId_args()
7876 
    args.read(iprot)
7877 
    iprot.readMessageEnd()
7878 
    result = acceptOrdersForItemId_result()
7879 
    try:
7880 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
7881 
    except TransactionServiceException, ex:
7882 
      result.ex = ex
7883 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
7884 
    result.write(oprot)
7885 
    oprot.writeMessageEnd()
7886 
    oprot.trans.flush()
4259 anupam.sin 7887 
 
4303 rajveer 7888 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
7889 
    args = markOrdersAsPORaised_args()
7890 
    args.read(iprot)
7891 
    iprot.readMessageEnd()
7892 
    result = markOrdersAsPORaised_result()
7893 
    try:
4369 rajveer 7894 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7895 
    except TransactionServiceException, ex:
7896 
      result.ex = ex
7897 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
7898 
    result.write(oprot)
7899 
    oprot.writeMessageEnd()
7900 
    oprot.trans.flush()
4285 rajveer 7901 
 
4303 rajveer 7902 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
7903 
    args = markOrdersAsReversalInitiated_args()
7904 
    args.read(iprot)
7905 
    iprot.readMessageEnd()
7906 
    result = markOrdersAsReversalInitiated_result()
7907 
    try:
4369 rajveer 7908 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7909 
    except TransactionServiceException, ex:
7910 
      result.ex = ex
7911 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
7912 
    result.write(oprot)
7913 
    oprot.writeMessageEnd()
7914 
    oprot.trans.flush()
7915 
 
7916 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
7917 
    args = markOrdersAsNotAvailabke_args()
7918 
    args.read(iprot)
7919 
    iprot.readMessageEnd()
7920 
    result = markOrdersAsNotAvailabke_result()
7921 
    try:
4369 rajveer 7922 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7923 
    except TransactionServiceException, ex:
7924 
      result.ex = ex
7925 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
7926 
    result.write(oprot)
7927 
    oprot.writeMessageEnd()
7928 
    oprot.trans.flush()
7929 
 
4369 rajveer 7930 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
7931 
    args = markOrdersAsTimeout_args()
7932 
    args.read(iprot)
7933 
    iprot.readMessageEnd()
7934 
    result = markOrdersAsTimeout_result()
7935 
    try:
7936 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
7937 
    except TransactionServiceException, ex:
7938 
      result.ex = ex
7939 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
7940 
    result.write(oprot)
7941 
    oprot.writeMessageEnd()
7942 
    oprot.trans.flush()
4303 rajveer 7943 
 
4662 rajveer 7944 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
7945 
    args = markOrderAsLostInTransit_args()
7946 
    args.read(iprot)
7947 
    iprot.readMessageEnd()
7948 
    result = markOrderAsLostInTransit_result()
7949 
    try:
7950 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
7951 
    except TransactionServiceException, ex:
7952 
      result.ex = ex
7953 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
7954 
    result.write(oprot)
7955 
    oprot.writeMessageEnd()
7956 
    oprot.trans.flush()
7957 
 
4386 anupam.sin 7958 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
7959 
    args = getOrderForAwb_args()
7960 
    args.read(iprot)
7961 
    iprot.readMessageEnd()
7962 
    result = getOrderForAwb_result()
7963 
    try:
7964 
      result.success = self._handler.getOrderForAwb(args.awb)
7965 
    except TransactionServiceException, ex:
7966 
      result.ex = ex
7967 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
7968 
    result.write(oprot)
7969 
    oprot.writeMessageEnd()
7970 
    oprot.trans.flush()
4369 rajveer 7971 
 
4506 phani.kuma 7972 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
7973 
    args = getOrdersForProviderForStatus_args()
7974 
    args.read(iprot)
7975 
    iprot.readMessageEnd()
7976 
    result = getOrdersForProviderForStatus_result()
7977 
    try:
4910 phani.kuma 7978 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 7979 
    except TransactionServiceException, ex:
7980 
      result.ex = ex
7981 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
7982 
    result.write(oprot)
7983 
    oprot.writeMessageEnd()
7984 
    oprot.trans.flush()
4386 anupam.sin 7985 
 
4600 varun.gupt 7986 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
7987 
    args = getBilledOrdersForVendor_args()
7988 
    args.read(iprot)
7989 
    iprot.readMessageEnd()
7990 
    result = getBilledOrdersForVendor_result()
7991 
    try:
7992 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
7993 
    except TransactionServiceException, ex:
7994 
      result.ex = ex
7995 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
7996 
    result.write(oprot)
7997 
    oprot.writeMessageEnd()
7998 
    oprot.trans.flush()
4506 phani.kuma 7999 
 
4607 rajveer 8000 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
8001 
    args = getSlippedSippingDateOrders_args()
8002 
    args.read(iprot)
8003 
    iprot.readMessageEnd()
8004 
    result = getSlippedSippingDateOrders_result()
8005 
    try:
8006 
      result.success = self._handler.getSlippedSippingDateOrders()
8007 
    except TransactionServiceException, ex:
8008 
      result.ex = ex
8009 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
8010 
    result.write(oprot)
8011 
    oprot.writeMessageEnd()
8012 
    oprot.trans.flush()
8013 
 
4709 rajveer 8014 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
8015 
    args = getCancelledOrders_args()
8016 
    args.read(iprot)
8017 
    iprot.readMessageEnd()
8018 
    result = getCancelledOrders_result()
8019 
    try:
8020 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
8021 
    except TransactionServiceException, ex:
8022 
      result.ex = ex
8023 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
8024 
    result.write(oprot)
8025 
    oprot.writeMessageEnd()
8026 
    oprot.trans.flush()
8027 
 
4600 varun.gupt 8028 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
8029 
    args = saveBluedartSettlements_args()
8030 
    args.read(iprot)
8031 
    iprot.readMessageEnd()
8032 
    result = saveBluedartSettlements_result()
8033 
    try:
8034 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
8035 
    except TransactionServiceException, ex:
8036 
      result.ex = ex
8037 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
8038 
    result.write(oprot)
8039 
    oprot.writeMessageEnd()
8040 
    oprot.trans.flush()
8041 
 
8042 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
8043 
    args = savePaymentSettlements_args()
8044 
    args.read(iprot)
8045 
    iprot.readMessageEnd()
8046 
    result = savePaymentSettlements_result()
8047 
    try:
4905 varun.gupt 8048 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 8049 
    except TransactionServiceException, ex:
8050 
      result.ex = ex
8051 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
8052 
    result.write(oprot)
8053 
    oprot.writeMessageEnd()
8054 
    oprot.trans.flush()
8055 
 
8056 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
8057 
    args = saveEBSSettlementSummary_args()
8058 
    args.read(iprot)
8059 
    iprot.readMessageEnd()
8060 
    result = saveEBSSettlementSummary_result()
8061 
    try:
8062 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
8063 
    except TransactionServiceException, ex:
8064 
      result.ex = ex
8065 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
8066 
    result.write(oprot)
8067 
    oprot.writeMessageEnd()
8068 
    oprot.trans.flush()
8069 
 
5386 phani.kuma 8070 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
8071 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 8072 
    args.read(iprot)
8073 
    iprot.readMessageEnd()
5386 phani.kuma 8074 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 8075 
    try:
5386 phani.kuma 8076 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 8077 
    except TransactionServiceException, ex:
8078 
      result.ex = ex
5386 phani.kuma 8079 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 8080 
    result.write(oprot)
8081 
    oprot.writeMessageEnd()
8082 
    oprot.trans.flush()
8083 
 
5386 phani.kuma 8084 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
8085 
    args = getSettlementForCod_args()
8086 
    args.read(iprot)
8087 
    iprot.readMessageEnd()
8088 
    result = getSettlementForCod_result()
8089 
    try:
8090 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
8091 
    except TransactionServiceException, ex:
8092 
      result.ex = ex
8093 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
8094 
    result.write(oprot)
8095 
    oprot.writeMessageEnd()
8096 
    oprot.trans.flush()
8097 
 
4600 varun.gupt 8098 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
8099 
    args = getEBSSettlementSummaries_args()
8100 
    args.read(iprot)
8101 
    iprot.readMessageEnd()
8102 
    result = getEBSSettlementSummaries_result()
8103 
    try:
8104 
      result.success = self._handler.getEBSSettlementSummaries()
8105 
    except TransactionServiceException, ex:
8106 
      result.ex = ex
8107 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
8108 
    result.write(oprot)
8109 
    oprot.writeMessageEnd()
8110 
    oprot.trans.flush()
8111 
 
8112 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
8113 
    args = markEBSSettlementUploaded_args()
8114 
    args.read(iprot)
8115 
    iprot.readMessageEnd()
8116 
    result = markEBSSettlementUploaded_result()
8117 
    try:
8118 
      self._handler.markEBSSettlementUploaded(args.settlementId)
8119 
    except TransactionServiceException, ex:
8120 
      result.ex = ex
8121 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
8122 
    result.write(oprot)
8123 
    oprot.writeMessageEnd()
8124 
    oprot.trans.flush()
8125 
 
8126 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
8127 
    args = getEBSSettlementDate_args()
8128 
    args.read(iprot)
8129 
    iprot.readMessageEnd()
8130 
    result = getEBSSettlementDate_result()
8131 
    try:
8132 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
8133 
    except TransactionServiceException, ex:
8134 
      result.ex = ex
8135 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
8136 
    result.write(oprot)
8137 
    oprot.writeMessageEnd()
8138 
    oprot.trans.flush()
8139 
 
4715 varun.gupt 8140 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
8141 
    args = getSettlementsByDate_args()
8142 
    args.read(iprot)
8143 
    iprot.readMessageEnd()
8144 
    result = getSettlementsByDate_result()
8145 
    try:
8146 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
8147 
    except TransactionServiceException, ex:
8148 
      result.ex = ex
8149 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
8150 
    result.write(oprot)
8151 
    oprot.writeMessageEnd()
8152 
    oprot.trans.flush()
4600 varun.gupt 8153 
 
4715 varun.gupt 8154 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
8155 
    args = getReshippedOrderIds_args()
8156 
    args.read(iprot)
8157 
    iprot.readMessageEnd()
8158 
    result = getReshippedOrderIds_result()
8159 
    try:
8160 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8161 
    except TransactionServiceException, ex:
8162 
      result.ex = ex
8163 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8164 
    result.write(oprot)
8165 
    oprot.writeMessageEnd()
8166 
    oprot.trans.flush()
8167 
 
5481 phani.kuma 8168 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8169 
    args = getBilledOrders_args()
4875 varun.gupt 8170 
    args.read(iprot)
8171 
    iprot.readMessageEnd()
5481 phani.kuma 8172 
    result = getBilledOrders_result()
4875 varun.gupt 8173 
    try:
5481 phani.kuma 8174 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8175 
    except TransactionServiceException, ex:
8176 
      result.ex = ex
5481 phani.kuma 8177 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8178 
    result.write(oprot)
8179 
    oprot.writeMessageEnd()
8180 
    oprot.trans.flush()
4757 mandeep.dh 8181 
 
5031 varun.gupt 8182 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8183 
    args = getStatusDistributionOfOrders_args()
8184 
    args.read(iprot)
8185 
    iprot.readMessageEnd()
8186 
    result = getStatusDistributionOfOrders_result()
8187 
    try:
8188 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8189 
    except TransactionServiceException, ex:
8190 
      result.ex = ex
8191 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8192 
    result.write(oprot)
8193 
    oprot.writeMessageEnd()
8194 
    oprot.trans.flush()
4875 varun.gupt 8195 
 
5067 varun.gupt 8196 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8197 
    args = getOrderIdsForStatus_args()
8198 
    args.read(iprot)
8199 
    iprot.readMessageEnd()
8200 
    result = getOrderIdsForStatus_result()
8201 
    try:
8202 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8203 
    except TransactionServiceException, ex:
8204 
      result.ex = ex
8205 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8206 
    result.write(oprot)
8207 
    oprot.writeMessageEnd()
8208 
    oprot.trans.flush()
5031 varun.gupt 8209 
 
5348 anupam.sin 8210 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8211 
    args = updateCODAgent_args()
8212 
    args.read(iprot)
8213 
    iprot.readMessageEnd()
8214 
    result = updateCODAgent_result()
8215 
    try:
8216 
      self._handler.updateCODAgent(args.agent, args.orderId)
8217 
    except TransactionServiceException, ex:
8218 
      result.ex = ex
8219 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8220 
    result.write(oprot)
8221 
    oprot.writeMessageEnd()
8222 
    oprot.trans.flush()
8223 
 
5099 varun.gupt 8224 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8225 
    args = updateOrderAsPaidToVendor_args()
8226 
    args.read(iprot)
8227 
    iprot.readMessageEnd()
8228 
    result = updateOrderAsPaidToVendor_result()
8229 
    try:
8230 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8231 
    except TransactionServiceException, ex:
8232 
      result.ex = ex
8233 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8234 
    result.write(oprot)
8235 
    oprot.writeMessageEnd()
8236 
    oprot.trans.flush()
5067 varun.gupt 8237 
 
5386 phani.kuma 8238 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8239 
    args = updateOrderOnlyAsPaidToVendor_args()
8240 
    args.read(iprot)
8241 
    iprot.readMessageEnd()
8242 
    result = updateOrderOnlyAsPaidToVendor_result()
8243 
    try:
8244 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8245 
    except TransactionServiceException, ex:
8246 
      result.ex = ex
8247 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8248 
    result.write(oprot)
8249 
    oprot.writeMessageEnd()
8250 
    oprot.trans.flush()
8251 
 
5208 varun.gupt 8252 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8253 
    args = getRefundedOrdersMarkedPaid_args()
8254 
    args.read(iprot)
8255 
    iprot.readMessageEnd()
8256 
    result = getRefundedOrdersMarkedPaid_result()
8257 
    try:
8258 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8259 
    except TransactionServiceException, ex:
8260 
      result.ex = ex
8261 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8262 
    result.write(oprot)
8263 
    oprot.writeMessageEnd()
8264 
    oprot.trans.flush()
5099 varun.gupt 8265 
 
5447 anupam.sin 8266 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8267 
    args = getAllVerificationAgents_args()
8268 
    args.read(iprot)
8269 
    iprot.readMessageEnd()
8270 
    result = getAllVerificationAgents_result()
8271 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8272 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8273 
    result.write(oprot)
8274 
    oprot.writeMessageEnd()
8275 
    oprot.trans.flush()
5208 varun.gupt 8276 
 
5527 anupam.sin 8277 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8278 
    args = getAllAttributesForOrderId_args()
8279 
    args.read(iprot)
8280 
    iprot.readMessageEnd()
8281 
    result = getAllAttributesForOrderId_result()
8282 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8283 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8284 
    result.write(oprot)
8285 
    oprot.writeMessageEnd()
8286 
    oprot.trans.flush()
5447 anupam.sin 8287 
 
5676 rajveer 8288 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8289 
    args = setOrderAttributes_args()
8290 
    args.read(iprot)
8291 
    iprot.readMessageEnd()
8292 
    result = setOrderAttributes_result()
8293 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8294 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8295 
    result.write(oprot)
8296 
    oprot.writeMessageEnd()
8297 
    oprot.trans.flush()
8298 
 
5527 anupam.sin 8299 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8300 
    args = setOrderAttributeForTransaction_args()
8301 
    args.read(iprot)
8302 
    iprot.readMessageEnd()
8303 
    result = setOrderAttributeForTransaction_result()
8304 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8305 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8306 
    result.write(oprot)
8307 
    oprot.writeMessageEnd()
8308 
    oprot.trans.flush()
8309 
 
5553 rajveer 8310 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8311 
    args = getReceivePendingOrders_args()
8312 
    args.read(iprot)
8313 
    iprot.readMessageEnd()
8314 
    result = getReceivePendingOrders_result()
8315 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8316 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8317 
    result.write(oprot)
8318 
    oprot.writeMessageEnd()
8319 
    oprot.trans.flush()
5527 anupam.sin 8320 
 
5553 rajveer 8321 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8322 
    args = getReceivedAtStoreOrders_args()
8323 
    args.read(iprot)
8324 
    iprot.readMessageEnd()
8325 
    result = getReceivedAtStoreOrders_result()
8326 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8327 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8328 
    result.write(oprot)
8329 
    oprot.writeMessageEnd()
8330 
    oprot.trans.flush()
8331 
 
5713 rajveer 8332 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8333 
    args = getOrdersCollectionAtStore_args()
8334 
    args.read(iprot)
8335 
    iprot.readMessageEnd()
8336 
    result = getOrdersCollectionAtStore_result()
8337 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8338 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8339 
    result.write(oprot)
8340 
    oprot.writeMessageEnd()
8341 
    oprot.trans.flush()
8342 
 
5833 rajveer 8343 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8344 
    args = getOrderAttributeValue_args()
8345 
    args.read(iprot)
8346 
    iprot.readMessageEnd()
8347 
    result = getOrderAttributeValue_result()
8348 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8349 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8350 
    result.write(oprot)
8351 
    oprot.writeMessageEnd()
8352 
    oprot.trans.flush()
8353 
 
6019 rajveer 8354 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8355 
    args = changeJacketNumber_args()
8356 
    args.read(iprot)
8357 
    iprot.readMessageEnd()
8358 
    result = changeJacketNumber_result()
8359 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8360 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8361 
    result.write(oprot)
8362 
    oprot.writeMessageEnd()
8363 
    oprot.trans.flush()
8364 
 
8365 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8366 
    args = markOrderAsRtoInTransit_args()
8367 
    args.read(iprot)
8368 
    iprot.readMessageEnd()
8369 
    result = markOrderAsRtoInTransit_result()
8370 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8371 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8372 
    result.write(oprot)
8373 
    oprot.writeMessageEnd()
8374 
    oprot.trans.flush()
8375 
 
5593 mandeep.dh 8376 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8377 
    args = acceptOrderForItem_args()
8378 
    args.read(iprot)
8379 
    iprot.readMessageEnd()
8380 
    result = acceptOrderForItem_result()
8381 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8382 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8383 
    result.write(oprot)
8384 
    oprot.writeMessageEnd()
8385 
    oprot.trans.flush()
5553 rajveer 8386 
 
6000 mandeep.dh 8387 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8388 
    args = createRechargeOrder_args()
8389 
    args.read(iprot)
8390 
    iprot.readMessageEnd()
8391 
    result = createRechargeOrder_result()
8392 
    try:
8393 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8394 
    except TransactionServiceException, ex:
8395 
      result.ex = ex
8396 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8397 
    result.write(oprot)
8398 
    oprot.writeMessageEnd()
8399 
    oprot.trans.flush()
5593 mandeep.dh 8400 
 
6031 rajveer 8401 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8402 
    args = getRechargeOrder_args()
8403 
    args.read(iprot)
8404 
    iprot.readMessageEnd()
8405 
    result = getRechargeOrder_result()
8406 
    try:
8407 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8408 
    except TransactionServiceException, ex:
8409 
      result.ex = ex
8410 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8411 
    result.write(oprot)
8412 
    oprot.writeMessageEnd()
8413 
    oprot.trans.flush()
8414 
 
8415 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8416 
    args = getRechargeOrders_args()
8417 
    args.read(iprot)
8418 
    iprot.readMessageEnd()
8419 
    result = getRechargeOrders_result()
8420 
    result.success = self._handler.getRechargeOrders(args.userId)
8421 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8422 
    result.write(oprot)
8423 
    oprot.writeMessageEnd()
8424 
    oprot.trans.flush()
8425 
 
6000 mandeep.dh 8426 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8427 
    args = updateRechargeOrderStatus_args()
8428 
    args.read(iprot)
8429 
    iprot.readMessageEnd()
8430 
    result = updateRechargeOrderStatus_result()
8431 
    try:
6031 rajveer 8432 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8433 
    except TransactionServiceException, ex:
8434 
      result.ex = ex
8435 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8436 
    result.write(oprot)
8437 
    oprot.writeMessageEnd()
8438 
    oprot.trans.flush()
8439 
 
8440 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8441 
    args = activateRechargeTxn_args()
8442 
    args.read(iprot)
8443 
    iprot.readMessageEnd()
8444 
    result = activateRechargeTxn_result()
8445 
    try:
6031 rajveer 8446 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8447 
    except TransactionServiceException, ex:
8448 
      result.ex = ex
8449 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8450 
    result.write(oprot)
8451 
    oprot.writeMessageEnd()
8452 
    oprot.trans.flush()
8453 
 
6031 rajveer 8454 
  def process_getUserWallet(self, seqid, iprot, oprot):
8455 
    args = getUserWallet_args()
6000 mandeep.dh 8456 
    args.read(iprot)
8457 
    iprot.readMessageEnd()
6031 rajveer 8458 
    result = getUserWallet_result()
8459 
    result.success = self._handler.getUserWallet(args.userId)
8460 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8461 
    result.write(oprot)
8462 
    oprot.writeMessageEnd()
8463 
    oprot.trans.flush()
8464 
 
6031 rajveer 8465 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8466 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8467 
    args.read(iprot)
8468 
    iprot.readMessageEnd()
6031 rajveer 8469 
    result = getUserWalletHistory_result()
8470 
    result.success = self._handler.getUserWalletHistory(args.userId)
8471 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8472 
    result.write(oprot)
8473 
    oprot.writeMessageEnd()
8474 
    oprot.trans.flush()
8475 
 
6050 anupam.sin 8476 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8477 
    args = getRechargeOrdersForTransaction_args()
8478 
    args.read(iprot)
8479 
    iprot.readMessageEnd()
8480 
    result = getRechargeOrdersForTransaction_result()
8481 
    try:
8482 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8483 
    except TransactionServiceException, ex:
8484 
      result.ex = ex
8485 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8486 
    result.write(oprot)
8487 
    oprot.writeMessageEnd()
8488 
    oprot.trans.flush()
8489 
 
6048 rajveer 8490 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8491 
    args = getServiceProviders_args()
8492 
    args.read(iprot)
8493 
    iprot.readMessageEnd()
8494 
    result = getServiceProviders_result()
6206 rajveer 8495 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 8496 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8497 
    result.write(oprot)
8498 
    oprot.writeMessageEnd()
8499 
    oprot.trans.flush()
6000 mandeep.dh 8500 
 
6048 rajveer 8501 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8502 
    args = getServiceProviderForDevice_args()
8503 
    args.read(iprot)
8504 
    iprot.readMessageEnd()
8505 
    result = getServiceProviderForDevice_result()
6049 rajveer 8506 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8507 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8508 
    result.write(oprot)
8509 
    oprot.writeMessageEnd()
8510 
    oprot.trans.flush()
8511 
 
6269 rajveer 8512 
  def process_validateRecharge(self, seqid, iprot, oprot):
8513 
    args = validateRecharge_args()
8514 
    args.read(iprot)
8515 
    iprot.readMessageEnd()
8516 
    result = validateRecharge_result()
6591 anupam.sin 8517 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId, args.clientAddress)
6269 rajveer 8518 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
8519 
    result.write(oprot)
8520 
    oprot.writeMessageEnd()
8521 
    oprot.trans.flush()
8522 
 
6094 rajveer 8523 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8524 
    args = getRechargeOrdersForDevice_args()
8525 
    args.read(iprot)
8526 
    iprot.readMessageEnd()
8527 
    result = getRechargeOrdersForDevice_result()
8528 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8529 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8530 
    result.write(oprot)
8531 
    oprot.writeMessageEnd()
8532 
    oprot.trans.flush()
6048 rajveer 8533 
 
6094 rajveer 8534 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8535 
    args = addAmountToWallet_args()
8536 
    args.read(iprot)
8537 
    iprot.readMessageEnd()
8538 
    result = addAmountToWallet_result()
8539 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8540 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8541 
    result.write(oprot)
8542 
    oprot.writeMessageEnd()
8543 
    oprot.trans.flush()
8544 
 
6188 rajveer 8545 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
8546 
    args = getRechargeStatistics_args()
8547 
    args.read(iprot)
8548 
    iprot.readMessageEnd()
8549 
    result = getRechargeStatistics_result()
8550 
    result.success = self._handler.getRechargeStatistics()
8551 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
8552 
    result.write(oprot)
8553 
    oprot.writeMessageEnd()
8554 
    oprot.trans.flush()
8555 
 
6154 rajveer 8556 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
8557 
    args = getRechargeOrdersForStatus_args()
8558 
    args.read(iprot)
8559 
    iprot.readMessageEnd()
8560 
    result = getRechargeOrdersForStatus_result()
8561 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
8562 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
8563 
    result.write(oprot)
8564 
    oprot.writeMessageEnd()
8565 
    oprot.trans.flush()
6094 rajveer 8566 
 
6159 rajveer 8567 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
8568 
    args = getPlansForOperator_args()
8569 
    args.read(iprot)
8570 
    iprot.readMessageEnd()
8571 
    result = getPlansForOperator_result()
8572 
    result.success = self._handler.getPlansForOperator(args.operatorId)
8573 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
8574 
    result.write(oprot)
8575 
    oprot.writeMessageEnd()
8576 
    oprot.trans.flush()
6154 rajveer 8577 
 
6289 anupam.sin 8578 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
8579 
    args = getRechargeDenominations_args()
8580 
    args.read(iprot)
8581 
    iprot.readMessageEnd()
8582 
    result = getRechargeDenominations_result()
8583 
    try:
6307 anupam.sin 8584 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 8585 
    except TransactionServiceException, ex:
8586 
      result.ex = ex
8587 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
8588 
    result.write(oprot)
8589 
    oprot.writeMessageEnd()
8590 
    oprot.trans.flush()
6159 rajveer 8591 
 
6371 rajveer 8592 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
8593 
    args = updateAvailabilityStatus_args()
8594 
    args.read(iprot)
8595 
    iprot.readMessageEnd()
8596 
    result = updateAvailabilityStatus_result()
8597 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
8598 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
8599 
    result.write(oprot)
8600 
    oprot.writeMessageEnd()
8601 
    oprot.trans.flush()
6289 anupam.sin 8602 
 
6389 rajveer 8603 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
8604 
    args = getAvailableEmiSchemes_args()
8605 
    args.read(iprot)
8606 
    iprot.readMessageEnd()
8607 
    result = getAvailableEmiSchemes_result()
8608 
    result.success = self._handler.getAvailableEmiSchemes()
8609 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
8610 
    result.write(oprot)
8611 
    oprot.writeMessageEnd()
8612 
    oprot.trans.flush()
6371 rajveer 8613 
 
6389 rajveer 8614 
  def process_getMiscCharges(self, seqid, iprot, oprot):
8615 
    args = getMiscCharges_args()
8616 
    args.read(iprot)
8617 
    iprot.readMessageEnd()
8618 
    result = getMiscCharges_result()
8619 
    result.success = self._handler.getMiscCharges(args.transactionId)
8620 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
8621 
    result.write(oprot)
8622 
    oprot.writeMessageEnd()
8623 
    oprot.trans.flush()
8624 
 
6507 anupam.sin 8625 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
8626 
    args = refundRechargeOrder_args()
8627 
    args.read(iprot)
8628 
    iprot.readMessageEnd()
8629 
    result = refundRechargeOrder_result()
8630 
    try:
8631 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
8632 
    except TransactionServiceException, ex:
8633 
      result.ex = ex
8634 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
8635 
    result.write(oprot)
8636 
    oprot.writeMessageEnd()
8637 
    oprot.trans.flush()
6389 rajveer 8638 
 
6507 anupam.sin 8639 
 
94 ashish 8640 
# HELPER FUNCTIONS AND STRUCTURES
8641 
 
8642 
class createTransaction_args:
8643 
  """
8644 
  Attributes:
8645 
   - transaction
8646 
  """
8647 
 
8648 
  thrift_spec = (
8649 
    None, # 0
8650 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8651 
  )
8652 
 
8653 
  def __init__(self, transaction=None,):
8654 
    self.transaction = transaction
8655 
 
8656 
  def read(self, iprot):
8657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8659 
      return
8660 
    iprot.readStructBegin()
8661 
    while True:
8662 
      (fname, ftype, fid) = iprot.readFieldBegin()
8663 
      if ftype == TType.STOP:
8664 
        break
8665 
      if fid == 1:
8666 
        if ftype == TType.STRUCT:
8667 
          self.transaction = Transaction()
8668 
          self.transaction.read(iprot)
8669 
        else:
8670 
          iprot.skip(ftype)
8671 
      else:
8672 
        iprot.skip(ftype)
8673 
      iprot.readFieldEnd()
8674 
    iprot.readStructEnd()
8675 
 
8676 
  def write(self, oprot):
8677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8679 
      return
8680 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8681 
    if self.transaction is not None:
94 ashish 8682 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
8683 
      self.transaction.write(oprot)
8684 
      oprot.writeFieldEnd()
8685 
    oprot.writeFieldStop()
8686 
    oprot.writeStructEnd()
8687 
 
3431 rajveer 8688 
  def validate(self):
8689 
    return
8690 
 
8691 
 
94 ashish 8692 
  def __repr__(self):
8693 
    L = ['%s=%r' % (key, value)
8694 
      for key, value in self.__dict__.iteritems()]
8695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8696 
 
8697 
  def __eq__(self, other):
8698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8699 
 
8700 
  def __ne__(self, other):
8701 
    return not (self == other)
8702 
 
8703 
class createTransaction_result:
8704 
  """
8705 
  Attributes:
132 ashish 8706 
   - success
94 ashish 8707 
   - ex
8708 
  """
8709 
 
8710 
  thrift_spec = (
132 ashish 8711 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8712 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8713 
  )
8714 
 
132 ashish 8715 
  def __init__(self, success=None, ex=None,):
8716 
    self.success = success
94 ashish 8717 
    self.ex = ex
8718 
 
8719 
  def read(self, iprot):
8720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8722 
      return
8723 
    iprot.readStructBegin()
8724 
    while True:
8725 
      (fname, ftype, fid) = iprot.readFieldBegin()
8726 
      if ftype == TType.STOP:
8727 
        break
132 ashish 8728 
      if fid == 0:
8729 
        if ftype == TType.I64:
8730 
          self.success = iprot.readI64();
8731 
        else:
8732 
          iprot.skip(ftype)
8733 
      elif fid == 1:
94 ashish 8734 
        if ftype == TType.STRUCT:
8735 
          self.ex = TransactionServiceException()
8736 
          self.ex.read(iprot)
8737 
        else:
8738 
          iprot.skip(ftype)
8739 
      else:
8740 
        iprot.skip(ftype)
8741 
      iprot.readFieldEnd()
8742 
    iprot.readStructEnd()
8743 
 
8744 
  def write(self, oprot):
8745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8747 
      return
8748 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 8749 
    if self.success is not None:
132 ashish 8750 
      oprot.writeFieldBegin('success', TType.I64, 0)
8751 
      oprot.writeI64(self.success)
8752 
      oprot.writeFieldEnd()
3431 rajveer 8753 
    if self.ex is not None:
94 ashish 8754 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8755 
      self.ex.write(oprot)
8756 
      oprot.writeFieldEnd()
8757 
    oprot.writeFieldStop()
8758 
    oprot.writeStructEnd()
8759 
 
3431 rajveer 8760 
  def validate(self):
8761 
    return
8762 
 
8763 
 
94 ashish 8764 
  def __repr__(self):
8765 
    L = ['%s=%r' % (key, value)
8766 
      for key, value in self.__dict__.iteritems()]
8767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8768 
 
8769 
  def __eq__(self, other):
8770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8771 
 
8772 
  def __ne__(self, other):
8773 
    return not (self == other)
8774 
 
8775 
class getTransaction_args:
8776 
  """
8777 
  Attributes:
8778 
   - id
8779 
  """
8780 
 
8781 
  thrift_spec = (
8782 
    None, # 0
8783 
    (1, TType.I64, 'id', None, None, ), # 1
8784 
  )
8785 
 
8786 
  def __init__(self, id=None,):
8787 
    self.id = id
8788 
 
8789 
  def read(self, iprot):
8790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8792 
      return
8793 
    iprot.readStructBegin()
8794 
    while True:
8795 
      (fname, ftype, fid) = iprot.readFieldBegin()
8796 
      if ftype == TType.STOP:
8797 
        break
8798 
      if fid == 1:
8799 
        if ftype == TType.I64:
8800 
          self.id = iprot.readI64();
8801 
        else:
8802 
          iprot.skip(ftype)
8803 
      else:
8804 
        iprot.skip(ftype)
8805 
      iprot.readFieldEnd()
8806 
    iprot.readStructEnd()
8807 
 
8808 
  def write(self, oprot):
8809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8811 
      return
8812 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 8813 
    if self.id is not None:
94 ashish 8814 
      oprot.writeFieldBegin('id', TType.I64, 1)
8815 
      oprot.writeI64(self.id)
8816 
      oprot.writeFieldEnd()
8817 
    oprot.writeFieldStop()
8818 
    oprot.writeStructEnd()
8819 
 
3431 rajveer 8820 
  def validate(self):
8821 
    return
8822 
 
8823 
 
94 ashish 8824 
  def __repr__(self):
8825 
    L = ['%s=%r' % (key, value)
8826 
      for key, value in self.__dict__.iteritems()]
8827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8828 
 
8829 
  def __eq__(self, other):
8830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8831 
 
8832 
  def __ne__(self, other):
8833 
    return not (self == other)
8834 
 
8835 
class getTransaction_result:
8836 
  """
8837 
  Attributes:
8838 
   - success
8839 
   - ex
8840 
  """
8841 
 
8842 
  thrift_spec = (
8843 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
8844 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8845 
  )
8846 
 
8847 
  def __init__(self, success=None, ex=None,):
8848 
    self.success = success
8849 
    self.ex = ex
8850 
 
8851 
  def read(self, iprot):
8852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8854 
      return
8855 
    iprot.readStructBegin()
8856 
    while True:
8857 
      (fname, ftype, fid) = iprot.readFieldBegin()
8858 
      if ftype == TType.STOP:
8859 
        break
8860 
      if fid == 0:
8861 
        if ftype == TType.STRUCT:
8862 
          self.success = Transaction()
8863 
          self.success.read(iprot)
8864 
        else:
8865 
          iprot.skip(ftype)
8866 
      elif fid == 1:
8867 
        if ftype == TType.STRUCT:
8868 
          self.ex = TransactionServiceException()
8869 
          self.ex.read(iprot)
8870 
        else:
8871 
          iprot.skip(ftype)
8872 
      else:
8873 
        iprot.skip(ftype)
8874 
      iprot.readFieldEnd()
8875 
    iprot.readStructEnd()
8876 
 
8877 
  def write(self, oprot):
8878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8880 
      return
8881 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 8882 
    if self.success is not None:
94 ashish 8883 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8884 
      self.success.write(oprot)
8885 
      oprot.writeFieldEnd()
3431 rajveer 8886 
    if self.ex is not None:
94 ashish 8887 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8888 
      self.ex.write(oprot)
8889 
      oprot.writeFieldEnd()
8890 
    oprot.writeFieldStop()
8891 
    oprot.writeStructEnd()
8892 
 
3431 rajveer 8893 
  def validate(self):
8894 
    return
8895 
 
8896 
 
94 ashish 8897 
  def __repr__(self):
8898 
    L = ['%s=%r' % (key, value)
8899 
      for key, value in self.__dict__.iteritems()]
8900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8901 
 
8902 
  def __eq__(self, other):
8903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8904 
 
8905 
  def __ne__(self, other):
8906 
    return not (self == other)
8907 
 
8908 
class getTransactionsForCustomer_args:
8909 
  """
8910 
  Attributes:
8911 
   - customerId
8912 
   - from_date
8913 
   - to_date
8914 
   - status
8915 
  """
8916 
 
8917 
  thrift_spec = (
8918 
    None, # 0
8919 
    (1, TType.I64, 'customerId', None, None, ), # 1
8920 
    (2, TType.I64, 'from_date', None, None, ), # 2
8921 
    (3, TType.I64, 'to_date', None, None, ), # 3
8922 
    (4, TType.I32, 'status', None, None, ), # 4
8923 
  )
8924 
 
8925 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
8926 
    self.customerId = customerId
8927 
    self.from_date = from_date
8928 
    self.to_date = to_date
8929 
    self.status = status
8930 
 
8931 
  def read(self, iprot):
8932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8934 
      return
8935 
    iprot.readStructBegin()
8936 
    while True:
8937 
      (fname, ftype, fid) = iprot.readFieldBegin()
8938 
      if ftype == TType.STOP:
8939 
        break
8940 
      if fid == 1:
8941 
        if ftype == TType.I64:
8942 
          self.customerId = iprot.readI64();
8943 
        else:
8944 
          iprot.skip(ftype)
8945 
      elif fid == 2:
8946 
        if ftype == TType.I64:
8947 
          self.from_date = iprot.readI64();
8948 
        else:
8949 
          iprot.skip(ftype)
8950 
      elif fid == 3:
8951 
        if ftype == TType.I64:
8952 
          self.to_date = iprot.readI64();
8953 
        else:
8954 
          iprot.skip(ftype)
8955 
      elif fid == 4:
8956 
        if ftype == TType.I32:
8957 
          self.status = iprot.readI32();
8958 
        else:
8959 
          iprot.skip(ftype)
8960 
      else:
8961 
        iprot.skip(ftype)
8962 
      iprot.readFieldEnd()
8963 
    iprot.readStructEnd()
8964 
 
8965 
  def write(self, oprot):
8966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8968 
      return
8969 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 8970 
    if self.customerId is not None:
94 ashish 8971 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
8972 
      oprot.writeI64(self.customerId)
8973 
      oprot.writeFieldEnd()
3431 rajveer 8974 
    if self.from_date is not None:
94 ashish 8975 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
8976 
      oprot.writeI64(self.from_date)
8977 
      oprot.writeFieldEnd()
3431 rajveer 8978 
    if self.to_date is not None:
94 ashish 8979 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
8980 
      oprot.writeI64(self.to_date)
8981 
      oprot.writeFieldEnd()
3431 rajveer 8982 
    if self.status is not None:
94 ashish 8983 
      oprot.writeFieldBegin('status', TType.I32, 4)
8984 
      oprot.writeI32(self.status)
8985 
      oprot.writeFieldEnd()
8986 
    oprot.writeFieldStop()
8987 
    oprot.writeStructEnd()
8988 
 
3431 rajveer 8989 
  def validate(self):
8990 
    return
8991 
 
8992 
 
94 ashish 8993 
  def __repr__(self):
8994 
    L = ['%s=%r' % (key, value)
8995 
      for key, value in self.__dict__.iteritems()]
8996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8997 
 
8998 
  def __eq__(self, other):
8999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9000 
 
9001 
  def __ne__(self, other):
9002 
    return not (self == other)
9003 
 
9004 
class getTransactionsForCustomer_result:
9005 
  """
9006 
  Attributes:
9007 
   - success
9008 
   - ex
9009 
  """
9010 
 
9011 
  thrift_spec = (
9012 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9013 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9014 
  )
9015 
 
9016 
  def __init__(self, success=None, ex=None,):
9017 
    self.success = success
9018 
    self.ex = ex
9019 
 
9020 
  def read(self, iprot):
9021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9023 
      return
9024 
    iprot.readStructBegin()
9025 
    while True:
9026 
      (fname, ftype, fid) = iprot.readFieldBegin()
9027 
      if ftype == TType.STOP:
9028 
        break
9029 
      if fid == 0:
9030 
        if ftype == TType.LIST:
9031 
          self.success = []
6188 rajveer 9032 
          (_etype109, _size106) = iprot.readListBegin()
9033 
          for _i110 in xrange(_size106):
9034 
            _elem111 = Transaction()
9035 
            _elem111.read(iprot)
9036 
            self.success.append(_elem111)
94 ashish 9037 
          iprot.readListEnd()
9038 
        else:
9039 
          iprot.skip(ftype)
9040 
      elif fid == 1:
9041 
        if ftype == TType.STRUCT:
9042 
          self.ex = TransactionServiceException()
9043 
          self.ex.read(iprot)
9044 
        else:
9045 
          iprot.skip(ftype)
9046 
      else:
9047 
        iprot.skip(ftype)
9048 
      iprot.readFieldEnd()
9049 
    iprot.readStructEnd()
9050 
 
9051 
  def write(self, oprot):
9052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9054 
      return
9055 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 9056 
    if self.success is not None:
94 ashish 9057 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9058 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9059 
      for iter112 in self.success:
9060 
        iter112.write(oprot)
94 ashish 9061 
      oprot.writeListEnd()
9062 
      oprot.writeFieldEnd()
3431 rajveer 9063 
    if self.ex is not None:
94 ashish 9064 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9065 
      self.ex.write(oprot)
9066 
      oprot.writeFieldEnd()
9067 
    oprot.writeFieldStop()
9068 
    oprot.writeStructEnd()
9069 
 
3431 rajveer 9070 
  def validate(self):
9071 
    return
9072 
 
9073 
 
94 ashish 9074 
  def __repr__(self):
9075 
    L = ['%s=%r' % (key, value)
9076 
      for key, value in self.__dict__.iteritems()]
9077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9078 
 
9079 
  def __eq__(self, other):
9080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9081 
 
9082 
  def __ne__(self, other):
9083 
    return not (self == other)
9084 
 
132 ashish 9085 
class getTransactionsForShoppingCartId_args:
9086 
  """
9087 
  Attributes:
9088 
   - shoppingCartId
9089 
  """
9090 
 
9091 
  thrift_spec = (
9092 
    None, # 0
9093 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
9094 
  )
9095 
 
9096 
  def __init__(self, shoppingCartId=None,):
9097 
    self.shoppingCartId = shoppingCartId
9098 
 
9099 
  def read(self, iprot):
9100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9102 
      return
9103 
    iprot.readStructBegin()
9104 
    while True:
9105 
      (fname, ftype, fid) = iprot.readFieldBegin()
9106 
      if ftype == TType.STOP:
9107 
        break
9108 
      if fid == 1:
9109 
        if ftype == TType.I64:
9110 
          self.shoppingCartId = iprot.readI64();
9111 
        else:
9112 
          iprot.skip(ftype)
9113 
      else:
9114 
        iprot.skip(ftype)
9115 
      iprot.readFieldEnd()
9116 
    iprot.readStructEnd()
9117 
 
9118 
  def write(self, oprot):
9119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9121 
      return
9122 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 9123 
    if self.shoppingCartId is not None:
132 ashish 9124 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
9125 
      oprot.writeI64(self.shoppingCartId)
9126 
      oprot.writeFieldEnd()
9127 
    oprot.writeFieldStop()
9128 
    oprot.writeStructEnd()
9129 
 
3431 rajveer 9130 
  def validate(self):
9131 
    return
9132 
 
9133 
 
132 ashish 9134 
  def __repr__(self):
9135 
    L = ['%s=%r' % (key, value)
9136 
      for key, value in self.__dict__.iteritems()]
9137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9138 
 
9139 
  def __eq__(self, other):
9140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9141 
 
9142 
  def __ne__(self, other):
9143 
    return not (self == other)
9144 
 
9145 
class getTransactionsForShoppingCartId_result:
9146 
  """
9147 
  Attributes:
9148 
   - success
9149 
   - ex
9150 
  """
9151 
 
9152 
  thrift_spec = (
9153 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9154 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9155 
  )
9156 
 
9157 
  def __init__(self, success=None, ex=None,):
9158 
    self.success = success
9159 
    self.ex = ex
9160 
 
9161 
  def read(self, iprot):
9162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9164 
      return
9165 
    iprot.readStructBegin()
9166 
    while True:
9167 
      (fname, ftype, fid) = iprot.readFieldBegin()
9168 
      if ftype == TType.STOP:
9169 
        break
9170 
      if fid == 0:
9171 
        if ftype == TType.LIST:
9172 
          self.success = []
6188 rajveer 9173 
          (_etype116, _size113) = iprot.readListBegin()
9174 
          for _i117 in xrange(_size113):
9175 
            _elem118 = Transaction()
9176 
            _elem118.read(iprot)
9177 
            self.success.append(_elem118)
132 ashish 9178 
          iprot.readListEnd()
9179 
        else:
9180 
          iprot.skip(ftype)
9181 
      elif fid == 1:
9182 
        if ftype == TType.STRUCT:
9183 
          self.ex = TransactionServiceException()
9184 
          self.ex.read(iprot)
9185 
        else:
9186 
          iprot.skip(ftype)
9187 
      else:
9188 
        iprot.skip(ftype)
9189 
      iprot.readFieldEnd()
9190 
    iprot.readStructEnd()
9191 
 
9192 
  def write(self, oprot):
9193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9195 
      return
9196 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 9197 
    if self.success is not None:
132 ashish 9198 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9199 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9200 
      for iter119 in self.success:
9201 
        iter119.write(oprot)
132 ashish 9202 
      oprot.writeListEnd()
9203 
      oprot.writeFieldEnd()
3431 rajveer 9204 
    if self.ex is not None:
132 ashish 9205 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9206 
      self.ex.write(oprot)
9207 
      oprot.writeFieldEnd()
9208 
    oprot.writeFieldStop()
9209 
    oprot.writeStructEnd()
9210 
 
3431 rajveer 9211 
  def validate(self):
9212 
    return
9213 
 
9214 
 
132 ashish 9215 
  def __repr__(self):
9216 
    L = ['%s=%r' % (key, value)
9217 
      for key, value in self.__dict__.iteritems()]
9218 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9219 
 
9220 
  def __eq__(self, other):
9221 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9222 
 
9223 
  def __ne__(self, other):
9224 
    return not (self == other)
9225 
 
94 ashish 9226 
class getTransactionStatus_args:
9227 
  """
9228 
  Attributes:
9229 
   - transactionId
9230 
  """
9231 
 
9232 
  thrift_spec = (
9233 
    None, # 0
9234 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9235 
  )
9236 
 
9237 
  def __init__(self, transactionId=None,):
9238 
    self.transactionId = transactionId
9239 
 
9240 
  def read(self, iprot):
9241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9243 
      return
9244 
    iprot.readStructBegin()
9245 
    while True:
9246 
      (fname, ftype, fid) = iprot.readFieldBegin()
9247 
      if ftype == TType.STOP:
9248 
        break
9249 
      if fid == 1:
9250 
        if ftype == TType.I64:
9251 
          self.transactionId = iprot.readI64();
9252 
        else:
9253 
          iprot.skip(ftype)
9254 
      else:
9255 
        iprot.skip(ftype)
9256 
      iprot.readFieldEnd()
9257 
    iprot.readStructEnd()
9258 
 
9259 
  def write(self, oprot):
9260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9262 
      return
9263 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 9264 
    if self.transactionId is not None:
94 ashish 9265 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9266 
      oprot.writeI64(self.transactionId)
9267 
      oprot.writeFieldEnd()
9268 
    oprot.writeFieldStop()
9269 
    oprot.writeStructEnd()
9270 
 
3431 rajveer 9271 
  def validate(self):
9272 
    return
9273 
 
9274 
 
94 ashish 9275 
  def __repr__(self):
9276 
    L = ['%s=%r' % (key, value)
9277 
      for key, value in self.__dict__.iteritems()]
9278 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9279 
 
9280 
  def __eq__(self, other):
9281 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9282 
 
9283 
  def __ne__(self, other):
9284 
    return not (self == other)
9285 
 
9286 
class getTransactionStatus_result:
9287 
  """
9288 
  Attributes:
9289 
   - success
9290 
   - ex
9291 
  """
9292 
 
9293 
  thrift_spec = (
9294 
    (0, TType.I32, 'success', None, None, ), # 0
9295 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9296 
  )
9297 
 
9298 
  def __init__(self, success=None, ex=None,):
9299 
    self.success = success
9300 
    self.ex = ex
9301 
 
9302 
  def read(self, iprot):
9303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9305 
      return
9306 
    iprot.readStructBegin()
9307 
    while True:
9308 
      (fname, ftype, fid) = iprot.readFieldBegin()
9309 
      if ftype == TType.STOP:
9310 
        break
9311 
      if fid == 0:
9312 
        if ftype == TType.I32:
9313 
          self.success = iprot.readI32();
9314 
        else:
9315 
          iprot.skip(ftype)
9316 
      elif fid == 1:
9317 
        if ftype == TType.STRUCT:
9318 
          self.ex = TransactionServiceException()
9319 
          self.ex.read(iprot)
9320 
        else:
9321 
          iprot.skip(ftype)
9322 
      else:
9323 
        iprot.skip(ftype)
9324 
      iprot.readFieldEnd()
9325 
    iprot.readStructEnd()
9326 
 
9327 
  def write(self, oprot):
9328 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9329 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9330 
      return
9331 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 9332 
    if self.success is not None:
94 ashish 9333 
      oprot.writeFieldBegin('success', TType.I32, 0)
9334 
      oprot.writeI32(self.success)
9335 
      oprot.writeFieldEnd()
3431 rajveer 9336 
    if self.ex is not None:
94 ashish 9337 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9338 
      self.ex.write(oprot)
9339 
      oprot.writeFieldEnd()
9340 
    oprot.writeFieldStop()
9341 
    oprot.writeStructEnd()
9342 
 
3431 rajveer 9343 
  def validate(self):
9344 
    return
9345 
 
9346 
 
94 ashish 9347 
  def __repr__(self):
9348 
    L = ['%s=%r' % (key, value)
9349 
      for key, value in self.__dict__.iteritems()]
9350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9351 
 
9352 
  def __eq__(self, other):
9353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9354 
 
9355 
  def __ne__(self, other):
9356 
    return not (self == other)
9357 
 
9358 
class changeTransactionStatus_args:
9359 
  """
9360 
  Attributes:
9361 
   - transactionId
9362 
   - status
9363 
   - description
5527 anupam.sin 9364 
   - pickUp
9365 
   - orderType
94 ashish 9366 
  """
9367 
 
9368 
  thrift_spec = (
9369 
    None, # 0
9370 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9371 
    (2, TType.I32, 'status', None, None, ), # 2
9372 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 9373 
    (4, TType.I64, 'pickUp', None, None, ), # 4
9374 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 9375 
  )
9376 
 
5527 anupam.sin 9377 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 9378 
    self.transactionId = transactionId
9379 
    self.status = status
9380 
    self.description = description
5527 anupam.sin 9381 
    self.pickUp = pickUp
9382 
    self.orderType = orderType
94 ashish 9383 
 
9384 
  def read(self, iprot):
9385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9387 
      return
9388 
    iprot.readStructBegin()
9389 
    while True:
9390 
      (fname, ftype, fid) = iprot.readFieldBegin()
9391 
      if ftype == TType.STOP:
9392 
        break
9393 
      if fid == 1:
9394 
        if ftype == TType.I64:
9395 
          self.transactionId = iprot.readI64();
9396 
        else:
9397 
          iprot.skip(ftype)
9398 
      elif fid == 2:
9399 
        if ftype == TType.I32:
9400 
          self.status = iprot.readI32();
9401 
        else:
9402 
          iprot.skip(ftype)
9403 
      elif fid == 3:
9404 
        if ftype == TType.STRING:
9405 
          self.description = iprot.readString();
9406 
        else:
9407 
          iprot.skip(ftype)
5387 rajveer 9408 
      elif fid == 4:
5527 anupam.sin 9409 
        if ftype == TType.I64:
9410 
          self.pickUp = iprot.readI64();
5387 rajveer 9411 
        else:
9412 
          iprot.skip(ftype)
5527 anupam.sin 9413 
      elif fid == 5:
9414 
        if ftype == TType.I32:
9415 
          self.orderType = iprot.readI32();
9416 
        else:
9417 
          iprot.skip(ftype)
94 ashish 9418 
      else:
9419 
        iprot.skip(ftype)
9420 
      iprot.readFieldEnd()
9421 
    iprot.readStructEnd()
9422 
 
9423 
  def write(self, oprot):
9424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9426 
      return
9427 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 9428 
    if self.transactionId is not None:
94 ashish 9429 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9430 
      oprot.writeI64(self.transactionId)
9431 
      oprot.writeFieldEnd()
3431 rajveer 9432 
    if self.status is not None:
94 ashish 9433 
      oprot.writeFieldBegin('status', TType.I32, 2)
9434 
      oprot.writeI32(self.status)
9435 
      oprot.writeFieldEnd()
3431 rajveer 9436 
    if self.description is not None:
94 ashish 9437 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9438 
      oprot.writeString(self.description)
9439 
      oprot.writeFieldEnd()
5527 anupam.sin 9440 
    if self.pickUp is not None:
9441 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
9442 
      oprot.writeI64(self.pickUp)
5387 rajveer 9443 
      oprot.writeFieldEnd()
5527 anupam.sin 9444 
    if self.orderType is not None:
9445 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
9446 
      oprot.writeI32(self.orderType)
9447 
      oprot.writeFieldEnd()
94 ashish 9448 
    oprot.writeFieldStop()
9449 
    oprot.writeStructEnd()
9450 
 
3431 rajveer 9451 
  def validate(self):
9452 
    return
9453 
 
9454 
 
94 ashish 9455 
  def __repr__(self):
9456 
    L = ['%s=%r' % (key, value)
9457 
      for key, value in self.__dict__.iteritems()]
9458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9459 
 
9460 
  def __eq__(self, other):
9461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9462 
 
9463 
  def __ne__(self, other):
9464 
    return not (self == other)
9465 
 
9466 
class changeTransactionStatus_result:
9467 
  """
9468 
  Attributes:
9469 
   - success
9470 
   - ex
9471 
  """
9472 
 
9473 
  thrift_spec = (
9474 
    (0, TType.BOOL, 'success', None, None, ), # 0
9475 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9476 
  )
9477 
 
9478 
  def __init__(self, success=None, ex=None,):
9479 
    self.success = success
9480 
    self.ex = ex
9481 
 
9482 
  def read(self, iprot):
9483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9485 
      return
9486 
    iprot.readStructBegin()
9487 
    while True:
9488 
      (fname, ftype, fid) = iprot.readFieldBegin()
9489 
      if ftype == TType.STOP:
9490 
        break
9491 
      if fid == 0:
9492 
        if ftype == TType.BOOL:
9493 
          self.success = iprot.readBool();
9494 
        else:
9495 
          iprot.skip(ftype)
9496 
      elif fid == 1:
9497 
        if ftype == TType.STRUCT:
9498 
          self.ex = TransactionServiceException()
9499 
          self.ex.read(iprot)
9500 
        else:
9501 
          iprot.skip(ftype)
9502 
      else:
9503 
        iprot.skip(ftype)
9504 
      iprot.readFieldEnd()
9505 
    iprot.readStructEnd()
9506 
 
9507 
  def write(self, oprot):
9508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9510 
      return
9511 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9512 
    if self.success is not None:
94 ashish 9513 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9514 
      oprot.writeBool(self.success)
9515 
      oprot.writeFieldEnd()
3431 rajveer 9516 
    if self.ex is not None:
94 ashish 9517 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9518 
      self.ex.write(oprot)
9519 
      oprot.writeFieldEnd()
9520 
    oprot.writeFieldStop()
9521 
    oprot.writeStructEnd()
9522 
 
3431 rajveer 9523 
  def validate(self):
9524 
    return
9525 
 
9526 
 
94 ashish 9527 
  def __repr__(self):
9528 
    L = ['%s=%r' % (key, value)
9529 
      for key, value in self.__dict__.iteritems()]
9530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9531 
 
9532 
  def __eq__(self, other):
9533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9534 
 
9535 
  def __ne__(self, other):
9536 
    return not (self == other)
9537 
 
1398 varun.gupt 9538 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 9539 
  """
9540 
  Attributes:
9541 
   - transactionId
9542 
  """
9543 
 
9544 
  thrift_spec = (
9545 
    None, # 0
9546 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9547 
  )
9548 
 
9549 
  def __init__(self, transactionId=None,):
9550 
    self.transactionId = transactionId
9551 
 
9552 
  def read(self, iprot):
9553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9555 
      return
9556 
    iprot.readStructBegin()
9557 
    while True:
9558 
      (fname, ftype, fid) = iprot.readFieldBegin()
9559 
      if ftype == TType.STOP:
9560 
        break
9561 
      if fid == 1:
9562 
        if ftype == TType.I64:
9563 
          self.transactionId = iprot.readI64();
9564 
        else:
9565 
          iprot.skip(ftype)
9566 
      else:
9567 
        iprot.skip(ftype)
9568 
      iprot.readFieldEnd()
9569 
    iprot.readStructEnd()
9570 
 
9571 
  def write(self, oprot):
9572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9574 
      return
1398 varun.gupt 9575 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 9576 
    if self.transactionId is not None:
1382 varun.gupt 9577 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9578 
      oprot.writeI64(self.transactionId)
9579 
      oprot.writeFieldEnd()
9580 
    oprot.writeFieldStop()
9581 
    oprot.writeStructEnd()
9582 
 
3431 rajveer 9583 
  def validate(self):
9584 
    return
9585 
 
9586 
 
1382 varun.gupt 9587 
  def __repr__(self):
9588 
    L = ['%s=%r' % (key, value)
9589 
      for key, value in self.__dict__.iteritems()]
9590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9591 
 
9592 
  def __eq__(self, other):
9593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9594 
 
9595 
  def __ne__(self, other):
9596 
    return not (self == other)
9597 
 
1398 varun.gupt 9598 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 9599 
  """
9600 
  Attributes:
9601 
   - success
9602 
   - ex
9603 
  """
9604 
 
9605 
  thrift_spec = (
9606 
    (0, TType.BOOL, 'success', None, None, ), # 0
9607 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9608 
  )
9609 
 
9610 
  def __init__(self, success=None, ex=None,):
9611 
    self.success = success
9612 
    self.ex = ex
9613 
 
9614 
  def read(self, iprot):
9615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9617 
      return
9618 
    iprot.readStructBegin()
9619 
    while True:
9620 
      (fname, ftype, fid) = iprot.readFieldBegin()
9621 
      if ftype == TType.STOP:
9622 
        break
9623 
      if fid == 0:
9624 
        if ftype == TType.BOOL:
9625 
          self.success = iprot.readBool();
9626 
        else:
9627 
          iprot.skip(ftype)
9628 
      elif fid == 1:
9629 
        if ftype == TType.STRUCT:
9630 
          self.ex = TransactionServiceException()
9631 
          self.ex.read(iprot)
9632 
        else:
9633 
          iprot.skip(ftype)
9634 
      else:
9635 
        iprot.skip(ftype)
9636 
      iprot.readFieldEnd()
9637 
    iprot.readStructEnd()
9638 
 
9639 
  def write(self, oprot):
9640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9642 
      return
1398 varun.gupt 9643 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9644 
    if self.success is not None:
1382 varun.gupt 9645 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9646 
      oprot.writeBool(self.success)
9647 
      oprot.writeFieldEnd()
3431 rajveer 9648 
    if self.ex is not None:
1382 varun.gupt 9649 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9650 
      self.ex.write(oprot)
9651 
      oprot.writeFieldEnd()
9652 
    oprot.writeFieldStop()
9653 
    oprot.writeStructEnd()
9654 
 
3431 rajveer 9655 
  def validate(self):
9656 
    return
9657 
 
9658 
 
1382 varun.gupt 9659 
  def __repr__(self):
9660 
    L = ['%s=%r' % (key, value)
9661 
      for key, value in self.__dict__.iteritems()]
9662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9663 
 
9664 
  def __eq__(self, other):
9665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9666 
 
9667 
  def __ne__(self, other):
9668 
    return not (self == other)
9669 
 
483 rajveer 9670 
class getAllOrders_args:
94 ashish 9671 
  """
9672 
  Attributes:
4801 anupam.sin 9673 
   - statuses
483 rajveer 9674 
   - from_date
9675 
   - to_date
9676 
   - warehouse_id
94 ashish 9677 
  """
9678 
 
9679 
  thrift_spec = (
9680 
    None, # 0
4801 anupam.sin 9681 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 9682 
    (2, TType.I64, 'from_date', None, None, ), # 2
9683 
    (3, TType.I64, 'to_date', None, None, ), # 3
9684 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 9685 
  )
9686 
 
4801 anupam.sin 9687 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
9688 
    self.statuses = statuses
483 rajveer 9689 
    self.from_date = from_date
9690 
    self.to_date = to_date
9691 
    self.warehouse_id = warehouse_id
94 ashish 9692 
 
9693 
  def read(self, iprot):
9694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9696 
      return
9697 
    iprot.readStructBegin()
9698 
    while True:
9699 
      (fname, ftype, fid) = iprot.readFieldBegin()
9700 
      if ftype == TType.STOP:
9701 
        break
9702 
      if fid == 1:
4801 anupam.sin 9703 
        if ftype == TType.LIST:
9704 
          self.statuses = []
6188 rajveer 9705 
          (_etype123, _size120) = iprot.readListBegin()
9706 
          for _i124 in xrange(_size120):
9707 
            _elem125 = iprot.readI32();
9708 
            self.statuses.append(_elem125)
4801 anupam.sin 9709 
          iprot.readListEnd()
94 ashish 9710 
        else:
9711 
          iprot.skip(ftype)
483 rajveer 9712 
      elif fid == 2:
9713 
        if ftype == TType.I64:
9714 
          self.from_date = iprot.readI64();
94 ashish 9715 
        else:
9716 
          iprot.skip(ftype)
483 rajveer 9717 
      elif fid == 3:
9718 
        if ftype == TType.I64:
9719 
          self.to_date = iprot.readI64();
94 ashish 9720 
        else:
9721 
          iprot.skip(ftype)
483 rajveer 9722 
      elif fid == 4:
94 ashish 9723 
        if ftype == TType.I64:
483 rajveer 9724 
          self.warehouse_id = iprot.readI64();
94 ashish 9725 
        else:
9726 
          iprot.skip(ftype)
9727 
      else:
9728 
        iprot.skip(ftype)
9729 
      iprot.readFieldEnd()
9730 
    iprot.readStructEnd()
9731 
 
9732 
  def write(self, oprot):
9733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9735 
      return
483 rajveer 9736 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 9737 
    if self.statuses is not None:
9738 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9739 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9740 
      for iter126 in self.statuses:
9741 
        oprot.writeI32(iter126)
4801 anupam.sin 9742 
      oprot.writeListEnd()
94 ashish 9743 
      oprot.writeFieldEnd()
3431 rajveer 9744 
    if self.from_date is not None:
483 rajveer 9745 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9746 
      oprot.writeI64(self.from_date)
94 ashish 9747 
      oprot.writeFieldEnd()
3431 rajveer 9748 
    if self.to_date is not None:
483 rajveer 9749 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9750 
      oprot.writeI64(self.to_date)
94 ashish 9751 
      oprot.writeFieldEnd()
3431 rajveer 9752 
    if self.warehouse_id is not None:
483 rajveer 9753 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9754 
      oprot.writeI64(self.warehouse_id)
94 ashish 9755 
      oprot.writeFieldEnd()
9756 
    oprot.writeFieldStop()
9757 
    oprot.writeStructEnd()
9758 
 
3431 rajveer 9759 
  def validate(self):
9760 
    return
9761 
 
9762 
 
94 ashish 9763 
  def __repr__(self):
9764 
    L = ['%s=%r' % (key, value)
9765 
      for key, value in self.__dict__.iteritems()]
9766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9767 
 
9768 
  def __eq__(self, other):
9769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9770 
 
9771 
  def __ne__(self, other):
9772 
    return not (self == other)
9773 
 
483 rajveer 9774 
class getAllOrders_result:
94 ashish 9775 
  """
9776 
  Attributes:
9777 
   - success
9778 
   - ex
9779 
  """
9780 
 
9781 
  thrift_spec = (
483 rajveer 9782 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 9783 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9784 
  )
9785 
 
9786 
  def __init__(self, success=None, ex=None,):
9787 
    self.success = success
9788 
    self.ex = ex
9789 
 
9790 
  def read(self, iprot):
9791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9793 
      return
9794 
    iprot.readStructBegin()
9795 
    while True:
9796 
      (fname, ftype, fid) = iprot.readFieldBegin()
9797 
      if ftype == TType.STOP:
9798 
        break
9799 
      if fid == 0:
483 rajveer 9800 
        if ftype == TType.LIST:
9801 
          self.success = []
6188 rajveer 9802 
          (_etype130, _size127) = iprot.readListBegin()
9803 
          for _i131 in xrange(_size127):
9804 
            _elem132 = Order()
9805 
            _elem132.read(iprot)
9806 
            self.success.append(_elem132)
483 rajveer 9807 
          iprot.readListEnd()
94 ashish 9808 
        else:
9809 
          iprot.skip(ftype)
9810 
      elif fid == 1:
9811 
        if ftype == TType.STRUCT:
9812 
          self.ex = TransactionServiceException()
9813 
          self.ex.read(iprot)
9814 
        else:
9815 
          iprot.skip(ftype)
9816 
      else:
9817 
        iprot.skip(ftype)
9818 
      iprot.readFieldEnd()
9819 
    iprot.readStructEnd()
9820 
 
9821 
  def write(self, oprot):
9822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9824 
      return
483 rajveer 9825 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 9826 
    if self.success is not None:
483 rajveer 9827 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9828 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9829 
      for iter133 in self.success:
9830 
        iter133.write(oprot)
483 rajveer 9831 
      oprot.writeListEnd()
94 ashish 9832 
      oprot.writeFieldEnd()
3431 rajveer 9833 
    if self.ex is not None:
94 ashish 9834 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9835 
      self.ex.write(oprot)
9836 
      oprot.writeFieldEnd()
9837 
    oprot.writeFieldStop()
9838 
    oprot.writeStructEnd()
9839 
 
3431 rajveer 9840 
  def validate(self):
9841 
    return
9842 
 
9843 
 
94 ashish 9844 
  def __repr__(self):
9845 
    L = ['%s=%r' % (key, value)
9846 
      for key, value in self.__dict__.iteritems()]
9847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9848 
 
9849 
  def __eq__(self, other):
9850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9851 
 
9852 
  def __ne__(self, other):
9853 
    return not (self == other)
9854 
 
4133 chandransh 9855 
class getOrdersInBatch_args:
9856 
  """
9857 
  Attributes:
9858 
   - statuses
9859 
   - offset
9860 
   - limit
9861 
   - warehouse_id
9862 
  """
9863 
 
9864 
  thrift_spec = (
9865 
    None, # 0
9866 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9867 
    (2, TType.I64, 'offset', None, None, ), # 2
9868 
    (3, TType.I64, 'limit', None, None, ), # 3
9869 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9870 
  )
9871 
 
9872 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
9873 
    self.statuses = statuses
9874 
    self.offset = offset
9875 
    self.limit = limit
9876 
    self.warehouse_id = warehouse_id
9877 
 
9878 
  def read(self, iprot):
9879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9881 
      return
9882 
    iprot.readStructBegin()
9883 
    while True:
9884 
      (fname, ftype, fid) = iprot.readFieldBegin()
9885 
      if ftype == TType.STOP:
9886 
        break
9887 
      if fid == 1:
9888 
        if ftype == TType.LIST:
9889 
          self.statuses = []
6188 rajveer 9890 
          (_etype137, _size134) = iprot.readListBegin()
9891 
          for _i138 in xrange(_size134):
9892 
            _elem139 = iprot.readI32();
9893 
            self.statuses.append(_elem139)
4133 chandransh 9894 
          iprot.readListEnd()
9895 
        else:
9896 
          iprot.skip(ftype)
9897 
      elif fid == 2:
9898 
        if ftype == TType.I64:
9899 
          self.offset = iprot.readI64();
9900 
        else:
9901 
          iprot.skip(ftype)
9902 
      elif fid == 3:
9903 
        if ftype == TType.I64:
9904 
          self.limit = iprot.readI64();
9905 
        else:
9906 
          iprot.skip(ftype)
9907 
      elif fid == 4:
9908 
        if ftype == TType.I64:
9909 
          self.warehouse_id = iprot.readI64();
9910 
        else:
9911 
          iprot.skip(ftype)
9912 
      else:
9913 
        iprot.skip(ftype)
9914 
      iprot.readFieldEnd()
9915 
    iprot.readStructEnd()
9916 
 
9917 
  def write(self, oprot):
9918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9920 
      return
9921 
    oprot.writeStructBegin('getOrdersInBatch_args')
9922 
    if self.statuses is not None:
9923 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9924 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9925 
      for iter140 in self.statuses:
9926 
        oprot.writeI32(iter140)
4133 chandransh 9927 
      oprot.writeListEnd()
9928 
      oprot.writeFieldEnd()
9929 
    if self.offset is not None:
9930 
      oprot.writeFieldBegin('offset', TType.I64, 2)
9931 
      oprot.writeI64(self.offset)
9932 
      oprot.writeFieldEnd()
9933 
    if self.limit is not None:
9934 
      oprot.writeFieldBegin('limit', TType.I64, 3)
9935 
      oprot.writeI64(self.limit)
9936 
      oprot.writeFieldEnd()
9937 
    if self.warehouse_id is not None:
9938 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9939 
      oprot.writeI64(self.warehouse_id)
9940 
      oprot.writeFieldEnd()
9941 
    oprot.writeFieldStop()
9942 
    oprot.writeStructEnd()
9943 
 
9944 
  def validate(self):
9945 
    return
9946 
 
9947 
 
9948 
  def __repr__(self):
9949 
    L = ['%s=%r' % (key, value)
9950 
      for key, value in self.__dict__.iteritems()]
9951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9952 
 
9953 
  def __eq__(self, other):
9954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9955 
 
9956 
  def __ne__(self, other):
9957 
    return not (self == other)
9958 
 
9959 
class getOrdersInBatch_result:
9960 
  """
9961 
  Attributes:
9962 
   - success
9963 
   - ex
9964 
  """
9965 
 
9966 
  thrift_spec = (
9967 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
9968 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9969 
  )
9970 
 
9971 
  def __init__(self, success=None, ex=None,):
9972 
    self.success = success
9973 
    self.ex = ex
9974 
 
9975 
  def read(self, iprot):
9976 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9977 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9978 
      return
9979 
    iprot.readStructBegin()
9980 
    while True:
9981 
      (fname, ftype, fid) = iprot.readFieldBegin()
9982 
      if ftype == TType.STOP:
9983 
        break
9984 
      if fid == 0:
9985 
        if ftype == TType.LIST:
9986 
          self.success = []
6188 rajveer 9987 
          (_etype144, _size141) = iprot.readListBegin()
9988 
          for _i145 in xrange(_size141):
9989 
            _elem146 = Order()
9990 
            _elem146.read(iprot)
9991 
            self.success.append(_elem146)
4133 chandransh 9992 
          iprot.readListEnd()
9993 
        else:
9994 
          iprot.skip(ftype)
9995 
      elif fid == 1:
9996 
        if ftype == TType.STRUCT:
9997 
          self.ex = TransactionServiceException()
9998 
          self.ex.read(iprot)
9999 
        else:
10000 
          iprot.skip(ftype)
10001 
      else:
10002 
        iprot.skip(ftype)
10003 
      iprot.readFieldEnd()
10004 
    iprot.readStructEnd()
10005 
 
10006 
  def write(self, oprot):
10007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10009 
      return
10010 
    oprot.writeStructBegin('getOrdersInBatch_result')
10011 
    if self.success is not None:
10012 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10013 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10014 
      for iter147 in self.success:
10015 
        iter147.write(oprot)
4133 chandransh 10016 
      oprot.writeListEnd()
10017 
      oprot.writeFieldEnd()
10018 
    if self.ex is not None:
10019 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10020 
      self.ex.write(oprot)
10021 
      oprot.writeFieldEnd()
10022 
    oprot.writeFieldStop()
10023 
    oprot.writeStructEnd()
10024 
 
10025 
  def validate(self):
10026 
    return
10027 
 
10028 
 
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 
 
10040 
class getOrderCount_args:
10041 
  """
10042 
  Attributes:
10043 
   - statuses
10044 
   - warehouseId
10045 
  """
10046 
 
10047 
  thrift_spec = (
10048 
    None, # 0
10049 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10050 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10051 
  )
10052 
 
10053 
  def __init__(self, statuses=None, warehouseId=None,):
10054 
    self.statuses = statuses
10055 
    self.warehouseId = warehouseId
10056 
 
10057 
  def read(self, iprot):
10058 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10059 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10060 
      return
10061 
    iprot.readStructBegin()
10062 
    while True:
10063 
      (fname, ftype, fid) = iprot.readFieldBegin()
10064 
      if ftype == TType.STOP:
10065 
        break
10066 
      if fid == 1:
10067 
        if ftype == TType.LIST:
10068 
          self.statuses = []
6188 rajveer 10069 
          (_etype151, _size148) = iprot.readListBegin()
10070 
          for _i152 in xrange(_size148):
10071 
            _elem153 = iprot.readI32();
10072 
            self.statuses.append(_elem153)
4133 chandransh 10073 
          iprot.readListEnd()
10074 
        else:
10075 
          iprot.skip(ftype)
10076 
      elif fid == 2:
10077 
        if ftype == TType.I64:
10078 
          self.warehouseId = iprot.readI64();
10079 
        else:
10080 
          iprot.skip(ftype)
10081 
      else:
10082 
        iprot.skip(ftype)
10083 
      iprot.readFieldEnd()
10084 
    iprot.readStructEnd()
10085 
 
10086 
  def write(self, oprot):
10087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10089 
      return
10090 
    oprot.writeStructBegin('getOrderCount_args')
10091 
    if self.statuses is not None:
10092 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10093 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10094 
      for iter154 in self.statuses:
10095 
        oprot.writeI32(iter154)
4133 chandransh 10096 
      oprot.writeListEnd()
10097 
      oprot.writeFieldEnd()
10098 
    if self.warehouseId is not None:
10099 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10100 
      oprot.writeI64(self.warehouseId)
10101 
      oprot.writeFieldEnd()
10102 
    oprot.writeFieldStop()
10103 
    oprot.writeStructEnd()
10104 
 
10105 
  def validate(self):
10106 
    return
10107 
 
10108 
 
10109 
  def __repr__(self):
10110 
    L = ['%s=%r' % (key, value)
10111 
      for key, value in self.__dict__.iteritems()]
10112 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10113 
 
10114 
  def __eq__(self, other):
10115 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10116 
 
10117 
  def __ne__(self, other):
10118 
    return not (self == other)
10119 
 
10120 
class getOrderCount_result:
10121 
  """
10122 
  Attributes:
10123 
   - success
10124 
   - ex
10125 
  """
10126 
 
10127 
  thrift_spec = (
10128 
    (0, TType.I32, 'success', None, None, ), # 0
10129 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10130 
  )
10131 
 
10132 
  def __init__(self, success=None, ex=None,):
10133 
    self.success = success
10134 
    self.ex = ex
10135 
 
10136 
  def read(self, iprot):
10137 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10138 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10139 
      return
10140 
    iprot.readStructBegin()
10141 
    while True:
10142 
      (fname, ftype, fid) = iprot.readFieldBegin()
10143 
      if ftype == TType.STOP:
10144 
        break
10145 
      if fid == 0:
10146 
        if ftype == TType.I32:
10147 
          self.success = iprot.readI32();
10148 
        else:
10149 
          iprot.skip(ftype)
10150 
      elif fid == 1:
10151 
        if ftype == TType.STRUCT:
10152 
          self.ex = TransactionServiceException()
10153 
          self.ex.read(iprot)
10154 
        else:
10155 
          iprot.skip(ftype)
10156 
      else:
10157 
        iprot.skip(ftype)
10158 
      iprot.readFieldEnd()
10159 
    iprot.readStructEnd()
10160 
 
10161 
  def write(self, oprot):
10162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10164 
      return
10165 
    oprot.writeStructBegin('getOrderCount_result')
10166 
    if self.success is not None:
10167 
      oprot.writeFieldBegin('success', TType.I32, 0)
10168 
      oprot.writeI32(self.success)
10169 
      oprot.writeFieldEnd()
10170 
    if self.ex is not None:
10171 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10172 
      self.ex.write(oprot)
10173 
      oprot.writeFieldEnd()
10174 
    oprot.writeFieldStop()
10175 
    oprot.writeStructEnd()
10176 
 
10177 
  def validate(self):
10178 
    return
10179 
 
10180 
 
10181 
  def __repr__(self):
10182 
    L = ['%s=%r' % (key, value)
10183 
      for key, value in self.__dict__.iteritems()]
10184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10185 
 
10186 
  def __eq__(self, other):
10187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10188 
 
10189 
  def __ne__(self, other):
10190 
    return not (self == other)
10191 
 
999 varun.gupt 10192 
class getOrdersByBillingDate_args:
10193 
  """
10194 
  Attributes:
10195 
   - status
10196 
   - start_billing_date
10197 
   - end_billing_date
10198 
   - warehouse_id
10199 
  """
10200 
 
10201 
  thrift_spec = (
10202 
    None, # 0
10203 
    (1, TType.I32, 'status', None, None, ), # 1
10204 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
10205 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
10206 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10207 
  )
10208 
 
10209 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
10210 
    self.status = status
10211 
    self.start_billing_date = start_billing_date
10212 
    self.end_billing_date = end_billing_date
10213 
    self.warehouse_id = warehouse_id
10214 
 
10215 
  def read(self, iprot):
10216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10218 
      return
10219 
    iprot.readStructBegin()
10220 
    while True:
10221 
      (fname, ftype, fid) = iprot.readFieldBegin()
10222 
      if ftype == TType.STOP:
10223 
        break
10224 
      if fid == 1:
10225 
        if ftype == TType.I32:
10226 
          self.status = iprot.readI32();
10227 
        else:
10228 
          iprot.skip(ftype)
10229 
      elif fid == 2:
10230 
        if ftype == TType.I64:
10231 
          self.start_billing_date = iprot.readI64();
10232 
        else:
10233 
          iprot.skip(ftype)
10234 
      elif fid == 3:
10235 
        if ftype == TType.I64:
10236 
          self.end_billing_date = iprot.readI64();
10237 
        else:
10238 
          iprot.skip(ftype)
10239 
      elif fid == 4:
10240 
        if ftype == TType.I64:
10241 
          self.warehouse_id = iprot.readI64();
10242 
        else:
10243 
          iprot.skip(ftype)
10244 
      else:
10245 
        iprot.skip(ftype)
10246 
      iprot.readFieldEnd()
10247 
    iprot.readStructEnd()
10248 
 
10249 
  def write(self, oprot):
10250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10252 
      return
10253 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 10254 
    if self.status is not None:
999 varun.gupt 10255 
      oprot.writeFieldBegin('status', TType.I32, 1)
10256 
      oprot.writeI32(self.status)
10257 
      oprot.writeFieldEnd()
3431 rajveer 10258 
    if self.start_billing_date is not None:
999 varun.gupt 10259 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
10260 
      oprot.writeI64(self.start_billing_date)
10261 
      oprot.writeFieldEnd()
3431 rajveer 10262 
    if self.end_billing_date is not None:
999 varun.gupt 10263 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
10264 
      oprot.writeI64(self.end_billing_date)
10265 
      oprot.writeFieldEnd()
3431 rajveer 10266 
    if self.warehouse_id is not None:
999 varun.gupt 10267 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10268 
      oprot.writeI64(self.warehouse_id)
10269 
      oprot.writeFieldEnd()
10270 
    oprot.writeFieldStop()
10271 
    oprot.writeStructEnd()
10272 
 
3431 rajveer 10273 
  def validate(self):
10274 
    return
10275 
 
10276 
 
999 varun.gupt 10277 
  def __repr__(self):
10278 
    L = ['%s=%r' % (key, value)
10279 
      for key, value in self.__dict__.iteritems()]
10280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10281 
 
10282 
  def __eq__(self, other):
10283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10284 
 
10285 
  def __ne__(self, other):
10286 
    return not (self == other)
10287 
 
10288 
class getOrdersByBillingDate_result:
10289 
  """
10290 
  Attributes:
10291 
   - success
10292 
   - ex
10293 
  """
10294 
 
10295 
  thrift_spec = (
10296 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10297 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10298 
  )
10299 
 
10300 
  def __init__(self, success=None, ex=None,):
10301 
    self.success = success
10302 
    self.ex = ex
10303 
 
10304 
  def read(self, iprot):
10305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10307 
      return
10308 
    iprot.readStructBegin()
10309 
    while True:
10310 
      (fname, ftype, fid) = iprot.readFieldBegin()
10311 
      if ftype == TType.STOP:
10312 
        break
10313 
      if fid == 0:
10314 
        if ftype == TType.LIST:
10315 
          self.success = []
6188 rajveer 10316 
          (_etype158, _size155) = iprot.readListBegin()
10317 
          for _i159 in xrange(_size155):
10318 
            _elem160 = Order()
10319 
            _elem160.read(iprot)
10320 
            self.success.append(_elem160)
999 varun.gupt 10321 
          iprot.readListEnd()
10322 
        else:
10323 
          iprot.skip(ftype)
10324 
      elif fid == 1:
10325 
        if ftype == TType.STRUCT:
10326 
          self.ex = TransactionServiceException()
10327 
          self.ex.read(iprot)
10328 
        else:
10329 
          iprot.skip(ftype)
10330 
      else:
10331 
        iprot.skip(ftype)
10332 
      iprot.readFieldEnd()
10333 
    iprot.readStructEnd()
10334 
 
10335 
  def write(self, oprot):
10336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10338 
      return
10339 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 10340 
    if self.success is not None:
999 varun.gupt 10341 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10342 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10343 
      for iter161 in self.success:
10344 
        iter161.write(oprot)
999 varun.gupt 10345 
      oprot.writeListEnd()
10346 
      oprot.writeFieldEnd()
3431 rajveer 10347 
    if self.ex is not None:
999 varun.gupt 10348 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10349 
      self.ex.write(oprot)
10350 
      oprot.writeFieldEnd()
10351 
    oprot.writeFieldStop()
10352 
    oprot.writeStructEnd()
10353 
 
3431 rajveer 10354 
  def validate(self):
10355 
    return
10356 
 
10357 
 
999 varun.gupt 10358 
  def __repr__(self):
10359 
    L = ['%s=%r' % (key, value)
10360 
      for key, value in self.__dict__.iteritems()]
10361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10362 
 
10363 
  def __eq__(self, other):
10364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10365 
 
10366 
  def __ne__(self, other):
10367 
    return not (self == other)
10368 
 
3427 chandransh 10369 
class getOrdersByShippingDate_args:
10370 
  """
10371 
  Attributes:
10372 
   - fromShippingDate
10373 
   - toShippingDate
10374 
   - providerId
10375 
   - warehouseId
3451 chandransh 10376 
   - cod
3427 chandransh 10377 
  """
10378 
 
10379 
  thrift_spec = (
10380 
    None, # 0
10381 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
10382 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
10383 
    (3, TType.I64, 'providerId', None, None, ), # 3
10384 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 10385 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 10386 
  )
10387 
 
3451 chandransh 10388 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 10389 
    self.fromShippingDate = fromShippingDate
10390 
    self.toShippingDate = toShippingDate
10391 
    self.providerId = providerId
10392 
    self.warehouseId = warehouseId
3451 chandransh 10393 
    self.cod = cod
3427 chandransh 10394 
 
10395 
  def read(self, iprot):
10396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10398 
      return
10399 
    iprot.readStructBegin()
10400 
    while True:
10401 
      (fname, ftype, fid) = iprot.readFieldBegin()
10402 
      if ftype == TType.STOP:
10403 
        break
10404 
      if fid == 1:
10405 
        if ftype == TType.I64:
10406 
          self.fromShippingDate = iprot.readI64();
10407 
        else:
10408 
          iprot.skip(ftype)
10409 
      elif fid == 2:
10410 
        if ftype == TType.I64:
10411 
          self.toShippingDate = iprot.readI64();
10412 
        else:
10413 
          iprot.skip(ftype)
10414 
      elif fid == 3:
10415 
        if ftype == TType.I64:
10416 
          self.providerId = iprot.readI64();
10417 
        else:
10418 
          iprot.skip(ftype)
10419 
      elif fid == 4:
10420 
        if ftype == TType.I64:
10421 
          self.warehouseId = iprot.readI64();
10422 
        else:
10423 
          iprot.skip(ftype)
3451 chandransh 10424 
      elif fid == 5:
10425 
        if ftype == TType.BOOL:
10426 
          self.cod = iprot.readBool();
10427 
        else:
10428 
          iprot.skip(ftype)
3427 chandransh 10429 
      else:
10430 
        iprot.skip(ftype)
10431 
      iprot.readFieldEnd()
10432 
    iprot.readStructEnd()
10433 
 
10434 
  def write(self, oprot):
10435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10437 
      return
10438 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 10439 
    if self.fromShippingDate is not None:
3427 chandransh 10440 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
10441 
      oprot.writeI64(self.fromShippingDate)
10442 
      oprot.writeFieldEnd()
3431 rajveer 10443 
    if self.toShippingDate is not None:
3427 chandransh 10444 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
10445 
      oprot.writeI64(self.toShippingDate)
10446 
      oprot.writeFieldEnd()
3431 rajveer 10447 
    if self.providerId is not None:
3427 chandransh 10448 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
10449 
      oprot.writeI64(self.providerId)
10450 
      oprot.writeFieldEnd()
3431 rajveer 10451 
    if self.warehouseId is not None:
3427 chandransh 10452 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
10453 
      oprot.writeI64(self.warehouseId)
10454 
      oprot.writeFieldEnd()
3451 chandransh 10455 
    if self.cod is not None:
10456 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
10457 
      oprot.writeBool(self.cod)
10458 
      oprot.writeFieldEnd()
3427 chandransh 10459 
    oprot.writeFieldStop()
10460 
    oprot.writeStructEnd()
10461 
 
3431 rajveer 10462 
  def validate(self):
10463 
    return
10464 
 
10465 
 
3427 chandransh 10466 
  def __repr__(self):
10467 
    L = ['%s=%r' % (key, value)
10468 
      for key, value in self.__dict__.iteritems()]
10469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10470 
 
10471 
  def __eq__(self, other):
10472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10473 
 
10474 
  def __ne__(self, other):
10475 
    return not (self == other)
10476 
 
10477 
class getOrdersByShippingDate_result:
10478 
  """
10479 
  Attributes:
10480 
   - success
10481 
   - ex
10482 
  """
10483 
 
10484 
  thrift_spec = (
10485 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10486 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10487 
  )
10488 
 
10489 
  def __init__(self, success=None, ex=None,):
10490 
    self.success = success
10491 
    self.ex = ex
10492 
 
10493 
  def read(self, iprot):
10494 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10495 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10496 
      return
10497 
    iprot.readStructBegin()
10498 
    while True:
10499 
      (fname, ftype, fid) = iprot.readFieldBegin()
10500 
      if ftype == TType.STOP:
10501 
        break
10502 
      if fid == 0:
10503 
        if ftype == TType.LIST:
10504 
          self.success = []
6188 rajveer 10505 
          (_etype165, _size162) = iprot.readListBegin()
10506 
          for _i166 in xrange(_size162):
10507 
            _elem167 = Order()
10508 
            _elem167.read(iprot)
10509 
            self.success.append(_elem167)
3427 chandransh 10510 
          iprot.readListEnd()
10511 
        else:
10512 
          iprot.skip(ftype)
10513 
      elif fid == 1:
10514 
        if ftype == TType.STRUCT:
10515 
          self.ex = TransactionServiceException()
10516 
          self.ex.read(iprot)
10517 
        else:
10518 
          iprot.skip(ftype)
10519 
      else:
10520 
        iprot.skip(ftype)
10521 
      iprot.readFieldEnd()
10522 
    iprot.readStructEnd()
10523 
 
10524 
  def write(self, oprot):
10525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10527 
      return
10528 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10529 
    if self.success is not None:
3427 chandransh 10530 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10531 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10532 
      for iter168 in self.success:
10533 
        iter168.write(oprot)
3427 chandransh 10534 
      oprot.writeListEnd()
10535 
      oprot.writeFieldEnd()
3431 rajveer 10536 
    if self.ex is not None:
3427 chandransh 10537 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10538 
      self.ex.write(oprot)
10539 
      oprot.writeFieldEnd()
10540 
    oprot.writeFieldStop()
10541 
    oprot.writeStructEnd()
10542 
 
3431 rajveer 10543 
  def validate(self):
10544 
    return
10545 
 
10546 
 
3427 chandransh 10547 
  def __repr__(self):
10548 
    L = ['%s=%r' % (key, value)
10549 
      for key, value in self.__dict__.iteritems()]
10550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10551 
 
10552 
  def __eq__(self, other):
10553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10554 
 
10555 
  def __ne__(self, other):
10556 
    return not (self == other)
10557 
 
1382 varun.gupt 10558 
class getReturnableOrdersForCustomer_args:
10559 
  """
10560 
  Attributes:
10561 
   - customer_id
10562 
   - limit
10563 
  """
10564 
 
10565 
  thrift_spec = (
10566 
    None, # 0
10567 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10568 
    (2, TType.I64, 'limit', None, None, ), # 2
10569 
  )
10570 
 
10571 
  def __init__(self, customer_id=None, limit=None,):
10572 
    self.customer_id = customer_id
10573 
    self.limit = limit
10574 
 
10575 
  def read(self, iprot):
10576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10578 
      return
10579 
    iprot.readStructBegin()
10580 
    while True:
10581 
      (fname, ftype, fid) = iprot.readFieldBegin()
10582 
      if ftype == TType.STOP:
10583 
        break
10584 
      if fid == 1:
10585 
        if ftype == TType.I64:
10586 
          self.customer_id = iprot.readI64();
10587 
        else:
10588 
          iprot.skip(ftype)
10589 
      elif fid == 2:
10590 
        if ftype == TType.I64:
10591 
          self.limit = iprot.readI64();
10592 
        else:
10593 
          iprot.skip(ftype)
10594 
      else:
10595 
        iprot.skip(ftype)
10596 
      iprot.readFieldEnd()
10597 
    iprot.readStructEnd()
10598 
 
10599 
  def write(self, oprot):
10600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10602 
      return
10603 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 10604 
    if self.customer_id is not None:
1382 varun.gupt 10605 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10606 
      oprot.writeI64(self.customer_id)
10607 
      oprot.writeFieldEnd()
3431 rajveer 10608 
    if self.limit is not None:
1382 varun.gupt 10609 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10610 
      oprot.writeI64(self.limit)
10611 
      oprot.writeFieldEnd()
10612 
    oprot.writeFieldStop()
10613 
    oprot.writeStructEnd()
10614 
 
3431 rajveer 10615 
  def validate(self):
10616 
    return
10617 
 
10618 
 
1382 varun.gupt 10619 
  def __repr__(self):
10620 
    L = ['%s=%r' % (key, value)
10621 
      for key, value in self.__dict__.iteritems()]
10622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10623 
 
10624 
  def __eq__(self, other):
10625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10626 
 
10627 
  def __ne__(self, other):
10628 
    return not (self == other)
10629 
 
10630 
class getReturnableOrdersForCustomer_result:
10631 
  """
10632 
  Attributes:
10633 
   - success
10634 
   - ex
10635 
  """
10636 
 
10637 
  thrift_spec = (
10638 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10639 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10640 
  )
10641 
 
10642 
  def __init__(self, success=None, ex=None,):
10643 
    self.success = success
10644 
    self.ex = ex
10645 
 
10646 
  def read(self, iprot):
10647 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10648 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10649 
      return
10650 
    iprot.readStructBegin()
10651 
    while True:
10652 
      (fname, ftype, fid) = iprot.readFieldBegin()
10653 
      if ftype == TType.STOP:
10654 
        break
10655 
      if fid == 0:
10656 
        if ftype == TType.LIST:
10657 
          self.success = []
6188 rajveer 10658 
          (_etype172, _size169) = iprot.readListBegin()
10659 
          for _i173 in xrange(_size169):
10660 
            _elem174 = iprot.readI64();
10661 
            self.success.append(_elem174)
1382 varun.gupt 10662 
          iprot.readListEnd()
10663 
        else:
10664 
          iprot.skip(ftype)
10665 
      elif fid == 1:
10666 
        if ftype == TType.STRUCT:
10667 
          self.ex = TransactionServiceException()
10668 
          self.ex.read(iprot)
10669 
        else:
10670 
          iprot.skip(ftype)
10671 
      else:
10672 
        iprot.skip(ftype)
10673 
      iprot.readFieldEnd()
10674 
    iprot.readStructEnd()
10675 
 
10676 
  def write(self, oprot):
10677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10679 
      return
10680 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10681 
    if self.success is not None:
1382 varun.gupt 10682 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10683 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10684 
      for iter175 in self.success:
10685 
        oprot.writeI64(iter175)
1382 varun.gupt 10686 
      oprot.writeListEnd()
10687 
      oprot.writeFieldEnd()
3431 rajveer 10688 
    if self.ex is not None:
1382 varun.gupt 10689 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10690 
      self.ex.write(oprot)
10691 
      oprot.writeFieldEnd()
10692 
    oprot.writeFieldStop()
10693 
    oprot.writeStructEnd()
10694 
 
3431 rajveer 10695 
  def validate(self):
10696 
    return
10697 
 
10698 
 
1382 varun.gupt 10699 
  def __repr__(self):
10700 
    L = ['%s=%r' % (key, value)
10701 
      for key, value in self.__dict__.iteritems()]
10702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10703 
 
10704 
  def __eq__(self, other):
10705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10706 
 
10707 
  def __ne__(self, other):
10708 
    return not (self == other)
10709 
 
10710 
class getCancellableOrdersForCustomer_args:
10711 
  """
10712 
  Attributes:
10713 
   - customer_id
10714 
   - limit
10715 
  """
10716 
 
10717 
  thrift_spec = (
10718 
    None, # 0
10719 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10720 
    (2, TType.I64, 'limit', None, None, ), # 2
10721 
  )
10722 
 
10723 
  def __init__(self, customer_id=None, limit=None,):
10724 
    self.customer_id = customer_id
10725 
    self.limit = limit
10726 
 
10727 
  def read(self, iprot):
10728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10730 
      return
10731 
    iprot.readStructBegin()
10732 
    while True:
10733 
      (fname, ftype, fid) = iprot.readFieldBegin()
10734 
      if ftype == TType.STOP:
10735 
        break
10736 
      if fid == 1:
10737 
        if ftype == TType.I64:
10738 
          self.customer_id = iprot.readI64();
10739 
        else:
10740 
          iprot.skip(ftype)
10741 
      elif fid == 2:
10742 
        if ftype == TType.I64:
10743 
          self.limit = iprot.readI64();
10744 
        else:
10745 
          iprot.skip(ftype)
10746 
      else:
10747 
        iprot.skip(ftype)
10748 
      iprot.readFieldEnd()
10749 
    iprot.readStructEnd()
10750 
 
10751 
  def write(self, oprot):
10752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10754 
      return
10755 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 10756 
    if self.customer_id is not None:
1382 varun.gupt 10757 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10758 
      oprot.writeI64(self.customer_id)
10759 
      oprot.writeFieldEnd()
3431 rajveer 10760 
    if self.limit is not None:
1382 varun.gupt 10761 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10762 
      oprot.writeI64(self.limit)
10763 
      oprot.writeFieldEnd()
10764 
    oprot.writeFieldStop()
10765 
    oprot.writeStructEnd()
10766 
 
3431 rajveer 10767 
  def validate(self):
10768 
    return
10769 
 
10770 
 
1382 varun.gupt 10771 
  def __repr__(self):
10772 
    L = ['%s=%r' % (key, value)
10773 
      for key, value in self.__dict__.iteritems()]
10774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10775 
 
10776 
  def __eq__(self, other):
10777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10778 
 
10779 
  def __ne__(self, other):
10780 
    return not (self == other)
10781 
 
10782 
class getCancellableOrdersForCustomer_result:
10783 
  """
10784 
  Attributes:
10785 
   - success
10786 
   - ex
10787 
  """
10788 
 
10789 
  thrift_spec = (
10790 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10791 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10792 
  )
10793 
 
10794 
  def __init__(self, success=None, ex=None,):
10795 
    self.success = success
10796 
    self.ex = ex
10797 
 
10798 
  def read(self, iprot):
10799 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10800 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10801 
      return
10802 
    iprot.readStructBegin()
10803 
    while True:
10804 
      (fname, ftype, fid) = iprot.readFieldBegin()
10805 
      if ftype == TType.STOP:
10806 
        break
10807 
      if fid == 0:
10808 
        if ftype == TType.LIST:
10809 
          self.success = []
6188 rajveer 10810 
          (_etype179, _size176) = iprot.readListBegin()
10811 
          for _i180 in xrange(_size176):
10812 
            _elem181 = iprot.readI64();
10813 
            self.success.append(_elem181)
1382 varun.gupt 10814 
          iprot.readListEnd()
10815 
        else:
10816 
          iprot.skip(ftype)
10817 
      elif fid == 1:
10818 
        if ftype == TType.STRUCT:
10819 
          self.ex = TransactionServiceException()
10820 
          self.ex.read(iprot)
10821 
        else:
10822 
          iprot.skip(ftype)
10823 
      else:
10824 
        iprot.skip(ftype)
10825 
      iprot.readFieldEnd()
10826 
    iprot.readStructEnd()
10827 
 
10828 
  def write(self, oprot):
10829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10831 
      return
10832 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 10833 
    if self.success is not None:
1382 varun.gupt 10834 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10835 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10836 
      for iter182 in self.success:
10837 
        oprot.writeI64(iter182)
1382 varun.gupt 10838 
      oprot.writeListEnd()
10839 
      oprot.writeFieldEnd()
3431 rajveer 10840 
    if self.ex is not None:
1382 varun.gupt 10841 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10842 
      self.ex.write(oprot)
10843 
      oprot.writeFieldEnd()
10844 
    oprot.writeFieldStop()
10845 
    oprot.writeStructEnd()
10846 
 
3431 rajveer 10847 
  def validate(self):
10848 
    return
10849 
 
10850 
 
1382 varun.gupt 10851 
  def __repr__(self):
10852 
    L = ['%s=%r' % (key, value)
10853 
      for key, value in self.__dict__.iteritems()]
10854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10855 
 
10856 
  def __eq__(self, other):
10857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10858 
 
10859 
  def __ne__(self, other):
10860 
    return not (self == other)
10861 
 
483 rajveer 10862 
class changeOrderStatus_args:
94 ashish 10863 
  """
10864 
  Attributes:
483 rajveer 10865 
   - orderId
10866 
   - status
10867 
   - description
94 ashish 10868 
  """
10869 
 
10870 
  thrift_spec = (
10871 
    None, # 0
483 rajveer 10872 
    (1, TType.I64, 'orderId', None, None, ), # 1
10873 
    (2, TType.I32, 'status', None, None, ), # 2
10874 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10875 
  )
10876 
 
483 rajveer 10877 
  def __init__(self, orderId=None, status=None, description=None,):
10878 
    self.orderId = orderId
10879 
    self.status = status
10880 
    self.description = description
94 ashish 10881 
 
10882 
  def read(self, iprot):
10883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10885 
      return
10886 
    iprot.readStructBegin()
10887 
    while True:
10888 
      (fname, ftype, fid) = iprot.readFieldBegin()
10889 
      if ftype == TType.STOP:
10890 
        break
10891 
      if fid == 1:
10892 
        if ftype == TType.I64:
483 rajveer 10893 
          self.orderId = iprot.readI64();
94 ashish 10894 
        else:
10895 
          iprot.skip(ftype)
10896 
      elif fid == 2:
483 rajveer 10897 
        if ftype == TType.I32:
10898 
          self.status = iprot.readI32();
94 ashish 10899 
        else:
10900 
          iprot.skip(ftype)
483 rajveer 10901 
      elif fid == 3:
10902 
        if ftype == TType.STRING:
10903 
          self.description = iprot.readString();
10904 
        else:
10905 
          iprot.skip(ftype)
94 ashish 10906 
      else:
10907 
        iprot.skip(ftype)
10908 
      iprot.readFieldEnd()
10909 
    iprot.readStructEnd()
10910 
 
10911 
  def write(self, oprot):
10912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10914 
      return
483 rajveer 10915 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 10916 
    if self.orderId is not None:
483 rajveer 10917 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
10918 
      oprot.writeI64(self.orderId)
94 ashish 10919 
      oprot.writeFieldEnd()
3431 rajveer 10920 
    if self.status is not None:
483 rajveer 10921 
      oprot.writeFieldBegin('status', TType.I32, 2)
10922 
      oprot.writeI32(self.status)
94 ashish 10923 
      oprot.writeFieldEnd()
3431 rajveer 10924 
    if self.description is not None:
483 rajveer 10925 
      oprot.writeFieldBegin('description', TType.STRING, 3)
10926 
      oprot.writeString(self.description)
10927 
      oprot.writeFieldEnd()
94 ashish 10928 
    oprot.writeFieldStop()
10929 
    oprot.writeStructEnd()
10930 
 
3431 rajveer 10931 
  def validate(self):
10932 
    return
10933 
 
10934 
 
94 ashish 10935 
  def __repr__(self):
10936 
    L = ['%s=%r' % (key, value)
10937 
      for key, value in self.__dict__.iteritems()]
10938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10939 
 
10940 
  def __eq__(self, other):
10941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10942 
 
10943 
  def __ne__(self, other):
10944 
    return not (self == other)
10945 
 
483 rajveer 10946 
class changeOrderStatus_result:
94 ashish 10947 
  """
10948 
  Attributes:
10949 
   - success
10950 
   - ex
10951 
  """
10952 
 
10953 
  thrift_spec = (
10954 
    (0, TType.BOOL, 'success', None, None, ), # 0
10955 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10956 
  )
10957 
 
10958 
  def __init__(self, success=None, ex=None,):
10959 
    self.success = success
10960 
    self.ex = ex
10961 
 
10962 
  def read(self, iprot):
10963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10965 
      return
10966 
    iprot.readStructBegin()
10967 
    while True:
10968 
      (fname, ftype, fid) = iprot.readFieldBegin()
10969 
      if ftype == TType.STOP:
10970 
        break
10971 
      if fid == 0:
10972 
        if ftype == TType.BOOL:
10973 
          self.success = iprot.readBool();
10974 
        else:
10975 
          iprot.skip(ftype)
10976 
      elif fid == 1:
10977 
        if ftype == TType.STRUCT:
10978 
          self.ex = TransactionServiceException()
10979 
          self.ex.read(iprot)
10980 
        else:
10981 
          iprot.skip(ftype)
10982 
      else:
10983 
        iprot.skip(ftype)
10984 
      iprot.readFieldEnd()
10985 
    iprot.readStructEnd()
10986 
 
10987 
  def write(self, oprot):
10988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10990 
      return
483 rajveer 10991 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 10992 
    if self.success is not None:
94 ashish 10993 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10994 
      oprot.writeBool(self.success)
10995 
      oprot.writeFieldEnd()
3431 rajveer 10996 
    if self.ex is not None:
94 ashish 10997 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10998 
      self.ex.write(oprot)
10999 
      oprot.writeFieldEnd()
11000 
    oprot.writeFieldStop()
11001 
    oprot.writeStructEnd()
11002 
 
3431 rajveer 11003 
  def validate(self):
11004 
    return
11005 
 
11006 
 
94 ashish 11007 
  def __repr__(self):
11008 
    L = ['%s=%r' % (key, value)
11009 
      for key, value in self.__dict__.iteritems()]
11010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11011 
 
11012 
  def __eq__(self, other):
11013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11014 
 
11015 
  def __ne__(self, other):
11016 
    return not (self == other)
11017 
 
3064 chandransh 11018 
class getOrdersForTransaction_args:
494 rajveer 11019 
  """
11020 
  Attributes:
3064 chandransh 11021 
   - transactionId
11022 
   - customerId
494 rajveer 11023 
  """
11024 
 
11025 
  thrift_spec = (
11026 
    None, # 0
3064 chandransh 11027 
    (1, TType.I64, 'transactionId', None, None, ), # 1
11028 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 11029 
  )
11030 
 
3064 chandransh 11031 
  def __init__(self, transactionId=None, customerId=None,):
11032 
    self.transactionId = transactionId
11033 
    self.customerId = customerId
494 rajveer 11034 
 
11035 
  def read(self, iprot):
11036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11038 
      return
11039 
    iprot.readStructBegin()
11040 
    while True:
11041 
      (fname, ftype, fid) = iprot.readFieldBegin()
11042 
      if ftype == TType.STOP:
11043 
        break
11044 
      if fid == 1:
11045 
        if ftype == TType.I64:
3064 chandransh 11046 
          self.transactionId = iprot.readI64();
494 rajveer 11047 
        else:
11048 
          iprot.skip(ftype)
11049 
      elif fid == 2:
3064 chandransh 11050 
        if ftype == TType.I64:
11051 
          self.customerId = iprot.readI64();
494 rajveer 11052 
        else:
11053 
          iprot.skip(ftype)
11054 
      else:
11055 
        iprot.skip(ftype)
11056 
      iprot.readFieldEnd()
11057 
    iprot.readStructEnd()
11058 
 
11059 
  def write(self, oprot):
11060 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11061 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11062 
      return
3064 chandransh 11063 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 11064 
    if self.transactionId is not None:
3064 chandransh 11065 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
11066 
      oprot.writeI64(self.transactionId)
494 rajveer 11067 
      oprot.writeFieldEnd()
3431 rajveer 11068 
    if self.customerId is not None:
3064 chandransh 11069 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
11070 
      oprot.writeI64(self.customerId)
494 rajveer 11071 
      oprot.writeFieldEnd()
11072 
    oprot.writeFieldStop()
11073 
    oprot.writeStructEnd()
11074 
 
3431 rajveer 11075 
  def validate(self):
11076 
    return
11077 
 
11078 
 
494 rajveer 11079 
  def __repr__(self):
11080 
    L = ['%s=%r' % (key, value)
11081 
      for key, value in self.__dict__.iteritems()]
11082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11083 
 
11084 
  def __eq__(self, other):
11085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11086 
 
11087 
  def __ne__(self, other):
11088 
    return not (self == other)
11089 
 
3064 chandransh 11090 
class getOrdersForTransaction_result:
494 rajveer 11091 
  """
11092 
  Attributes:
11093 
   - success
11094 
   - ex
11095 
  """
11096 
 
11097 
  thrift_spec = (
3064 chandransh 11098 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 11099 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11100 
  )
11101 
 
11102 
  def __init__(self, success=None, ex=None,):
11103 
    self.success = success
11104 
    self.ex = ex
11105 
 
11106 
  def read(self, iprot):
11107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11109 
      return
11110 
    iprot.readStructBegin()
11111 
    while True:
11112 
      (fname, ftype, fid) = iprot.readFieldBegin()
11113 
      if ftype == TType.STOP:
11114 
        break
11115 
      if fid == 0:
3064 chandransh 11116 
        if ftype == TType.LIST:
11117 
          self.success = []
6188 rajveer 11118 
          (_etype186, _size183) = iprot.readListBegin()
11119 
          for _i187 in xrange(_size183):
11120 
            _elem188 = Order()
11121 
            _elem188.read(iprot)
11122 
            self.success.append(_elem188)
3064 chandransh 11123 
          iprot.readListEnd()
494 rajveer 11124 
        else:
11125 
          iprot.skip(ftype)
11126 
      elif fid == 1:
11127 
        if ftype == TType.STRUCT:
11128 
          self.ex = TransactionServiceException()
11129 
          self.ex.read(iprot)
11130 
        else:
11131 
          iprot.skip(ftype)
11132 
      else:
11133 
        iprot.skip(ftype)
11134 
      iprot.readFieldEnd()
11135 
    iprot.readStructEnd()
11136 
 
11137 
  def write(self, oprot):
11138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11140 
      return
3064 chandransh 11141 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 11142 
    if self.success is not None:
3064 chandransh 11143 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11144 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11145 
      for iter189 in self.success:
11146 
        iter189.write(oprot)
3064 chandransh 11147 
      oprot.writeListEnd()
494 rajveer 11148 
      oprot.writeFieldEnd()
3431 rajveer 11149 
    if self.ex is not None:
494 rajveer 11150 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11151 
      self.ex.write(oprot)
11152 
      oprot.writeFieldEnd()
11153 
    oprot.writeFieldStop()
11154 
    oprot.writeStructEnd()
11155 
 
3431 rajveer 11156 
  def validate(self):
11157 
    return
11158 
 
11159 
 
494 rajveer 11160 
  def __repr__(self):
11161 
    L = ['%s=%r' % (key, value)
11162 
      for key, value in self.__dict__.iteritems()]
11163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11164 
 
11165 
  def __eq__(self, other):
11166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11167 
 
11168 
  def __ne__(self, other):
11169 
    return not (self == other)
11170 
 
3064 chandransh 11171 
class getOrdersForCustomer_args:
1149 chandransh 11172 
  """
11173 
  Attributes:
3064 chandransh 11174 
   - customerId
11175 
   - from_date
11176 
   - to_date
11177 
   - statuses
1149 chandransh 11178 
  """
11179 
 
11180 
  thrift_spec = (
11181 
    None, # 0
3064 chandransh 11182 
    (1, TType.I64, 'customerId', None, None, ), # 1
11183 
    (2, TType.I64, 'from_date', None, None, ), # 2
11184 
    (3, TType.I64, 'to_date', None, None, ), # 3
11185 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 11186 
  )
11187 
 
3064 chandransh 11188 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
11189 
    self.customerId = customerId
11190 
    self.from_date = from_date
11191 
    self.to_date = to_date
11192 
    self.statuses = statuses
1149 chandransh 11193 
 
11194 
  def read(self, iprot):
11195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11197 
      return
11198 
    iprot.readStructBegin()
11199 
    while True:
11200 
      (fname, ftype, fid) = iprot.readFieldBegin()
11201 
      if ftype == TType.STOP:
11202 
        break
11203 
      if fid == 1:
11204 
        if ftype == TType.I64:
3064 chandransh 11205 
          self.customerId = iprot.readI64();
1149 chandransh 11206 
        else:
11207 
          iprot.skip(ftype)
11208 
      elif fid == 2:
11209 
        if ftype == TType.I64:
3064 chandransh 11210 
          self.from_date = iprot.readI64();
1149 chandransh 11211 
        else:
11212 
          iprot.skip(ftype)
2783 chandransh 11213 
      elif fid == 3:
11214 
        if ftype == TType.I64:
3064 chandransh 11215 
          self.to_date = iprot.readI64();
2783 chandransh 11216 
        else:
11217 
          iprot.skip(ftype)
11218 
      elif fid == 4:
3064 chandransh 11219 
        if ftype == TType.LIST:
11220 
          self.statuses = []
6188 rajveer 11221 
          (_etype193, _size190) = iprot.readListBegin()
11222 
          for _i194 in xrange(_size190):
11223 
            _elem195 = iprot.readI32();
11224 
            self.statuses.append(_elem195)
3064 chandransh 11225 
          iprot.readListEnd()
2783 chandransh 11226 
        else:
11227 
          iprot.skip(ftype)
1149 chandransh 11228 
      else:
11229 
        iprot.skip(ftype)
11230 
      iprot.readFieldEnd()
11231 
    iprot.readStructEnd()
11232 
 
11233 
  def write(self, oprot):
11234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11236 
      return
3064 chandransh 11237 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 11238 
    if self.customerId is not None:
3064 chandransh 11239 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
11240 
      oprot.writeI64(self.customerId)
1149 chandransh 11241 
      oprot.writeFieldEnd()
3431 rajveer 11242 
    if self.from_date is not None:
3064 chandransh 11243 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
11244 
      oprot.writeI64(self.from_date)
1149 chandransh 11245 
      oprot.writeFieldEnd()
3431 rajveer 11246 
    if self.to_date is not None:
3064 chandransh 11247 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
11248 
      oprot.writeI64(self.to_date)
2783 chandransh 11249 
      oprot.writeFieldEnd()
3431 rajveer 11250 
    if self.statuses is not None:
3064 chandransh 11251 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
11252 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11253 
      for iter196 in self.statuses:
11254 
        oprot.writeI32(iter196)
3064 chandransh 11255 
      oprot.writeListEnd()
2783 chandransh 11256 
      oprot.writeFieldEnd()
1149 chandransh 11257 
    oprot.writeFieldStop()
11258 
    oprot.writeStructEnd()
11259 
 
3431 rajveer 11260 
  def validate(self):
11261 
    return
11262 
 
11263 
 
1149 chandransh 11264 
  def __repr__(self):
11265 
    L = ['%s=%r' % (key, value)
11266 
      for key, value in self.__dict__.iteritems()]
11267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11268 
 
11269 
  def __eq__(self, other):
11270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11271 
 
11272 
  def __ne__(self, other):
11273 
    return not (self == other)
11274 
 
3064 chandransh 11275 
class getOrdersForCustomer_result:
1149 chandransh 11276 
  """
11277 
  Attributes:
11278 
   - success
11279 
   - ex
11280 
  """
11281 
 
11282 
  thrift_spec = (
3064 chandransh 11283 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 11284 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11285 
  )
11286 
 
11287 
  def __init__(self, success=None, ex=None,):
11288 
    self.success = success
11289 
    self.ex = ex
11290 
 
11291 
  def read(self, iprot):
11292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11294 
      return
11295 
    iprot.readStructBegin()
11296 
    while True:
11297 
      (fname, ftype, fid) = iprot.readFieldBegin()
11298 
      if ftype == TType.STOP:
11299 
        break
11300 
      if fid == 0:
3064 chandransh 11301 
        if ftype == TType.LIST:
11302 
          self.success = []
6188 rajveer 11303 
          (_etype200, _size197) = iprot.readListBegin()
11304 
          for _i201 in xrange(_size197):
11305 
            _elem202 = Order()
11306 
            _elem202.read(iprot)
11307 
            self.success.append(_elem202)
3064 chandransh 11308 
          iprot.readListEnd()
1149 chandransh 11309 
        else:
11310 
          iprot.skip(ftype)
11311 
      elif fid == 1:
11312 
        if ftype == TType.STRUCT:
11313 
          self.ex = TransactionServiceException()
11314 
          self.ex.read(iprot)
11315 
        else:
11316 
          iprot.skip(ftype)
11317 
      else:
11318 
        iprot.skip(ftype)
11319 
      iprot.readFieldEnd()
11320 
    iprot.readStructEnd()
11321 
 
11322 
  def write(self, oprot):
11323 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11324 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11325 
      return
3064 chandransh 11326 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 11327 
    if self.success is not None:
3064 chandransh 11328 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11329 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11330 
      for iter203 in self.success:
11331 
        iter203.write(oprot)
3064 chandransh 11332 
      oprot.writeListEnd()
1149 chandransh 11333 
      oprot.writeFieldEnd()
3431 rajveer 11334 
    if self.ex is not None:
1149 chandransh 11335 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11336 
      self.ex.write(oprot)
11337 
      oprot.writeFieldEnd()
11338 
    oprot.writeFieldStop()
11339 
    oprot.writeStructEnd()
11340 
 
3431 rajveer 11341 
  def validate(self):
11342 
    return
11343 
 
11344 
 
1149 chandransh 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 createOrder_args:
921 rajveer 11357 
  """
11358 
  Attributes:
3064 chandransh 11359 
   - order
921 rajveer 11360 
  """
11361 
 
11362 
  thrift_spec = (
11363 
    None, # 0
3064 chandransh 11364 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 11365 
  )
11366 
 
3064 chandransh 11367 
  def __init__(self, order=None,):
11368 
    self.order = order
921 rajveer 11369 
 
11370 
  def read(self, iprot):
11371 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11372 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11373 
      return
11374 
    iprot.readStructBegin()
11375 
    while True:
11376 
      (fname, ftype, fid) = iprot.readFieldBegin()
11377 
      if ftype == TType.STOP:
11378 
        break
11379 
      if fid == 1:
3064 chandransh 11380 
        if ftype == TType.STRUCT:
11381 
          self.order = Order()
11382 
          self.order.read(iprot)
921 rajveer 11383 
        else:
11384 
          iprot.skip(ftype)
11385 
      else:
11386 
        iprot.skip(ftype)
11387 
      iprot.readFieldEnd()
11388 
    iprot.readStructEnd()
11389 
 
11390 
  def write(self, oprot):
11391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11393 
      return
3064 chandransh 11394 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 11395 
    if self.order is not None:
3064 chandransh 11396 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
11397 
      self.order.write(oprot)
921 rajveer 11398 
      oprot.writeFieldEnd()
11399 
    oprot.writeFieldStop()
11400 
    oprot.writeStructEnd()
11401 
 
3431 rajveer 11402 
  def validate(self):
11403 
    return
11404 
 
11405 
 
921 rajveer 11406 
  def __repr__(self):
11407 
    L = ['%s=%r' % (key, value)
11408 
      for key, value in self.__dict__.iteritems()]
11409 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11410 
 
11411 
  def __eq__(self, other):
11412 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11413 
 
11414 
  def __ne__(self, other):
11415 
    return not (self == other)
11416 
 
3064 chandransh 11417 
class createOrder_result:
921 rajveer 11418 
  """
11419 
  Attributes:
11420 
   - success
11421 
   - ex
11422 
  """
11423 
 
11424 
  thrift_spec = (
3064 chandransh 11425 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 11426 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11427 
  )
11428 
 
11429 
  def __init__(self, success=None, ex=None,):
11430 
    self.success = success
11431 
    self.ex = ex
11432 
 
11433 
  def read(self, iprot):
11434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11436 
      return
11437 
    iprot.readStructBegin()
11438 
    while True:
11439 
      (fname, ftype, fid) = iprot.readFieldBegin()
11440 
      if ftype == TType.STOP:
11441 
        break
11442 
      if fid == 0:
3064 chandransh 11443 
        if ftype == TType.I64:
11444 
          self.success = iprot.readI64();
921 rajveer 11445 
        else:
11446 
          iprot.skip(ftype)
11447 
      elif fid == 1:
11448 
        if ftype == TType.STRUCT:
11449 
          self.ex = TransactionServiceException()
11450 
          self.ex.read(iprot)
11451 
        else:
11452 
          iprot.skip(ftype)
11453 
      else:
11454 
        iprot.skip(ftype)
11455 
      iprot.readFieldEnd()
11456 
    iprot.readStructEnd()
11457 
 
11458 
  def write(self, oprot):
11459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11461 
      return
3064 chandransh 11462 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 11463 
    if self.success is not None:
3064 chandransh 11464 
      oprot.writeFieldBegin('success', TType.I64, 0)
11465 
      oprot.writeI64(self.success)
921 rajveer 11466 
      oprot.writeFieldEnd()
3431 rajveer 11467 
    if self.ex is not None:
921 rajveer 11468 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11469 
      self.ex.write(oprot)
11470 
      oprot.writeFieldEnd()
11471 
    oprot.writeFieldStop()
11472 
    oprot.writeStructEnd()
11473 
 
3431 rajveer 11474 
  def validate(self):
11475 
    return
11476 
 
11477 
 
921 rajveer 11478 
  def __repr__(self):
11479 
    L = ['%s=%r' % (key, value)
11480 
      for key, value in self.__dict__.iteritems()]
11481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11482 
 
11483 
  def __eq__(self, other):
11484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11485 
 
11486 
  def __ne__(self, other):
11487 
    return not (self == other)
11488 
 
3064 chandransh 11489 
class getOrder_args:
921 rajveer 11490 
  """
11491 
  Attributes:
3064 chandransh 11492 
   - id
921 rajveer 11493 
  """
11494 
 
11495 
  thrift_spec = (
11496 
    None, # 0
3064 chandransh 11497 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11498 
  )
11499 
 
3064 chandransh 11500 
  def __init__(self, id=None,):
11501 
    self.id = id
921 rajveer 11502 
 
11503 
  def read(self, iprot):
11504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11506 
      return
11507 
    iprot.readStructBegin()
11508 
    while True:
11509 
      (fname, ftype, fid) = iprot.readFieldBegin()
11510 
      if ftype == TType.STOP:
11511 
        break
11512 
      if fid == 1:
11513 
        if ftype == TType.I64:
3064 chandransh 11514 
          self.id = iprot.readI64();
921 rajveer 11515 
        else:
11516 
          iprot.skip(ftype)
11517 
      else:
11518 
        iprot.skip(ftype)
11519 
      iprot.readFieldEnd()
11520 
    iprot.readStructEnd()
11521 
 
11522 
  def write(self, oprot):
11523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11525 
      return
3064 chandransh 11526 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 11527 
    if self.id is not None:
3064 chandransh 11528 
      oprot.writeFieldBegin('id', TType.I64, 1)
11529 
      oprot.writeI64(self.id)
921 rajveer 11530 
      oprot.writeFieldEnd()
11531 
    oprot.writeFieldStop()
11532 
    oprot.writeStructEnd()
11533 
 
3431 rajveer 11534 
  def validate(self):
11535 
    return
11536 
 
11537 
 
921 rajveer 11538 
  def __repr__(self):
11539 
    L = ['%s=%r' % (key, value)
11540 
      for key, value in self.__dict__.iteritems()]
11541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11542 
 
11543 
  def __eq__(self, other):
11544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11545 
 
11546 
  def __ne__(self, other):
11547 
    return not (self == other)
11548 
 
3064 chandransh 11549 
class getOrder_result:
921 rajveer 11550 
  """
11551 
  Attributes:
11552 
   - success
11553 
   - ex
11554 
  """
11555 
 
11556 
  thrift_spec = (
3064 chandransh 11557 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 11558 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11559 
  )
11560 
 
11561 
  def __init__(self, success=None, ex=None,):
11562 
    self.success = success
11563 
    self.ex = ex
11564 
 
11565 
  def read(self, iprot):
11566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11568 
      return
11569 
    iprot.readStructBegin()
11570 
    while True:
11571 
      (fname, ftype, fid) = iprot.readFieldBegin()
11572 
      if ftype == TType.STOP:
11573 
        break
11574 
      if fid == 0:
3064 chandransh 11575 
        if ftype == TType.STRUCT:
11576 
          self.success = Order()
11577 
          self.success.read(iprot)
921 rajveer 11578 
        else:
11579 
          iprot.skip(ftype)
11580 
      elif fid == 1:
11581 
        if ftype == TType.STRUCT:
11582 
          self.ex = TransactionServiceException()
11583 
          self.ex.read(iprot)
11584 
        else:
11585 
          iprot.skip(ftype)
11586 
      else:
11587 
        iprot.skip(ftype)
11588 
      iprot.readFieldEnd()
11589 
    iprot.readStructEnd()
11590 
 
11591 
  def write(self, oprot):
11592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11594 
      return
3064 chandransh 11595 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 11596 
    if self.success is not None:
3064 chandransh 11597 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11598 
      self.success.write(oprot)
921 rajveer 11599 
      oprot.writeFieldEnd()
3431 rajveer 11600 
    if self.ex is not None:
921 rajveer 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 
 
921 rajveer 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 getLineItemsForOrder_args:
94 ashish 11623 
  """
11624 
  Attributes:
3064 chandransh 11625 
   - orderId
94 ashish 11626 
  """
11627 
 
11628 
  thrift_spec = (
11629 
    None, # 0
3064 chandransh 11630 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11631 
  )
11632 
 
3064 chandransh 11633 
  def __init__(self, orderId=None,):
11634 
    self.orderId = orderId
94 ashish 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:
11646 
        if ftype == TType.I64:
3064 chandransh 11647 
          self.orderId = iprot.readI64();
94 ashish 11648 
        else:
11649 
          iprot.skip(ftype)
11650 
      else:
11651 
        iprot.skip(ftype)
11652 
      iprot.readFieldEnd()
11653 
    iprot.readStructEnd()
11654 
 
11655 
  def write(self, oprot):
11656 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11657 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11658 
      return
3064 chandransh 11659 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 11660 
    if self.orderId is not None:
3064 chandransh 11661 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11662 
      oprot.writeI64(self.orderId)
94 ashish 11663 
      oprot.writeFieldEnd()
11664 
    oprot.writeFieldStop()
11665 
    oprot.writeStructEnd()
11666 
 
3431 rajveer 11667 
  def validate(self):
11668 
    return
11669 
 
11670 
 
94 ashish 11671 
  def __repr__(self):
11672 
    L = ['%s=%r' % (key, value)
11673 
      for key, value in self.__dict__.iteritems()]
11674 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11675 
 
11676 
  def __eq__(self, other):
11677 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11678 
 
11679 
  def __ne__(self, other):
11680 
    return not (self == other)
11681 
 
3064 chandransh 11682 
class getLineItemsForOrder_result:
94 ashish 11683 
  """
11684 
  Attributes:
11685 
   - success
11686 
   - ex
11687 
  """
11688 
 
11689 
  thrift_spec = (
3064 chandransh 11690 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 11691 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11692 
  )
11693 
 
11694 
  def __init__(self, success=None, ex=None,):
11695 
    self.success = success
11696 
    self.ex = ex
11697 
 
11698 
  def read(self, iprot):
11699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11701 
      return
11702 
    iprot.readStructBegin()
11703 
    while True:
11704 
      (fname, ftype, fid) = iprot.readFieldBegin()
11705 
      if ftype == TType.STOP:
11706 
        break
11707 
      if fid == 0:
483 rajveer 11708 
        if ftype == TType.LIST:
11709 
          self.success = []
6188 rajveer 11710 
          (_etype207, _size204) = iprot.readListBegin()
11711 
          for _i208 in xrange(_size204):
11712 
            _elem209 = LineItem()
11713 
            _elem209.read(iprot)
11714 
            self.success.append(_elem209)
483 rajveer 11715 
          iprot.readListEnd()
94 ashish 11716 
        else:
11717 
          iprot.skip(ftype)
11718 
      elif fid == 1:
11719 
        if ftype == TType.STRUCT:
11720 
          self.ex = TransactionServiceException()
11721 
          self.ex.read(iprot)
11722 
        else:
11723 
          iprot.skip(ftype)
11724 
      else:
11725 
        iprot.skip(ftype)
11726 
      iprot.readFieldEnd()
11727 
    iprot.readStructEnd()
11728 
 
11729 
  def write(self, oprot):
11730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11732 
      return
3064 chandransh 11733 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 11734 
    if self.success is not None:
483 rajveer 11735 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11736 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11737 
      for iter210 in self.success:
11738 
        iter210.write(oprot)
483 rajveer 11739 
      oprot.writeListEnd()
94 ashish 11740 
      oprot.writeFieldEnd()
3431 rajveer 11741 
    if self.ex is not None:
94 ashish 11742 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11743 
      self.ex.write(oprot)
11744 
      oprot.writeFieldEnd()
11745 
    oprot.writeFieldStop()
11746 
    oprot.writeStructEnd()
11747 
 
3431 rajveer 11748 
  def validate(self):
11749 
    return
11750 
 
11751 
 
94 ashish 11752 
  def __repr__(self):
11753 
    L = ['%s=%r' % (key, value)
11754 
      for key, value in self.__dict__.iteritems()]
11755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11756 
 
11757 
  def __eq__(self, other):
11758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11759 
 
11760 
  def __ne__(self, other):
11761 
    return not (self == other)
11762 
 
4999 phani.kuma 11763 
class getOrderList_args:
11764 
  """
11765 
  Attributes:
11766 
   - order_ids
11767 
  """
11768 
 
11769 
  thrift_spec = (
11770 
    None, # 0
11771 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11772 
  )
11773 
 
11774 
  def __init__(self, order_ids=None,):
11775 
    self.order_ids = order_ids
11776 
 
11777 
  def read(self, iprot):
11778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11780 
      return
11781 
    iprot.readStructBegin()
11782 
    while True:
11783 
      (fname, ftype, fid) = iprot.readFieldBegin()
11784 
      if ftype == TType.STOP:
11785 
        break
11786 
      if fid == 1:
11787 
        if ftype == TType.LIST:
11788 
          self.order_ids = []
6188 rajveer 11789 
          (_etype214, _size211) = iprot.readListBegin()
11790 
          for _i215 in xrange(_size211):
11791 
            _elem216 = iprot.readI64();
11792 
            self.order_ids.append(_elem216)
4999 phani.kuma 11793 
          iprot.readListEnd()
11794 
        else:
11795 
          iprot.skip(ftype)
11796 
      else:
11797 
        iprot.skip(ftype)
11798 
      iprot.readFieldEnd()
11799 
    iprot.readStructEnd()
11800 
 
11801 
  def write(self, oprot):
11802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11804 
      return
11805 
    oprot.writeStructBegin('getOrderList_args')
11806 
    if self.order_ids is not None:
11807 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11808 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11809 
      for iter217 in self.order_ids:
11810 
        oprot.writeI64(iter217)
4999 phani.kuma 11811 
      oprot.writeListEnd()
11812 
      oprot.writeFieldEnd()
11813 
    oprot.writeFieldStop()
11814 
    oprot.writeStructEnd()
11815 
 
11816 
  def validate(self):
11817 
    return
11818 
 
11819 
 
11820 
  def __repr__(self):
11821 
    L = ['%s=%r' % (key, value)
11822 
      for key, value in self.__dict__.iteritems()]
11823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11824 
 
11825 
  def __eq__(self, other):
11826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11827 
 
11828 
  def __ne__(self, other):
11829 
    return not (self == other)
11830 
 
11831 
class getOrderList_result:
11832 
  """
11833 
  Attributes:
11834 
   - success
11835 
  """
11836 
 
11837 
  thrift_spec = (
11838 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11839 
  )
11840 
 
11841 
  def __init__(self, success=None,):
11842 
    self.success = success
11843 
 
11844 
  def read(self, iprot):
11845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11847 
      return
11848 
    iprot.readStructBegin()
11849 
    while True:
11850 
      (fname, ftype, fid) = iprot.readFieldBegin()
11851 
      if ftype == TType.STOP:
11852 
        break
11853 
      if fid == 0:
11854 
        if ftype == TType.LIST:
11855 
          self.success = []
6188 rajveer 11856 
          (_etype221, _size218) = iprot.readListBegin()
11857 
          for _i222 in xrange(_size218):
11858 
            _elem223 = Order()
11859 
            _elem223.read(iprot)
11860 
            self.success.append(_elem223)
4999 phani.kuma 11861 
          iprot.readListEnd()
11862 
        else:
11863 
          iprot.skip(ftype)
11864 
      else:
11865 
        iprot.skip(ftype)
11866 
      iprot.readFieldEnd()
11867 
    iprot.readStructEnd()
11868 
 
11869 
  def write(self, oprot):
11870 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11871 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11872 
      return
11873 
    oprot.writeStructBegin('getOrderList_result')
11874 
    if self.success is not None:
11875 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11876 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11877 
      for iter224 in self.success:
11878 
        iter224.write(oprot)
4999 phani.kuma 11879 
      oprot.writeListEnd()
11880 
      oprot.writeFieldEnd()
11881 
    oprot.writeFieldStop()
11882 
    oprot.writeStructEnd()
11883 
 
11884 
  def validate(self):
11885 
    return
11886 
 
11887 
 
11888 
  def __repr__(self):
11889 
    L = ['%s=%r' % (key, value)
11890 
      for key, value in self.__dict__.iteritems()]
11891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11892 
 
11893 
  def __eq__(self, other):
11894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11895 
 
11896 
  def __ne__(self, other):
11897 
    return not (self == other)
11898 
 
5386 phani.kuma 11899 
class getOrderListForVendor_args:
11900 
  """
11901 
  Attributes:
11902 
   - order_ids
11903 
   - vendorId
11904 
  """
11905 
 
11906 
  thrift_spec = (
11907 
    None, # 0
11908 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11909 
    (2, TType.I64, 'vendorId', None, None, ), # 2
11910 
  )
11911 
 
11912 
  def __init__(self, order_ids=None, vendorId=None,):
11913 
    self.order_ids = order_ids
11914 
    self.vendorId = vendorId
11915 
 
11916 
  def read(self, iprot):
11917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11919 
      return
11920 
    iprot.readStructBegin()
11921 
    while True:
11922 
      (fname, ftype, fid) = iprot.readFieldBegin()
11923 
      if ftype == TType.STOP:
11924 
        break
11925 
      if fid == 1:
11926 
        if ftype == TType.LIST:
11927 
          self.order_ids = []
6188 rajveer 11928 
          (_etype228, _size225) = iprot.readListBegin()
11929 
          for _i229 in xrange(_size225):
11930 
            _elem230 = iprot.readI64();
11931 
            self.order_ids.append(_elem230)
5386 phani.kuma 11932 
          iprot.readListEnd()
11933 
        else:
11934 
          iprot.skip(ftype)
11935 
      elif fid == 2:
11936 
        if ftype == TType.I64:
11937 
          self.vendorId = iprot.readI64();
11938 
        else:
11939 
          iprot.skip(ftype)
11940 
      else:
11941 
        iprot.skip(ftype)
11942 
      iprot.readFieldEnd()
11943 
    iprot.readStructEnd()
11944 
 
11945 
  def write(self, oprot):
11946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11948 
      return
11949 
    oprot.writeStructBegin('getOrderListForVendor_args')
11950 
    if self.order_ids is not None:
11951 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11952 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11953 
      for iter231 in self.order_ids:
11954 
        oprot.writeI64(iter231)
5386 phani.kuma 11955 
      oprot.writeListEnd()
11956 
      oprot.writeFieldEnd()
11957 
    if self.vendorId is not None:
11958 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
11959 
      oprot.writeI64(self.vendorId)
11960 
      oprot.writeFieldEnd()
11961 
    oprot.writeFieldStop()
11962 
    oprot.writeStructEnd()
11963 
 
11964 
  def validate(self):
11965 
    return
11966 
 
11967 
 
11968 
  def __repr__(self):
11969 
    L = ['%s=%r' % (key, value)
11970 
      for key, value in self.__dict__.iteritems()]
11971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11972 
 
11973 
  def __eq__(self, other):
11974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11975 
 
11976 
  def __ne__(self, other):
11977 
    return not (self == other)
11978 
 
11979 
class getOrderListForVendor_result:
11980 
  """
11981 
  Attributes:
11982 
   - success
11983 
  """
11984 
 
11985 
  thrift_spec = (
11986 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11987 
  )
11988 
 
11989 
  def __init__(self, success=None,):
11990 
    self.success = success
11991 
 
11992 
  def read(self, iprot):
11993 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11994 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11995 
      return
11996 
    iprot.readStructBegin()
11997 
    while True:
11998 
      (fname, ftype, fid) = iprot.readFieldBegin()
11999 
      if ftype == TType.STOP:
12000 
        break
12001 
      if fid == 0:
12002 
        if ftype == TType.LIST:
12003 
          self.success = []
6188 rajveer 12004 
          (_etype235, _size232) = iprot.readListBegin()
12005 
          for _i236 in xrange(_size232):
12006 
            _elem237 = Order()
12007 
            _elem237.read(iprot)
12008 
            self.success.append(_elem237)
5386 phani.kuma 12009 
          iprot.readListEnd()
12010 
        else:
12011 
          iprot.skip(ftype)
12012 
      else:
12013 
        iprot.skip(ftype)
12014 
      iprot.readFieldEnd()
12015 
    iprot.readStructEnd()
12016 
 
12017 
  def write(self, oprot):
12018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12020 
      return
12021 
    oprot.writeStructBegin('getOrderListForVendor_result')
12022 
    if self.success is not None:
12023 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12024 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12025 
      for iter238 in self.success:
12026 
        iter238.write(oprot)
5386 phani.kuma 12027 
      oprot.writeListEnd()
12028 
      oprot.writeFieldEnd()
12029 
    oprot.writeFieldStop()
12030 
    oprot.writeStructEnd()
12031 
 
12032 
  def validate(self):
12033 
    return
12034 
 
12035 
 
12036 
  def __repr__(self):
12037 
    L = ['%s=%r' % (key, value)
12038 
      for key, value in self.__dict__.iteritems()]
12039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12040 
 
12041 
  def __eq__(self, other):
12042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12043 
 
12044 
  def __ne__(self, other):
12045 
    return not (self == other)
12046 
 
3064 chandransh 12047 
class getOrderForCustomer_args:
94 ashish 12048 
  """
12049 
  Attributes:
3064 chandransh 12050 
   - orderId
483 rajveer 12051 
   - customerId
94 ashish 12052 
  """
12053 
 
12054 
  thrift_spec = (
12055 
    None, # 0
3064 chandransh 12056 
    (1, TType.I64, 'orderId', None, None, ), # 1
12057 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 12058 
  )
12059 
 
3064 chandransh 12060 
  def __init__(self, orderId=None, customerId=None,):
12061 
    self.orderId = orderId
483 rajveer 12062 
    self.customerId = customerId
94 ashish 12063 
 
12064 
  def read(self, iprot):
12065 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12066 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12067 
      return
12068 
    iprot.readStructBegin()
12069 
    while True:
12070 
      (fname, ftype, fid) = iprot.readFieldBegin()
12071 
      if ftype == TType.STOP:
12072 
        break
12073 
      if fid == 1:
12074 
        if ftype == TType.I64:
3064 chandransh 12075 
          self.orderId = iprot.readI64();
94 ashish 12076 
        else:
12077 
          iprot.skip(ftype)
12078 
      elif fid == 2:
12079 
        if ftype == TType.I64:
3064 chandransh 12080 
          self.customerId = iprot.readI64();
94 ashish 12081 
        else:
12082 
          iprot.skip(ftype)
12083 
      else:
12084 
        iprot.skip(ftype)
12085 
      iprot.readFieldEnd()
12086 
    iprot.readStructEnd()
12087 
 
12088 
  def write(self, oprot):
12089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12091 
      return
3064 chandransh 12092 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 12093 
    if self.orderId is not None:
3064 chandransh 12094 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12095 
      oprot.writeI64(self.orderId)
12096 
      oprot.writeFieldEnd()
3431 rajveer 12097 
    if self.customerId is not None:
3064 chandransh 12098 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 12099 
      oprot.writeI64(self.customerId)
94 ashish 12100 
      oprot.writeFieldEnd()
12101 
    oprot.writeFieldStop()
12102 
    oprot.writeStructEnd()
12103 
 
3431 rajveer 12104 
  def validate(self):
12105 
    return
12106 
 
12107 
 
94 ashish 12108 
  def __repr__(self):
12109 
    L = ['%s=%r' % (key, value)
12110 
      for key, value in self.__dict__.iteritems()]
12111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12112 
 
12113 
  def __eq__(self, other):
12114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12115 
 
12116 
  def __ne__(self, other):
12117 
    return not (self == other)
12118 
 
3064 chandransh 12119 
class getOrderForCustomer_result:
94 ashish 12120 
  """
12121 
  Attributes:
12122 
   - success
12123 
   - ex
12124 
  """
12125 
 
12126 
  thrift_spec = (
3064 chandransh 12127 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 12128 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12129 
  )
12130 
 
12131 
  def __init__(self, success=None, ex=None,):
12132 
    self.success = success
12133 
    self.ex = ex
12134 
 
12135 
  def read(self, iprot):
12136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12138 
      return
12139 
    iprot.readStructBegin()
12140 
    while True:
12141 
      (fname, ftype, fid) = iprot.readFieldBegin()
12142 
      if ftype == TType.STOP:
12143 
        break
12144 
      if fid == 0:
3064 chandransh 12145 
        if ftype == TType.STRUCT:
12146 
          self.success = Order()
12147 
          self.success.read(iprot)
94 ashish 12148 
        else:
12149 
          iprot.skip(ftype)
12150 
      elif fid == 1:
12151 
        if ftype == TType.STRUCT:
12152 
          self.ex = TransactionServiceException()
12153 
          self.ex.read(iprot)
12154 
        else:
12155 
          iprot.skip(ftype)
12156 
      else:
12157 
        iprot.skip(ftype)
12158 
      iprot.readFieldEnd()
12159 
    iprot.readStructEnd()
12160 
 
12161 
  def write(self, oprot):
12162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12164 
      return
3064 chandransh 12165 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 12166 
    if self.success is not None:
3064 chandransh 12167 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12168 
      self.success.write(oprot)
94 ashish 12169 
      oprot.writeFieldEnd()
3431 rajveer 12170 
    if self.ex is not None:
94 ashish 12171 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12172 
      self.ex.write(oprot)
12173 
      oprot.writeFieldEnd()
12174 
    oprot.writeFieldStop()
12175 
    oprot.writeStructEnd()
12176 
 
3431 rajveer 12177 
  def validate(self):
12178 
    return
12179 
 
12180 
 
94 ashish 12181 
  def __repr__(self):
12182 
    L = ['%s=%r' % (key, value)
12183 
      for key, value in self.__dict__.iteritems()]
12184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12185 
 
12186 
  def __eq__(self, other):
12187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12188 
 
12189 
  def __ne__(self, other):
12190 
    return not (self == other)
12191 
 
3064 chandransh 12192 
class getAlerts_args:
94 ashish 12193 
  """
12194 
  Attributes:
4394 rajveer 12195 
   - type
4444 rajveer 12196 
   - warehouseId
4394 rajveer 12197 
   - status
12198 
   - timestamp
94 ashish 12199 
  """
12200 
 
12201 
  thrift_spec = (
12202 
    None, # 0
4394 rajveer 12203 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12204 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12205 
    (3, TType.I64, 'status', None, None, ), # 3
12206 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 12207 
  )
12208 
 
4444 rajveer 12209 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 12210 
    self.type = type
4444 rajveer 12211 
    self.warehouseId = warehouseId
4394 rajveer 12212 
    self.status = status
12213 
    self.timestamp = timestamp
94 ashish 12214 
 
12215 
  def read(self, iprot):
12216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12218 
      return
12219 
    iprot.readStructBegin()
12220 
    while True:
12221 
      (fname, ftype, fid) = iprot.readFieldBegin()
12222 
      if ftype == TType.STOP:
12223 
        break
12224 
      if fid == 1:
3064 chandransh 12225 
        if ftype == TType.I64:
4394 rajveer 12226 
          self.type = iprot.readI64();
94 ashish 12227 
        else:
12228 
          iprot.skip(ftype)
3064 chandransh 12229 
      elif fid == 2:
4394 rajveer 12230 
        if ftype == TType.I64:
4444 rajveer 12231 
          self.warehouseId = iprot.readI64();
3064 chandransh 12232 
        else:
12233 
          iprot.skip(ftype)
4394 rajveer 12234 
      elif fid == 3:
12235 
        if ftype == TType.I64:
4444 rajveer 12236 
          self.status = iprot.readI64();
12237 
        else:
12238 
          iprot.skip(ftype)
12239 
      elif fid == 4:
12240 
        if ftype == TType.I64:
4394 rajveer 12241 
          self.timestamp = iprot.readI64();
12242 
        else:
12243 
          iprot.skip(ftype)
94 ashish 12244 
      else:
12245 
        iprot.skip(ftype)
12246 
      iprot.readFieldEnd()
12247 
    iprot.readStructEnd()
12248 
 
12249 
  def write(self, oprot):
12250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12252 
      return
3064 chandransh 12253 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 12254 
    if self.type is not None:
12255 
      oprot.writeFieldBegin('type', TType.I64, 1)
12256 
      oprot.writeI64(self.type)
94 ashish 12257 
      oprot.writeFieldEnd()
4444 rajveer 12258 
    if self.warehouseId is not None:
12259 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12260 
      oprot.writeI64(self.warehouseId)
12261 
      oprot.writeFieldEnd()
4394 rajveer 12262 
    if self.status is not None:
4444 rajveer 12263 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 12264 
      oprot.writeI64(self.status)
3064 chandransh 12265 
      oprot.writeFieldEnd()
4394 rajveer 12266 
    if self.timestamp is not None:
4444 rajveer 12267 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 12268 
      oprot.writeI64(self.timestamp)
12269 
      oprot.writeFieldEnd()
94 ashish 12270 
    oprot.writeFieldStop()
12271 
    oprot.writeStructEnd()
12272 
 
3431 rajveer 12273 
  def validate(self):
12274 
    return
12275 
 
12276 
 
94 ashish 12277 
  def __repr__(self):
12278 
    L = ['%s=%r' % (key, value)
12279 
      for key, value in self.__dict__.iteritems()]
12280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12281 
 
12282 
  def __eq__(self, other):
12283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12284 
 
12285 
  def __ne__(self, other):
12286 
    return not (self == other)
12287 
 
3064 chandransh 12288 
class getAlerts_result:
94 ashish 12289 
  """
12290 
  Attributes:
12291 
   - success
12292 
  """
12293 
 
12294 
  thrift_spec = (
3064 chandransh 12295 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 12296 
  )
12297 
 
3064 chandransh 12298 
  def __init__(self, success=None,):
94 ashish 12299 
    self.success = success
12300 
 
12301 
  def read(self, iprot):
12302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12304 
      return
12305 
    iprot.readStructBegin()
12306 
    while True:
12307 
      (fname, ftype, fid) = iprot.readFieldBegin()
12308 
      if ftype == TType.STOP:
12309 
        break
12310 
      if fid == 0:
3064 chandransh 12311 
        if ftype == TType.LIST:
12312 
          self.success = []
6188 rajveer 12313 
          (_etype242, _size239) = iprot.readListBegin()
12314 
          for _i243 in xrange(_size239):
12315 
            _elem244 = Alert()
12316 
            _elem244.read(iprot)
12317 
            self.success.append(_elem244)
3064 chandransh 12318 
          iprot.readListEnd()
94 ashish 12319 
        else:
12320 
          iprot.skip(ftype)
12321 
      else:
12322 
        iprot.skip(ftype)
12323 
      iprot.readFieldEnd()
12324 
    iprot.readStructEnd()
12325 
 
12326 
  def write(self, oprot):
12327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12329 
      return
3064 chandransh 12330 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 12331 
    if self.success is not None:
3064 chandransh 12332 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12333 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12334 
      for iter245 in self.success:
12335 
        iter245.write(oprot)
3064 chandransh 12336 
      oprot.writeListEnd()
94 ashish 12337 
      oprot.writeFieldEnd()
12338 
    oprot.writeFieldStop()
12339 
    oprot.writeStructEnd()
12340 
 
3431 rajveer 12341 
  def validate(self):
12342 
    return
12343 
 
12344 
 
94 ashish 12345 
  def __repr__(self):
12346 
    L = ['%s=%r' % (key, value)
12347 
      for key, value in self.__dict__.iteritems()]
12348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12349 
 
12350 
  def __eq__(self, other):
12351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12352 
 
12353 
  def __ne__(self, other):
12354 
    return not (self == other)
12355 
 
4394 rajveer 12356 
class addAlert_args:
94 ashish 12357 
  """
12358 
  Attributes:
3064 chandransh 12359 
   - type
4444 rajveer 12360 
   - warehouseId
4394 rajveer 12361 
   - description
94 ashish 12362 
  """
12363 
 
12364 
  thrift_spec = (
12365 
    None, # 0
4394 rajveer 12366 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12367 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12368 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12369 
  )
12370 
 
4444 rajveer 12371 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 12372 
    self.type = type
4444 rajveer 12373 
    self.warehouseId = warehouseId
4394 rajveer 12374 
    self.description = description
94 ashish 12375 
 
12376 
  def read(self, iprot):
12377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12379 
      return
12380 
    iprot.readStructBegin()
12381 
    while True:
12382 
      (fname, ftype, fid) = iprot.readFieldBegin()
12383 
      if ftype == TType.STOP:
12384 
        break
12385 
      if fid == 1:
12386 
        if ftype == TType.I64:
4394 rajveer 12387 
          self.type = iprot.readI64();
94 ashish 12388 
        else:
12389 
          iprot.skip(ftype)
3064 chandransh 12390 
      elif fid == 2:
4444 rajveer 12391 
        if ftype == TType.I64:
12392 
          self.warehouseId = iprot.readI64();
12393 
        else:
12394 
          iprot.skip(ftype)
12395 
      elif fid == 3:
3064 chandransh 12396 
        if ftype == TType.STRING:
4394 rajveer 12397 
          self.description = iprot.readString();
3064 chandransh 12398 
        else:
12399 
          iprot.skip(ftype)
94 ashish 12400 
      else:
12401 
        iprot.skip(ftype)
12402 
      iprot.readFieldEnd()
12403 
    iprot.readStructEnd()
12404 
 
12405 
  def write(self, oprot):
12406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12408 
      return
4394 rajveer 12409 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 12410 
    if self.type is not None:
4394 rajveer 12411 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 12412 
      oprot.writeI64(self.type)
12413 
      oprot.writeFieldEnd()
4444 rajveer 12414 
    if self.warehouseId is not None:
12415 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12416 
      oprot.writeI64(self.warehouseId)
12417 
      oprot.writeFieldEnd()
4394 rajveer 12418 
    if self.description is not None:
4444 rajveer 12419 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 12420 
      oprot.writeString(self.description)
3064 chandransh 12421 
      oprot.writeFieldEnd()
94 ashish 12422 
    oprot.writeFieldStop()
12423 
    oprot.writeStructEnd()
12424 
 
3431 rajveer 12425 
  def validate(self):
12426 
    return
12427 
 
12428 
 
94 ashish 12429 
  def __repr__(self):
12430 
    L = ['%s=%r' % (key, value)
12431 
      for key, value in self.__dict__.iteritems()]
12432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12433 
 
12434 
  def __eq__(self, other):
12435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12436 
 
12437 
  def __ne__(self, other):
12438 
    return not (self == other)
12439 
 
4394 rajveer 12440 
class addAlert_result:
3064 chandransh 12441 
 
12442 
  thrift_spec = (
12443 
  )
12444 
 
12445 
  def read(self, iprot):
12446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12448 
      return
12449 
    iprot.readStructBegin()
12450 
    while True:
12451 
      (fname, ftype, fid) = iprot.readFieldBegin()
12452 
      if ftype == TType.STOP:
12453 
        break
12454 
      else:
12455 
        iprot.skip(ftype)
12456 
      iprot.readFieldEnd()
12457 
    iprot.readStructEnd()
12458 
 
12459 
  def write(self, oprot):
12460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12462 
      return
4394 rajveer 12463 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 12464 
    oprot.writeFieldStop()
12465 
    oprot.writeStructEnd()
12466 
 
3431 rajveer 12467 
  def validate(self):
12468 
    return
12469 
 
12470 
 
3064 chandransh 12471 
  def __repr__(self):
12472 
    L = ['%s=%r' % (key, value)
12473 
      for key, value in self.__dict__.iteritems()]
12474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12475 
 
12476 
  def __eq__(self, other):
12477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12478 
 
12479 
  def __ne__(self, other):
12480 
    return not (self == other)
12481 
 
4444 rajveer 12482 
class markAlertsAsSeen_args:
12483 
  """
12484 
  Attributes:
12485 
   - warehouseId
12486 
  """
12487 
 
12488 
  thrift_spec = (
12489 
    None, # 0
12490 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12491 
  )
12492 
 
12493 
  def __init__(self, warehouseId=None,):
12494 
    self.warehouseId = warehouseId
12495 
 
12496 
  def read(self, iprot):
12497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12499 
      return
12500 
    iprot.readStructBegin()
12501 
    while True:
12502 
      (fname, ftype, fid) = iprot.readFieldBegin()
12503 
      if ftype == TType.STOP:
12504 
        break
12505 
      if fid == 1:
12506 
        if ftype == TType.I64:
12507 
          self.warehouseId = iprot.readI64();
12508 
        else:
12509 
          iprot.skip(ftype)
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
12519 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12520 
    if self.warehouseId is not None:
12521 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12522 
      oprot.writeI64(self.warehouseId)
12523 
      oprot.writeFieldEnd()
12524 
    oprot.writeFieldStop()
12525 
    oprot.writeStructEnd()
12526 
 
12527 
  def validate(self):
12528 
    return
12529 
 
12530 
 
12531 
  def __repr__(self):
12532 
    L = ['%s=%r' % (key, value)
12533 
      for key, value in self.__dict__.iteritems()]
12534 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12535 
 
12536 
  def __eq__(self, other):
12537 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12538 
 
12539 
  def __ne__(self, other):
12540 
    return not (self == other)
12541 
 
12542 
class markAlertsAsSeen_result:
12543 
 
12544 
  thrift_spec = (
12545 
  )
12546 
 
12547 
  def read(self, iprot):
12548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12550 
      return
12551 
    iprot.readStructBegin()
12552 
    while True:
12553 
      (fname, ftype, fid) = iprot.readFieldBegin()
12554 
      if ftype == TType.STOP:
12555 
        break
12556 
      else:
12557 
        iprot.skip(ftype)
12558 
      iprot.readFieldEnd()
12559 
    iprot.readStructEnd()
12560 
 
12561 
  def write(self, oprot):
12562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12564 
      return
12565 
    oprot.writeStructBegin('markAlertsAsSeen_result')
12566 
    oprot.writeFieldStop()
12567 
    oprot.writeStructEnd()
12568 
 
12569 
  def validate(self):
12570 
    return
12571 
 
12572 
 
12573 
  def __repr__(self):
12574 
    L = ['%s=%r' % (key, value)
12575 
      for key, value in self.__dict__.iteritems()]
12576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12577 
 
12578 
  def __eq__(self, other):
12579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12580 
 
12581 
  def __ne__(self, other):
12582 
    return not (self == other)
12583 
 
3064 chandransh 12584 
class getValidOrderCount_args:
12585 
 
12586 
  thrift_spec = (
12587 
  )
12588 
 
12589 
  def read(self, iprot):
12590 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12591 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12592 
      return
12593 
    iprot.readStructBegin()
12594 
    while True:
12595 
      (fname, ftype, fid) = iprot.readFieldBegin()
12596 
      if ftype == TType.STOP:
12597 
        break
12598 
      else:
12599 
        iprot.skip(ftype)
12600 
      iprot.readFieldEnd()
12601 
    iprot.readStructEnd()
12602 
 
12603 
  def write(self, oprot):
12604 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12605 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12606 
      return
12607 
    oprot.writeStructBegin('getValidOrderCount_args')
12608 
    oprot.writeFieldStop()
12609 
    oprot.writeStructEnd()
12610 
 
3431 rajveer 12611 
  def validate(self):
12612 
    return
12613 
 
12614 
 
3064 chandransh 12615 
  def __repr__(self):
12616 
    L = ['%s=%r' % (key, value)
12617 
      for key, value in self.__dict__.iteritems()]
12618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12619 
 
12620 
  def __eq__(self, other):
12621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12622 
 
12623 
  def __ne__(self, other):
12624 
    return not (self == other)
12625 
 
12626 
class getValidOrderCount_result:
94 ashish 12627 
  """
12628 
  Attributes:
12629 
   - success
12630 
  """
12631 
 
12632 
  thrift_spec = (
3064 chandransh 12633 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12634 
  )
12635 
 
3064 chandransh 12636 
  def __init__(self, success=None,):
94 ashish 12637 
    self.success = success
12638 
 
12639 
  def read(self, iprot):
12640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12642 
      return
12643 
    iprot.readStructBegin()
12644 
    while True:
12645 
      (fname, ftype, fid) = iprot.readFieldBegin()
12646 
      if ftype == TType.STOP:
12647 
        break
12648 
      if fid == 0:
3064 chandransh 12649 
        if ftype == TType.I64:
12650 
          self.success = iprot.readI64();
94 ashish 12651 
        else:
12652 
          iprot.skip(ftype)
12653 
      else:
12654 
        iprot.skip(ftype)
12655 
      iprot.readFieldEnd()
12656 
    iprot.readStructEnd()
12657 
 
12658 
  def write(self, oprot):
12659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12661 
      return
3064 chandransh 12662 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12663 
    if self.success is not None:
3064 chandransh 12664 
      oprot.writeFieldBegin('success', TType.I64, 0)
12665 
      oprot.writeI64(self.success)
94 ashish 12666 
      oprot.writeFieldEnd()
12667 
    oprot.writeFieldStop()
12668 
    oprot.writeStructEnd()
12669 
 
3431 rajveer 12670 
  def validate(self):
12671 
    return
12672 
 
12673 
 
94 ashish 12674 
  def __repr__(self):
12675 
    L = ['%s=%r' % (key, value)
12676 
      for key, value in self.__dict__.iteritems()]
12677 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12678 
 
12679 
  def __eq__(self, other):
12680 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12681 
 
12682 
  def __ne__(self, other):
12683 
    return not (self == other)
12684 
 
3064 chandransh 12685 
class getNoOfCustomersWithSuccessfulTransaction_args:
12686 
 
12687 
  thrift_spec = (
12688 
  )
12689 
 
12690 
  def read(self, iprot):
12691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12693 
      return
12694 
    iprot.readStructBegin()
12695 
    while True:
12696 
      (fname, ftype, fid) = iprot.readFieldBegin()
12697 
      if ftype == TType.STOP:
12698 
        break
12699 
      else:
12700 
        iprot.skip(ftype)
12701 
      iprot.readFieldEnd()
12702 
    iprot.readStructEnd()
12703 
 
12704 
  def write(self, oprot):
12705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12707 
      return
12708 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
12709 
    oprot.writeFieldStop()
12710 
    oprot.writeStructEnd()
12711 
 
3431 rajveer 12712 
  def validate(self):
12713 
    return
12714 
 
12715 
 
3064 chandransh 12716 
  def __repr__(self):
12717 
    L = ['%s=%r' % (key, value)
12718 
      for key, value in self.__dict__.iteritems()]
12719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12720 
 
12721 
  def __eq__(self, other):
12722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12723 
 
12724 
  def __ne__(self, other):
12725 
    return not (self == other)
12726 
 
12727 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 12728 
  """
12729 
  Attributes:
3064 chandransh 12730 
   - success
94 ashish 12731 
  """
12732 
 
12733 
  thrift_spec = (
3064 chandransh 12734 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12735 
  )
12736 
 
3064 chandransh 12737 
  def __init__(self, success=None,):
12738 
    self.success = success
94 ashish 12739 
 
12740 
  def read(self, iprot):
12741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12743 
      return
12744 
    iprot.readStructBegin()
12745 
    while True:
12746 
      (fname, ftype, fid) = iprot.readFieldBegin()
12747 
      if ftype == TType.STOP:
12748 
        break
3064 chandransh 12749 
      if fid == 0:
94 ashish 12750 
        if ftype == TType.I64:
3064 chandransh 12751 
          self.success = iprot.readI64();
94 ashish 12752 
        else:
12753 
          iprot.skip(ftype)
12754 
      else:
12755 
        iprot.skip(ftype)
12756 
      iprot.readFieldEnd()
12757 
    iprot.readStructEnd()
12758 
 
12759 
  def write(self, oprot):
12760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12762 
      return
3064 chandransh 12763 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 12764 
    if self.success is not None:
3064 chandransh 12765 
      oprot.writeFieldBegin('success', TType.I64, 0)
12766 
      oprot.writeI64(self.success)
94 ashish 12767 
      oprot.writeFieldEnd()
12768 
    oprot.writeFieldStop()
12769 
    oprot.writeStructEnd()
12770 
 
3431 rajveer 12771 
  def validate(self):
12772 
    return
12773 
 
12774 
 
94 ashish 12775 
  def __repr__(self):
12776 
    L = ['%s=%r' % (key, value)
12777 
      for key, value in self.__dict__.iteritems()]
12778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12779 
 
12780 
  def __eq__(self, other):
12781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12782 
 
12783 
  def __ne__(self, other):
12784 
    return not (self == other)
12785 
 
3064 chandransh 12786 
class getValidOrdersAmountRange_args:
12787 
 
12788 
  thrift_spec = (
12789 
  )
12790 
 
12791 
  def read(self, iprot):
12792 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12793 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12794 
      return
12795 
    iprot.readStructBegin()
12796 
    while True:
12797 
      (fname, ftype, fid) = iprot.readFieldBegin()
12798 
      if ftype == TType.STOP:
12799 
        break
12800 
      else:
12801 
        iprot.skip(ftype)
12802 
      iprot.readFieldEnd()
12803 
    iprot.readStructEnd()
12804 
 
12805 
  def write(self, oprot):
12806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12808 
      return
12809 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
12810 
    oprot.writeFieldStop()
12811 
    oprot.writeStructEnd()
12812 
 
3431 rajveer 12813 
  def validate(self):
12814 
    return
12815 
 
12816 
 
3064 chandransh 12817 
  def __repr__(self):
12818 
    L = ['%s=%r' % (key, value)
12819 
      for key, value in self.__dict__.iteritems()]
12820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12821 
 
12822 
  def __eq__(self, other):
12823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12824 
 
12825 
  def __ne__(self, other):
12826 
    return not (self == other)
12827 
 
12828 
class getValidOrdersAmountRange_result:
94 ashish 12829 
  """
12830 
  Attributes:
12831 
   - success
12832 
  """
12833 
 
12834 
  thrift_spec = (
3064 chandransh 12835 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 12836 
  )
12837 
 
3064 chandransh 12838 
  def __init__(self, success=None,):
94 ashish 12839 
    self.success = success
12840 
 
12841 
  def read(self, iprot):
12842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12844 
      return
12845 
    iprot.readStructBegin()
12846 
    while True:
12847 
      (fname, ftype, fid) = iprot.readFieldBegin()
12848 
      if ftype == TType.STOP:
12849 
        break
12850 
      if fid == 0:
483 rajveer 12851 
        if ftype == TType.LIST:
12852 
          self.success = []
6188 rajveer 12853 
          (_etype249, _size246) = iprot.readListBegin()
12854 
          for _i250 in xrange(_size246):
12855 
            _elem251 = iprot.readDouble();
12856 
            self.success.append(_elem251)
483 rajveer 12857 
          iprot.readListEnd()
94 ashish 12858 
        else:
12859 
          iprot.skip(ftype)
12860 
      else:
12861 
        iprot.skip(ftype)
12862 
      iprot.readFieldEnd()
12863 
    iprot.readStructEnd()
12864 
 
12865 
  def write(self, oprot):
12866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12868 
      return
3064 chandransh 12869 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 12870 
    if self.success is not None:
483 rajveer 12871 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 12872 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 12873 
      for iter252 in self.success:
12874 
        oprot.writeDouble(iter252)
483 rajveer 12875 
      oprot.writeListEnd()
94 ashish 12876 
      oprot.writeFieldEnd()
12877 
    oprot.writeFieldStop()
12878 
    oprot.writeStructEnd()
12879 
 
3431 rajveer 12880 
  def validate(self):
12881 
    return
12882 
 
12883 
 
94 ashish 12884 
  def __repr__(self):
12885 
    L = ['%s=%r' % (key, value)
12886 
      for key, value in self.__dict__.iteritems()]
12887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12888 
 
12889 
  def __eq__(self, other):
12890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12891 
 
12892 
  def __ne__(self, other):
12893 
    return not (self == other)
12894 
 
3064 chandransh 12895 
class getValidOrders_args:
1528 ankur.sing 12896 
  """
12897 
  Attributes:
3064 chandransh 12898 
   - limit
5874 rajveer 12899 
   - onlyStore
1528 ankur.sing 12900 
  """
12901 
 
12902 
  thrift_spec = (
12903 
    None, # 0
3064 chandransh 12904 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 12905 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 12906 
  )
12907 
 
5874 rajveer 12908 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 12909 
    self.limit = limit
5874 rajveer 12910 
    self.onlyStore = onlyStore
1528 ankur.sing 12911 
 
12912 
  def read(self, iprot):
12913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12915 
      return
12916 
    iprot.readStructBegin()
12917 
    while True:
12918 
      (fname, ftype, fid) = iprot.readFieldBegin()
12919 
      if ftype == TType.STOP:
12920 
        break
12921 
      if fid == 1:
12922 
        if ftype == TType.I64:
3064 chandransh 12923 
          self.limit = iprot.readI64();
1528 ankur.sing 12924 
        else:
12925 
          iprot.skip(ftype)
5874 rajveer 12926 
      elif fid == 2:
12927 
        if ftype == TType.BOOL:
12928 
          self.onlyStore = iprot.readBool();
12929 
        else:
12930 
          iprot.skip(ftype)
1528 ankur.sing 12931 
      else:
12932 
        iprot.skip(ftype)
12933 
      iprot.readFieldEnd()
12934 
    iprot.readStructEnd()
12935 
 
12936 
  def write(self, oprot):
12937 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12938 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12939 
      return
3064 chandransh 12940 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 12941 
    if self.limit is not None:
3064 chandransh 12942 
      oprot.writeFieldBegin('limit', TType.I64, 1)
12943 
      oprot.writeI64(self.limit)
1528 ankur.sing 12944 
      oprot.writeFieldEnd()
5874 rajveer 12945 
    if self.onlyStore is not None:
12946 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
12947 
      oprot.writeBool(self.onlyStore)
12948 
      oprot.writeFieldEnd()
1528 ankur.sing 12949 
    oprot.writeFieldStop()
12950 
    oprot.writeStructEnd()
12951 
 
3431 rajveer 12952 
  def validate(self):
12953 
    return
12954 
 
12955 
 
1528 ankur.sing 12956 
  def __repr__(self):
12957 
    L = ['%s=%r' % (key, value)
12958 
      for key, value in self.__dict__.iteritems()]
12959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12960 
 
12961 
  def __eq__(self, other):
12962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12963 
 
12964 
  def __ne__(self, other):
12965 
    return not (self == other)
12966 
 
3064 chandransh 12967 
class getValidOrders_result:
1528 ankur.sing 12968 
  """
12969 
  Attributes:
12970 
   - success
12971 
  """
12972 
 
12973 
  thrift_spec = (
3064 chandransh 12974 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 12975 
  )
12976 
 
3064 chandransh 12977 
  def __init__(self, success=None,):
1528 ankur.sing 12978 
    self.success = success
12979 
 
12980 
  def read(self, iprot):
12981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12983 
      return
12984 
    iprot.readStructBegin()
12985 
    while True:
12986 
      (fname, ftype, fid) = iprot.readFieldBegin()
12987 
      if ftype == TType.STOP:
12988 
        break
12989 
      if fid == 0:
3064 chandransh 12990 
        if ftype == TType.LIST:
12991 
          self.success = []
6188 rajveer 12992 
          (_etype256, _size253) = iprot.readListBegin()
12993 
          for _i257 in xrange(_size253):
12994 
            _elem258 = Order()
12995 
            _elem258.read(iprot)
12996 
            self.success.append(_elem258)
3064 chandransh 12997 
          iprot.readListEnd()
1528 ankur.sing 12998 
        else:
12999 
          iprot.skip(ftype)
13000 
      else:
13001 
        iprot.skip(ftype)
13002 
      iprot.readFieldEnd()
13003 
    iprot.readStructEnd()
13004 
 
13005 
  def write(self, oprot):
13006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13008 
      return
3064 chandransh 13009 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 13010 
    if self.success is not None:
3064 chandransh 13011 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13012 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13013 
      for iter259 in self.success:
13014 
        iter259.write(oprot)
3064 chandransh 13015 
      oprot.writeListEnd()
1528 ankur.sing 13016 
      oprot.writeFieldEnd()
13017 
    oprot.writeFieldStop()
13018 
    oprot.writeStructEnd()
13019 
 
3431 rajveer 13020 
  def validate(self):
13021 
    return
13022 
 
13023 
 
1528 ankur.sing 13024 
  def __repr__(self):
13025 
    L = ['%s=%r' % (key, value)
13026 
      for key, value in self.__dict__.iteritems()]
13027 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13028 
 
13029 
  def __eq__(self, other):
13030 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13031 
 
13032 
  def __ne__(self, other):
13033 
    return not (self == other)
13034 
 
1220 chandransh 13035 
class batchOrders_args:
13036 
  """
13037 
  Attributes:
13038 
   - warehouseId
13039 
  """
13040 
 
13041 
  thrift_spec = (
13042 
    None, # 0
13043 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13044 
  )
13045 
 
13046 
  def __init__(self, warehouseId=None,):
13047 
    self.warehouseId = warehouseId
13048 
 
13049 
  def read(self, iprot):
13050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13052 
      return
13053 
    iprot.readStructBegin()
13054 
    while True:
13055 
      (fname, ftype, fid) = iprot.readFieldBegin()
13056 
      if ftype == TType.STOP:
13057 
        break
13058 
      if fid == 1:
13059 
        if ftype == TType.I64:
13060 
          self.warehouseId = iprot.readI64();
13061 
        else:
13062 
          iprot.skip(ftype)
13063 
      else:
13064 
        iprot.skip(ftype)
13065 
      iprot.readFieldEnd()
13066 
    iprot.readStructEnd()
13067 
 
13068 
  def write(self, oprot):
13069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13071 
      return
13072 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 13073 
    if self.warehouseId is not None:
1220 chandransh 13074 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13075 
      oprot.writeI64(self.warehouseId)
13076 
      oprot.writeFieldEnd()
13077 
    oprot.writeFieldStop()
13078 
    oprot.writeStructEnd()
13079 
 
3431 rajveer 13080 
  def validate(self):
13081 
    return
13082 
 
13083 
 
1220 chandransh 13084 
  def __repr__(self):
13085 
    L = ['%s=%r' % (key, value)
13086 
      for key, value in self.__dict__.iteritems()]
13087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13088 
 
13089 
  def __eq__(self, other):
13090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13091 
 
13092 
  def __ne__(self, other):
13093 
    return not (self == other)
13094 
 
13095 
class batchOrders_result:
13096 
  """
13097 
  Attributes:
13098 
   - success
13099 
   - ex
13100 
  """
13101 
 
13102 
  thrift_spec = (
13103 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13104 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13105 
  )
13106 
 
13107 
  def __init__(self, success=None, ex=None,):
13108 
    self.success = success
13109 
    self.ex = ex
13110 
 
13111 
  def read(self, iprot):
13112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13114 
      return
13115 
    iprot.readStructBegin()
13116 
    while True:
13117 
      (fname, ftype, fid) = iprot.readFieldBegin()
13118 
      if ftype == TType.STOP:
13119 
        break
13120 
      if fid == 0:
13121 
        if ftype == TType.LIST:
13122 
          self.success = []
6188 rajveer 13123 
          (_etype263, _size260) = iprot.readListBegin()
13124 
          for _i264 in xrange(_size260):
13125 
            _elem265 = Order()
13126 
            _elem265.read(iprot)
13127 
            self.success.append(_elem265)
1220 chandransh 13128 
          iprot.readListEnd()
13129 
        else:
13130 
          iprot.skip(ftype)
13131 
      elif fid == 1:
13132 
        if ftype == TType.STRUCT:
13133 
          self.ex = TransactionServiceException()
13134 
          self.ex.read(iprot)
13135 
        else:
13136 
          iprot.skip(ftype)
13137 
      else:
13138 
        iprot.skip(ftype)
13139 
      iprot.readFieldEnd()
13140 
    iprot.readStructEnd()
13141 
 
13142 
  def write(self, oprot):
13143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13145 
      return
13146 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 13147 
    if self.success is not None:
1220 chandransh 13148 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13149 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13150 
      for iter266 in self.success:
13151 
        iter266.write(oprot)
1220 chandransh 13152 
      oprot.writeListEnd()
13153 
      oprot.writeFieldEnd()
3431 rajveer 13154 
    if self.ex is not None:
1220 chandransh 13155 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13156 
      self.ex.write(oprot)
13157 
      oprot.writeFieldEnd()
13158 
    oprot.writeFieldStop()
13159 
    oprot.writeStructEnd()
13160 
 
3431 rajveer 13161 
  def validate(self):
13162 
    return
13163 
 
13164 
 
1220 chandransh 13165 
  def __repr__(self):
13166 
    L = ['%s=%r' % (key, value)
13167 
      for key, value in self.__dict__.iteritems()]
13168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13169 
 
13170 
  def __eq__(self, other):
13171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13172 
 
13173 
  def __ne__(self, other):
13174 
    return not (self == other)
13175 
 
1208 chandransh 13176 
class markOrderAsOutOfStock_args:
13177 
  """
13178 
  Attributes:
13179 
   - orderId
13180 
  """
13181 
 
13182 
  thrift_spec = (
13183 
    None, # 0
13184 
    (1, TType.I64, 'orderId', None, None, ), # 1
13185 
  )
13186 
 
13187 
  def __init__(self, orderId=None,):
13188 
    self.orderId = orderId
13189 
 
13190 
  def read(self, iprot):
13191 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13192 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13193 
      return
13194 
    iprot.readStructBegin()
13195 
    while True:
13196 
      (fname, ftype, fid) = iprot.readFieldBegin()
13197 
      if ftype == TType.STOP:
13198 
        break
13199 
      if fid == 1:
13200 
        if ftype == TType.I64:
13201 
          self.orderId = iprot.readI64();
13202 
        else:
13203 
          iprot.skip(ftype)
13204 
      else:
13205 
        iprot.skip(ftype)
13206 
      iprot.readFieldEnd()
13207 
    iprot.readStructEnd()
13208 
 
13209 
  def write(self, oprot):
13210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13212 
      return
13213 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 13214 
    if self.orderId is not None:
1208 chandransh 13215 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13216 
      oprot.writeI64(self.orderId)
13217 
      oprot.writeFieldEnd()
13218 
    oprot.writeFieldStop()
13219 
    oprot.writeStructEnd()
13220 
 
3431 rajveer 13221 
  def validate(self):
13222 
    return
13223 
 
13224 
 
1208 chandransh 13225 
  def __repr__(self):
13226 
    L = ['%s=%r' % (key, value)
13227 
      for key, value in self.__dict__.iteritems()]
13228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13229 
 
13230 
  def __eq__(self, other):
13231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13232 
 
13233 
  def __ne__(self, other):
13234 
    return not (self == other)
13235 
 
13236 
class markOrderAsOutOfStock_result:
13237 
  """
13238 
  Attributes:
13239 
   - success
13240 
   - ex
13241 
  """
13242 
 
13243 
  thrift_spec = (
13244 
    (0, TType.BOOL, 'success', None, None, ), # 0
13245 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13246 
  )
13247 
 
13248 
  def __init__(self, success=None, ex=None,):
13249 
    self.success = success
13250 
    self.ex = ex
13251 
 
13252 
  def read(self, iprot):
13253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13255 
      return
13256 
    iprot.readStructBegin()
13257 
    while True:
13258 
      (fname, ftype, fid) = iprot.readFieldBegin()
13259 
      if ftype == TType.STOP:
13260 
        break
13261 
      if fid == 0:
13262 
        if ftype == TType.BOOL:
13263 
          self.success = iprot.readBool();
13264 
        else:
13265 
          iprot.skip(ftype)
13266 
      elif fid == 1:
13267 
        if ftype == TType.STRUCT:
13268 
          self.ex = TransactionServiceException()
13269 
          self.ex.read(iprot)
13270 
        else:
13271 
          iprot.skip(ftype)
13272 
      else:
13273 
        iprot.skip(ftype)
13274 
      iprot.readFieldEnd()
13275 
    iprot.readStructEnd()
13276 
 
13277 
  def write(self, oprot):
13278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13280 
      return
13281 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 13282 
    if self.success is not None:
1208 chandransh 13283 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13284 
      oprot.writeBool(self.success)
13285 
      oprot.writeFieldEnd()
3431 rajveer 13286 
    if self.ex is not None:
1208 chandransh 13287 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13288 
      self.ex.write(oprot)
13289 
      oprot.writeFieldEnd()
13290 
    oprot.writeFieldStop()
13291 
    oprot.writeStructEnd()
13292 
 
3431 rajveer 13293 
  def validate(self):
13294 
    return
13295 
 
13296 
 
1208 chandransh 13297 
  def __repr__(self):
13298 
    L = ['%s=%r' % (key, value)
13299 
      for key, value in self.__dict__.iteritems()]
13300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13301 
 
13302 
  def __eq__(self, other):
13303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13304 
 
13305 
  def __ne__(self, other):
13306 
    return not (self == other)
13307 
 
3064 chandransh 13308 
class verifyOrder_args:
759 chandransh 13309 
  """
13310 
  Attributes:
3064 chandransh 13311 
   - orderId
759 chandransh 13312 
  """
13313 
 
13314 
  thrift_spec = (
13315 
    None, # 0
3064 chandransh 13316 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 13317 
  )
13318 
 
3064 chandransh 13319 
  def __init__(self, orderId=None,):
13320 
    self.orderId = orderId
759 chandransh 13321 
 
13322 
  def read(self, iprot):
13323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13325 
      return
13326 
    iprot.readStructBegin()
13327 
    while True:
13328 
      (fname, ftype, fid) = iprot.readFieldBegin()
13329 
      if ftype == TType.STOP:
13330 
        break
13331 
      if fid == 1:
13332 
        if ftype == TType.I64:
3064 chandransh 13333 
          self.orderId = iprot.readI64();
759 chandransh 13334 
        else:
13335 
          iprot.skip(ftype)
13336 
      else:
13337 
        iprot.skip(ftype)
13338 
      iprot.readFieldEnd()
13339 
    iprot.readStructEnd()
13340 
 
13341 
  def write(self, oprot):
13342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13344 
      return
3064 chandransh 13345 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 13346 
    if self.orderId is not None:
3064 chandransh 13347 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13348 
      oprot.writeI64(self.orderId)
759 chandransh 13349 
      oprot.writeFieldEnd()
13350 
    oprot.writeFieldStop()
13351 
    oprot.writeStructEnd()
13352 
 
3431 rajveer 13353 
  def validate(self):
13354 
    return
13355 
 
13356 
 
759 chandransh 13357 
  def __repr__(self):
13358 
    L = ['%s=%r' % (key, value)
13359 
      for key, value in self.__dict__.iteritems()]
13360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13361 
 
13362 
  def __eq__(self, other):
13363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13364 
 
13365 
  def __ne__(self, other):
13366 
    return not (self == other)
13367 
 
3064 chandransh 13368 
class verifyOrder_result:
759 chandransh 13369 
  """
13370 
  Attributes:
13371 
   - success
13372 
   - ex
13373 
  """
13374 
 
13375 
  thrift_spec = (
13376 
    (0, TType.BOOL, 'success', None, None, ), # 0
13377 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13378 
  )
13379 
 
13380 
  def __init__(self, success=None, ex=None,):
13381 
    self.success = success
13382 
    self.ex = ex
13383 
 
13384 
  def read(self, iprot):
13385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13387 
      return
13388 
    iprot.readStructBegin()
13389 
    while True:
13390 
      (fname, ftype, fid) = iprot.readFieldBegin()
13391 
      if ftype == TType.STOP:
13392 
        break
13393 
      if fid == 0:
13394 
        if ftype == TType.BOOL:
13395 
          self.success = iprot.readBool();
13396 
        else:
13397 
          iprot.skip(ftype)
13398 
      elif fid == 1:
13399 
        if ftype == TType.STRUCT:
13400 
          self.ex = TransactionServiceException()
13401 
          self.ex.read(iprot)
13402 
        else:
13403 
          iprot.skip(ftype)
13404 
      else:
13405 
        iprot.skip(ftype)
13406 
      iprot.readFieldEnd()
13407 
    iprot.readStructEnd()
13408 
 
13409 
  def write(self, oprot):
13410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13412 
      return
3064 chandransh 13413 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 13414 
    if self.success is not None:
759 chandransh 13415 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13416 
      oprot.writeBool(self.success)
13417 
      oprot.writeFieldEnd()
3431 rajveer 13418 
    if self.ex is not None:
759 chandransh 13419 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13420 
      self.ex.write(oprot)
13421 
      oprot.writeFieldEnd()
13422 
    oprot.writeFieldStop()
13423 
    oprot.writeStructEnd()
13424 
 
3431 rajveer 13425 
  def validate(self):
13426 
    return
13427 
 
13428 
 
759 chandransh 13429 
  def __repr__(self):
13430 
    L = ['%s=%r' % (key, value)
13431 
      for key, value in self.__dict__.iteritems()]
13432 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13433 
 
13434 
  def __eq__(self, other):
13435 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13436 
 
13437 
  def __ne__(self, other):
13438 
    return not (self == other)
13439 
 
3064 chandransh 13440 
class acceptOrder_args:
1113 chandransh 13441 
  """
13442 
  Attributes:
3064 chandransh 13443 
   - orderId
1113 chandransh 13444 
  """
13445 
 
13446 
  thrift_spec = (
13447 
    None, # 0
3064 chandransh 13448 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 13449 
  )
13450 
 
3064 chandransh 13451 
  def __init__(self, orderId=None,):
13452 
    self.orderId = orderId
1113 chandransh 13453 
 
13454 
  def read(self, iprot):
13455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13457 
      return
13458 
    iprot.readStructBegin()
13459 
    while True:
13460 
      (fname, ftype, fid) = iprot.readFieldBegin()
13461 
      if ftype == TType.STOP:
13462 
        break
13463 
      if fid == 1:
13464 
        if ftype == TType.I64:
3064 chandransh 13465 
          self.orderId = iprot.readI64();
1113 chandransh 13466 
        else:
13467 
          iprot.skip(ftype)
13468 
      else:
13469 
        iprot.skip(ftype)
13470 
      iprot.readFieldEnd()
13471 
    iprot.readStructEnd()
13472 
 
13473 
  def write(self, oprot):
13474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13476 
      return
3064 chandransh 13477 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 13478 
    if self.orderId is not None:
3064 chandransh 13479 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13480 
      oprot.writeI64(self.orderId)
1113 chandransh 13481 
      oprot.writeFieldEnd()
13482 
    oprot.writeFieldStop()
13483 
    oprot.writeStructEnd()
13484 
 
3431 rajveer 13485 
  def validate(self):
13486 
    return
13487 
 
13488 
 
1113 chandransh 13489 
  def __repr__(self):
13490 
    L = ['%s=%r' % (key, value)
13491 
      for key, value in self.__dict__.iteritems()]
13492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13493 
 
13494 
  def __eq__(self, other):
13495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13496 
 
13497 
  def __ne__(self, other):
13498 
    return not (self == other)
13499 
 
3064 chandransh 13500 
class acceptOrder_result:
1113 chandransh 13501 
  """
13502 
  Attributes:
13503 
   - success
13504 
   - ex
13505 
  """
13506 
 
13507 
  thrift_spec = (
3064 chandransh 13508 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13509 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13510 
  )
13511 
 
13512 
  def __init__(self, success=None, ex=None,):
13513 
    self.success = success
13514 
    self.ex = ex
13515 
 
13516 
  def read(self, iprot):
13517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13519 
      return
13520 
    iprot.readStructBegin()
13521 
    while True:
13522 
      (fname, ftype, fid) = iprot.readFieldBegin()
13523 
      if ftype == TType.STOP:
13524 
        break
13525 
      if fid == 0:
3064 chandransh 13526 
        if ftype == TType.BOOL:
13527 
          self.success = iprot.readBool();
1113 chandransh 13528 
        else:
13529 
          iprot.skip(ftype)
13530 
      elif fid == 1:
13531 
        if ftype == TType.STRUCT:
13532 
          self.ex = TransactionServiceException()
13533 
          self.ex.read(iprot)
13534 
        else:
13535 
          iprot.skip(ftype)
13536 
      else:
13537 
        iprot.skip(ftype)
13538 
      iprot.readFieldEnd()
13539 
    iprot.readStructEnd()
13540 
 
13541 
  def write(self, oprot):
13542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13544 
      return
3064 chandransh 13545 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 13546 
    if self.success is not None:
3064 chandransh 13547 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13548 
      oprot.writeBool(self.success)
1113 chandransh 13549 
      oprot.writeFieldEnd()
3431 rajveer 13550 
    if self.ex is not None:
1113 chandransh 13551 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13552 
      self.ex.write(oprot)
13553 
      oprot.writeFieldEnd()
13554 
    oprot.writeFieldStop()
13555 
    oprot.writeStructEnd()
13556 
 
3431 rajveer 13557 
  def validate(self):
13558 
    return
13559 
 
13560 
 
1113 chandransh 13561 
  def __repr__(self):
13562 
    L = ['%s=%r' % (key, value)
13563 
      for key, value in self.__dict__.iteritems()]
13564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13565 
 
13566 
  def __eq__(self, other):
13567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13568 
 
13569 
  def __ne__(self, other):
13570 
    return not (self == other)
13571 
 
3064 chandransh 13572 
class addBillingDetails_args:
1135 chandransh 13573 
  """
13574 
  Attributes:
3064 chandransh 13575 
   - orderId
13576 
   - invoice_number
4658 mandeep.dh 13577 
   - serialNumber
4283 anupam.sin 13578 
   - itemNumber
3064 chandransh 13579 
   - billed_by
4264 rajveer 13580 
   - jacketNumber
4283 anupam.sin 13581 
   - billingType
5110 mandeep.dh 13582 
   - fulfilmentWarehouseId
4763 rajveer 13583 
   - authorize
1135 chandransh 13584 
  """
13585 
 
13586 
  thrift_spec = (
13587 
    None, # 0
3064 chandransh 13588 
    (1, TType.I64, 'orderId', None, None, ), # 1
13589 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 13590 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
13591 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 13592 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
13593 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
13594 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 13595 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 13596 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 13597 
  )
13598 
 
5110 mandeep.dh 13599 
  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 13600 
    self.orderId = orderId
13601 
    self.invoice_number = invoice_number
4658 mandeep.dh 13602 
    self.serialNumber = serialNumber
4283 anupam.sin 13603 
    self.itemNumber = itemNumber
3064 chandransh 13604 
    self.billed_by = billed_by
4264 rajveer 13605 
    self.jacketNumber = jacketNumber
4283 anupam.sin 13606 
    self.billingType = billingType
5110 mandeep.dh 13607 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 13608 
    self.authorize = authorize
1135 chandransh 13609 
 
13610 
  def read(self, iprot):
13611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13613 
      return
13614 
    iprot.readStructBegin()
13615 
    while True:
13616 
      (fname, ftype, fid) = iprot.readFieldBegin()
13617 
      if ftype == TType.STOP:
13618 
        break
13619 
      if fid == 1:
13620 
        if ftype == TType.I64:
3064 chandransh 13621 
          self.orderId = iprot.readI64();
1135 chandransh 13622 
        else:
13623 
          iprot.skip(ftype)
13624 
      elif fid == 2:
3064 chandransh 13625 
        if ftype == TType.STRING:
13626 
          self.invoice_number = iprot.readString();
1135 chandransh 13627 
        else:
13628 
          iprot.skip(ftype)
3064 chandransh 13629 
      elif fid == 3:
5411 rajveer 13630 
        if ftype == TType.LIST:
13631 
          self.serialNumber = []
6188 rajveer 13632 
          (_etype270, _size267) = iprot.readListBegin()
13633 
          for _i271 in xrange(_size267):
13634 
            _elem272 = iprot.readString();
13635 
            self.serialNumber.append(_elem272)
5411 rajveer 13636 
          iprot.readListEnd()
3064 chandransh 13637 
        else:
13638 
          iprot.skip(ftype)
13639 
      elif fid == 4:
5411 rajveer 13640 
        if ftype == TType.LIST:
13641 
          self.itemNumber = []
6188 rajveer 13642 
          (_etype276, _size273) = iprot.readListBegin()
13643 
          for _i277 in xrange(_size273):
13644 
            _elem278 = iprot.readString();
13645 
            self.itemNumber.append(_elem278)
5411 rajveer 13646 
          iprot.readListEnd()
3064 chandransh 13647 
        else:
13648 
          iprot.skip(ftype)
13649 
      elif fid == 5:
13650 
        if ftype == TType.STRING:
4283 anupam.sin 13651 
          self.billed_by = iprot.readString();
3064 chandransh 13652 
        else:
13653 
          iprot.skip(ftype)
13654 
      elif fid == 6:
13655 
        if ftype == TType.I64:
4283 anupam.sin 13656 
          self.jacketNumber = iprot.readI64();
13657 
        else:
13658 
          iprot.skip(ftype)
13659 
      elif fid == 7:
13660 
        if ftype == TType.I64:
3064 chandransh 13661 
          self.billingType = iprot.readI64();
13662 
        else:
13663 
          iprot.skip(ftype)
4283 anupam.sin 13664 
      elif fid == 8:
13665 
        if ftype == TType.I64:
5110 mandeep.dh 13666 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13667 
        else:
13668 
          iprot.skip(ftype)
4763 rajveer 13669 
      elif fid == 9:
13670 
        if ftype == TType.BOOL:
13671 
          self.authorize = iprot.readBool();
13672 
        else:
13673 
          iprot.skip(ftype)
1246 chandransh 13674 
      else:
13675 
        iprot.skip(ftype)
13676 
      iprot.readFieldEnd()
13677 
    iprot.readStructEnd()
13678 
 
13679 
  def write(self, oprot):
13680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13682 
      return
4283 anupam.sin 13683 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 13684 
    if self.orderId is not None:
3064 chandransh 13685 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13686 
      oprot.writeI64(self.orderId)
1246 chandransh 13687 
      oprot.writeFieldEnd()
4283 anupam.sin 13688 
    if self.invoice_number is not None:
13689 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
13690 
      oprot.writeString(self.invoice_number)
1246 chandransh 13691 
      oprot.writeFieldEnd()
4658 mandeep.dh 13692 
    if self.serialNumber is not None:
5411 rajveer 13693 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
13694 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 13695 
      for iter279 in self.serialNumber:
13696 
        oprot.writeString(iter279)
5411 rajveer 13697 
      oprot.writeListEnd()
3064 chandransh 13698 
      oprot.writeFieldEnd()
3431 rajveer 13699 
    if self.itemNumber is not None:
5411 rajveer 13700 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
13701 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 13702 
      for iter280 in self.itemNumber:
13703 
        oprot.writeString(iter280)
5411 rajveer 13704 
      oprot.writeListEnd()
3064 chandransh 13705 
      oprot.writeFieldEnd()
4283 anupam.sin 13706 
    if self.billed_by is not None:
13707 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
13708 
      oprot.writeString(self.billed_by)
3064 chandransh 13709 
      oprot.writeFieldEnd()
4283 anupam.sin 13710 
    if self.jacketNumber is not None:
13711 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
13712 
      oprot.writeI64(self.jacketNumber)
13713 
      oprot.writeFieldEnd()
3431 rajveer 13714 
    if self.billingType is not None:
4283 anupam.sin 13715 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 13716 
      oprot.writeI64(self.billingType)
13717 
      oprot.writeFieldEnd()
5110 mandeep.dh 13718 
    if self.fulfilmentWarehouseId is not None:
13719 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
13720 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 13721 
      oprot.writeFieldEnd()
4763 rajveer 13722 
    if self.authorize is not None:
13723 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
13724 
      oprot.writeBool(self.authorize)
13725 
      oprot.writeFieldEnd()
1246 chandransh 13726 
    oprot.writeFieldStop()
13727 
    oprot.writeStructEnd()
13728 
 
3431 rajveer 13729 
  def validate(self):
13730 
    return
13731 
 
13732 
 
1246 chandransh 13733 
  def __repr__(self):
13734 
    L = ['%s=%r' % (key, value)
13735 
      for key, value in self.__dict__.iteritems()]
13736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13737 
 
13738 
  def __eq__(self, other):
13739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13740 
 
13741 
  def __ne__(self, other):
13742 
    return not (self == other)
13743 
 
4283 anupam.sin 13744 
class addBillingDetails_result:
1246 chandransh 13745 
  """
13746 
  Attributes:
3064 chandransh 13747 
   - success
1246 chandransh 13748 
   - ex
13749 
  """
13750 
 
13751 
  thrift_spec = (
3064 chandransh 13752 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 13753 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13754 
  )
13755 
 
3064 chandransh 13756 
  def __init__(self, success=None, ex=None,):
13757 
    self.success = success
1246 chandransh 13758 
    self.ex = ex
13759 
 
13760 
  def read(self, iprot):
13761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13763 
      return
13764 
    iprot.readStructBegin()
13765 
    while True:
13766 
      (fname, ftype, fid) = iprot.readFieldBegin()
13767 
      if ftype == TType.STOP:
13768 
        break
3064 chandransh 13769 
      if fid == 0:
13770 
        if ftype == TType.BOOL:
13771 
          self.success = iprot.readBool();
13772 
        else:
13773 
          iprot.skip(ftype)
13774 
      elif fid == 1:
1246 chandransh 13775 
        if ftype == TType.STRUCT:
13776 
          self.ex = TransactionServiceException()
13777 
          self.ex.read(iprot)
13778 
        else:
13779 
          iprot.skip(ftype)
13780 
      else:
13781 
        iprot.skip(ftype)
13782 
      iprot.readFieldEnd()
13783 
    iprot.readStructEnd()
13784 
 
13785 
  def write(self, oprot):
13786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13788 
      return
4283 anupam.sin 13789 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 13790 
    if self.success is not None:
3064 chandransh 13791 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13792 
      oprot.writeBool(self.success)
13793 
      oprot.writeFieldEnd()
3431 rajveer 13794 
    if self.ex is not None:
1246 chandransh 13795 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13796 
      self.ex.write(oprot)
13797 
      oprot.writeFieldEnd()
13798 
    oprot.writeFieldStop()
13799 
    oprot.writeStructEnd()
13800 
 
3431 rajveer 13801 
  def validate(self):
13802 
    return
13803 
 
13804 
 
1246 chandransh 13805 
  def __repr__(self):
13806 
    L = ['%s=%r' % (key, value)
13807 
      for key, value in self.__dict__.iteritems()]
13808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13809 
 
13810 
  def __eq__(self, other):
13811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13812 
 
13813 
  def __ne__(self, other):
13814 
    return not (self == other)
13815 
 
4579 rajveer 13816 
class addInvoiceNumber_args:
13817 
  """
13818 
  Attributes:
13819 
   - orderId
13820 
   - invoiceNumber
4763 rajveer 13821 
   - color
6756 amar.kumar 13822 
   - serialNumber
13823 
   - itemNumber
4579 rajveer 13824 
  """
13825 
 
13826 
  thrift_spec = (
13827 
    None, # 0
13828 
    (1, TType.I64, 'orderId', None, None, ), # 1
13829 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 13830 
    (3, TType.STRING, 'color', None, None, ), # 3
6756 amar.kumar 13831 
    (4, TType.STRING, 'serialNumber', None, None, ), # 4
13832 
    (5, TType.STRING, 'itemNumber', None, None, ), # 5
4579 rajveer 13833 
  )
13834 
 
6756 amar.kumar 13835 
  def __init__(self, orderId=None, invoiceNumber=None, color=None, serialNumber=None, itemNumber=None,):
4579 rajveer 13836 
    self.orderId = orderId
13837 
    self.invoiceNumber = invoiceNumber
4763 rajveer 13838 
    self.color = color
6756 amar.kumar 13839 
    self.serialNumber = serialNumber
13840 
    self.itemNumber = itemNumber
4579 rajveer 13841 
 
13842 
  def read(self, iprot):
13843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13845 
      return
13846 
    iprot.readStructBegin()
13847 
    while True:
13848 
      (fname, ftype, fid) = iprot.readFieldBegin()
13849 
      if ftype == TType.STOP:
13850 
        break
13851 
      if fid == 1:
13852 
        if ftype == TType.I64:
13853 
          self.orderId = iprot.readI64();
13854 
        else:
13855 
          iprot.skip(ftype)
13856 
      elif fid == 2:
13857 
        if ftype == TType.STRING:
13858 
          self.invoiceNumber = iprot.readString();
13859 
        else:
13860 
          iprot.skip(ftype)
4763 rajveer 13861 
      elif fid == 3:
13862 
        if ftype == TType.STRING:
13863 
          self.color = iprot.readString();
13864 
        else:
13865 
          iprot.skip(ftype)
6756 amar.kumar 13866 
      elif fid == 4:
13867 
        if ftype == TType.STRING:
13868 
          self.serialNumber = iprot.readString();
13869 
        else:
13870 
          iprot.skip(ftype)
13871 
      elif fid == 5:
13872 
        if ftype == TType.STRING:
13873 
          self.itemNumber = iprot.readString();
13874 
        else:
13875 
          iprot.skip(ftype)
4579 rajveer 13876 
      else:
13877 
        iprot.skip(ftype)
13878 
      iprot.readFieldEnd()
13879 
    iprot.readStructEnd()
13880 
 
13881 
  def write(self, oprot):
13882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13884 
      return
13885 
    oprot.writeStructBegin('addInvoiceNumber_args')
13886 
    if self.orderId is not None:
13887 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13888 
      oprot.writeI64(self.orderId)
13889 
      oprot.writeFieldEnd()
13890 
    if self.invoiceNumber is not None:
13891 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
13892 
      oprot.writeString(self.invoiceNumber)
13893 
      oprot.writeFieldEnd()
4763 rajveer 13894 
    if self.color is not None:
13895 
      oprot.writeFieldBegin('color', TType.STRING, 3)
13896 
      oprot.writeString(self.color)
13897 
      oprot.writeFieldEnd()
6756 amar.kumar 13898 
    if self.serialNumber is not None:
13899 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 4)
13900 
      oprot.writeString(self.serialNumber)
13901 
      oprot.writeFieldEnd()
13902 
    if self.itemNumber is not None:
13903 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 5)
13904 
      oprot.writeString(self.itemNumber)
13905 
      oprot.writeFieldEnd()
4579 rajveer 13906 
    oprot.writeFieldStop()
13907 
    oprot.writeStructEnd()
13908 
 
13909 
  def validate(self):
13910 
    return
13911 
 
13912 
 
13913 
  def __repr__(self):
13914 
    L = ['%s=%r' % (key, value)
13915 
      for key, value in self.__dict__.iteritems()]
13916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13917 
 
13918 
  def __eq__(self, other):
13919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13920 
 
13921 
  def __ne__(self, other):
13922 
    return not (self == other)
13923 
 
13924 
class addInvoiceNumber_result:
13925 
  """
13926 
  Attributes:
13927 
   - ex
13928 
  """
13929 
 
13930 
  thrift_spec = (
13931 
    None, # 0
13932 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13933 
  )
13934 
 
13935 
  def __init__(self, ex=None,):
13936 
    self.ex = ex
13937 
 
13938 
  def read(self, iprot):
13939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13941 
      return
13942 
    iprot.readStructBegin()
13943 
    while True:
13944 
      (fname, ftype, fid) = iprot.readFieldBegin()
13945 
      if ftype == TType.STOP:
13946 
        break
13947 
      if fid == 1:
13948 
        if ftype == TType.STRUCT:
13949 
          self.ex = TransactionServiceException()
13950 
          self.ex.read(iprot)
13951 
        else:
13952 
          iprot.skip(ftype)
13953 
      else:
13954 
        iprot.skip(ftype)
13955 
      iprot.readFieldEnd()
13956 
    iprot.readStructEnd()
13957 
 
13958 
  def write(self, oprot):
13959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13961 
      return
13962 
    oprot.writeStructBegin('addInvoiceNumber_result')
13963 
    if self.ex is not None:
13964 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13965 
      self.ex.write(oprot)
13966 
      oprot.writeFieldEnd()
13967 
    oprot.writeFieldStop()
13968 
    oprot.writeStructEnd()
13969 
 
13970 
  def validate(self):
13971 
    return
13972 
 
13973 
 
13974 
  def __repr__(self):
13975 
    L = ['%s=%r' % (key, value)
13976 
      for key, value in self.__dict__.iteritems()]
13977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13978 
 
13979 
  def __eq__(self, other):
13980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13981 
 
13982 
  def __ne__(self, other):
13983 
    return not (self == other)
13984 
 
4910 phani.kuma 13985 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 13986 
  """
13987 
  Attributes:
3064 chandransh 13988 
   - warehouseId
1408 ankur.sing 13989 
   - providerId
3064 chandransh 13990 
   - cod
4910 phani.kuma 13991 
   - orderIds
1408 ankur.sing 13992 
  """
13993 
 
13994 
  thrift_spec = (
13995 
    None, # 0
3064 chandransh 13996 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13997 
    (2, TType.I64, 'providerId', None, None, ), # 2
13998 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 13999 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 14000 
  )
14001 
 
4910 phani.kuma 14002 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 14003 
    self.warehouseId = warehouseId
1408 ankur.sing 14004 
    self.providerId = providerId
3064 chandransh 14005 
    self.cod = cod
4910 phani.kuma 14006 
    self.orderIds = orderIds
1408 ankur.sing 14007 
 
14008 
  def read(self, iprot):
14009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14011 
      return
14012 
    iprot.readStructBegin()
14013 
    while True:
14014 
      (fname, ftype, fid) = iprot.readFieldBegin()
14015 
      if ftype == TType.STOP:
14016 
        break
14017 
      if fid == 1:
14018 
        if ftype == TType.I64:
3064 chandransh 14019 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 14020 
        else:
14021 
          iprot.skip(ftype)
14022 
      elif fid == 2:
14023 
        if ftype == TType.I64:
3064 chandransh 14024 
          self.providerId = iprot.readI64();
1408 ankur.sing 14025 
        else:
14026 
          iprot.skip(ftype)
3064 chandransh 14027 
      elif fid == 3:
14028 
        if ftype == TType.BOOL:
14029 
          self.cod = iprot.readBool();
14030 
        else:
14031 
          iprot.skip(ftype)
4910 phani.kuma 14032 
      elif fid == 4:
14033 
        if ftype == TType.LIST:
14034 
          self.orderIds = []
6188 rajveer 14035 
          (_etype284, _size281) = iprot.readListBegin()
14036 
          for _i285 in xrange(_size281):
14037 
            _elem286 = iprot.readI64();
14038 
            self.orderIds.append(_elem286)
4910 phani.kuma 14039 
          iprot.readListEnd()
14040 
        else:
14041 
          iprot.skip(ftype)
1408 ankur.sing 14042 
      else:
14043 
        iprot.skip(ftype)
14044 
      iprot.readFieldEnd()
14045 
    iprot.readStructEnd()
14046 
 
14047 
  def write(self, oprot):
14048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14050 
      return
4910 phani.kuma 14051 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 14052 
    if self.warehouseId is not None:
3064 chandransh 14053 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14054 
      oprot.writeI64(self.warehouseId)
14055 
      oprot.writeFieldEnd()
3431 rajveer 14056 
    if self.providerId is not None:
3064 chandransh 14057 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 14058 
      oprot.writeI64(self.providerId)
14059 
      oprot.writeFieldEnd()
3431 rajveer 14060 
    if self.cod is not None:
3064 chandransh 14061 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
14062 
      oprot.writeBool(self.cod)
1408 ankur.sing 14063 
      oprot.writeFieldEnd()
4910 phani.kuma 14064 
    if self.orderIds is not None:
14065 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
14066 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14067 
      for iter287 in self.orderIds:
14068 
        oprot.writeI64(iter287)
4910 phani.kuma 14069 
      oprot.writeListEnd()
14070 
      oprot.writeFieldEnd()
1408 ankur.sing 14071 
    oprot.writeFieldStop()
14072 
    oprot.writeStructEnd()
14073 
 
3431 rajveer 14074 
  def validate(self):
14075 
    return
14076 
 
14077 
 
1408 ankur.sing 14078 
  def __repr__(self):
14079 
    L = ['%s=%r' % (key, value)
14080 
      for key, value in self.__dict__.iteritems()]
14081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14082 
 
14083 
  def __eq__(self, other):
14084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14085 
 
14086 
  def __ne__(self, other):
14087 
    return not (self == other)
14088 
 
4910 phani.kuma 14089 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 14090 
  """
14091 
  Attributes:
14092 
   - success
3064 chandransh 14093 
   - ex
1408 ankur.sing 14094 
  """
14095 
 
14096 
  thrift_spec = (
3064 chandransh 14097 
    (0, TType.BOOL, 'success', None, None, ), # 0
14098 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 14099 
  )
14100 
 
3064 chandransh 14101 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 14102 
    self.success = success
3064 chandransh 14103 
    self.ex = ex
1408 ankur.sing 14104 
 
14105 
  def read(self, iprot):
14106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14108 
      return
14109 
    iprot.readStructBegin()
14110 
    while True:
14111 
      (fname, ftype, fid) = iprot.readFieldBegin()
14112 
      if ftype == TType.STOP:
14113 
        break
14114 
      if fid == 0:
3064 chandransh 14115 
        if ftype == TType.BOOL:
14116 
          self.success = iprot.readBool();
1408 ankur.sing 14117 
        else:
14118 
          iprot.skip(ftype)
3064 chandransh 14119 
      elif fid == 1:
14120 
        if ftype == TType.STRUCT:
14121 
          self.ex = TransactionServiceException()
14122 
          self.ex.read(iprot)
14123 
        else:
14124 
          iprot.skip(ftype)
1408 ankur.sing 14125 
      else:
14126 
        iprot.skip(ftype)
14127 
      iprot.readFieldEnd()
14128 
    iprot.readStructEnd()
14129 
 
14130 
  def write(self, oprot):
14131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14133 
      return
4910 phani.kuma 14134 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 14135 
    if self.success is not None:
3064 chandransh 14136 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14137 
      oprot.writeBool(self.success)
1408 ankur.sing 14138 
      oprot.writeFieldEnd()
3431 rajveer 14139 
    if self.ex is not None:
3064 chandransh 14140 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14141 
      self.ex.write(oprot)
14142 
      oprot.writeFieldEnd()
1408 ankur.sing 14143 
    oprot.writeFieldStop()
14144 
    oprot.writeStructEnd()
14145 
 
3431 rajveer 14146 
  def validate(self):
14147 
    return
14148 
 
14149 
 
1408 ankur.sing 14150 
  def __repr__(self):
14151 
    L = ['%s=%r' % (key, value)
14152 
      for key, value in self.__dict__.iteritems()]
14153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14154 
 
14155 
  def __eq__(self, other):
14156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14157 
 
14158 
  def __ne__(self, other):
14159 
    return not (self == other)
14160 
 
5676 rajveer 14161 
class markOrdersAsReturnedFromStore_args:
14162 
  """
14163 
  Attributes:
14164 
   - providerId
14165 
   - orderIds
5713 rajveer 14166 
   - awbs
5676 rajveer 14167 
  """
14168 
 
14169 
  thrift_spec = (
14170 
    None, # 0
14171 
    (1, TType.I64, 'providerId', None, None, ), # 1
14172 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 14173 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 14174 
  )
14175 
 
5713 rajveer 14176 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 14177 
    self.providerId = providerId
14178 
    self.orderIds = orderIds
5713 rajveer 14179 
    self.awbs = awbs
5676 rajveer 14180 
 
14181 
  def read(self, iprot):
14182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14184 
      return
14185 
    iprot.readStructBegin()
14186 
    while True:
14187 
      (fname, ftype, fid) = iprot.readFieldBegin()
14188 
      if ftype == TType.STOP:
14189 
        break
14190 
      if fid == 1:
14191 
        if ftype == TType.I64:
14192 
          self.providerId = iprot.readI64();
14193 
        else:
14194 
          iprot.skip(ftype)
14195 
      elif fid == 2:
14196 
        if ftype == TType.LIST:
14197 
          self.orderIds = []
6188 rajveer 14198 
          (_etype291, _size288) = iprot.readListBegin()
14199 
          for _i292 in xrange(_size288):
14200 
            _elem293 = iprot.readI64();
14201 
            self.orderIds.append(_elem293)
5676 rajveer 14202 
          iprot.readListEnd()
14203 
        else:
14204 
          iprot.skip(ftype)
5713 rajveer 14205 
      elif fid == 3:
14206 
        if ftype == TType.LIST:
14207 
          self.awbs = []
6188 rajveer 14208 
          (_etype297, _size294) = iprot.readListBegin()
14209 
          for _i298 in xrange(_size294):
14210 
            _elem299 = iprot.readString();
14211 
            self.awbs.append(_elem299)
5713 rajveer 14212 
          iprot.readListEnd()
14213 
        else:
14214 
          iprot.skip(ftype)
5676 rajveer 14215 
      else:
14216 
        iprot.skip(ftype)
14217 
      iprot.readFieldEnd()
14218 
    iprot.readStructEnd()
14219 
 
14220 
  def write(self, oprot):
14221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14223 
      return
14224 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
14225 
    if self.providerId is not None:
14226 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14227 
      oprot.writeI64(self.providerId)
14228 
      oprot.writeFieldEnd()
14229 
    if self.orderIds is not None:
14230 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
14231 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14232 
      for iter300 in self.orderIds:
14233 
        oprot.writeI64(iter300)
5676 rajveer 14234 
      oprot.writeListEnd()
14235 
      oprot.writeFieldEnd()
5713 rajveer 14236 
    if self.awbs is not None:
14237 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
14238 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 14239 
      for iter301 in self.awbs:
14240 
        oprot.writeString(iter301)
5713 rajveer 14241 
      oprot.writeListEnd()
14242 
      oprot.writeFieldEnd()
5676 rajveer 14243 
    oprot.writeFieldStop()
14244 
    oprot.writeStructEnd()
14245 
 
14246 
  def validate(self):
14247 
    return
14248 
 
14249 
 
14250 
  def __repr__(self):
14251 
    L = ['%s=%r' % (key, value)
14252 
      for key, value in self.__dict__.iteritems()]
14253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14254 
 
14255 
  def __eq__(self, other):
14256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14257 
 
14258 
  def __ne__(self, other):
14259 
    return not (self == other)
14260 
 
14261 
class markOrdersAsReturnedFromStore_result:
14262 
  """
14263 
  Attributes:
14264 
   - success
14265 
   - ex
14266 
  """
14267 
 
14268 
  thrift_spec = (
14269 
    (0, TType.BOOL, 'success', None, None, ), # 0
14270 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14271 
  )
14272 
 
14273 
  def __init__(self, success=None, ex=None,):
14274 
    self.success = success
14275 
    self.ex = ex
14276 
 
14277 
  def read(self, iprot):
14278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14280 
      return
14281 
    iprot.readStructBegin()
14282 
    while True:
14283 
      (fname, ftype, fid) = iprot.readFieldBegin()
14284 
      if ftype == TType.STOP:
14285 
        break
14286 
      if fid == 0:
14287 
        if ftype == TType.BOOL:
14288 
          self.success = iprot.readBool();
14289 
        else:
14290 
          iprot.skip(ftype)
14291 
      elif fid == 1:
14292 
        if ftype == TType.STRUCT:
14293 
          self.ex = TransactionServiceException()
14294 
          self.ex.read(iprot)
14295 
        else:
14296 
          iprot.skip(ftype)
14297 
      else:
14298 
        iprot.skip(ftype)
14299 
      iprot.readFieldEnd()
14300 
    iprot.readStructEnd()
14301 
 
14302 
  def write(self, oprot):
14303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14305 
      return
14306 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
14307 
    if self.success is not None:
14308 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14309 
      oprot.writeBool(self.success)
14310 
      oprot.writeFieldEnd()
14311 
    if self.ex is not None:
14312 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14313 
      self.ex.write(oprot)
14314 
      oprot.writeFieldEnd()
14315 
    oprot.writeFieldStop()
14316 
    oprot.writeStructEnd()
14317 
 
14318 
  def validate(self):
14319 
    return
14320 
 
14321 
 
14322 
  def __repr__(self):
14323 
    L = ['%s=%r' % (key, value)
14324 
      for key, value in self.__dict__.iteritems()]
14325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14326 
 
14327 
  def __eq__(self, other):
14328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14329 
 
14330 
  def __ne__(self, other):
14331 
    return not (self == other)
14332 
 
4910 phani.kuma 14333 
class markOrdersAsPickedUp_args:
4410 rajveer 14334 
  """
14335 
  Attributes:
14336 
   - providerId
4910 phani.kuma 14337 
   - pickupDetails
4410 rajveer 14338 
  """
14339 
 
14340 
  thrift_spec = (
14341 
    None, # 0
4910 phani.kuma 14342 
    (1, TType.I64, 'providerId', None, None, ), # 1
14343 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 14344 
  )
14345 
 
4910 phani.kuma 14346 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 14347 
    self.providerId = providerId
4910 phani.kuma 14348 
    self.pickupDetails = pickupDetails
4410 rajveer 14349 
 
14350 
  def read(self, iprot):
14351 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14352 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14353 
      return
14354 
    iprot.readStructBegin()
14355 
    while True:
14356 
      (fname, ftype, fid) = iprot.readFieldBegin()
14357 
      if ftype == TType.STOP:
14358 
        break
14359 
      if fid == 1:
14360 
        if ftype == TType.I64:
4910 phani.kuma 14361 
          self.providerId = iprot.readI64();
4410 rajveer 14362 
        else:
14363 
          iprot.skip(ftype)
14364 
      elif fid == 2:
4910 phani.kuma 14365 
        if ftype == TType.MAP:
14366 
          self.pickupDetails = {}
6188 rajveer 14367 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
14368 
          for _i306 in xrange(_size302):
14369 
            _key307 = iprot.readString();
14370 
            _val308 = iprot.readString();
14371 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 14372 
          iprot.readMapEnd()
4410 rajveer 14373 
        else:
14374 
          iprot.skip(ftype)
14375 
      else:
14376 
        iprot.skip(ftype)
14377 
      iprot.readFieldEnd()
14378 
    iprot.readStructEnd()
14379 
 
14380 
  def write(self, oprot):
14381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14383 
      return
4910 phani.kuma 14384 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 14385 
    if self.providerId is not None:
4910 phani.kuma 14386 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 14387 
      oprot.writeI64(self.providerId)
14388 
      oprot.writeFieldEnd()
4910 phani.kuma 14389 
    if self.pickupDetails is not None:
14390 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14391 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 14392 
      for kiter309,viter310 in self.pickupDetails.items():
14393 
        oprot.writeString(kiter309)
14394 
        oprot.writeString(viter310)
4910 phani.kuma 14395 
      oprot.writeMapEnd()
4410 rajveer 14396 
      oprot.writeFieldEnd()
14397 
    oprot.writeFieldStop()
14398 
    oprot.writeStructEnd()
14399 
 
14400 
  def validate(self):
14401 
    return
14402 
 
14403 
 
14404 
  def __repr__(self):
14405 
    L = ['%s=%r' % (key, value)
14406 
      for key, value in self.__dict__.iteritems()]
14407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14408 
 
14409 
  def __eq__(self, other):
14410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14411 
 
14412 
  def __ne__(self, other):
14413 
    return not (self == other)
14414 
 
4910 phani.kuma 14415 
class markOrdersAsPickedUp_result:
4410 rajveer 14416 
  """
14417 
  Attributes:
14418 
   - ex
14419 
  """
14420 
 
14421 
  thrift_spec = (
4910 phani.kuma 14422 
    None, # 0
4410 rajveer 14423 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14424 
  )
14425 
 
4910 phani.kuma 14426 
  def __init__(self, ex=None,):
4410 rajveer 14427 
    self.ex = ex
14428 
 
14429 
  def read(self, iprot):
14430 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14431 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14432 
      return
14433 
    iprot.readStructBegin()
14434 
    while True:
14435 
      (fname, ftype, fid) = iprot.readFieldBegin()
14436 
      if ftype == TType.STOP:
14437 
        break
4910 phani.kuma 14438 
      if fid == 1:
4410 rajveer 14439 
        if ftype == TType.STRUCT:
14440 
          self.ex = TransactionServiceException()
14441 
          self.ex.read(iprot)
14442 
        else:
14443 
          iprot.skip(ftype)
14444 
      else:
14445 
        iprot.skip(ftype)
14446 
      iprot.readFieldEnd()
14447 
    iprot.readStructEnd()
14448 
 
14449 
  def write(self, oprot):
14450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14452 
      return
4910 phani.kuma 14453 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 14454 
    if self.ex is not None:
14455 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14456 
      self.ex.write(oprot)
14457 
      oprot.writeFieldEnd()
14458 
    oprot.writeFieldStop()
14459 
    oprot.writeStructEnd()
14460 
 
14461 
  def validate(self):
14462 
    return
14463 
 
14464 
 
14465 
  def __repr__(self):
14466 
    L = ['%s=%r' % (key, value)
14467 
      for key, value in self.__dict__.iteritems()]
14468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14469 
 
14470 
  def __eq__(self, other):
14471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14472 
 
14473 
  def __ne__(self, other):
14474 
    return not (self == other)
14475 
 
4910 phani.kuma 14476 
class getOrdersNotPickedUp_args:
304 ashish 14477 
  """
14478 
  Attributes:
3064 chandransh 14479 
   - providerId
304 ashish 14480 
  """
94 ashish 14481 
 
304 ashish 14482 
  thrift_spec = (
14483 
    None, # 0
3064 chandransh 14484 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 14485 
  )
14486 
 
4910 phani.kuma 14487 
  def __init__(self, providerId=None,):
3064 chandransh 14488 
    self.providerId = providerId
304 ashish 14489 
 
14490 
  def read(self, iprot):
14491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14493 
      return
14494 
    iprot.readStructBegin()
14495 
    while True:
14496 
      (fname, ftype, fid) = iprot.readFieldBegin()
14497 
      if ftype == TType.STOP:
14498 
        break
14499 
      if fid == 1:
14500 
        if ftype == TType.I64:
3064 chandransh 14501 
          self.providerId = iprot.readI64();
304 ashish 14502 
        else:
14503 
          iprot.skip(ftype)
14504 
      else:
14505 
        iprot.skip(ftype)
14506 
      iprot.readFieldEnd()
14507 
    iprot.readStructEnd()
14508 
 
14509 
  def write(self, oprot):
14510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14512 
      return
4910 phani.kuma 14513 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14514 
    if self.providerId is not None:
3064 chandransh 14515 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14516 
      oprot.writeI64(self.providerId)
304 ashish 14517 
      oprot.writeFieldEnd()
14518 
    oprot.writeFieldStop()
14519 
    oprot.writeStructEnd()
14520 
 
3431 rajveer 14521 
  def validate(self):
14522 
    return
14523 
 
14524 
 
304 ashish 14525 
  def __repr__(self):
14526 
    L = ['%s=%r' % (key, value)
14527 
      for key, value in self.__dict__.iteritems()]
14528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14529 
 
14530 
  def __eq__(self, other):
14531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14532 
 
14533 
  def __ne__(self, other):
14534 
    return not (self == other)
14535 
 
4910 phani.kuma 14536 
class getOrdersNotPickedUp_result:
304 ashish 14537 
  """
14538 
  Attributes:
14539 
   - success
14540 
  """
14541 
 
14542 
  thrift_spec = (
3064 chandransh 14543 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 14544 
  )
14545 
 
4910 phani.kuma 14546 
  def __init__(self, success=None,):
304 ashish 14547 
    self.success = success
14548 
 
14549 
  def read(self, iprot):
14550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14552 
      return
14553 
    iprot.readStructBegin()
14554 
    while True:
14555 
      (fname, ftype, fid) = iprot.readFieldBegin()
14556 
      if ftype == TType.STOP:
14557 
        break
14558 
      if fid == 0:
14559 
        if ftype == TType.LIST:
14560 
          self.success = []
6188 rajveer 14561 
          (_etype314, _size311) = iprot.readListBegin()
14562 
          for _i315 in xrange(_size311):
14563 
            _elem316 = Order()
14564 
            _elem316.read(iprot)
14565 
            self.success.append(_elem316)
304 ashish 14566 
          iprot.readListEnd()
14567 
        else:
14568 
          iprot.skip(ftype)
14569 
      else:
14570 
        iprot.skip(ftype)
14571 
      iprot.readFieldEnd()
14572 
    iprot.readStructEnd()
14573 
 
14574 
  def write(self, oprot):
14575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14577 
      return
4910 phani.kuma 14578 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 14579 
    if self.success is not None:
304 ashish 14580 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14581 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14582 
      for iter317 in self.success:
14583 
        iter317.write(oprot)
304 ashish 14584 
      oprot.writeListEnd()
14585 
      oprot.writeFieldEnd()
14586 
    oprot.writeFieldStop()
14587 
    oprot.writeStructEnd()
14588 
 
3431 rajveer 14589 
  def validate(self):
14590 
    return
14591 
 
14592 
 
304 ashish 14593 
  def __repr__(self):
14594 
    L = ['%s=%r' % (key, value)
14595 
      for key, value in self.__dict__.iteritems()]
14596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14597 
 
14598 
  def __eq__(self, other):
14599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14600 
 
14601 
  def __ne__(self, other):
14602 
    return not (self == other)
14603 
 
3064 chandransh 14604 
class markOrdersAsDelivered_args:
304 ashish 14605 
  """
14606 
  Attributes:
3064 chandransh 14607 
   - providerId
14608 
   - deliveredOrders
304 ashish 14609 
  """
14610 
 
14611 
  thrift_spec = (
14612 
    None, # 0
3064 chandransh 14613 
    (1, TType.I64, 'providerId', None, None, ), # 1
14614 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 14615 
  )
14616 
 
3064 chandransh 14617 
  def __init__(self, providerId=None, deliveredOrders=None,):
14618 
    self.providerId = providerId
14619 
    self.deliveredOrders = deliveredOrders
304 ashish 14620 
 
14621 
  def read(self, iprot):
14622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14624 
      return
14625 
    iprot.readStructBegin()
14626 
    while True:
14627 
      (fname, ftype, fid) = iprot.readFieldBegin()
14628 
      if ftype == TType.STOP:
14629 
        break
14630 
      if fid == 1:
14631 
        if ftype == TType.I64:
3064 chandransh 14632 
          self.providerId = iprot.readI64();
304 ashish 14633 
        else:
14634 
          iprot.skip(ftype)
14635 
      elif fid == 2:
3064 chandransh 14636 
        if ftype == TType.MAP:
14637 
          self.deliveredOrders = {}
6188 rajveer 14638 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
14639 
          for _i322 in xrange(_size318):
14640 
            _key323 = iprot.readString();
14641 
            _val324 = iprot.readString();
14642 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 14643 
          iprot.readMapEnd()
304 ashish 14644 
        else:
14645 
          iprot.skip(ftype)
14646 
      else:
14647 
        iprot.skip(ftype)
14648 
      iprot.readFieldEnd()
14649 
    iprot.readStructEnd()
14650 
 
14651 
  def write(self, oprot):
14652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14654 
      return
3064 chandransh 14655 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14656 
    if self.providerId is not None:
3064 chandransh 14657 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14658 
      oprot.writeI64(self.providerId)
304 ashish 14659 
      oprot.writeFieldEnd()
3431 rajveer 14660 
    if self.deliveredOrders is not None:
3064 chandransh 14661 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14662 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 14663 
      for kiter325,viter326 in self.deliveredOrders.items():
14664 
        oprot.writeString(kiter325)
14665 
        oprot.writeString(viter326)
3064 chandransh 14666 
      oprot.writeMapEnd()
304 ashish 14667 
      oprot.writeFieldEnd()
14668 
    oprot.writeFieldStop()
14669 
    oprot.writeStructEnd()
14670 
 
3431 rajveer 14671 
  def validate(self):
14672 
    return
14673 
 
14674 
 
304 ashish 14675 
  def __repr__(self):
14676 
    L = ['%s=%r' % (key, value)
14677 
      for key, value in self.__dict__.iteritems()]
14678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14679 
 
14680 
  def __eq__(self, other):
14681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14682 
 
14683 
  def __ne__(self, other):
14684 
    return not (self == other)
14685 
 
3064 chandransh 14686 
class markOrdersAsDelivered_result:
14687 
  """
14688 
  Attributes:
14689 
   - ex
14690 
  """
304 ashish 14691 
 
14692 
  thrift_spec = (
3064 chandransh 14693 
    None, # 0
14694 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 14695 
  )
14696 
 
3064 chandransh 14697 
  def __init__(self, ex=None,):
14698 
    self.ex = ex
304 ashish 14699 
 
1596 ankur.sing 14700 
  def read(self, iprot):
14701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14703 
      return
14704 
    iprot.readStructBegin()
14705 
    while True:
14706 
      (fname, ftype, fid) = iprot.readFieldBegin()
14707 
      if ftype == TType.STOP:
14708 
        break
3064 chandransh 14709 
      if fid == 1:
14710 
        if ftype == TType.STRUCT:
14711 
          self.ex = TransactionServiceException()
14712 
          self.ex.read(iprot)
14713 
        else:
14714 
          iprot.skip(ftype)
1596 ankur.sing 14715 
      else:
14716 
        iprot.skip(ftype)
14717 
      iprot.readFieldEnd()
14718 
    iprot.readStructEnd()
14719 
 
14720 
  def write(self, oprot):
14721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14723 
      return
3064 chandransh 14724 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 14725 
    if self.ex is not None:
3064 chandransh 14726 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14727 
      self.ex.write(oprot)
14728 
      oprot.writeFieldEnd()
1596 ankur.sing 14729 
    oprot.writeFieldStop()
14730 
    oprot.writeStructEnd()
14731 
 
3431 rajveer 14732 
  def validate(self):
14733 
    return
14734 
 
14735 
 
1596 ankur.sing 14736 
  def __repr__(self):
14737 
    L = ['%s=%r' % (key, value)
14738 
      for key, value in self.__dict__.iteritems()]
14739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14740 
 
14741 
  def __eq__(self, other):
14742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14743 
 
14744 
  def __ne__(self, other):
14745 
    return not (self == other)
14746 
 
4910 phani.kuma 14747 
class markAsRTOrders_args:
1596 ankur.sing 14748 
  """
14749 
  Attributes:
3064 chandransh 14750 
   - providerId
14751 
   - returnedOrders
1596 ankur.sing 14752 
  """
14753 
 
14754 
  thrift_spec = (
3064 chandransh 14755 
    None, # 0
14756 
    (1, TType.I64, 'providerId', None, None, ), # 1
14757 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 14758 
  )
14759 
 
3064 chandransh 14760 
  def __init__(self, providerId=None, returnedOrders=None,):
14761 
    self.providerId = providerId
14762 
    self.returnedOrders = returnedOrders
1596 ankur.sing 14763 
 
14764 
  def read(self, iprot):
14765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14767 
      return
14768 
    iprot.readStructBegin()
14769 
    while True:
14770 
      (fname, ftype, fid) = iprot.readFieldBegin()
14771 
      if ftype == TType.STOP:
14772 
        break
3064 chandransh 14773 
      if fid == 1:
1596 ankur.sing 14774 
        if ftype == TType.I64:
3064 chandransh 14775 
          self.providerId = iprot.readI64();
1596 ankur.sing 14776 
        else:
14777 
          iprot.skip(ftype)
3064 chandransh 14778 
      elif fid == 2:
14779 
        if ftype == TType.MAP:
14780 
          self.returnedOrders = {}
6188 rajveer 14781 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
14782 
          for _i331 in xrange(_size327):
14783 
            _key332 = iprot.readString();
14784 
            _val333 = iprot.readString();
14785 
            self.returnedOrders[_key332] = _val333
3064 chandransh 14786 
          iprot.readMapEnd()
14787 
        else:
14788 
          iprot.skip(ftype)
1596 ankur.sing 14789 
      else:
14790 
        iprot.skip(ftype)
14791 
      iprot.readFieldEnd()
14792 
    iprot.readStructEnd()
14793 
 
14794 
  def write(self, oprot):
14795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14797 
      return
4910 phani.kuma 14798 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 14799 
    if self.providerId is not None:
3064 chandransh 14800 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14801 
      oprot.writeI64(self.providerId)
1596 ankur.sing 14802 
      oprot.writeFieldEnd()
3431 rajveer 14803 
    if self.returnedOrders is not None:
3064 chandransh 14804 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
14805 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 14806 
      for kiter334,viter335 in self.returnedOrders.items():
14807 
        oprot.writeString(kiter334)
14808 
        oprot.writeString(viter335)
3064 chandransh 14809 
      oprot.writeMapEnd()
14810 
      oprot.writeFieldEnd()
1596 ankur.sing 14811 
    oprot.writeFieldStop()
14812 
    oprot.writeStructEnd()
14813 
 
3431 rajveer 14814 
  def validate(self):
14815 
    return
14816 
 
14817 
 
1596 ankur.sing 14818 
  def __repr__(self):
14819 
    L = ['%s=%r' % (key, value)
14820 
      for key, value in self.__dict__.iteritems()]
14821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14822 
 
14823 
  def __eq__(self, other):
14824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14825 
 
14826 
  def __ne__(self, other):
14827 
    return not (self == other)
14828 
 
4910 phani.kuma 14829 
class markAsRTOrders_result:
3064 chandransh 14830 
  """
14831 
  Attributes:
14832 
   - ex
14833 
  """
1596 ankur.sing 14834 
 
1627 ankur.sing 14835 
  thrift_spec = (
3064 chandransh 14836 
    None, # 0
14837 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14838 
  )
14839 
 
3064 chandransh 14840 
  def __init__(self, ex=None,):
14841 
    self.ex = ex
14842 
 
1627 ankur.sing 14843 
  def read(self, iprot):
14844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14846 
      return
14847 
    iprot.readStructBegin()
14848 
    while True:
14849 
      (fname, ftype, fid) = iprot.readFieldBegin()
14850 
      if ftype == TType.STOP:
14851 
        break
3064 chandransh 14852 
      if fid == 1:
14853 
        if ftype == TType.STRUCT:
14854 
          self.ex = TransactionServiceException()
14855 
          self.ex.read(iprot)
14856 
        else:
14857 
          iprot.skip(ftype)
1627 ankur.sing 14858 
      else:
14859 
        iprot.skip(ftype)
14860 
      iprot.readFieldEnd()
14861 
    iprot.readStructEnd()
14862 
 
14863 
  def write(self, oprot):
14864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14866 
      return
4910 phani.kuma 14867 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 14868 
    if self.ex is not None:
3064 chandransh 14869 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14870 
      self.ex.write(oprot)
14871 
      oprot.writeFieldEnd()
1627 ankur.sing 14872 
    oprot.writeFieldStop()
14873 
    oprot.writeStructEnd()
14874 
 
3431 rajveer 14875 
  def validate(self):
14876 
    return
14877 
 
14878 
 
1627 ankur.sing 14879 
  def __repr__(self):
14880 
    L = ['%s=%r' % (key, value)
14881 
      for key, value in self.__dict__.iteritems()]
14882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14883 
 
14884 
  def __eq__(self, other):
14885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14886 
 
14887 
  def __ne__(self, other):
14888 
    return not (self == other)
14889 
 
4910 phani.kuma 14890 
class getRTOrders_args:
14891 
  """
14892 
  Attributes:
14893 
   - providerId
14894 
  """
14895 
 
14896 
  thrift_spec = (
14897 
    None, # 0
14898 
    (1, TType.I64, 'providerId', None, None, ), # 1
14899 
  )
14900 
 
14901 
  def __init__(self, providerId=None,):
14902 
    self.providerId = providerId
14903 
 
14904 
  def read(self, iprot):
14905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14907 
      return
14908 
    iprot.readStructBegin()
14909 
    while True:
14910 
      (fname, ftype, fid) = iprot.readFieldBegin()
14911 
      if ftype == TType.STOP:
14912 
        break
14913 
      if fid == 1:
14914 
        if ftype == TType.I64:
14915 
          self.providerId = iprot.readI64();
14916 
        else:
14917 
          iprot.skip(ftype)
14918 
      else:
14919 
        iprot.skip(ftype)
14920 
      iprot.readFieldEnd()
14921 
    iprot.readStructEnd()
14922 
 
14923 
  def write(self, oprot):
14924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14926 
      return
14927 
    oprot.writeStructBegin('getRTOrders_args')
14928 
    if self.providerId is not None:
14929 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14930 
      oprot.writeI64(self.providerId)
14931 
      oprot.writeFieldEnd()
14932 
    oprot.writeFieldStop()
14933 
    oprot.writeStructEnd()
14934 
 
14935 
  def validate(self):
14936 
    return
14937 
 
14938 
 
14939 
  def __repr__(self):
14940 
    L = ['%s=%r' % (key, value)
14941 
      for key, value in self.__dict__.iteritems()]
14942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14943 
 
14944 
  def __eq__(self, other):
14945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14946 
 
14947 
  def __ne__(self, other):
14948 
    return not (self == other)
14949 
 
14950 
class getRTOrders_result:
14951 
  """
14952 
  Attributes:
14953 
   - success
14954 
  """
14955 
 
14956 
  thrift_spec = (
14957 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
14958 
  )
14959 
 
14960 
  def __init__(self, success=None,):
14961 
    self.success = success
14962 
 
14963 
  def read(self, iprot):
14964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14966 
      return
14967 
    iprot.readStructBegin()
14968 
    while True:
14969 
      (fname, ftype, fid) = iprot.readFieldBegin()
14970 
      if ftype == TType.STOP:
14971 
        break
14972 
      if fid == 0:
14973 
        if ftype == TType.LIST:
14974 
          self.success = []
6188 rajveer 14975 
          (_etype339, _size336) = iprot.readListBegin()
14976 
          for _i340 in xrange(_size336):
14977 
            _elem341 = Order()
14978 
            _elem341.read(iprot)
14979 
            self.success.append(_elem341)
4910 phani.kuma 14980 
          iprot.readListEnd()
14981 
        else:
14982 
          iprot.skip(ftype)
14983 
      else:
14984 
        iprot.skip(ftype)
14985 
      iprot.readFieldEnd()
14986 
    iprot.readStructEnd()
14987 
 
14988 
  def write(self, oprot):
14989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14991 
      return
14992 
    oprot.writeStructBegin('getRTOrders_result')
14993 
    if self.success is not None:
14994 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14995 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14996 
      for iter342 in self.success:
14997 
        iter342.write(oprot)
4910 phani.kuma 14998 
      oprot.writeListEnd()
14999 
      oprot.writeFieldEnd()
15000 
    oprot.writeFieldStop()
15001 
    oprot.writeStructEnd()
15002 
 
15003 
  def validate(self):
15004 
    return
15005 
 
15006 
 
15007 
  def __repr__(self):
15008 
    L = ['%s=%r' % (key, value)
15009 
      for key, value in self.__dict__.iteritems()]
15010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15011 
 
15012 
  def __eq__(self, other):
15013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15014 
 
15015 
  def __ne__(self, other):
15016 
    return not (self == other)
15017 
 
3064 chandransh 15018 
class updateNonDeliveryReason_args:
1627 ankur.sing 15019 
  """
15020 
  Attributes:
3064 chandransh 15021 
   - providerId
15022 
   - undeliveredOrders
1627 ankur.sing 15023 
  """
15024 
 
15025 
  thrift_spec = (
3064 chandransh 15026 
    None, # 0
15027 
    (1, TType.I64, 'providerId', None, None, ), # 1
15028 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 15029 
  )
15030 
 
3064 chandransh 15031 
  def __init__(self, providerId=None, undeliveredOrders=None,):
15032 
    self.providerId = providerId
15033 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 15034 
 
15035 
  def read(self, iprot):
15036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15038 
      return
15039 
    iprot.readStructBegin()
15040 
    while True:
15041 
      (fname, ftype, fid) = iprot.readFieldBegin()
15042 
      if ftype == TType.STOP:
15043 
        break
3064 chandransh 15044 
      if fid == 1:
1627 ankur.sing 15045 
        if ftype == TType.I64:
3064 chandransh 15046 
          self.providerId = iprot.readI64();
1627 ankur.sing 15047 
        else:
15048 
          iprot.skip(ftype)
3064 chandransh 15049 
      elif fid == 2:
15050 
        if ftype == TType.MAP:
15051 
          self.undeliveredOrders = {}
6188 rajveer 15052 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
15053 
          for _i347 in xrange(_size343):
15054 
            _key348 = iprot.readString();
15055 
            _val349 = iprot.readString();
15056 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 15057 
          iprot.readMapEnd()
15058 
        else:
15059 
          iprot.skip(ftype)
1627 ankur.sing 15060 
      else:
15061 
        iprot.skip(ftype)
15062 
      iprot.readFieldEnd()
15063 
    iprot.readStructEnd()
15064 
 
15065 
  def write(self, oprot):
15066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15068 
      return
3064 chandransh 15069 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 15070 
    if self.providerId is not None:
3064 chandransh 15071 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15072 
      oprot.writeI64(self.providerId)
1627 ankur.sing 15073 
      oprot.writeFieldEnd()
3431 rajveer 15074 
    if self.undeliveredOrders is not None:
3064 chandransh 15075 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
15076 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 15077 
      for kiter350,viter351 in self.undeliveredOrders.items():
15078 
        oprot.writeString(kiter350)
15079 
        oprot.writeString(viter351)
3064 chandransh 15080 
      oprot.writeMapEnd()
15081 
      oprot.writeFieldEnd()
1627 ankur.sing 15082 
    oprot.writeFieldStop()
15083 
    oprot.writeStructEnd()
15084 
 
3431 rajveer 15085 
  def validate(self):
15086 
    return
15087 
 
15088 
 
1627 ankur.sing 15089 
  def __repr__(self):
15090 
    L = ['%s=%r' % (key, value)
15091 
      for key, value in self.__dict__.iteritems()]
15092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15093 
 
15094 
  def __eq__(self, other):
15095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15096 
 
15097 
  def __ne__(self, other):
15098 
    return not (self == other)
15099 
 
3064 chandransh 15100 
class updateNonDeliveryReason_result:
1627 ankur.sing 15101 
  """
15102 
  Attributes:
3064 chandransh 15103 
   - ex
1627 ankur.sing 15104 
  """
15105 
 
15106 
  thrift_spec = (
4910 phani.kuma 15107 
    None, # 0
3064 chandransh 15108 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15109 
  )
15110 
 
4910 phani.kuma 15111 
  def __init__(self, ex=None,):
3064 chandransh 15112 
    self.ex = ex
1627 ankur.sing 15113 
 
15114 
  def read(self, iprot):
15115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15117 
      return
15118 
    iprot.readStructBegin()
15119 
    while True:
15120 
      (fname, ftype, fid) = iprot.readFieldBegin()
15121 
      if ftype == TType.STOP:
15122 
        break
4910 phani.kuma 15123 
      if fid == 1:
15124 
        if ftype == TType.STRUCT:
15125 
          self.ex = TransactionServiceException()
15126 
          self.ex.read(iprot)
15127 
        else:
15128 
          iprot.skip(ftype)
15129 
      else:
15130 
        iprot.skip(ftype)
15131 
      iprot.readFieldEnd()
15132 
    iprot.readStructEnd()
15133 
 
15134 
  def write(self, oprot):
15135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15137 
      return
15138 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
15139 
    if self.ex is not None:
15140 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15141 
      self.ex.write(oprot)
15142 
      oprot.writeFieldEnd()
15143 
    oprot.writeFieldStop()
15144 
    oprot.writeStructEnd()
15145 
 
15146 
  def validate(self):
15147 
    return
15148 
 
15149 
 
15150 
  def __repr__(self):
15151 
    L = ['%s=%r' % (key, value)
15152 
      for key, value in self.__dict__.iteritems()]
15153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15154 
 
15155 
  def __eq__(self, other):
15156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15157 
 
15158 
  def __ne__(self, other):
15159 
    return not (self == other)
15160 
 
15161 
class getNonDeliveredOrdersbyCourier_args:
15162 
  """
15163 
  Attributes:
15164 
   - providerId
15165 
  """
15166 
 
15167 
  thrift_spec = (
15168 
    None, # 0
15169 
    (1, TType.I64, 'providerId', None, None, ), # 1
15170 
  )
15171 
 
15172 
  def __init__(self, providerId=None,):
15173 
    self.providerId = providerId
15174 
 
15175 
  def read(self, iprot):
15176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15178 
      return
15179 
    iprot.readStructBegin()
15180 
    while True:
15181 
      (fname, ftype, fid) = iprot.readFieldBegin()
15182 
      if ftype == TType.STOP:
15183 
        break
15184 
      if fid == 1:
15185 
        if ftype == TType.I64:
15186 
          self.providerId = iprot.readI64();
15187 
        else:
15188 
          iprot.skip(ftype)
15189 
      else:
15190 
        iprot.skip(ftype)
15191 
      iprot.readFieldEnd()
15192 
    iprot.readStructEnd()
15193 
 
15194 
  def write(self, oprot):
15195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15197 
      return
15198 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
15199 
    if self.providerId is not None:
15200 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15201 
      oprot.writeI64(self.providerId)
15202 
      oprot.writeFieldEnd()
15203 
    oprot.writeFieldStop()
15204 
    oprot.writeStructEnd()
15205 
 
15206 
  def validate(self):
15207 
    return
15208 
 
15209 
 
15210 
  def __repr__(self):
15211 
    L = ['%s=%r' % (key, value)
15212 
      for key, value in self.__dict__.iteritems()]
15213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15214 
 
15215 
  def __eq__(self, other):
15216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15217 
 
15218 
  def __ne__(self, other):
15219 
    return not (self == other)
15220 
 
15221 
class getNonDeliveredOrdersbyCourier_result:
15222 
  """
15223 
  Attributes:
15224 
   - success
15225 
  """
15226 
 
15227 
  thrift_spec = (
15228 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15229 
  )
15230 
 
15231 
  def __init__(self, success=None,):
15232 
    self.success = success
15233 
 
15234 
  def read(self, iprot):
15235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15237 
      return
15238 
    iprot.readStructBegin()
15239 
    while True:
15240 
      (fname, ftype, fid) = iprot.readFieldBegin()
15241 
      if ftype == TType.STOP:
15242 
        break
4581 phani.kuma 15243 
      if fid == 0:
15244 
        if ftype == TType.LIST:
15245 
          self.success = []
6188 rajveer 15246 
          (_etype355, _size352) = iprot.readListBegin()
15247 
          for _i356 in xrange(_size352):
15248 
            _elem357 = Order()
15249 
            _elem357.read(iprot)
15250 
            self.success.append(_elem357)
4581 phani.kuma 15251 
          iprot.readListEnd()
15252 
        else:
15253 
          iprot.skip(ftype)
4910 phani.kuma 15254 
      else:
15255 
        iprot.skip(ftype)
15256 
      iprot.readFieldEnd()
15257 
    iprot.readStructEnd()
15258 
 
15259 
  def write(self, oprot):
15260 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15261 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15262 
      return
15263 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
15264 
    if self.success is not None:
15265 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15266 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15267 
      for iter358 in self.success:
15268 
        iter358.write(oprot)
4910 phani.kuma 15269 
      oprot.writeListEnd()
15270 
      oprot.writeFieldEnd()
15271 
    oprot.writeFieldStop()
15272 
    oprot.writeStructEnd()
15273 
 
15274 
  def validate(self):
15275 
    return
15276 
 
15277 
 
15278 
  def __repr__(self):
15279 
    L = ['%s=%r' % (key, value)
15280 
      for key, value in self.__dict__.iteritems()]
15281 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15282 
 
15283 
  def __eq__(self, other):
15284 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15285 
 
15286 
  def __ne__(self, other):
15287 
    return not (self == other)
15288 
 
15289 
class markOrdersAsLocalConnected_args:
15290 
  """
15291 
  Attributes:
15292 
   - providerId
15293 
   - local_connected_orders
15294 
  """
15295 
 
15296 
  thrift_spec = (
15297 
    None, # 0
15298 
    (1, TType.I64, 'providerId', None, None, ), # 1
15299 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15300 
  )
15301 
 
15302 
  def __init__(self, providerId=None, local_connected_orders=None,):
15303 
    self.providerId = providerId
15304 
    self.local_connected_orders = local_connected_orders
15305 
 
15306 
  def read(self, iprot):
15307 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15308 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15309 
      return
15310 
    iprot.readStructBegin()
15311 
    while True:
15312 
      (fname, ftype, fid) = iprot.readFieldBegin()
15313 
      if ftype == TType.STOP:
15314 
        break
15315 
      if fid == 1:
15316 
        if ftype == TType.I64:
15317 
          self.providerId = iprot.readI64();
15318 
        else:
15319 
          iprot.skip(ftype)
15320 
      elif fid == 2:
15321 
        if ftype == TType.MAP:
15322 
          self.local_connected_orders = {}
6188 rajveer 15323 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
15324 
          for _i363 in xrange(_size359):
15325 
            _key364 = iprot.readString();
15326 
            _val365 = iprot.readString();
15327 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 15328 
          iprot.readMapEnd()
15329 
        else:
15330 
          iprot.skip(ftype)
15331 
      else:
15332 
        iprot.skip(ftype)
15333 
      iprot.readFieldEnd()
15334 
    iprot.readStructEnd()
15335 
 
15336 
  def write(self, oprot):
15337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15339 
      return
15340 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
15341 
    if self.providerId is not None:
15342 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15343 
      oprot.writeI64(self.providerId)
15344 
      oprot.writeFieldEnd()
15345 
    if self.local_connected_orders is not None:
15346 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
15347 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 15348 
      for kiter366,viter367 in self.local_connected_orders.items():
15349 
        oprot.writeString(kiter366)
15350 
        oprot.writeString(viter367)
4910 phani.kuma 15351 
      oprot.writeMapEnd()
15352 
      oprot.writeFieldEnd()
15353 
    oprot.writeFieldStop()
15354 
    oprot.writeStructEnd()
15355 
 
15356 
  def validate(self):
15357 
    return
15358 
 
15359 
 
15360 
  def __repr__(self):
15361 
    L = ['%s=%r' % (key, value)
15362 
      for key, value in self.__dict__.iteritems()]
15363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15364 
 
15365 
  def __eq__(self, other):
15366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15367 
 
15368 
  def __ne__(self, other):
15369 
    return not (self == other)
15370 
 
15371 
class markOrdersAsLocalConnected_result:
15372 
  """
15373 
  Attributes:
15374 
   - ex
15375 
  """
15376 
 
15377 
  thrift_spec = (
15378 
    None, # 0
15379 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15380 
  )
15381 
 
15382 
  def __init__(self, ex=None,):
15383 
    self.ex = ex
15384 
 
15385 
  def read(self, iprot):
15386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15388 
      return
15389 
    iprot.readStructBegin()
15390 
    while True:
15391 
      (fname, ftype, fid) = iprot.readFieldBegin()
15392 
      if ftype == TType.STOP:
15393 
        break
15394 
      if fid == 1:
3064 chandransh 15395 
        if ftype == TType.STRUCT:
15396 
          self.ex = TransactionServiceException()
15397 
          self.ex.read(iprot)
1627 ankur.sing 15398 
        else:
15399 
          iprot.skip(ftype)
15400 
      else:
15401 
        iprot.skip(ftype)
15402 
      iprot.readFieldEnd()
15403 
    iprot.readStructEnd()
15404 
 
15405 
  def write(self, oprot):
15406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15408 
      return
4910 phani.kuma 15409 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
15410 
    if self.ex is not None:
15411 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15412 
      self.ex.write(oprot)
15413 
      oprot.writeFieldEnd()
15414 
    oprot.writeFieldStop()
15415 
    oprot.writeStructEnd()
15416 
 
15417 
  def validate(self):
15418 
    return
15419 
 
15420 
 
15421 
  def __repr__(self):
15422 
    L = ['%s=%r' % (key, value)
15423 
      for key, value in self.__dict__.iteritems()]
15424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15425 
 
15426 
  def __eq__(self, other):
15427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15428 
 
15429 
  def __ne__(self, other):
15430 
    return not (self == other)
15431 
 
15432 
class getOrdersNotLocalConnected_args:
15433 
  """
15434 
  Attributes:
15435 
   - providerId
15436 
  """
15437 
 
15438 
  thrift_spec = (
15439 
    None, # 0
15440 
    (1, TType.I64, 'providerId', None, None, ), # 1
15441 
  )
15442 
 
15443 
  def __init__(self, providerId=None,):
15444 
    self.providerId = providerId
15445 
 
15446 
  def read(self, iprot):
15447 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15448 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15449 
      return
15450 
    iprot.readStructBegin()
15451 
    while True:
15452 
      (fname, ftype, fid) = iprot.readFieldBegin()
15453 
      if ftype == TType.STOP:
15454 
        break
15455 
      if fid == 1:
15456 
        if ftype == TType.I64:
15457 
          self.providerId = iprot.readI64();
15458 
        else:
15459 
          iprot.skip(ftype)
15460 
      else:
15461 
        iprot.skip(ftype)
15462 
      iprot.readFieldEnd()
15463 
    iprot.readStructEnd()
15464 
 
15465 
  def write(self, oprot):
15466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15468 
      return
15469 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
15470 
    if self.providerId is not None:
15471 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15472 
      oprot.writeI64(self.providerId)
15473 
      oprot.writeFieldEnd()
15474 
    oprot.writeFieldStop()
15475 
    oprot.writeStructEnd()
15476 
 
15477 
  def validate(self):
15478 
    return
15479 
 
15480 
 
15481 
  def __repr__(self):
15482 
    L = ['%s=%r' % (key, value)
15483 
      for key, value in self.__dict__.iteritems()]
15484 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15485 
 
15486 
  def __eq__(self, other):
15487 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15488 
 
15489 
  def __ne__(self, other):
15490 
    return not (self == other)
15491 
 
15492 
class getOrdersNotLocalConnected_result:
15493 
  """
15494 
  Attributes:
15495 
   - success
15496 
  """
15497 
 
15498 
  thrift_spec = (
15499 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15500 
  )
15501 
 
15502 
  def __init__(self, success=None,):
15503 
    self.success = success
15504 
 
15505 
  def read(self, iprot):
15506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15508 
      return
15509 
    iprot.readStructBegin()
15510 
    while True:
15511 
      (fname, ftype, fid) = iprot.readFieldBegin()
15512 
      if ftype == TType.STOP:
15513 
        break
15514 
      if fid == 0:
15515 
        if ftype == TType.LIST:
15516 
          self.success = []
6188 rajveer 15517 
          (_etype371, _size368) = iprot.readListBegin()
15518 
          for _i372 in xrange(_size368):
15519 
            _elem373 = Order()
15520 
            _elem373.read(iprot)
15521 
            self.success.append(_elem373)
4910 phani.kuma 15522 
          iprot.readListEnd()
15523 
        else:
15524 
          iprot.skip(ftype)
15525 
      else:
15526 
        iprot.skip(ftype)
15527 
      iprot.readFieldEnd()
15528 
    iprot.readStructEnd()
15529 
 
15530 
  def write(self, oprot):
15531 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15532 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15533 
      return
15534 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 15535 
    if self.success is not None:
15536 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15537 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15538 
      for iter374 in self.success:
15539 
        iter374.write(oprot)
4581 phani.kuma 15540 
      oprot.writeListEnd()
15541 
      oprot.writeFieldEnd()
4910 phani.kuma 15542 
    oprot.writeFieldStop()
15543 
    oprot.writeStructEnd()
15544 
 
15545 
  def validate(self):
15546 
    return
15547 
 
15548 
 
15549 
  def __repr__(self):
15550 
    L = ['%s=%r' % (key, value)
15551 
      for key, value in self.__dict__.iteritems()]
15552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15553 
 
15554 
  def __eq__(self, other):
15555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15556 
 
15557 
  def __ne__(self, other):
15558 
    return not (self == other)
15559 
 
15560 
class markOrdersAsDestinationCityReached_args:
15561 
  """
15562 
  Attributes:
15563 
   - providerId
15564 
   - destination_city_reached_orders
15565 
  """
15566 
 
15567 
  thrift_spec = (
15568 
    None, # 0
15569 
    (1, TType.I64, 'providerId', None, None, ), # 1
15570 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15571 
  )
15572 
 
15573 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
15574 
    self.providerId = providerId
15575 
    self.destination_city_reached_orders = destination_city_reached_orders
15576 
 
15577 
  def read(self, iprot):
15578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15580 
      return
15581 
    iprot.readStructBegin()
15582 
    while True:
15583 
      (fname, ftype, fid) = iprot.readFieldBegin()
15584 
      if ftype == TType.STOP:
15585 
        break
15586 
      if fid == 1:
15587 
        if ftype == TType.I64:
15588 
          self.providerId = iprot.readI64();
15589 
        else:
15590 
          iprot.skip(ftype)
15591 
      elif fid == 2:
15592 
        if ftype == TType.MAP:
15593 
          self.destination_city_reached_orders = {}
6188 rajveer 15594 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
15595 
          for _i379 in xrange(_size375):
15596 
            _key380 = iprot.readString();
15597 
            _val381 = iprot.readString();
15598 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 15599 
          iprot.readMapEnd()
15600 
        else:
15601 
          iprot.skip(ftype)
15602 
      else:
15603 
        iprot.skip(ftype)
15604 
      iprot.readFieldEnd()
15605 
    iprot.readStructEnd()
15606 
 
15607 
  def write(self, oprot):
15608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15610 
      return
15611 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
15612 
    if self.providerId is not None:
15613 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15614 
      oprot.writeI64(self.providerId)
15615 
      oprot.writeFieldEnd()
15616 
    if self.destination_city_reached_orders is not None:
15617 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
15618 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 15619 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
15620 
        oprot.writeString(kiter382)
15621 
        oprot.writeString(viter383)
4910 phani.kuma 15622 
      oprot.writeMapEnd()
15623 
      oprot.writeFieldEnd()
15624 
    oprot.writeFieldStop()
15625 
    oprot.writeStructEnd()
15626 
 
15627 
  def validate(self):
15628 
    return
15629 
 
15630 
 
15631 
  def __repr__(self):
15632 
    L = ['%s=%r' % (key, value)
15633 
      for key, value in self.__dict__.iteritems()]
15634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15635 
 
15636 
  def __eq__(self, other):
15637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15638 
 
15639 
  def __ne__(self, other):
15640 
    return not (self == other)
15641 
 
15642 
class markOrdersAsDestinationCityReached_result:
15643 
  """
15644 
  Attributes:
15645 
   - ex
15646 
  """
15647 
 
15648 
  thrift_spec = (
15649 
    None, # 0
15650 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15651 
  )
15652 
 
15653 
  def __init__(self, ex=None,):
15654 
    self.ex = ex
15655 
 
15656 
  def read(self, iprot):
15657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15659 
      return
15660 
    iprot.readStructBegin()
15661 
    while True:
15662 
      (fname, ftype, fid) = iprot.readFieldBegin()
15663 
      if ftype == TType.STOP:
15664 
        break
15665 
      if fid == 1:
15666 
        if ftype == TType.STRUCT:
15667 
          self.ex = TransactionServiceException()
15668 
          self.ex.read(iprot)
15669 
        else:
15670 
          iprot.skip(ftype)
15671 
      else:
15672 
        iprot.skip(ftype)
15673 
      iprot.readFieldEnd()
15674 
    iprot.readStructEnd()
15675 
 
15676 
  def write(self, oprot):
15677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15679 
      return
15680 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15681 
    if self.ex is not None:
3064 chandransh 15682 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15683 
      self.ex.write(oprot)
1627 ankur.sing 15684 
      oprot.writeFieldEnd()
15685 
    oprot.writeFieldStop()
15686 
    oprot.writeStructEnd()
15687 
 
3431 rajveer 15688 
  def validate(self):
15689 
    return
15690 
 
15691 
 
1627 ankur.sing 15692 
  def __repr__(self):
15693 
    L = ['%s=%r' % (key, value)
15694 
      for key, value in self.__dict__.iteritems()]
15695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15696 
 
15697 
  def __eq__(self, other):
15698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15699 
 
15700 
  def __ne__(self, other):
15701 
    return not (self == other)
15702 
 
4910 phani.kuma 15703 
class markOrdersAsFirstDeliveryAttempted_args:
15704 
  """
15705 
  Attributes:
15706 
   - providerId
15707 
   - first_atdl_orders
15708 
  """
15709 
 
15710 
  thrift_spec = (
15711 
    None, # 0
15712 
    (1, TType.I64, 'providerId', None, None, ), # 1
15713 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15714 
  )
15715 
 
15716 
  def __init__(self, providerId=None, first_atdl_orders=None,):
15717 
    self.providerId = providerId
15718 
    self.first_atdl_orders = first_atdl_orders
15719 
 
15720 
  def read(self, iprot):
15721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15723 
      return
15724 
    iprot.readStructBegin()
15725 
    while True:
15726 
      (fname, ftype, fid) = iprot.readFieldBegin()
15727 
      if ftype == TType.STOP:
15728 
        break
15729 
      if fid == 1:
15730 
        if ftype == TType.I64:
15731 
          self.providerId = iprot.readI64();
15732 
        else:
15733 
          iprot.skip(ftype)
15734 
      elif fid == 2:
15735 
        if ftype == TType.MAP:
15736 
          self.first_atdl_orders = {}
6188 rajveer 15737 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
15738 
          for _i388 in xrange(_size384):
15739 
            _key389 = iprot.readString();
15740 
            _val390 = iprot.readString();
15741 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 15742 
          iprot.readMapEnd()
15743 
        else:
15744 
          iprot.skip(ftype)
15745 
      else:
15746 
        iprot.skip(ftype)
15747 
      iprot.readFieldEnd()
15748 
    iprot.readStructEnd()
15749 
 
15750 
  def write(self, oprot):
15751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15753 
      return
15754 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
15755 
    if self.providerId is not None:
15756 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15757 
      oprot.writeI64(self.providerId)
15758 
      oprot.writeFieldEnd()
15759 
    if self.first_atdl_orders is not None:
15760 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
15761 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 15762 
      for kiter391,viter392 in self.first_atdl_orders.items():
15763 
        oprot.writeString(kiter391)
15764 
        oprot.writeString(viter392)
4910 phani.kuma 15765 
      oprot.writeMapEnd()
15766 
      oprot.writeFieldEnd()
15767 
    oprot.writeFieldStop()
15768 
    oprot.writeStructEnd()
15769 
 
15770 
  def validate(self):
15771 
    return
15772 
 
15773 
 
15774 
  def __repr__(self):
15775 
    L = ['%s=%r' % (key, value)
15776 
      for key, value in self.__dict__.iteritems()]
15777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15778 
 
15779 
  def __eq__(self, other):
15780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15781 
 
15782 
  def __ne__(self, other):
15783 
    return not (self == other)
15784 
 
15785 
class markOrdersAsFirstDeliveryAttempted_result:
15786 
  """
15787 
  Attributes:
15788 
   - ex
15789 
  """
15790 
 
15791 
  thrift_spec = (
15792 
    None, # 0
15793 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15794 
  )
15795 
 
15796 
  def __init__(self, ex=None,):
15797 
    self.ex = ex
15798 
 
15799 
  def read(self, iprot):
15800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15802 
      return
15803 
    iprot.readStructBegin()
15804 
    while True:
15805 
      (fname, ftype, fid) = iprot.readFieldBegin()
15806 
      if ftype == TType.STOP:
15807 
        break
15808 
      if fid == 1:
15809 
        if ftype == TType.STRUCT:
15810 
          self.ex = TransactionServiceException()
15811 
          self.ex.read(iprot)
15812 
        else:
15813 
          iprot.skip(ftype)
15814 
      else:
15815 
        iprot.skip(ftype)
15816 
      iprot.readFieldEnd()
15817 
    iprot.readStructEnd()
15818 
 
15819 
  def write(self, oprot):
15820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15822 
      return
15823 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
15824 
    if self.ex is not None:
15825 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15826 
      self.ex.write(oprot)
15827 
      oprot.writeFieldEnd()
15828 
    oprot.writeFieldStop()
15829 
    oprot.writeStructEnd()
15830 
 
15831 
  def validate(self):
15832 
    return
15833 
 
15834 
 
15835 
  def __repr__(self):
15836 
    L = ['%s=%r' % (key, value)
15837 
      for key, value in self.__dict__.iteritems()]
15838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15839 
 
15840 
  def __eq__(self, other):
15841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15842 
 
15843 
  def __ne__(self, other):
15844 
    return not (self == other)
15845 
 
3064 chandransh 15846 
class getUndeliveredOrders_args:
1886 ankur.sing 15847 
  """
15848 
  Attributes:
3064 chandransh 15849 
   - providerId
15850 
   - warehouseId
1886 ankur.sing 15851 
  """
1627 ankur.sing 15852 
 
1886 ankur.sing 15853 
  thrift_spec = (
15854 
    None, # 0
3064 chandransh 15855 
    (1, TType.I64, 'providerId', None, None, ), # 1
15856 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 15857 
  )
15858 
 
3064 chandransh 15859 
  def __init__(self, providerId=None, warehouseId=None,):
15860 
    self.providerId = providerId
15861 
    self.warehouseId = warehouseId
1886 ankur.sing 15862 
 
15863 
  def read(self, iprot):
15864 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15865 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15866 
      return
15867 
    iprot.readStructBegin()
15868 
    while True:
15869 
      (fname, ftype, fid) = iprot.readFieldBegin()
15870 
      if ftype == TType.STOP:
15871 
        break
15872 
      if fid == 1:
15873 
        if ftype == TType.I64:
3064 chandransh 15874 
          self.providerId = iprot.readI64();
1886 ankur.sing 15875 
        else:
15876 
          iprot.skip(ftype)
3064 chandransh 15877 
      elif fid == 2:
15878 
        if ftype == TType.I64:
15879 
          self.warehouseId = iprot.readI64();
15880 
        else:
15881 
          iprot.skip(ftype)
1886 ankur.sing 15882 
      else:
15883 
        iprot.skip(ftype)
15884 
      iprot.readFieldEnd()
15885 
    iprot.readStructEnd()
15886 
 
15887 
  def write(self, oprot):
15888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15890 
      return
3064 chandransh 15891 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 15892 
    if self.providerId is not None:
3064 chandransh 15893 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15894 
      oprot.writeI64(self.providerId)
1886 ankur.sing 15895 
      oprot.writeFieldEnd()
3431 rajveer 15896 
    if self.warehouseId is not None:
3064 chandransh 15897 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
15898 
      oprot.writeI64(self.warehouseId)
15899 
      oprot.writeFieldEnd()
1886 ankur.sing 15900 
    oprot.writeFieldStop()
15901 
    oprot.writeStructEnd()
15902 
 
3431 rajveer 15903 
  def validate(self):
15904 
    return
15905 
 
15906 
 
1886 ankur.sing 15907 
  def __repr__(self):
15908 
    L = ['%s=%r' % (key, value)
15909 
      for key, value in self.__dict__.iteritems()]
15910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15911 
 
15912 
  def __eq__(self, other):
15913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15914 
 
15915 
  def __ne__(self, other):
15916 
    return not (self == other)
15917 
 
3064 chandransh 15918 
class getUndeliveredOrders_result:
1886 ankur.sing 15919 
  """
15920 
  Attributes:
15921 
   - success
15922 
  """
15923 
 
15924 
  thrift_spec = (
15925 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15926 
  )
15927 
 
15928 
  def __init__(self, success=None,):
15929 
    self.success = success
15930 
 
15931 
  def read(self, iprot):
15932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15934 
      return
15935 
    iprot.readStructBegin()
15936 
    while True:
15937 
      (fname, ftype, fid) = iprot.readFieldBegin()
15938 
      if ftype == TType.STOP:
15939 
        break
15940 
      if fid == 0:
15941 
        if ftype == TType.LIST:
15942 
          self.success = []
6188 rajveer 15943 
          (_etype396, _size393) = iprot.readListBegin()
15944 
          for _i397 in xrange(_size393):
15945 
            _elem398 = Order()
15946 
            _elem398.read(iprot)
15947 
            self.success.append(_elem398)
1886 ankur.sing 15948 
          iprot.readListEnd()
15949 
        else:
15950 
          iprot.skip(ftype)
15951 
      else:
15952 
        iprot.skip(ftype)
15953 
      iprot.readFieldEnd()
15954 
    iprot.readStructEnd()
15955 
 
15956 
  def write(self, oprot):
15957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15959 
      return
3064 chandransh 15960 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 15961 
    if self.success is not None:
1886 ankur.sing 15962 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15963 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15964 
      for iter399 in self.success:
15965 
        iter399.write(oprot)
1886 ankur.sing 15966 
      oprot.writeListEnd()
15967 
      oprot.writeFieldEnd()
15968 
    oprot.writeFieldStop()
15969 
    oprot.writeStructEnd()
15970 
 
3431 rajveer 15971 
  def validate(self):
15972 
    return
15973 
 
15974 
 
1886 ankur.sing 15975 
  def __repr__(self):
15976 
    L = ['%s=%r' % (key, value)
15977 
      for key, value in self.__dict__.iteritems()]
15978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15979 
 
15980 
  def __eq__(self, other):
15981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15982 
 
15983 
  def __ne__(self, other):
15984 
    return not (self == other)
15985 
 
4783 phani.kuma 15986 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
15987 
 
15988 
  thrift_spec = (
15989 
  )
15990 
 
15991 
  def read(self, iprot):
15992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15994 
      return
15995 
    iprot.readStructBegin()
15996 
    while True:
15997 
      (fname, ftype, fid) = iprot.readFieldBegin()
15998 
      if ftype == TType.STOP:
15999 
        break
16000 
      else:
16001 
        iprot.skip(ftype)
16002 
      iprot.readFieldEnd()
16003 
    iprot.readStructEnd()
16004 
 
16005 
  def write(self, oprot):
16006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16008 
      return
16009 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
16010 
    oprot.writeFieldStop()
16011 
    oprot.writeStructEnd()
16012 
 
16013 
  def validate(self):
16014 
    return
16015 
 
16016 
 
16017 
  def __repr__(self):
16018 
    L = ['%s=%r' % (key, value)
16019 
      for key, value in self.__dict__.iteritems()]
16020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16021 
 
16022 
  def __eq__(self, other):
16023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16024 
 
16025 
  def __ne__(self, other):
16026 
    return not (self == other)
16027 
 
16028 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
16029 
  """
16030 
  Attributes:
16031 
   - success
16032 
  """
16033 
 
16034 
  thrift_spec = (
16035 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16036 
  )
16037 
 
16038 
  def __init__(self, success=None,):
16039 
    self.success = success
16040 
 
16041 
  def read(self, iprot):
16042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16044 
      return
16045 
    iprot.readStructBegin()
16046 
    while True:
16047 
      (fname, ftype, fid) = iprot.readFieldBegin()
16048 
      if ftype == TType.STOP:
16049 
        break
16050 
      if fid == 0:
16051 
        if ftype == TType.LIST:
16052 
          self.success = []
6188 rajveer 16053 
          (_etype403, _size400) = iprot.readListBegin()
16054 
          for _i404 in xrange(_size400):
16055 
            _elem405 = Order()
16056 
            _elem405.read(iprot)
16057 
            self.success.append(_elem405)
4783 phani.kuma 16058 
          iprot.readListEnd()
16059 
        else:
16060 
          iprot.skip(ftype)
16061 
      else:
16062 
        iprot.skip(ftype)
16063 
      iprot.readFieldEnd()
16064 
    iprot.readStructEnd()
16065 
 
16066 
  def write(self, oprot):
16067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16069 
      return
16070 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
16071 
    if self.success is not None:
16072 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16073 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16074 
      for iter406 in self.success:
16075 
        iter406.write(oprot)
4783 phani.kuma 16076 
      oprot.writeListEnd()
16077 
      oprot.writeFieldEnd()
16078 
    oprot.writeFieldStop()
16079 
    oprot.writeStructEnd()
16080 
 
16081 
  def validate(self):
16082 
    return
16083 
 
16084 
 
16085 
  def __repr__(self):
16086 
    L = ['%s=%r' % (key, value)
16087 
      for key, value in self.__dict__.iteritems()]
16088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16089 
 
16090 
  def __eq__(self, other):
16091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16092 
 
16093 
  def __ne__(self, other):
16094 
    return not (self == other)
16095 
 
2536 chandransh 16096 
class toggleDOAFlag_args:
16097 
  """
16098 
  Attributes:
16099 
   - orderId
16100 
  """
1886 ankur.sing 16101 
 
2536 chandransh 16102 
  thrift_spec = (
16103 
    None, # 0
16104 
    (1, TType.I64, 'orderId', None, None, ), # 1
16105 
  )
16106 
 
16107 
  def __init__(self, orderId=None,):
16108 
    self.orderId = orderId
16109 
 
16110 
  def read(self, iprot):
16111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16113 
      return
16114 
    iprot.readStructBegin()
16115 
    while True:
16116 
      (fname, ftype, fid) = iprot.readFieldBegin()
16117 
      if ftype == TType.STOP:
16118 
        break
16119 
      if fid == 1:
16120 
        if ftype == TType.I64:
16121 
          self.orderId = iprot.readI64();
16122 
        else:
16123 
          iprot.skip(ftype)
16124 
      else:
16125 
        iprot.skip(ftype)
16126 
      iprot.readFieldEnd()
16127 
    iprot.readStructEnd()
16128 
 
16129 
  def write(self, oprot):
16130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16132 
      return
16133 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 16134 
    if self.orderId is not None:
2536 chandransh 16135 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16136 
      oprot.writeI64(self.orderId)
16137 
      oprot.writeFieldEnd()
16138 
    oprot.writeFieldStop()
16139 
    oprot.writeStructEnd()
16140 
 
3431 rajveer 16141 
  def validate(self):
16142 
    return
16143 
 
16144 
 
2536 chandransh 16145 
  def __repr__(self):
16146 
    L = ['%s=%r' % (key, value)
16147 
      for key, value in self.__dict__.iteritems()]
16148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16149 
 
16150 
  def __eq__(self, other):
16151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16152 
 
16153 
  def __ne__(self, other):
16154 
    return not (self == other)
16155 
 
16156 
class toggleDOAFlag_result:
16157 
  """
16158 
  Attributes:
16159 
   - success
16160 
   - ex
16161 
  """
16162 
 
16163 
  thrift_spec = (
16164 
    (0, TType.BOOL, 'success', None, None, ), # 0
16165 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16166 
  )
16167 
 
16168 
  def __init__(self, success=None, ex=None,):
16169 
    self.success = success
16170 
    self.ex = ex
16171 
 
16172 
  def read(self, iprot):
16173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16175 
      return
16176 
    iprot.readStructBegin()
16177 
    while True:
16178 
      (fname, ftype, fid) = iprot.readFieldBegin()
16179 
      if ftype == TType.STOP:
16180 
        break
16181 
      if fid == 0:
16182 
        if ftype == TType.BOOL:
16183 
          self.success = iprot.readBool();
16184 
        else:
16185 
          iprot.skip(ftype)
16186 
      elif fid == 1:
16187 
        if ftype == TType.STRUCT:
16188 
          self.ex = TransactionServiceException()
16189 
          self.ex.read(iprot)
16190 
        else:
16191 
          iprot.skip(ftype)
16192 
      else:
16193 
        iprot.skip(ftype)
16194 
      iprot.readFieldEnd()
16195 
    iprot.readStructEnd()
16196 
 
16197 
  def write(self, oprot):
16198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16200 
      return
16201 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 16202 
    if self.success is not None:
2536 chandransh 16203 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16204 
      oprot.writeBool(self.success)
16205 
      oprot.writeFieldEnd()
3431 rajveer 16206 
    if self.ex is not None:
2536 chandransh 16207 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16208 
      self.ex.write(oprot)
16209 
      oprot.writeFieldEnd()
16210 
    oprot.writeFieldStop()
16211 
    oprot.writeStructEnd()
16212 
 
3431 rajveer 16213 
  def validate(self):
16214 
    return
16215 
 
16216 
 
2536 chandransh 16217 
  def __repr__(self):
16218 
    L = ['%s=%r' % (key, value)
16219 
      for key, value in self.__dict__.iteritems()]
16220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16221 
 
16222 
  def __eq__(self, other):
16223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16224 
 
16225 
  def __ne__(self, other):
16226 
    return not (self == other)
16227 
 
4712 rajveer 16228 
class markOrderAsDelivered_args:
16229 
  """
16230 
  Attributes:
16231 
   - orderId
16232 
   - deliveryTimestamp
16233 
   - receiver
16234 
  """
16235 
 
16236 
  thrift_spec = None
16237 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
16238 
    self.orderId = orderId
16239 
    self.deliveryTimestamp = deliveryTimestamp
16240 
    self.receiver = receiver
16241 
 
16242 
  def read(self, iprot):
16243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16245 
      return
16246 
    iprot.readStructBegin()
16247 
    while True:
16248 
      (fname, ftype, fid) = iprot.readFieldBegin()
16249 
      if ftype == TType.STOP:
16250 
        break
16251 
      if fid == 1:
16252 
        if ftype == TType.I64:
16253 
          self.orderId = iprot.readI64();
16254 
        else:
16255 
          iprot.skip(ftype)
16256 
      elif fid == 2:
16257 
        if ftype == TType.I64:
16258 
          self.deliveryTimestamp = iprot.readI64();
16259 
        else:
16260 
          iprot.skip(ftype)
16261 
      elif fid == -1:
16262 
        if ftype == TType.STRING:
16263 
          self.receiver = iprot.readString();
16264 
        else:
16265 
          iprot.skip(ftype)
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('markOrderAsDelivered_args')
16276 
    if self.receiver is not None:
16277 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
16278 
      oprot.writeString(self.receiver)
16279 
      oprot.writeFieldEnd()
16280 
    if self.orderId is not None:
16281 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16282 
      oprot.writeI64(self.orderId)
16283 
      oprot.writeFieldEnd()
16284 
    if self.deliveryTimestamp is not None:
16285 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16286 
      oprot.writeI64(self.deliveryTimestamp)
16287 
      oprot.writeFieldEnd()
16288 
    oprot.writeFieldStop()
16289 
    oprot.writeStructEnd()
16290 
 
16291 
  def validate(self):
16292 
    return
16293 
 
16294 
 
16295 
  def __repr__(self):
16296 
    L = ['%s=%r' % (key, value)
16297 
      for key, value in self.__dict__.iteritems()]
16298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16299 
 
16300 
  def __eq__(self, other):
16301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16302 
 
16303 
  def __ne__(self, other):
16304 
    return not (self == other)
16305 
 
16306 
class markOrderAsDelivered_result:
16307 
  """
16308 
  Attributes:
16309 
   - ex
16310 
  """
16311 
 
16312 
  thrift_spec = (
16313 
    None, # 0
16314 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16315 
  )
16316 
 
16317 
  def __init__(self, ex=None,):
16318 
    self.ex = ex
16319 
 
16320 
  def read(self, iprot):
16321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16323 
      return
16324 
    iprot.readStructBegin()
16325 
    while True:
16326 
      (fname, ftype, fid) = iprot.readFieldBegin()
16327 
      if ftype == TType.STOP:
16328 
        break
16329 
      if fid == 1:
16330 
        if ftype == TType.STRUCT:
16331 
          self.ex = TransactionServiceException()
16332 
          self.ex.read(iprot)
16333 
        else:
16334 
          iprot.skip(ftype)
16335 
      else:
16336 
        iprot.skip(ftype)
16337 
      iprot.readFieldEnd()
16338 
    iprot.readStructEnd()
16339 
 
16340 
  def write(self, oprot):
16341 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16342 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16343 
      return
16344 
    oprot.writeStructBegin('markOrderAsDelivered_result')
16345 
    if self.ex is not None:
16346 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16347 
      self.ex.write(oprot)
16348 
      oprot.writeFieldEnd()
16349 
    oprot.writeFieldStop()
16350 
    oprot.writeStructEnd()
16351 
 
16352 
  def validate(self):
16353 
    return
16354 
 
16355 
 
16356 
  def __repr__(self):
16357 
    L = ['%s=%r' % (key, value)
16358 
      for key, value in self.__dict__.iteritems()]
16359 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16360 
 
16361 
  def __eq__(self, other):
16362 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16363 
 
16364 
  def __ne__(self, other):
16365 
    return not (self == other)
16366 
 
5553 rajveer 16367 
class markOrderAsReceivedAtStore_args:
16368 
  """
16369 
  Attributes:
16370 
   - orderId
16371 
   - deliveryTimestamp
16372 
  """
16373 
 
16374 
  thrift_spec = (
16375 
    None, # 0
16376 
    (1, TType.I64, 'orderId', None, None, ), # 1
16377 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
16378 
  )
16379 
 
16380 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
16381 
    self.orderId = orderId
16382 
    self.deliveryTimestamp = deliveryTimestamp
16383 
 
16384 
  def read(self, iprot):
16385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16387 
      return
16388 
    iprot.readStructBegin()
16389 
    while True:
16390 
      (fname, ftype, fid) = iprot.readFieldBegin()
16391 
      if ftype == TType.STOP:
16392 
        break
16393 
      if fid == 1:
16394 
        if ftype == TType.I64:
16395 
          self.orderId = iprot.readI64();
16396 
        else:
16397 
          iprot.skip(ftype)
16398 
      elif fid == 2:
16399 
        if ftype == TType.I64:
16400 
          self.deliveryTimestamp = iprot.readI64();
16401 
        else:
16402 
          iprot.skip(ftype)
16403 
      else:
16404 
        iprot.skip(ftype)
16405 
      iprot.readFieldEnd()
16406 
    iprot.readStructEnd()
16407 
 
16408 
  def write(self, oprot):
16409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16411 
      return
16412 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
16413 
    if self.orderId is not None:
16414 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16415 
      oprot.writeI64(self.orderId)
16416 
      oprot.writeFieldEnd()
16417 
    if self.deliveryTimestamp is not None:
16418 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16419 
      oprot.writeI64(self.deliveryTimestamp)
16420 
      oprot.writeFieldEnd()
16421 
    oprot.writeFieldStop()
16422 
    oprot.writeStructEnd()
16423 
 
16424 
  def validate(self):
16425 
    return
16426 
 
16427 
 
16428 
  def __repr__(self):
16429 
    L = ['%s=%r' % (key, value)
16430 
      for key, value in self.__dict__.iteritems()]
16431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16432 
 
16433 
  def __eq__(self, other):
16434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16435 
 
16436 
  def __ne__(self, other):
16437 
    return not (self == other)
16438 
 
16439 
class markOrderAsReceivedAtStore_result:
16440 
  """
16441 
  Attributes:
16442 
   - ex
16443 
  """
16444 
 
16445 
  thrift_spec = (
16446 
    None, # 0
16447 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16448 
  )
16449 
 
16450 
  def __init__(self, ex=None,):
16451 
    self.ex = ex
16452 
 
16453 
  def read(self, iprot):
16454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16456 
      return
16457 
    iprot.readStructBegin()
16458 
    while True:
16459 
      (fname, ftype, fid) = iprot.readFieldBegin()
16460 
      if ftype == TType.STOP:
16461 
        break
16462 
      if fid == 1:
16463 
        if ftype == TType.STRUCT:
16464 
          self.ex = TransactionServiceException()
16465 
          self.ex.read(iprot)
16466 
        else:
16467 
          iprot.skip(ftype)
16468 
      else:
16469 
        iprot.skip(ftype)
16470 
      iprot.readFieldEnd()
16471 
    iprot.readStructEnd()
16472 
 
16473 
  def write(self, oprot):
16474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16476 
      return
16477 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
16478 
    if self.ex is not None:
16479 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16480 
      self.ex.write(oprot)
16481 
      oprot.writeFieldEnd()
16482 
    oprot.writeFieldStop()
16483 
    oprot.writeStructEnd()
16484 
 
16485 
  def validate(self):
16486 
    return
16487 
 
16488 
 
16489 
  def __repr__(self):
16490 
    L = ['%s=%r' % (key, value)
16491 
      for key, value in self.__dict__.iteritems()]
16492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16493 
 
16494 
  def __eq__(self, other):
16495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16496 
 
16497 
  def __ne__(self, other):
16498 
    return not (self == other)
16499 
 
4454 rajveer 16500 
class markOrderDoaRequestReceived_args:
16501 
  """
16502 
  Attributes:
16503 
   - orderId
16504 
  """
16505 
 
16506 
  thrift_spec = (
16507 
    None, # 0
16508 
    (1, TType.I64, 'orderId', None, None, ), # 1
16509 
  )
16510 
 
16511 
  def __init__(self, orderId=None,):
16512 
    self.orderId = orderId
16513 
 
16514 
  def read(self, iprot):
16515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16517 
      return
16518 
    iprot.readStructBegin()
16519 
    while True:
16520 
      (fname, ftype, fid) = iprot.readFieldBegin()
16521 
      if ftype == TType.STOP:
16522 
        break
16523 
      if fid == 1:
16524 
        if ftype == TType.I64:
16525 
          self.orderId = iprot.readI64();
16526 
        else:
16527 
          iprot.skip(ftype)
16528 
      else:
16529 
        iprot.skip(ftype)
16530 
      iprot.readFieldEnd()
16531 
    iprot.readStructEnd()
16532 
 
16533 
  def write(self, oprot):
16534 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16535 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16536 
      return
16537 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
16538 
    if self.orderId is not None:
16539 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16540 
      oprot.writeI64(self.orderId)
16541 
      oprot.writeFieldEnd()
16542 
    oprot.writeFieldStop()
16543 
    oprot.writeStructEnd()
16544 
 
16545 
  def validate(self):
16546 
    return
16547 
 
16548 
 
16549 
  def __repr__(self):
16550 
    L = ['%s=%r' % (key, value)
16551 
      for key, value in self.__dict__.iteritems()]
16552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16553 
 
16554 
  def __eq__(self, other):
16555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16556 
 
16557 
  def __ne__(self, other):
16558 
    return not (self == other)
16559 
 
16560 
class markOrderDoaRequestReceived_result:
16561 
  """
16562 
  Attributes:
16563 
   - success
16564 
   - ex
16565 
  """
16566 
 
16567 
  thrift_spec = (
16568 
    (0, TType.BOOL, 'success', None, None, ), # 0
16569 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16570 
  )
16571 
 
16572 
  def __init__(self, success=None, ex=None,):
16573 
    self.success = success
16574 
    self.ex = ex
16575 
 
16576 
  def read(self, iprot):
16577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16579 
      return
16580 
    iprot.readStructBegin()
16581 
    while True:
16582 
      (fname, ftype, fid) = iprot.readFieldBegin()
16583 
      if ftype == TType.STOP:
16584 
        break
16585 
      if fid == 0:
16586 
        if ftype == TType.BOOL:
16587 
          self.success = iprot.readBool();
16588 
        else:
16589 
          iprot.skip(ftype)
16590 
      elif fid == 1:
16591 
        if ftype == TType.STRUCT:
16592 
          self.ex = TransactionServiceException()
16593 
          self.ex.read(iprot)
16594 
        else:
16595 
          iprot.skip(ftype)
16596 
      else:
16597 
        iprot.skip(ftype)
16598 
      iprot.readFieldEnd()
16599 
    iprot.readStructEnd()
16600 
 
16601 
  def write(self, oprot):
16602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16604 
      return
16605 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
16606 
    if self.success is not None:
16607 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16608 
      oprot.writeBool(self.success)
16609 
      oprot.writeFieldEnd()
16610 
    if self.ex is not None:
16611 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16612 
      self.ex.write(oprot)
16613 
      oprot.writeFieldEnd()
16614 
    oprot.writeFieldStop()
16615 
    oprot.writeStructEnd()
16616 
 
16617 
  def validate(self):
16618 
    return
16619 
 
16620 
 
16621 
  def __repr__(self):
16622 
    L = ['%s=%r' % (key, value)
16623 
      for key, value in self.__dict__.iteritems()]
16624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16625 
 
16626 
  def __eq__(self, other):
16627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16628 
 
16629 
  def __ne__(self, other):
16630 
    return not (self == other)
16631 
 
16632 
class markOrderDoaRequestAuthorized_args:
16633 
  """
16634 
  Attributes:
16635 
   - orderId
16636 
   - isAuthorized
16637 
  """
16638 
 
16639 
  thrift_spec = (
16640 
    None, # 0
16641 
    (1, TType.I64, 'orderId', None, None, ), # 1
16642 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16643 
  )
16644 
 
16645 
  def __init__(self, orderId=None, isAuthorized=None,):
16646 
    self.orderId = orderId
16647 
    self.isAuthorized = isAuthorized
16648 
 
16649 
  def read(self, iprot):
16650 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16651 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16652 
      return
16653 
    iprot.readStructBegin()
16654 
    while True:
16655 
      (fname, ftype, fid) = iprot.readFieldBegin()
16656 
      if ftype == TType.STOP:
16657 
        break
16658 
      if fid == 1:
16659 
        if ftype == TType.I64:
16660 
          self.orderId = iprot.readI64();
16661 
        else:
16662 
          iprot.skip(ftype)
16663 
      elif fid == 2:
16664 
        if ftype == TType.BOOL:
16665 
          self.isAuthorized = iprot.readBool();
16666 
        else:
16667 
          iprot.skip(ftype)
16668 
      else:
16669 
        iprot.skip(ftype)
16670 
      iprot.readFieldEnd()
16671 
    iprot.readStructEnd()
16672 
 
16673 
  def write(self, oprot):
16674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16676 
      return
16677 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16678 
    if self.orderId is not None:
16679 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16680 
      oprot.writeI64(self.orderId)
16681 
      oprot.writeFieldEnd()
16682 
    if self.isAuthorized is not None:
16683 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16684 
      oprot.writeBool(self.isAuthorized)
16685 
      oprot.writeFieldEnd()
16686 
    oprot.writeFieldStop()
16687 
    oprot.writeStructEnd()
16688 
 
16689 
  def validate(self):
16690 
    return
16691 
 
16692 
 
16693 
  def __repr__(self):
16694 
    L = ['%s=%r' % (key, value)
16695 
      for key, value in self.__dict__.iteritems()]
16696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16697 
 
16698 
  def __eq__(self, other):
16699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16700 
 
16701 
  def __ne__(self, other):
16702 
    return not (self == other)
16703 
 
16704 
class markOrderDoaRequestAuthorized_result:
16705 
  """
16706 
  Attributes:
16707 
   - success
16708 
   - ex
16709 
  """
16710 
 
16711 
  thrift_spec = (
16712 
    (0, TType.BOOL, 'success', None, None, ), # 0
16713 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16714 
  )
16715 
 
16716 
  def __init__(self, success=None, ex=None,):
16717 
    self.success = success
16718 
    self.ex = ex
16719 
 
16720 
  def read(self, iprot):
16721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16723 
      return
16724 
    iprot.readStructBegin()
16725 
    while True:
16726 
      (fname, ftype, fid) = iprot.readFieldBegin()
16727 
      if ftype == TType.STOP:
16728 
        break
16729 
      if fid == 0:
16730 
        if ftype == TType.BOOL:
16731 
          self.success = iprot.readBool();
16732 
        else:
16733 
          iprot.skip(ftype)
16734 
      elif fid == 1:
16735 
        if ftype == TType.STRUCT:
16736 
          self.ex = TransactionServiceException()
16737 
          self.ex.read(iprot)
16738 
        else:
16739 
          iprot.skip(ftype)
16740 
      else:
16741 
        iprot.skip(ftype)
16742 
      iprot.readFieldEnd()
16743 
    iprot.readStructEnd()
16744 
 
16745 
  def write(self, oprot):
16746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16748 
      return
16749 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
16750 
    if self.success is not None:
16751 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16752 
      oprot.writeBool(self.success)
16753 
      oprot.writeFieldEnd()
16754 
    if self.ex is not None:
16755 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16756 
      self.ex.write(oprot)
16757 
      oprot.writeFieldEnd()
16758 
    oprot.writeFieldStop()
16759 
    oprot.writeStructEnd()
16760 
 
16761 
  def validate(self):
16762 
    return
16763 
 
16764 
 
16765 
  def __repr__(self):
16766 
    L = ['%s=%r' % (key, value)
16767 
      for key, value in self.__dict__.iteritems()]
16768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16769 
 
16770 
  def __eq__(self, other):
16771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16772 
 
16773 
  def __ne__(self, other):
16774 
    return not (self == other)
16775 
 
4488 rajveer 16776 
class markOrderReturnRequestReceived_args:
16777 
  """
16778 
  Attributes:
16779 
   - orderId
16780 
  """
16781 
 
16782 
  thrift_spec = (
16783 
    None, # 0
16784 
    (1, TType.I64, 'orderId', None, None, ), # 1
16785 
  )
16786 
 
16787 
  def __init__(self, orderId=None,):
16788 
    self.orderId = orderId
16789 
 
16790 
  def read(self, iprot):
16791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16793 
      return
16794 
    iprot.readStructBegin()
16795 
    while True:
16796 
      (fname, ftype, fid) = iprot.readFieldBegin()
16797 
      if ftype == TType.STOP:
16798 
        break
16799 
      if fid == 1:
16800 
        if ftype == TType.I64:
16801 
          self.orderId = iprot.readI64();
16802 
        else:
16803 
          iprot.skip(ftype)
16804 
      else:
16805 
        iprot.skip(ftype)
16806 
      iprot.readFieldEnd()
16807 
    iprot.readStructEnd()
16808 
 
16809 
  def write(self, oprot):
16810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16812 
      return
16813 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
16814 
    if self.orderId is not None:
16815 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16816 
      oprot.writeI64(self.orderId)
16817 
      oprot.writeFieldEnd()
16818 
    oprot.writeFieldStop()
16819 
    oprot.writeStructEnd()
16820 
 
16821 
  def validate(self):
16822 
    return
16823 
 
16824 
 
16825 
  def __repr__(self):
16826 
    L = ['%s=%r' % (key, value)
16827 
      for key, value in self.__dict__.iteritems()]
16828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16829 
 
16830 
  def __eq__(self, other):
16831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16832 
 
16833 
  def __ne__(self, other):
16834 
    return not (self == other)
16835 
 
16836 
class markOrderReturnRequestReceived_result:
16837 
  """
16838 
  Attributes:
16839 
   - success
16840 
   - ex
16841 
  """
16842 
 
16843 
  thrift_spec = (
16844 
    (0, TType.BOOL, 'success', None, None, ), # 0
16845 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16846 
  )
16847 
 
16848 
  def __init__(self, success=None, ex=None,):
16849 
    self.success = success
16850 
    self.ex = ex
16851 
 
16852 
  def read(self, iprot):
16853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16855 
      return
16856 
    iprot.readStructBegin()
16857 
    while True:
16858 
      (fname, ftype, fid) = iprot.readFieldBegin()
16859 
      if ftype == TType.STOP:
16860 
        break
16861 
      if fid == 0:
16862 
        if ftype == TType.BOOL:
16863 
          self.success = iprot.readBool();
16864 
        else:
16865 
          iprot.skip(ftype)
16866 
      elif fid == 1:
16867 
        if ftype == TType.STRUCT:
16868 
          self.ex = TransactionServiceException()
16869 
          self.ex.read(iprot)
16870 
        else:
16871 
          iprot.skip(ftype)
16872 
      else:
16873 
        iprot.skip(ftype)
16874 
      iprot.readFieldEnd()
16875 
    iprot.readStructEnd()
16876 
 
16877 
  def write(self, oprot):
16878 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16879 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16880 
      return
16881 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
16882 
    if self.success is not None:
16883 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16884 
      oprot.writeBool(self.success)
16885 
      oprot.writeFieldEnd()
16886 
    if self.ex is not None:
16887 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16888 
      self.ex.write(oprot)
16889 
      oprot.writeFieldEnd()
16890 
    oprot.writeFieldStop()
16891 
    oprot.writeStructEnd()
16892 
 
16893 
  def validate(self):
16894 
    return
16895 
 
16896 
 
16897 
  def __repr__(self):
16898 
    L = ['%s=%r' % (key, value)
16899 
      for key, value in self.__dict__.iteritems()]
16900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16901 
 
16902 
  def __eq__(self, other):
16903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16904 
 
16905 
  def __ne__(self, other):
16906 
    return not (self == other)
16907 
 
16908 
class markOrderReturnRequestAuthorized_args:
16909 
  """
16910 
  Attributes:
16911 
   - orderId
16912 
   - isAuthorized
16913 
  """
16914 
 
16915 
  thrift_spec = (
16916 
    None, # 0
16917 
    (1, TType.I64, 'orderId', None, None, ), # 1
16918 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16919 
  )
16920 
 
16921 
  def __init__(self, orderId=None, isAuthorized=None,):
16922 
    self.orderId = orderId
16923 
    self.isAuthorized = isAuthorized
16924 
 
16925 
  def read(self, iprot):
16926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16928 
      return
16929 
    iprot.readStructBegin()
16930 
    while True:
16931 
      (fname, ftype, fid) = iprot.readFieldBegin()
16932 
      if ftype == TType.STOP:
16933 
        break
16934 
      if fid == 1:
16935 
        if ftype == TType.I64:
16936 
          self.orderId = iprot.readI64();
16937 
        else:
16938 
          iprot.skip(ftype)
16939 
      elif fid == 2:
16940 
        if ftype == TType.BOOL:
16941 
          self.isAuthorized = iprot.readBool();
16942 
        else:
16943 
          iprot.skip(ftype)
16944 
      else:
16945 
        iprot.skip(ftype)
16946 
      iprot.readFieldEnd()
16947 
    iprot.readStructEnd()
16948 
 
16949 
  def write(self, oprot):
16950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16952 
      return
16953 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
16954 
    if self.orderId is not None:
16955 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16956 
      oprot.writeI64(self.orderId)
16957 
      oprot.writeFieldEnd()
16958 
    if self.isAuthorized is not None:
16959 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16960 
      oprot.writeBool(self.isAuthorized)
16961 
      oprot.writeFieldEnd()
16962 
    oprot.writeFieldStop()
16963 
    oprot.writeStructEnd()
16964 
 
16965 
  def validate(self):
16966 
    return
16967 
 
16968 
 
16969 
  def __repr__(self):
16970 
    L = ['%s=%r' % (key, value)
16971 
      for key, value in self.__dict__.iteritems()]
16972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16973 
 
16974 
  def __eq__(self, other):
16975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16976 
 
16977 
  def __ne__(self, other):
16978 
    return not (self == other)
16979 
 
16980 
class markOrderReturnRequestAuthorized_result:
16981 
  """
16982 
  Attributes:
16983 
   - success
16984 
   - ex
16985 
  """
16986 
 
16987 
  thrift_spec = (
16988 
    (0, TType.BOOL, 'success', None, None, ), # 0
16989 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16990 
  )
16991 
 
16992 
  def __init__(self, success=None, ex=None,):
16993 
    self.success = success
16994 
    self.ex = ex
16995 
 
16996 
  def read(self, iprot):
16997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16999 
      return
17000 
    iprot.readStructBegin()
17001 
    while True:
17002 
      (fname, ftype, fid) = iprot.readFieldBegin()
17003 
      if ftype == TType.STOP:
17004 
        break
17005 
      if fid == 0:
17006 
        if ftype == TType.BOOL:
17007 
          self.success = iprot.readBool();
17008 
        else:
17009 
          iprot.skip(ftype)
17010 
      elif fid == 1:
17011 
        if ftype == TType.STRUCT:
17012 
          self.ex = TransactionServiceException()
17013 
          self.ex.read(iprot)
17014 
        else:
17015 
          iprot.skip(ftype)
17016 
      else:
17017 
        iprot.skip(ftype)
17018 
      iprot.readFieldEnd()
17019 
    iprot.readStructEnd()
17020 
 
17021 
  def write(self, oprot):
17022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17024 
      return
17025 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
17026 
    if self.success is not None:
17027 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17028 
      oprot.writeBool(self.success)
17029 
      oprot.writeFieldEnd()
17030 
    if self.ex is not None:
17031 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17032 
      self.ex.write(oprot)
17033 
      oprot.writeFieldEnd()
17034 
    oprot.writeFieldStop()
17035 
    oprot.writeStructEnd()
17036 
 
17037 
  def validate(self):
17038 
    return
17039 
 
17040 
 
17041 
  def __repr__(self):
17042 
    L = ['%s=%r' % (key, value)
17043 
      for key, value in self.__dict__.iteritems()]
17044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17045 
 
17046 
  def __eq__(self, other):
17047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17048 
 
17049 
  def __ne__(self, other):
17050 
    return not (self == other)
17051 
 
2536 chandransh 17052 
class requestPickupNumber_args:
17053 
  """
17054 
  Attributes:
17055 
   - orderId
4579 rajveer 17056 
   - providerId
2536 chandransh 17057 
  """
17058 
 
17059 
  thrift_spec = (
17060 
    None, # 0
17061 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 17062 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 17063 
  )
17064 
 
4579 rajveer 17065 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 17066 
    self.orderId = orderId
4579 rajveer 17067 
    self.providerId = providerId
2536 chandransh 17068 
 
17069 
  def read(self, iprot):
17070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17072 
      return
17073 
    iprot.readStructBegin()
17074 
    while True:
17075 
      (fname, ftype, fid) = iprot.readFieldBegin()
17076 
      if ftype == TType.STOP:
17077 
        break
17078 
      if fid == 1:
17079 
        if ftype == TType.I64:
17080 
          self.orderId = iprot.readI64();
17081 
        else:
17082 
          iprot.skip(ftype)
4579 rajveer 17083 
      elif fid == 2:
17084 
        if ftype == TType.I64:
17085 
          self.providerId = iprot.readI64();
17086 
        else:
17087 
          iprot.skip(ftype)
2536 chandransh 17088 
      else:
17089 
        iprot.skip(ftype)
17090 
      iprot.readFieldEnd()
17091 
    iprot.readStructEnd()
17092 
 
17093 
  def write(self, oprot):
17094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17096 
      return
17097 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 17098 
    if self.orderId is not None:
2536 chandransh 17099 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17100 
      oprot.writeI64(self.orderId)
17101 
      oprot.writeFieldEnd()
4579 rajveer 17102 
    if self.providerId is not None:
17103 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
17104 
      oprot.writeI64(self.providerId)
17105 
      oprot.writeFieldEnd()
2536 chandransh 17106 
    oprot.writeFieldStop()
17107 
    oprot.writeStructEnd()
17108 
 
3431 rajveer 17109 
  def validate(self):
17110 
    return
17111 
 
17112 
 
2536 chandransh 17113 
  def __repr__(self):
17114 
    L = ['%s=%r' % (key, value)
17115 
      for key, value in self.__dict__.iteritems()]
17116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17117 
 
17118 
  def __eq__(self, other):
17119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17120 
 
17121 
  def __ne__(self, other):
17122 
    return not (self == other)
17123 
 
17124 
class requestPickupNumber_result:
17125 
  """
17126 
  Attributes:
17127 
   - success
17128 
   - ex
17129 
  """
17130 
 
17131 
  thrift_spec = (
17132 
    (0, TType.BOOL, 'success', None, None, ), # 0
17133 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17134 
  )
17135 
 
17136 
  def __init__(self, success=None, ex=None,):
17137 
    self.success = success
17138 
    self.ex = ex
17139 
 
17140 
  def read(self, iprot):
17141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17143 
      return
17144 
    iprot.readStructBegin()
17145 
    while True:
17146 
      (fname, ftype, fid) = iprot.readFieldBegin()
17147 
      if ftype == TType.STOP:
17148 
        break
17149 
      if fid == 0:
17150 
        if ftype == TType.BOOL:
17151 
          self.success = iprot.readBool();
17152 
        else:
17153 
          iprot.skip(ftype)
17154 
      elif fid == 1:
17155 
        if ftype == TType.STRUCT:
17156 
          self.ex = TransactionServiceException()
17157 
          self.ex.read(iprot)
17158 
        else:
17159 
          iprot.skip(ftype)
17160 
      else:
17161 
        iprot.skip(ftype)
17162 
      iprot.readFieldEnd()
17163 
    iprot.readStructEnd()
17164 
 
17165 
  def write(self, oprot):
17166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17168 
      return
17169 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 17170 
    if self.success is not None:
2536 chandransh 17171 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17172 
      oprot.writeBool(self.success)
17173 
      oprot.writeFieldEnd()
3431 rajveer 17174 
    if self.ex is not None:
2536 chandransh 17175 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17176 
      self.ex.write(oprot)
17177 
      oprot.writeFieldEnd()
17178 
    oprot.writeFieldStop()
17179 
    oprot.writeStructEnd()
17180 
 
3431 rajveer 17181 
  def validate(self):
17182 
    return
17183 
 
17184 
 
2536 chandransh 17185 
  def __repr__(self):
17186 
    L = ['%s=%r' % (key, value)
17187 
      for key, value in self.__dict__.iteritems()]
17188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17189 
 
17190 
  def __eq__(self, other):
17191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17192 
 
17193 
  def __ne__(self, other):
17194 
    return not (self == other)
17195 
 
17196 
class authorizePickup_args:
17197 
  """
17198 
  Attributes:
17199 
   - orderId
17200 
   - pickupNumber
4602 rajveer 17201 
   - providerId
2536 chandransh 17202 
  """
17203 
 
17204 
  thrift_spec = (
17205 
    None, # 0
17206 
    (1, TType.I64, 'orderId', None, None, ), # 1
17207 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 17208 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 17209 
  )
17210 
 
4602 rajveer 17211 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 17212 
    self.orderId = orderId
17213 
    self.pickupNumber = pickupNumber
4602 rajveer 17214 
    self.providerId = providerId
2536 chandransh 17215 
 
17216 
  def read(self, iprot):
17217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17219 
      return
17220 
    iprot.readStructBegin()
17221 
    while True:
17222 
      (fname, ftype, fid) = iprot.readFieldBegin()
17223 
      if ftype == TType.STOP:
17224 
        break
17225 
      if fid == 1:
17226 
        if ftype == TType.I64:
17227 
          self.orderId = iprot.readI64();
17228 
        else:
17229 
          iprot.skip(ftype)
17230 
      elif fid == 2:
17231 
        if ftype == TType.STRING:
17232 
          self.pickupNumber = iprot.readString();
17233 
        else:
17234 
          iprot.skip(ftype)
4602 rajveer 17235 
      elif fid == 3:
17236 
        if ftype == TType.I64:
17237 
          self.providerId = iprot.readI64();
17238 
        else:
17239 
          iprot.skip(ftype)
2536 chandransh 17240 
      else:
17241 
        iprot.skip(ftype)
17242 
      iprot.readFieldEnd()
17243 
    iprot.readStructEnd()
17244 
 
17245 
  def write(self, oprot):
17246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17248 
      return
17249 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 17250 
    if self.orderId is not None:
2536 chandransh 17251 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17252 
      oprot.writeI64(self.orderId)
17253 
      oprot.writeFieldEnd()
3431 rajveer 17254 
    if self.pickupNumber is not None:
2536 chandransh 17255 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
17256 
      oprot.writeString(self.pickupNumber)
17257 
      oprot.writeFieldEnd()
4602 rajveer 17258 
    if self.providerId is not None:
17259 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
17260 
      oprot.writeI64(self.providerId)
17261 
      oprot.writeFieldEnd()
2536 chandransh 17262 
    oprot.writeFieldStop()
17263 
    oprot.writeStructEnd()
17264 
 
3431 rajveer 17265 
  def validate(self):
17266 
    return
17267 
 
17268 
 
2536 chandransh 17269 
  def __repr__(self):
17270 
    L = ['%s=%r' % (key, value)
17271 
      for key, value in self.__dict__.iteritems()]
17272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17273 
 
17274 
  def __eq__(self, other):
17275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17276 
 
17277 
  def __ne__(self, other):
17278 
    return not (self == other)
17279 
 
17280 
class authorizePickup_result:
17281 
  """
17282 
  Attributes:
17283 
   - success
17284 
   - ex
17285 
  """
17286 
 
17287 
  thrift_spec = (
17288 
    (0, TType.BOOL, 'success', None, None, ), # 0
17289 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17290 
  )
17291 
 
17292 
  def __init__(self, success=None, ex=None,):
17293 
    self.success = success
17294 
    self.ex = ex
17295 
 
17296 
  def read(self, iprot):
17297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17299 
      return
17300 
    iprot.readStructBegin()
17301 
    while True:
17302 
      (fname, ftype, fid) = iprot.readFieldBegin()
17303 
      if ftype == TType.STOP:
17304 
        break
17305 
      if fid == 0:
17306 
        if ftype == TType.BOOL:
17307 
          self.success = iprot.readBool();
17308 
        else:
17309 
          iprot.skip(ftype)
17310 
      elif fid == 1:
17311 
        if ftype == TType.STRUCT:
17312 
          self.ex = TransactionServiceException()
17313 
          self.ex.read(iprot)
17314 
        else:
17315 
          iprot.skip(ftype)
17316 
      else:
17317 
        iprot.skip(ftype)
17318 
      iprot.readFieldEnd()
17319 
    iprot.readStructEnd()
17320 
 
17321 
  def write(self, oprot):
17322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17324 
      return
17325 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 17326 
    if self.success is not None:
2536 chandransh 17327 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17328 
      oprot.writeBool(self.success)
17329 
      oprot.writeFieldEnd()
3431 rajveer 17330 
    if self.ex is not None:
2536 chandransh 17331 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17332 
      self.ex.write(oprot)
17333 
      oprot.writeFieldEnd()
17334 
    oprot.writeFieldStop()
17335 
    oprot.writeStructEnd()
17336 
 
3431 rajveer 17337 
  def validate(self):
17338 
    return
17339 
 
17340 
 
2536 chandransh 17341 
  def __repr__(self):
17342 
    L = ['%s=%r' % (key, value)
17343 
      for key, value in self.__dict__.iteritems()]
17344 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17345 
 
17346 
  def __eq__(self, other):
17347 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17348 
 
17349 
  def __ne__(self, other):
17350 
    return not (self == other)
17351 
 
2764 chandransh 17352 
class markDoasAsPickedUp_args:
17353 
  """
17354 
  Attributes:
17355 
   - providerId
17356 
   - pickupDetails
17357 
  """
17358 
 
17359 
  thrift_spec = (
17360 
    None, # 0
17361 
    (1, TType.I64, 'providerId', None, None, ), # 1
17362 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17363 
  )
17364 
 
17365 
  def __init__(self, providerId=None, pickupDetails=None,):
17366 
    self.providerId = providerId
17367 
    self.pickupDetails = pickupDetails
17368 
 
17369 
  def read(self, iprot):
17370 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17371 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17372 
      return
17373 
    iprot.readStructBegin()
17374 
    while True:
17375 
      (fname, ftype, fid) = iprot.readFieldBegin()
17376 
      if ftype == TType.STOP:
17377 
        break
17378 
      if fid == 1:
17379 
        if ftype == TType.I64:
17380 
          self.providerId = iprot.readI64();
17381 
        else:
17382 
          iprot.skip(ftype)
17383 
      elif fid == 2:
17384 
        if ftype == TType.MAP:
17385 
          self.pickupDetails = {}
6188 rajveer 17386 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
17387 
          for _i411 in xrange(_size407):
17388 
            _key412 = iprot.readString();
17389 
            _val413 = iprot.readString();
17390 
            self.pickupDetails[_key412] = _val413
2764 chandransh 17391 
          iprot.readMapEnd()
17392 
        else:
17393 
          iprot.skip(ftype)
17394 
      else:
17395 
        iprot.skip(ftype)
17396 
      iprot.readFieldEnd()
17397 
    iprot.readStructEnd()
17398 
 
17399 
  def write(self, oprot):
17400 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17401 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17402 
      return
17403 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 17404 
    if self.providerId is not None:
2764 chandransh 17405 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17406 
      oprot.writeI64(self.providerId)
17407 
      oprot.writeFieldEnd()
3431 rajveer 17408 
    if self.pickupDetails is not None:
2764 chandransh 17409 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17410 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17411 
      for kiter414,viter415 in self.pickupDetails.items():
17412 
        oprot.writeString(kiter414)
17413 
        oprot.writeString(viter415)
2764 chandransh 17414 
      oprot.writeMapEnd()
17415 
      oprot.writeFieldEnd()
17416 
    oprot.writeFieldStop()
17417 
    oprot.writeStructEnd()
17418 
 
3431 rajveer 17419 
  def validate(self):
17420 
    return
17421 
 
17422 
 
2764 chandransh 17423 
  def __repr__(self):
17424 
    L = ['%s=%r' % (key, value)
17425 
      for key, value in self.__dict__.iteritems()]
17426 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17427 
 
17428 
  def __eq__(self, other):
17429 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17430 
 
17431 
  def __ne__(self, other):
17432 
    return not (self == other)
17433 
 
17434 
class markDoasAsPickedUp_result:
4910 phani.kuma 17435 
 
17436 
  thrift_spec = (
17437 
  )
17438 
 
17439 
  def read(self, iprot):
17440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17442 
      return
17443 
    iprot.readStructBegin()
17444 
    while True:
17445 
      (fname, ftype, fid) = iprot.readFieldBegin()
17446 
      if ftype == TType.STOP:
17447 
        break
17448 
      else:
17449 
        iprot.skip(ftype)
17450 
      iprot.readFieldEnd()
17451 
    iprot.readStructEnd()
17452 
 
17453 
  def write(self, oprot):
17454 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17455 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17456 
      return
17457 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
17458 
    oprot.writeFieldStop()
17459 
    oprot.writeStructEnd()
17460 
 
17461 
  def validate(self):
17462 
    return
17463 
 
17464 
 
17465 
  def __repr__(self):
17466 
    L = ['%s=%r' % (key, value)
17467 
      for key, value in self.__dict__.iteritems()]
17468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17469 
 
17470 
  def __eq__(self, other):
17471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17472 
 
17473 
  def __ne__(self, other):
17474 
    return not (self == other)
17475 
 
17476 
class getDoasNotPickedUp_args:
2764 chandransh 17477 
  """
17478 
  Attributes:
4910 phani.kuma 17479 
   - providerId
17480 
  """
17481 
 
17482 
  thrift_spec = (
17483 
    None, # 0
17484 
    (1, TType.I64, 'providerId', None, None, ), # 1
17485 
  )
17486 
 
17487 
  def __init__(self, providerId=None,):
17488 
    self.providerId = providerId
17489 
 
17490 
  def read(self, iprot):
17491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17493 
      return
17494 
    iprot.readStructBegin()
17495 
    while True:
17496 
      (fname, ftype, fid) = iprot.readFieldBegin()
17497 
      if ftype == TType.STOP:
17498 
        break
17499 
      if fid == 1:
17500 
        if ftype == TType.I64:
17501 
          self.providerId = iprot.readI64();
17502 
        else:
17503 
          iprot.skip(ftype)
17504 
      else:
17505 
        iprot.skip(ftype)
17506 
      iprot.readFieldEnd()
17507 
    iprot.readStructEnd()
17508 
 
17509 
  def write(self, oprot):
17510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17512 
      return
17513 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17514 
    if self.providerId is not None:
17515 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17516 
      oprot.writeI64(self.providerId)
17517 
      oprot.writeFieldEnd()
17518 
    oprot.writeFieldStop()
17519 
    oprot.writeStructEnd()
17520 
 
17521 
  def validate(self):
17522 
    return
17523 
 
17524 
 
17525 
  def __repr__(self):
17526 
    L = ['%s=%r' % (key, value)
17527 
      for key, value in self.__dict__.iteritems()]
17528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17529 
 
17530 
  def __eq__(self, other):
17531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17532 
 
17533 
  def __ne__(self, other):
17534 
    return not (self == other)
17535 
 
17536 
class getDoasNotPickedUp_result:
17537 
  """
17538 
  Attributes:
2764 chandransh 17539 
   - success
17540 
  """
17541 
 
17542 
  thrift_spec = (
17543 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17544 
  )
17545 
 
17546 
  def __init__(self, success=None,):
17547 
    self.success = success
17548 
 
17549 
  def read(self, iprot):
17550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17552 
      return
17553 
    iprot.readStructBegin()
17554 
    while True:
17555 
      (fname, ftype, fid) = iprot.readFieldBegin()
17556 
      if ftype == TType.STOP:
17557 
        break
17558 
      if fid == 0:
17559 
        if ftype == TType.LIST:
17560 
          self.success = []
6188 rajveer 17561 
          (_etype419, _size416) = iprot.readListBegin()
17562 
          for _i420 in xrange(_size416):
17563 
            _elem421 = Order()
17564 
            _elem421.read(iprot)
17565 
            self.success.append(_elem421)
2764 chandransh 17566 
          iprot.readListEnd()
17567 
        else:
17568 
          iprot.skip(ftype)
17569 
      else:
17570 
        iprot.skip(ftype)
17571 
      iprot.readFieldEnd()
17572 
    iprot.readStructEnd()
17573 
 
17574 
  def write(self, oprot):
17575 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17576 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17577 
      return
4910 phani.kuma 17578 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 17579 
    if self.success is not None:
2764 chandransh 17580 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17581 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17582 
      for iter422 in self.success:
17583 
        iter422.write(oprot)
2764 chandransh 17584 
      oprot.writeListEnd()
17585 
      oprot.writeFieldEnd()
17586 
    oprot.writeFieldStop()
17587 
    oprot.writeStructEnd()
17588 
 
3431 rajveer 17589 
  def validate(self):
17590 
    return
17591 
 
17592 
 
2764 chandransh 17593 
  def __repr__(self):
17594 
    L = ['%s=%r' % (key, value)
17595 
      for key, value in self.__dict__.iteritems()]
17596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17597 
 
17598 
  def __eq__(self, other):
17599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17600 
 
17601 
  def __ne__(self, other):
17602 
    return not (self == other)
17603 
 
4741 phani.kuma 17604 
class markReturnOrdersAsPickedUp_args:
17605 
  """
17606 
  Attributes:
17607 
   - providerId
17608 
   - pickupDetails
17609 
  """
17610 
 
17611 
  thrift_spec = (
17612 
    None, # 0
17613 
    (1, TType.I64, 'providerId', None, None, ), # 1
17614 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17615 
  )
17616 
 
17617 
  def __init__(self, providerId=None, pickupDetails=None,):
17618 
    self.providerId = providerId
17619 
    self.pickupDetails = pickupDetails
17620 
 
17621 
  def read(self, iprot):
17622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17624 
      return
17625 
    iprot.readStructBegin()
17626 
    while True:
17627 
      (fname, ftype, fid) = iprot.readFieldBegin()
17628 
      if ftype == TType.STOP:
17629 
        break
17630 
      if fid == 1:
17631 
        if ftype == TType.I64:
17632 
          self.providerId = iprot.readI64();
17633 
        else:
17634 
          iprot.skip(ftype)
17635 
      elif fid == 2:
17636 
        if ftype == TType.MAP:
17637 
          self.pickupDetails = {}
6188 rajveer 17638 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
17639 
          for _i427 in xrange(_size423):
17640 
            _key428 = iprot.readString();
17641 
            _val429 = iprot.readString();
17642 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 17643 
          iprot.readMapEnd()
17644 
        else:
17645 
          iprot.skip(ftype)
17646 
      else:
17647 
        iprot.skip(ftype)
17648 
      iprot.readFieldEnd()
17649 
    iprot.readStructEnd()
17650 
 
17651 
  def write(self, oprot):
17652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17654 
      return
17655 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
17656 
    if self.providerId is not None:
17657 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17658 
      oprot.writeI64(self.providerId)
17659 
      oprot.writeFieldEnd()
17660 
    if self.pickupDetails is not None:
17661 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17662 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17663 
      for kiter430,viter431 in self.pickupDetails.items():
17664 
        oprot.writeString(kiter430)
17665 
        oprot.writeString(viter431)
4741 phani.kuma 17666 
      oprot.writeMapEnd()
17667 
      oprot.writeFieldEnd()
17668 
    oprot.writeFieldStop()
17669 
    oprot.writeStructEnd()
17670 
 
17671 
  def validate(self):
17672 
    return
17673 
 
17674 
 
17675 
  def __repr__(self):
17676 
    L = ['%s=%r' % (key, value)
17677 
      for key, value in self.__dict__.iteritems()]
17678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17679 
 
17680 
  def __eq__(self, other):
17681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17682 
 
17683 
  def __ne__(self, other):
17684 
    return not (self == other)
17685 
 
17686 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 17687 
 
17688 
  thrift_spec = (
17689 
  )
17690 
 
17691 
  def read(self, iprot):
17692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17694 
      return
17695 
    iprot.readStructBegin()
17696 
    while True:
17697 
      (fname, ftype, fid) = iprot.readFieldBegin()
17698 
      if ftype == TType.STOP:
17699 
        break
17700 
      else:
17701 
        iprot.skip(ftype)
17702 
      iprot.readFieldEnd()
17703 
    iprot.readStructEnd()
17704 
 
17705 
  def write(self, oprot):
17706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17708 
      return
17709 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
17710 
    oprot.writeFieldStop()
17711 
    oprot.writeStructEnd()
17712 
 
17713 
  def validate(self):
17714 
    return
17715 
 
17716 
 
17717 
  def __repr__(self):
17718 
    L = ['%s=%r' % (key, value)
17719 
      for key, value in self.__dict__.iteritems()]
17720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17721 
 
17722 
  def __eq__(self, other):
17723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17724 
 
17725 
  def __ne__(self, other):
17726 
    return not (self == other)
17727 
 
17728 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 17729 
  """
17730 
  Attributes:
4910 phani.kuma 17731 
   - providerId
17732 
  """
17733 
 
17734 
  thrift_spec = (
17735 
    None, # 0
17736 
    (1, TType.I64, 'providerId', None, None, ), # 1
17737 
  )
17738 
 
17739 
  def __init__(self, providerId=None,):
17740 
    self.providerId = providerId
17741 
 
17742 
  def read(self, iprot):
17743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17745 
      return
17746 
    iprot.readStructBegin()
17747 
    while True:
17748 
      (fname, ftype, fid) = iprot.readFieldBegin()
17749 
      if ftype == TType.STOP:
17750 
        break
17751 
      if fid == 1:
17752 
        if ftype == TType.I64:
17753 
          self.providerId = iprot.readI64();
17754 
        else:
17755 
          iprot.skip(ftype)
17756 
      else:
17757 
        iprot.skip(ftype)
17758 
      iprot.readFieldEnd()
17759 
    iprot.readStructEnd()
17760 
 
17761 
  def write(self, oprot):
17762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17764 
      return
17765 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
17766 
    if self.providerId is not None:
17767 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17768 
      oprot.writeI64(self.providerId)
17769 
      oprot.writeFieldEnd()
17770 
    oprot.writeFieldStop()
17771 
    oprot.writeStructEnd()
17772 
 
17773 
  def validate(self):
17774 
    return
17775 
 
17776 
 
17777 
  def __repr__(self):
17778 
    L = ['%s=%r' % (key, value)
17779 
      for key, value in self.__dict__.iteritems()]
17780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17781 
 
17782 
  def __eq__(self, other):
17783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17784 
 
17785 
  def __ne__(self, other):
17786 
    return not (self == other)
17787 
 
17788 
class getReturnOrdersNotPickedUp_result:
17789 
  """
17790 
  Attributes:
4741 phani.kuma 17791 
   - success
17792 
  """
17793 
 
17794 
  thrift_spec = (
17795 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17796 
  )
17797 
 
17798 
  def __init__(self, success=None,):
17799 
    self.success = success
17800 
 
17801 
  def read(self, iprot):
17802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17804 
      return
17805 
    iprot.readStructBegin()
17806 
    while True:
17807 
      (fname, ftype, fid) = iprot.readFieldBegin()
17808 
      if ftype == TType.STOP:
17809 
        break
17810 
      if fid == 0:
17811 
        if ftype == TType.LIST:
17812 
          self.success = []
6188 rajveer 17813 
          (_etype435, _size432) = iprot.readListBegin()
17814 
          for _i436 in xrange(_size432):
17815 
            _elem437 = Order()
17816 
            _elem437.read(iprot)
17817 
            self.success.append(_elem437)
4741 phani.kuma 17818 
          iprot.readListEnd()
17819 
        else:
17820 
          iprot.skip(ftype)
17821 
      else:
17822 
        iprot.skip(ftype)
17823 
      iprot.readFieldEnd()
17824 
    iprot.readStructEnd()
17825 
 
17826 
  def write(self, oprot):
17827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17829 
      return
4910 phani.kuma 17830 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 17831 
    if self.success is not None:
17832 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17833 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17834 
      for iter438 in self.success:
17835 
        iter438.write(oprot)
4741 phani.kuma 17836 
      oprot.writeListEnd()
17837 
      oprot.writeFieldEnd()
17838 
    oprot.writeFieldStop()
17839 
    oprot.writeStructEnd()
17840 
 
17841 
  def validate(self):
17842 
    return
17843 
 
17844 
 
17845 
  def __repr__(self):
17846 
    L = ['%s=%r' % (key, value)
17847 
      for key, value in self.__dict__.iteritems()]
17848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17849 
 
17850 
  def __eq__(self, other):
17851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17852 
 
17853 
  def __ne__(self, other):
17854 
    return not (self == other)
17855 
 
2616 chandransh 17856 
class receiveReturn_args:
2591 chandransh 17857 
  """
17858 
  Attributes:
17859 
   - orderId
4479 rajveer 17860 
   - receiveCondition
2591 chandransh 17861 
  """
2536 chandransh 17862 
 
2591 chandransh 17863 
  thrift_spec = (
17864 
    None, # 0
17865 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 17866 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 17867 
  )
17868 
 
4479 rajveer 17869 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 17870 
    self.orderId = orderId
4479 rajveer 17871 
    self.receiveCondition = receiveCondition
2591 chandransh 17872 
 
17873 
  def read(self, iprot):
17874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17876 
      return
17877 
    iprot.readStructBegin()
17878 
    while True:
17879 
      (fname, ftype, fid) = iprot.readFieldBegin()
17880 
      if ftype == TType.STOP:
17881 
        break
17882 
      if fid == 1:
17883 
        if ftype == TType.I64:
17884 
          self.orderId = iprot.readI64();
17885 
        else:
17886 
          iprot.skip(ftype)
4479 rajveer 17887 
      elif fid == 2:
17888 
        if ftype == TType.I64:
17889 
          self.receiveCondition = iprot.readI64();
17890 
        else:
17891 
          iprot.skip(ftype)
2591 chandransh 17892 
      else:
17893 
        iprot.skip(ftype)
17894 
      iprot.readFieldEnd()
17895 
    iprot.readStructEnd()
17896 
 
17897 
  def write(self, oprot):
17898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17900 
      return
2616 chandransh 17901 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 17902 
    if self.orderId is not None:
2591 chandransh 17903 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17904 
      oprot.writeI64(self.orderId)
17905 
      oprot.writeFieldEnd()
4479 rajveer 17906 
    if self.receiveCondition is not None:
17907 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
17908 
      oprot.writeI64(self.receiveCondition)
17909 
      oprot.writeFieldEnd()
2591 chandransh 17910 
    oprot.writeFieldStop()
17911 
    oprot.writeStructEnd()
17912 
 
3431 rajveer 17913 
  def validate(self):
17914 
    return
17915 
 
17916 
 
2591 chandransh 17917 
  def __repr__(self):
17918 
    L = ['%s=%r' % (key, value)
17919 
      for key, value in self.__dict__.iteritems()]
17920 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17921 
 
17922 
  def __eq__(self, other):
17923 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17924 
 
17925 
  def __ne__(self, other):
17926 
    return not (self == other)
17927 
 
2616 chandransh 17928 
class receiveReturn_result:
2591 chandransh 17929 
  """
17930 
  Attributes:
17931 
   - success
17932 
   - ex
17933 
  """
17934 
 
17935 
  thrift_spec = (
17936 
    (0, TType.BOOL, 'success', None, None, ), # 0
17937 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17938 
  )
17939 
 
17940 
  def __init__(self, success=None, ex=None,):
17941 
    self.success = success
17942 
    self.ex = ex
17943 
 
17944 
  def read(self, iprot):
17945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17947 
      return
17948 
    iprot.readStructBegin()
17949 
    while True:
17950 
      (fname, ftype, fid) = iprot.readFieldBegin()
17951 
      if ftype == TType.STOP:
17952 
        break
17953 
      if fid == 0:
17954 
        if ftype == TType.BOOL:
17955 
          self.success = iprot.readBool();
17956 
        else:
17957 
          iprot.skip(ftype)
17958 
      elif fid == 1:
17959 
        if ftype == TType.STRUCT:
17960 
          self.ex = TransactionServiceException()
17961 
          self.ex.read(iprot)
17962 
        else:
17963 
          iprot.skip(ftype)
17964 
      else:
17965 
        iprot.skip(ftype)
17966 
      iprot.readFieldEnd()
17967 
    iprot.readStructEnd()
17968 
 
17969 
  def write(self, oprot):
17970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17972 
      return
2616 chandransh 17973 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 17974 
    if self.success is not None:
2591 chandransh 17975 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17976 
      oprot.writeBool(self.success)
17977 
      oprot.writeFieldEnd()
3431 rajveer 17978 
    if self.ex is not None:
2591 chandransh 17979 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17980 
      self.ex.write(oprot)
17981 
      oprot.writeFieldEnd()
17982 
    oprot.writeFieldStop()
17983 
    oprot.writeStructEnd()
17984 
 
3431 rajveer 17985 
  def validate(self):
17986 
    return
17987 
 
17988 
 
2591 chandransh 17989 
  def __repr__(self):
17990 
    L = ['%s=%r' % (key, value)
17991 
      for key, value in self.__dict__.iteritems()]
17992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17993 
 
17994 
  def __eq__(self, other):
17995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17996 
 
17997 
  def __ne__(self, other):
17998 
    return not (self == other)
17999 
 
18000 
class validateDoa_args:
18001 
  """
18002 
  Attributes:
18003 
   - orderId
18004 
   - isValid
18005 
  """
18006 
 
18007 
  thrift_spec = (
18008 
    None, # 0
18009 
    (1, TType.I64, 'orderId', None, None, ), # 1
18010 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
18011 
  )
18012 
 
18013 
  def __init__(self, orderId=None, isValid=None,):
18014 
    self.orderId = orderId
18015 
    self.isValid = isValid
18016 
 
18017 
  def read(self, iprot):
18018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18020 
      return
18021 
    iprot.readStructBegin()
18022 
    while True:
18023 
      (fname, ftype, fid) = iprot.readFieldBegin()
18024 
      if ftype == TType.STOP:
18025 
        break
18026 
      if fid == 1:
18027 
        if ftype == TType.I64:
18028 
          self.orderId = iprot.readI64();
18029 
        else:
18030 
          iprot.skip(ftype)
18031 
      elif fid == 2:
18032 
        if ftype == TType.BOOL:
18033 
          self.isValid = iprot.readBool();
18034 
        else:
18035 
          iprot.skip(ftype)
18036 
      else:
18037 
        iprot.skip(ftype)
18038 
      iprot.readFieldEnd()
18039 
    iprot.readStructEnd()
18040 
 
18041 
  def write(self, oprot):
18042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18044 
      return
18045 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 18046 
    if self.orderId is not None:
2591 chandransh 18047 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18048 
      oprot.writeI64(self.orderId)
18049 
      oprot.writeFieldEnd()
3431 rajveer 18050 
    if self.isValid is not None:
2591 chandransh 18051 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
18052 
      oprot.writeBool(self.isValid)
18053 
      oprot.writeFieldEnd()
18054 
    oprot.writeFieldStop()
18055 
    oprot.writeStructEnd()
18056 
 
3431 rajveer 18057 
  def validate(self):
18058 
    return
18059 
 
18060 
 
2591 chandransh 18061 
  def __repr__(self):
18062 
    L = ['%s=%r' % (key, value)
18063 
      for key, value in self.__dict__.iteritems()]
18064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18065 
 
18066 
  def __eq__(self, other):
18067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18068 
 
18069 
  def __ne__(self, other):
18070 
    return not (self == other)
18071 
 
18072 
class validateDoa_result:
18073 
  """
18074 
  Attributes:
18075 
   - success
18076 
   - ex
18077 
  """
18078 
 
18079 
  thrift_spec = (
18080 
    (0, TType.BOOL, 'success', None, None, ), # 0
18081 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18082 
  )
18083 
 
18084 
  def __init__(self, success=None, ex=None,):
18085 
    self.success = success
18086 
    self.ex = ex
18087 
 
18088 
  def read(self, iprot):
18089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18091 
      return
18092 
    iprot.readStructBegin()
18093 
    while True:
18094 
      (fname, ftype, fid) = iprot.readFieldBegin()
18095 
      if ftype == TType.STOP:
18096 
        break
18097 
      if fid == 0:
18098 
        if ftype == TType.BOOL:
18099 
          self.success = iprot.readBool();
18100 
        else:
18101 
          iprot.skip(ftype)
18102 
      elif fid == 1:
18103 
        if ftype == TType.STRUCT:
18104 
          self.ex = TransactionServiceException()
18105 
          self.ex.read(iprot)
18106 
        else:
18107 
          iprot.skip(ftype)
18108 
      else:
18109 
        iprot.skip(ftype)
18110 
      iprot.readFieldEnd()
18111 
    iprot.readStructEnd()
18112 
 
18113 
  def write(self, oprot):
18114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18116 
      return
18117 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 18118 
    if self.success is not None:
2591 chandransh 18119 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18120 
      oprot.writeBool(self.success)
18121 
      oprot.writeFieldEnd()
3431 rajveer 18122 
    if self.ex is not None:
2591 chandransh 18123 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18124 
      self.ex.write(oprot)
18125 
      oprot.writeFieldEnd()
18126 
    oprot.writeFieldStop()
18127 
    oprot.writeStructEnd()
18128 
 
3431 rajveer 18129 
  def validate(self):
18130 
    return
18131 
 
18132 
 
2591 chandransh 18133 
  def __repr__(self):
18134 
    L = ['%s=%r' % (key, value)
18135 
      for key, value in self.__dict__.iteritems()]
18136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18137 
 
18138 
  def __eq__(self, other):
18139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18140 
 
18141 
  def __ne__(self, other):
18142 
    return not (self == other)
18143 
 
4495 rajveer 18144 
class validateReturnProduct_args:
18145 
  """
18146 
  Attributes:
18147 
   - orderId
18148 
   - isUsable
18149 
  """
18150 
 
18151 
  thrift_spec = (
18152 
    None, # 0
18153 
    (1, TType.I64, 'orderId', None, None, ), # 1
18154 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
18155 
  )
18156 
 
18157 
  def __init__(self, orderId=None, isUsable=None,):
18158 
    self.orderId = orderId
18159 
    self.isUsable = isUsable
18160 
 
18161 
  def read(self, iprot):
18162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18164 
      return
18165 
    iprot.readStructBegin()
18166 
    while True:
18167 
      (fname, ftype, fid) = iprot.readFieldBegin()
18168 
      if ftype == TType.STOP:
18169 
        break
18170 
      if fid == 1:
18171 
        if ftype == TType.I64:
18172 
          self.orderId = iprot.readI64();
18173 
        else:
18174 
          iprot.skip(ftype)
18175 
      elif fid == 2:
18176 
        if ftype == TType.BOOL:
18177 
          self.isUsable = iprot.readBool();
18178 
        else:
18179 
          iprot.skip(ftype)
18180 
      else:
18181 
        iprot.skip(ftype)
18182 
      iprot.readFieldEnd()
18183 
    iprot.readStructEnd()
18184 
 
18185 
  def write(self, oprot):
18186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18188 
      return
18189 
    oprot.writeStructBegin('validateReturnProduct_args')
18190 
    if self.orderId is not None:
18191 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18192 
      oprot.writeI64(self.orderId)
18193 
      oprot.writeFieldEnd()
18194 
    if self.isUsable is not None:
18195 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
18196 
      oprot.writeBool(self.isUsable)
18197 
      oprot.writeFieldEnd()
18198 
    oprot.writeFieldStop()
18199 
    oprot.writeStructEnd()
18200 
 
18201 
  def validate(self):
18202 
    return
18203 
 
18204 
 
18205 
  def __repr__(self):
18206 
    L = ['%s=%r' % (key, value)
18207 
      for key, value in self.__dict__.iteritems()]
18208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18209 
 
18210 
  def __eq__(self, other):
18211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18212 
 
18213 
  def __ne__(self, other):
18214 
    return not (self == other)
18215 
 
18216 
class validateReturnProduct_result:
18217 
  """
18218 
  Attributes:
18219 
   - success
18220 
   - ex
18221 
  """
18222 
 
18223 
  thrift_spec = (
18224 
    (0, TType.BOOL, 'success', None, None, ), # 0
18225 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18226 
  )
18227 
 
18228 
  def __init__(self, success=None, ex=None,):
18229 
    self.success = success
18230 
    self.ex = ex
18231 
 
18232 
  def read(self, iprot):
18233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18235 
      return
18236 
    iprot.readStructBegin()
18237 
    while True:
18238 
      (fname, ftype, fid) = iprot.readFieldBegin()
18239 
      if ftype == TType.STOP:
18240 
        break
18241 
      if fid == 0:
18242 
        if ftype == TType.BOOL:
18243 
          self.success = iprot.readBool();
18244 
        else:
18245 
          iprot.skip(ftype)
18246 
      elif fid == 1:
18247 
        if ftype == TType.STRUCT:
18248 
          self.ex = TransactionServiceException()
18249 
          self.ex.read(iprot)
18250 
        else:
18251 
          iprot.skip(ftype)
18252 
      else:
18253 
        iprot.skip(ftype)
18254 
      iprot.readFieldEnd()
18255 
    iprot.readStructEnd()
18256 
 
18257 
  def write(self, oprot):
18258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18260 
      return
18261 
    oprot.writeStructBegin('validateReturnProduct_result')
18262 
    if self.success is not None:
18263 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18264 
      oprot.writeBool(self.success)
18265 
      oprot.writeFieldEnd()
18266 
    if self.ex is not None:
18267 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18268 
      self.ex.write(oprot)
18269 
      oprot.writeFieldEnd()
18270 
    oprot.writeFieldStop()
18271 
    oprot.writeStructEnd()
18272 
 
18273 
  def validate(self):
18274 
    return
18275 
 
18276 
 
18277 
  def __repr__(self):
18278 
    L = ['%s=%r' % (key, value)
18279 
      for key, value in self.__dict__.iteritems()]
18280 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18281 
 
18282 
  def __eq__(self, other):
18283 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18284 
 
18285 
  def __ne__(self, other):
18286 
    return not (self == other)
18287 
 
2616 chandransh 18288 
class reshipOrder_args:
18289 
  """
18290 
  Attributes:
18291 
   - orderId
18292 
  """
2591 chandransh 18293 
 
2616 chandransh 18294 
  thrift_spec = (
18295 
    None, # 0
18296 
    (1, TType.I64, 'orderId', None, None, ), # 1
18297 
  )
18298 
 
18299 
  def __init__(self, orderId=None,):
18300 
    self.orderId = orderId
18301 
 
18302 
  def read(self, iprot):
18303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18305 
      return
18306 
    iprot.readStructBegin()
18307 
    while True:
18308 
      (fname, ftype, fid) = iprot.readFieldBegin()
18309 
      if ftype == TType.STOP:
18310 
        break
18311 
      if fid == 1:
18312 
        if ftype == TType.I64:
18313 
          self.orderId = iprot.readI64();
18314 
        else:
18315 
          iprot.skip(ftype)
18316 
      else:
18317 
        iprot.skip(ftype)
18318 
      iprot.readFieldEnd()
18319 
    iprot.readStructEnd()
18320 
 
18321 
  def write(self, oprot):
18322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18324 
      return
18325 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 18326 
    if self.orderId is not None:
2616 chandransh 18327 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18328 
      oprot.writeI64(self.orderId)
18329 
      oprot.writeFieldEnd()
18330 
    oprot.writeFieldStop()
18331 
    oprot.writeStructEnd()
18332 
 
3431 rajveer 18333 
  def validate(self):
18334 
    return
18335 
 
18336 
 
2616 chandransh 18337 
  def __repr__(self):
18338 
    L = ['%s=%r' % (key, value)
18339 
      for key, value in self.__dict__.iteritems()]
18340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18341 
 
18342 
  def __eq__(self, other):
18343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18344 
 
18345 
  def __ne__(self, other):
18346 
    return not (self == other)
18347 
 
18348 
class reshipOrder_result:
18349 
  """
18350 
  Attributes:
18351 
   - success
18352 
   - ex
18353 
  """
18354 
 
18355 
  thrift_spec = (
18356 
    (0, TType.I64, 'success', None, None, ), # 0
18357 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18358 
  )
18359 
 
18360 
  def __init__(self, success=None, ex=None,):
18361 
    self.success = success
18362 
    self.ex = ex
18363 
 
18364 
  def read(self, iprot):
18365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18367 
      return
18368 
    iprot.readStructBegin()
18369 
    while True:
18370 
      (fname, ftype, fid) = iprot.readFieldBegin()
18371 
      if ftype == TType.STOP:
18372 
        break
18373 
      if fid == 0:
18374 
        if ftype == TType.I64:
18375 
          self.success = iprot.readI64();
18376 
        else:
18377 
          iprot.skip(ftype)
18378 
      elif fid == 1:
18379 
        if ftype == TType.STRUCT:
18380 
          self.ex = TransactionServiceException()
18381 
          self.ex.read(iprot)
18382 
        else:
18383 
          iprot.skip(ftype)
18384 
      else:
18385 
        iprot.skip(ftype)
18386 
      iprot.readFieldEnd()
18387 
    iprot.readStructEnd()
18388 
 
18389 
  def write(self, oprot):
18390 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18391 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18392 
      return
18393 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 18394 
    if self.success is not None:
2616 chandransh 18395 
      oprot.writeFieldBegin('success', TType.I64, 0)
18396 
      oprot.writeI64(self.success)
18397 
      oprot.writeFieldEnd()
3431 rajveer 18398 
    if self.ex is not None:
2616 chandransh 18399 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18400 
      self.ex.write(oprot)
18401 
      oprot.writeFieldEnd()
18402 
    oprot.writeFieldStop()
18403 
    oprot.writeStructEnd()
18404 
 
3431 rajveer 18405 
  def validate(self):
18406 
    return
18407 
 
18408 
 
2616 chandransh 18409 
  def __repr__(self):
18410 
    L = ['%s=%r' % (key, value)
18411 
      for key, value in self.__dict__.iteritems()]
18412 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18413 
 
18414 
  def __eq__(self, other):
18415 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18416 
 
18417 
  def __ne__(self, other):
18418 
    return not (self == other)
18419 
 
18420 
class refundOrder_args:
18421 
  """
18422 
  Attributes:
18423 
   - orderId
3226 chandransh 18424 
   - refundedBy
18425 
   - reason
2616 chandransh 18426 
  """
18427 
 
18428 
  thrift_spec = (
18429 
    None, # 0
18430 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 18431 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18432 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 18433 
  )
18434 
 
3226 chandransh 18435 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 18436 
    self.orderId = orderId
3226 chandransh 18437 
    self.refundedBy = refundedBy
18438 
    self.reason = reason
2616 chandransh 18439 
 
18440 
  def read(self, iprot):
18441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18443 
      return
18444 
    iprot.readStructBegin()
18445 
    while True:
18446 
      (fname, ftype, fid) = iprot.readFieldBegin()
18447 
      if ftype == TType.STOP:
18448 
        break
18449 
      if fid == 1:
18450 
        if ftype == TType.I64:
18451 
          self.orderId = iprot.readI64();
18452 
        else:
18453 
          iprot.skip(ftype)
3226 chandransh 18454 
      elif fid == 2:
18455 
        if ftype == TType.STRING:
18456 
          self.refundedBy = iprot.readString();
18457 
        else:
18458 
          iprot.skip(ftype)
18459 
      elif fid == 3:
18460 
        if ftype == TType.STRING:
18461 
          self.reason = iprot.readString();
18462 
        else:
18463 
          iprot.skip(ftype)
2616 chandransh 18464 
      else:
18465 
        iprot.skip(ftype)
18466 
      iprot.readFieldEnd()
18467 
    iprot.readStructEnd()
18468 
 
18469 
  def write(self, oprot):
18470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18472 
      return
18473 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 18474 
    if self.orderId is not None:
2616 chandransh 18475 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18476 
      oprot.writeI64(self.orderId)
18477 
      oprot.writeFieldEnd()
3431 rajveer 18478 
    if self.refundedBy is not None:
3226 chandransh 18479 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18480 
      oprot.writeString(self.refundedBy)
18481 
      oprot.writeFieldEnd()
3431 rajveer 18482 
    if self.reason is not None:
3226 chandransh 18483 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18484 
      oprot.writeString(self.reason)
18485 
      oprot.writeFieldEnd()
2616 chandransh 18486 
    oprot.writeFieldStop()
18487 
    oprot.writeStructEnd()
18488 
 
3431 rajveer 18489 
  def validate(self):
18490 
    return
18491 
 
18492 
 
2616 chandransh 18493 
  def __repr__(self):
18494 
    L = ['%s=%r' % (key, value)
18495 
      for key, value in self.__dict__.iteritems()]
18496 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18497 
 
18498 
  def __eq__(self, other):
18499 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18500 
 
18501 
  def __ne__(self, other):
18502 
    return not (self == other)
18503 
 
18504 
class refundOrder_result:
18505 
  """
18506 
  Attributes:
18507 
   - success
18508 
   - ex
18509 
  """
18510 
 
18511 
  thrift_spec = (
18512 
    (0, TType.BOOL, 'success', None, None, ), # 0
18513 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18514 
  )
18515 
 
18516 
  def __init__(self, success=None, ex=None,):
18517 
    self.success = success
18518 
    self.ex = ex
18519 
 
18520 
  def read(self, iprot):
18521 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18522 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18523 
      return
18524 
    iprot.readStructBegin()
18525 
    while True:
18526 
      (fname, ftype, fid) = iprot.readFieldBegin()
18527 
      if ftype == TType.STOP:
18528 
        break
18529 
      if fid == 0:
18530 
        if ftype == TType.BOOL:
18531 
          self.success = iprot.readBool();
18532 
        else:
18533 
          iprot.skip(ftype)
18534 
      elif fid == 1:
18535 
        if ftype == TType.STRUCT:
18536 
          self.ex = TransactionServiceException()
18537 
          self.ex.read(iprot)
18538 
        else:
18539 
          iprot.skip(ftype)
18540 
      else:
18541 
        iprot.skip(ftype)
18542 
      iprot.readFieldEnd()
18543 
    iprot.readStructEnd()
18544 
 
18545 
  def write(self, oprot):
18546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18548 
      return
18549 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 18550 
    if self.success is not None:
2616 chandransh 18551 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18552 
      oprot.writeBool(self.success)
18553 
      oprot.writeFieldEnd()
3431 rajveer 18554 
    if self.ex is not None:
2616 chandransh 18555 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18556 
      self.ex.write(oprot)
18557 
      oprot.writeFieldEnd()
18558 
    oprot.writeFieldStop()
18559 
    oprot.writeStructEnd()
18560 
 
3431 rajveer 18561 
  def validate(self):
18562 
    return
18563 
 
18564 
 
2616 chandransh 18565 
  def __repr__(self):
18566 
    L = ['%s=%r' % (key, value)
18567 
      for key, value in self.__dict__.iteritems()]
18568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18569 
 
18570 
  def __eq__(self, other):
18571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18572 
 
18573 
  def __ne__(self, other):
18574 
    return not (self == other)
18575 
 
2690 chandransh 18576 
class getReturnOrders_args:
18577 
  """
18578 
  Attributes:
18579 
   - warehouseId
18580 
   - fromDate
18581 
   - toDate
18582 
  """
2616 chandransh 18583 
 
2690 chandransh 18584 
  thrift_spec = (
18585 
    None, # 0
18586 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
18587 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18588 
    (3, TType.I64, 'toDate', None, None, ), # 3
18589 
  )
18590 
 
18591 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
18592 
    self.warehouseId = warehouseId
18593 
    self.fromDate = fromDate
18594 
    self.toDate = toDate
18595 
 
18596 
  def read(self, iprot):
18597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18599 
      return
18600 
    iprot.readStructBegin()
18601 
    while True:
18602 
      (fname, ftype, fid) = iprot.readFieldBegin()
18603 
      if ftype == TType.STOP:
18604 
        break
18605 
      if fid == 1:
18606 
        if ftype == TType.I64:
18607 
          self.warehouseId = iprot.readI64();
18608 
        else:
18609 
          iprot.skip(ftype)
18610 
      elif fid == 2:
18611 
        if ftype == TType.I64:
18612 
          self.fromDate = iprot.readI64();
18613 
        else:
18614 
          iprot.skip(ftype)
18615 
      elif fid == 3:
18616 
        if ftype == TType.I64:
18617 
          self.toDate = iprot.readI64();
18618 
        else:
18619 
          iprot.skip(ftype)
18620 
      else:
18621 
        iprot.skip(ftype)
18622 
      iprot.readFieldEnd()
18623 
    iprot.readStructEnd()
18624 
 
18625 
  def write(self, oprot):
18626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18628 
      return
18629 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 18630 
    if self.warehouseId is not None:
2690 chandransh 18631 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
18632 
      oprot.writeI64(self.warehouseId)
18633 
      oprot.writeFieldEnd()
3431 rajveer 18634 
    if self.fromDate is not None:
2690 chandransh 18635 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18636 
      oprot.writeI64(self.fromDate)
18637 
      oprot.writeFieldEnd()
3431 rajveer 18638 
    if self.toDate is not None:
2690 chandransh 18639 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18640 
      oprot.writeI64(self.toDate)
18641 
      oprot.writeFieldEnd()
18642 
    oprot.writeFieldStop()
18643 
    oprot.writeStructEnd()
18644 
 
3431 rajveer 18645 
  def validate(self):
18646 
    return
18647 
 
18648 
 
2690 chandransh 18649 
  def __repr__(self):
18650 
    L = ['%s=%r' % (key, value)
18651 
      for key, value in self.__dict__.iteritems()]
18652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18653 
 
18654 
  def __eq__(self, other):
18655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18656 
 
18657 
  def __ne__(self, other):
18658 
    return not (self == other)
18659 
 
18660 
class getReturnOrders_result:
18661 
  """
18662 
  Attributes:
18663 
   - success
18664 
  """
18665 
 
18666 
  thrift_spec = (
18667 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18668 
  )
18669 
 
18670 
  def __init__(self, success=None,):
18671 
    self.success = success
18672 
 
18673 
  def read(self, iprot):
18674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18676 
      return
18677 
    iprot.readStructBegin()
18678 
    while True:
18679 
      (fname, ftype, fid) = iprot.readFieldBegin()
18680 
      if ftype == TType.STOP:
18681 
        break
18682 
      if fid == 0:
18683 
        if ftype == TType.LIST:
18684 
          self.success = []
6188 rajveer 18685 
          (_etype442, _size439) = iprot.readListBegin()
18686 
          for _i443 in xrange(_size439):
18687 
            _elem444 = ReturnOrder()
18688 
            _elem444.read(iprot)
18689 
            self.success.append(_elem444)
2690 chandransh 18690 
          iprot.readListEnd()
18691 
        else:
18692 
          iprot.skip(ftype)
18693 
      else:
18694 
        iprot.skip(ftype)
18695 
      iprot.readFieldEnd()
18696 
    iprot.readStructEnd()
18697 
 
18698 
  def write(self, oprot):
18699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18701 
      return
18702 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 18703 
    if self.success is not None:
2690 chandransh 18704 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18705 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18706 
      for iter445 in self.success:
18707 
        iter445.write(oprot)
2690 chandransh 18708 
      oprot.writeListEnd()
18709 
      oprot.writeFieldEnd()
18710 
    oprot.writeFieldStop()
18711 
    oprot.writeStructEnd()
18712 
 
3431 rajveer 18713 
  def validate(self):
18714 
    return
18715 
 
18716 
 
2690 chandransh 18717 
  def __repr__(self):
18718 
    L = ['%s=%r' % (key, value)
18719 
      for key, value in self.__dict__.iteritems()]
18720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18721 
 
18722 
  def __eq__(self, other):
18723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18724 
 
18725 
  def __ne__(self, other):
18726 
    return not (self == other)
18727 
 
5481 phani.kuma 18728 
class getAllReturnOrders_args:
18729 
  """
18730 
  Attributes:
18731 
   - onlyNotProcessed
18732 
   - fromDate
18733 
   - toDate
18734 
  """
18735 
 
18736 
  thrift_spec = (
18737 
    None, # 0
18738 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
18739 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18740 
    (3, TType.I64, 'toDate', None, None, ), # 3
18741 
  )
18742 
 
18743 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
18744 
    self.onlyNotProcessed = onlyNotProcessed
18745 
    self.fromDate = fromDate
18746 
    self.toDate = toDate
18747 
 
18748 
  def read(self, iprot):
18749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18751 
      return
18752 
    iprot.readStructBegin()
18753 
    while True:
18754 
      (fname, ftype, fid) = iprot.readFieldBegin()
18755 
      if ftype == TType.STOP:
18756 
        break
18757 
      if fid == 1:
18758 
        if ftype == TType.BOOL:
18759 
          self.onlyNotProcessed = iprot.readBool();
18760 
        else:
18761 
          iprot.skip(ftype)
18762 
      elif fid == 2:
18763 
        if ftype == TType.I64:
18764 
          self.fromDate = iprot.readI64();
18765 
        else:
18766 
          iprot.skip(ftype)
18767 
      elif fid == 3:
18768 
        if ftype == TType.I64:
18769 
          self.toDate = iprot.readI64();
18770 
        else:
18771 
          iprot.skip(ftype)
18772 
      else:
18773 
        iprot.skip(ftype)
18774 
      iprot.readFieldEnd()
18775 
    iprot.readStructEnd()
18776 
 
18777 
  def write(self, oprot):
18778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18780 
      return
18781 
    oprot.writeStructBegin('getAllReturnOrders_args')
18782 
    if self.onlyNotProcessed is not None:
18783 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
18784 
      oprot.writeBool(self.onlyNotProcessed)
18785 
      oprot.writeFieldEnd()
18786 
    if self.fromDate is not None:
18787 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18788 
      oprot.writeI64(self.fromDate)
18789 
      oprot.writeFieldEnd()
18790 
    if self.toDate is not None:
18791 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18792 
      oprot.writeI64(self.toDate)
18793 
      oprot.writeFieldEnd()
18794 
    oprot.writeFieldStop()
18795 
    oprot.writeStructEnd()
18796 
 
18797 
  def validate(self):
18798 
    return
18799 
 
18800 
 
18801 
  def __repr__(self):
18802 
    L = ['%s=%r' % (key, value)
18803 
      for key, value in self.__dict__.iteritems()]
18804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18805 
 
18806 
  def __eq__(self, other):
18807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18808 
 
18809 
  def __ne__(self, other):
18810 
    return not (self == other)
18811 
 
18812 
class getAllReturnOrders_result:
18813 
  """
18814 
  Attributes:
18815 
   - success
18816 
  """
18817 
 
18818 
  thrift_spec = (
18819 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18820 
  )
18821 
 
18822 
  def __init__(self, success=None,):
18823 
    self.success = success
18824 
 
18825 
  def read(self, iprot):
18826 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18827 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18828 
      return
18829 
    iprot.readStructBegin()
18830 
    while True:
18831 
      (fname, ftype, fid) = iprot.readFieldBegin()
18832 
      if ftype == TType.STOP:
18833 
        break
18834 
      if fid == 0:
18835 
        if ftype == TType.LIST:
18836 
          self.success = []
6188 rajveer 18837 
          (_etype449, _size446) = iprot.readListBegin()
18838 
          for _i450 in xrange(_size446):
18839 
            _elem451 = ReturnOrder()
18840 
            _elem451.read(iprot)
18841 
            self.success.append(_elem451)
5481 phani.kuma 18842 
          iprot.readListEnd()
18843 
        else:
18844 
          iprot.skip(ftype)
18845 
      else:
18846 
        iprot.skip(ftype)
18847 
      iprot.readFieldEnd()
18848 
    iprot.readStructEnd()
18849 
 
18850 
  def write(self, oprot):
18851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18853 
      return
18854 
    oprot.writeStructBegin('getAllReturnOrders_result')
18855 
    if self.success is not None:
18856 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18857 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18858 
      for iter452 in self.success:
18859 
        iter452.write(oprot)
5481 phani.kuma 18860 
      oprot.writeListEnd()
18861 
      oprot.writeFieldEnd()
18862 
    oprot.writeFieldStop()
18863 
    oprot.writeStructEnd()
18864 
 
18865 
  def validate(self):
18866 
    return
18867 
 
18868 
 
18869 
  def __repr__(self):
18870 
    L = ['%s=%r' % (key, value)
18871 
      for key, value in self.__dict__.iteritems()]
18872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18873 
 
18874 
  def __eq__(self, other):
18875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18876 
 
18877 
  def __ne__(self, other):
18878 
    return not (self == other)
18879 
 
2700 chandransh 18880 
class getReturnOrder_args:
18881 
  """
18882 
  Attributes:
18883 
   - id
18884 
  """
18885 
 
18886 
  thrift_spec = (
18887 
    None, # 0
18888 
    (1, TType.I64, 'id', None, None, ), # 1
18889 
  )
18890 
 
18891 
  def __init__(self, id=None,):
18892 
    self.id = id
18893 
 
18894 
  def read(self, iprot):
18895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18897 
      return
18898 
    iprot.readStructBegin()
18899 
    while True:
18900 
      (fname, ftype, fid) = iprot.readFieldBegin()
18901 
      if ftype == TType.STOP:
18902 
        break
18903 
      if fid == 1:
18904 
        if ftype == TType.I64:
18905 
          self.id = iprot.readI64();
18906 
        else:
18907 
          iprot.skip(ftype)
18908 
      else:
18909 
        iprot.skip(ftype)
18910 
      iprot.readFieldEnd()
18911 
    iprot.readStructEnd()
18912 
 
18913 
  def write(self, oprot):
18914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18916 
      return
18917 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 18918 
    if self.id is not None:
2700 chandransh 18919 
      oprot.writeFieldBegin('id', TType.I64, 1)
18920 
      oprot.writeI64(self.id)
18921 
      oprot.writeFieldEnd()
18922 
    oprot.writeFieldStop()
18923 
    oprot.writeStructEnd()
18924 
 
3431 rajveer 18925 
  def validate(self):
18926 
    return
18927 
 
18928 
 
2700 chandransh 18929 
  def __repr__(self):
18930 
    L = ['%s=%r' % (key, value)
18931 
      for key, value in self.__dict__.iteritems()]
18932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18933 
 
18934 
  def __eq__(self, other):
18935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18936 
 
18937 
  def __ne__(self, other):
18938 
    return not (self == other)
18939 
 
18940 
class getReturnOrder_result:
18941 
  """
18942 
  Attributes:
18943 
   - success
18944 
   - ex
18945 
  """
18946 
 
18947 
  thrift_spec = (
18948 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
18949 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18950 
  )
18951 
 
18952 
  def __init__(self, success=None, ex=None,):
18953 
    self.success = success
18954 
    self.ex = ex
18955 
 
18956 
  def read(self, iprot):
18957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18959 
      return
18960 
    iprot.readStructBegin()
18961 
    while True:
18962 
      (fname, ftype, fid) = iprot.readFieldBegin()
18963 
      if ftype == TType.STOP:
18964 
        break
18965 
      if fid == 0:
18966 
        if ftype == TType.STRUCT:
18967 
          self.success = ReturnOrder()
18968 
          self.success.read(iprot)
18969 
        else:
18970 
          iprot.skip(ftype)
18971 
      elif fid == 1:
18972 
        if ftype == TType.STRUCT:
18973 
          self.ex = TransactionServiceException()
18974 
          self.ex.read(iprot)
18975 
        else:
18976 
          iprot.skip(ftype)
18977 
      else:
18978 
        iprot.skip(ftype)
18979 
      iprot.readFieldEnd()
18980 
    iprot.readStructEnd()
18981 
 
18982 
  def write(self, oprot):
18983 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18984 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18985 
      return
18986 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 18987 
    if self.success is not None:
2700 chandransh 18988 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
18989 
      self.success.write(oprot)
18990 
      oprot.writeFieldEnd()
3431 rajveer 18991 
    if self.ex is not None:
2700 chandransh 18992 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18993 
      self.ex.write(oprot)
18994 
      oprot.writeFieldEnd()
18995 
    oprot.writeFieldStop()
18996 
    oprot.writeStructEnd()
18997 
 
3431 rajveer 18998 
  def validate(self):
18999 
    return
19000 
 
19001 
 
2700 chandransh 19002 
  def __repr__(self):
19003 
    L = ['%s=%r' % (key, value)
19004 
      for key, value in self.__dict__.iteritems()]
19005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19006 
 
19007 
  def __eq__(self, other):
19008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19009 
 
19010 
  def __ne__(self, other):
19011 
    return not (self == other)
19012 
 
2690 chandransh 19013 
class processReturn_args:
19014 
  """
19015 
  Attributes:
19016 
   - returnOrderId
19017 
  """
19018 
 
19019 
  thrift_spec = (
19020 
    None, # 0
19021 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
19022 
  )
19023 
 
19024 
  def __init__(self, returnOrderId=None,):
19025 
    self.returnOrderId = returnOrderId
19026 
 
19027 
  def read(self, iprot):
19028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19030 
      return
19031 
    iprot.readStructBegin()
19032 
    while True:
19033 
      (fname, ftype, fid) = iprot.readFieldBegin()
19034 
      if ftype == TType.STOP:
19035 
        break
19036 
      if fid == 1:
19037 
        if ftype == TType.I64:
19038 
          self.returnOrderId = iprot.readI64();
19039 
        else:
19040 
          iprot.skip(ftype)
19041 
      else:
19042 
        iprot.skip(ftype)
19043 
      iprot.readFieldEnd()
19044 
    iprot.readStructEnd()
19045 
 
19046 
  def write(self, oprot):
19047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19049 
      return
19050 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 19051 
    if self.returnOrderId is not None:
2690 chandransh 19052 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
19053 
      oprot.writeI64(self.returnOrderId)
19054 
      oprot.writeFieldEnd()
19055 
    oprot.writeFieldStop()
19056 
    oprot.writeStructEnd()
19057 
 
3431 rajveer 19058 
  def validate(self):
19059 
    return
19060 
 
19061 
 
2690 chandransh 19062 
  def __repr__(self):
19063 
    L = ['%s=%r' % (key, value)
19064 
      for key, value in self.__dict__.iteritems()]
19065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19066 
 
19067 
  def __eq__(self, other):
19068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19069 
 
19070 
  def __ne__(self, other):
19071 
    return not (self == other)
19072 
 
19073 
class processReturn_result:
19074 
  """
19075 
  Attributes:
19076 
   - ex
19077 
  """
19078 
 
19079 
  thrift_spec = (
19080 
    None, # 0
19081 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19082 
  )
19083 
 
19084 
  def __init__(self, ex=None,):
19085 
    self.ex = ex
19086 
 
19087 
  def read(self, iprot):
19088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19090 
      return
19091 
    iprot.readStructBegin()
19092 
    while True:
19093 
      (fname, ftype, fid) = iprot.readFieldBegin()
19094 
      if ftype == TType.STOP:
19095 
        break
19096 
      if fid == 1:
19097 
        if ftype == TType.STRUCT:
19098 
          self.ex = TransactionServiceException()
19099 
          self.ex.read(iprot)
19100 
        else:
19101 
          iprot.skip(ftype)
19102 
      else:
19103 
        iprot.skip(ftype)
19104 
      iprot.readFieldEnd()
19105 
    iprot.readStructEnd()
19106 
 
19107 
  def write(self, oprot):
19108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19110 
      return
19111 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 19112 
    if self.ex is not None:
2690 chandransh 19113 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19114 
      self.ex.write(oprot)
19115 
      oprot.writeFieldEnd()
19116 
    oprot.writeFieldStop()
19117 
    oprot.writeStructEnd()
19118 
 
3431 rajveer 19119 
  def validate(self):
19120 
    return
19121 
 
19122 
 
2690 chandransh 19123 
  def __repr__(self):
19124 
    L = ['%s=%r' % (key, value)
19125 
      for key, value in self.__dict__.iteritems()]
19126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19127 
 
19128 
  def __eq__(self, other):
19129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19130 
 
19131 
  def __ne__(self, other):
19132 
    return not (self == other)
19133 
 
3451 chandransh 19134 
class updateWeight_args:
19135 
  """
19136 
  Attributes:
19137 
   - orderId
19138 
   - weight
19139 
  """
19140 
 
19141 
  thrift_spec = (
19142 
    None, # 0
19143 
    (1, TType.I64, 'orderId', None, None, ), # 1
19144 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
19145 
  )
19146 
 
19147 
  def __init__(self, orderId=None, weight=None,):
19148 
    self.orderId = orderId
19149 
    self.weight = weight
19150 
 
19151 
  def read(self, iprot):
19152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19154 
      return
19155 
    iprot.readStructBegin()
19156 
    while True:
19157 
      (fname, ftype, fid) = iprot.readFieldBegin()
19158 
      if ftype == TType.STOP:
19159 
        break
19160 
      if fid == 1:
19161 
        if ftype == TType.I64:
19162 
          self.orderId = iprot.readI64();
19163 
        else:
19164 
          iprot.skip(ftype)
19165 
      elif fid == 2:
19166 
        if ftype == TType.DOUBLE:
19167 
          self.weight = iprot.readDouble();
19168 
        else:
19169 
          iprot.skip(ftype)
19170 
      else:
19171 
        iprot.skip(ftype)
19172 
      iprot.readFieldEnd()
19173 
    iprot.readStructEnd()
19174 
 
19175 
  def write(self, oprot):
19176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19178 
      return
19179 
    oprot.writeStructBegin('updateWeight_args')
19180 
    if self.orderId is not None:
19181 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19182 
      oprot.writeI64(self.orderId)
19183 
      oprot.writeFieldEnd()
19184 
    if self.weight is not None:
19185 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
19186 
      oprot.writeDouble(self.weight)
19187 
      oprot.writeFieldEnd()
19188 
    oprot.writeFieldStop()
19189 
    oprot.writeStructEnd()
19190 
 
19191 
  def validate(self):
19192 
    return
19193 
 
19194 
 
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 updateWeight_result:
19207 
  """
19208 
  Attributes:
19209 
   - success
19210 
   - ex
19211 
  """
19212 
 
19213 
  thrift_spec = (
19214 
    (0, TType.STRUCT, 'success', (Order, Order.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 = Order()
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('updateWeight_result')
19253 
    if self.success is not None:
19254 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19255 
      self.success.write(oprot)
19256 
      oprot.writeFieldEnd()
19257 
    if self.ex is not None:
19258 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19259 
      self.ex.write(oprot)
19260 
      oprot.writeFieldEnd()
19261 
    oprot.writeFieldStop()
19262 
    oprot.writeStructEnd()
19263 
 
19264 
  def validate(self):
19265 
    return
19266 
 
19267 
 
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)
3469 chandransh 19278 
 
19279 
class changeItem_args:
19280 
  """
19281 
  Attributes:
19282 
   - orderId
19283 
   - itemId
19284 
  """
19285 
 
19286 
  thrift_spec = (
19287 
    None, # 0
19288 
    (1, TType.I64, 'orderId', None, None, ), # 1
19289 
    (2, TType.I64, 'itemId', None, None, ), # 2
19290 
  )
19291 
 
19292 
  def __init__(self, orderId=None, itemId=None,):
19293 
    self.orderId = orderId
19294 
    self.itemId = itemId
19295 
 
19296 
  def read(self, iprot):
19297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19299 
      return
19300 
    iprot.readStructBegin()
19301 
    while True:
19302 
      (fname, ftype, fid) = iprot.readFieldBegin()
19303 
      if ftype == TType.STOP:
19304 
        break
19305 
      if fid == 1:
19306 
        if ftype == TType.I64:
19307 
          self.orderId = iprot.readI64();
19308 
        else:
19309 
          iprot.skip(ftype)
19310 
      elif fid == 2:
19311 
        if ftype == TType.I64:
19312 
          self.itemId = iprot.readI64();
19313 
        else:
19314 
          iprot.skip(ftype)
19315 
      else:
19316 
        iprot.skip(ftype)
19317 
      iprot.readFieldEnd()
19318 
    iprot.readStructEnd()
19319 
 
19320 
  def write(self, oprot):
19321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19323 
      return
19324 
    oprot.writeStructBegin('changeItem_args')
19325 
    if self.orderId is not None:
19326 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19327 
      oprot.writeI64(self.orderId)
19328 
      oprot.writeFieldEnd()
19329 
    if self.itemId is not None:
19330 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19331 
      oprot.writeI64(self.itemId)
19332 
      oprot.writeFieldEnd()
19333 
    oprot.writeFieldStop()
19334 
    oprot.writeStructEnd()
19335 
 
19336 
  def validate(self):
19337 
    return
19338 
 
19339 
 
19340 
  def __repr__(self):
19341 
    L = ['%s=%r' % (key, value)
19342 
      for key, value in self.__dict__.iteritems()]
19343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19344 
 
19345 
  def __eq__(self, other):
19346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19347 
 
19348 
  def __ne__(self, other):
19349 
    return not (self == other)
19350 
 
19351 
class changeItem_result:
19352 
  """
19353 
  Attributes:
19354 
   - success
19355 
   - ex
19356 
  """
19357 
 
19358 
  thrift_spec = (
19359 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19360 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19361 
  )
19362 
 
19363 
  def __init__(self, success=None, ex=None,):
19364 
    self.success = success
19365 
    self.ex = ex
19366 
 
19367 
  def read(self, iprot):
19368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19370 
      return
19371 
    iprot.readStructBegin()
19372 
    while True:
19373 
      (fname, ftype, fid) = iprot.readFieldBegin()
19374 
      if ftype == TType.STOP:
19375 
        break
19376 
      if fid == 0:
19377 
        if ftype == TType.STRUCT:
19378 
          self.success = Order()
19379 
          self.success.read(iprot)
19380 
        else:
19381 
          iprot.skip(ftype)
19382 
      elif fid == 1:
19383 
        if ftype == TType.STRUCT:
19384 
          self.ex = TransactionServiceException()
19385 
          self.ex.read(iprot)
19386 
        else:
19387 
          iprot.skip(ftype)
19388 
      else:
19389 
        iprot.skip(ftype)
19390 
      iprot.readFieldEnd()
19391 
    iprot.readStructEnd()
19392 
 
19393 
  def write(self, oprot):
19394 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19395 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19396 
      return
19397 
    oprot.writeStructBegin('changeItem_result')
19398 
    if self.success is not None:
19399 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19400 
      self.success.write(oprot)
19401 
      oprot.writeFieldEnd()
19402 
    if self.ex is not None:
19403 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19404 
      self.ex.write(oprot)
19405 
      oprot.writeFieldEnd()
19406 
    oprot.writeFieldStop()
19407 
    oprot.writeStructEnd()
19408 
 
19409 
  def validate(self):
19410 
    return
19411 
 
19412 
 
19413 
  def __repr__(self):
19414 
    L = ['%s=%r' % (key, value)
19415 
      for key, value in self.__dict__.iteritems()]
19416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19417 
 
19418 
  def __eq__(self, other):
19419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19420 
 
19421 
  def __ne__(self, other):
19422 
    return not (self == other)
19423 
 
19424 
class shiftToWarehouse_args:
19425 
  """
19426 
  Attributes:
19427 
   - orderId
19428 
   - warehouseId
19429 
  """
19430 
 
19431 
  thrift_spec = (
19432 
    None, # 0
19433 
    (1, TType.I64, 'orderId', None, None, ), # 1
19434 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
19435 
  )
19436 
 
19437 
  def __init__(self, orderId=None, warehouseId=None,):
19438 
    self.orderId = orderId
19439 
    self.warehouseId = warehouseId
19440 
 
19441 
  def read(self, iprot):
19442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19444 
      return
19445 
    iprot.readStructBegin()
19446 
    while True:
19447 
      (fname, ftype, fid) = iprot.readFieldBegin()
19448 
      if ftype == TType.STOP:
19449 
        break
19450 
      if fid == 1:
19451 
        if ftype == TType.I64:
19452 
          self.orderId = iprot.readI64();
19453 
        else:
19454 
          iprot.skip(ftype)
19455 
      elif fid == 2:
19456 
        if ftype == TType.I64:
19457 
          self.warehouseId = iprot.readI64();
19458 
        else:
19459 
          iprot.skip(ftype)
19460 
      else:
19461 
        iprot.skip(ftype)
19462 
      iprot.readFieldEnd()
19463 
    iprot.readStructEnd()
19464 
 
19465 
  def write(self, oprot):
19466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19468 
      return
19469 
    oprot.writeStructBegin('shiftToWarehouse_args')
19470 
    if self.orderId is not None:
19471 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19472 
      oprot.writeI64(self.orderId)
19473 
      oprot.writeFieldEnd()
19474 
    if self.warehouseId is not None:
19475 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
19476 
      oprot.writeI64(self.warehouseId)
19477 
      oprot.writeFieldEnd()
19478 
    oprot.writeFieldStop()
19479 
    oprot.writeStructEnd()
19480 
 
19481 
  def validate(self):
19482 
    return
19483 
 
19484 
 
19485 
  def __repr__(self):
19486 
    L = ['%s=%r' % (key, value)
19487 
      for key, value in self.__dict__.iteritems()]
19488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19489 
 
19490 
  def __eq__(self, other):
19491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19492 
 
19493 
  def __ne__(self, other):
19494 
    return not (self == other)
19495 
 
19496 
class shiftToWarehouse_result:
19497 
  """
19498 
  Attributes:
19499 
   - success
19500 
   - ex
19501 
  """
19502 
 
19503 
  thrift_spec = (
19504 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19505 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19506 
  )
19507 
 
19508 
  def __init__(self, success=None, ex=None,):
19509 
    self.success = success
19510 
    self.ex = ex
19511 
 
19512 
  def read(self, iprot):
19513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19515 
      return
19516 
    iprot.readStructBegin()
19517 
    while True:
19518 
      (fname, ftype, fid) = iprot.readFieldBegin()
19519 
      if ftype == TType.STOP:
19520 
        break
19521 
      if fid == 0:
19522 
        if ftype == TType.STRUCT:
19523 
          self.success = Order()
19524 
          self.success.read(iprot)
19525 
        else:
19526 
          iprot.skip(ftype)
19527 
      elif fid == 1:
19528 
        if ftype == TType.STRUCT:
19529 
          self.ex = TransactionServiceException()
19530 
          self.ex.read(iprot)
19531 
        else:
19532 
          iprot.skip(ftype)
19533 
      else:
19534 
        iprot.skip(ftype)
19535 
      iprot.readFieldEnd()
19536 
    iprot.readStructEnd()
19537 
 
19538 
  def write(self, oprot):
19539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19541 
      return
19542 
    oprot.writeStructBegin('shiftToWarehouse_result')
19543 
    if self.success is not None:
19544 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19545 
      self.success.write(oprot)
19546 
      oprot.writeFieldEnd()
19547 
    if self.ex is not None:
19548 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19549 
      self.ex.write(oprot)
19550 
      oprot.writeFieldEnd()
19551 
    oprot.writeFieldStop()
19552 
    oprot.writeStructEnd()
19553 
 
19554 
  def validate(self):
19555 
    return
19556 
 
19557 
 
19558 
  def __repr__(self):
19559 
    L = ['%s=%r' % (key, value)
19560 
      for key, value in self.__dict__.iteritems()]
19561 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19562 
 
19563 
  def __eq__(self, other):
19564 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19565 
 
19566 
  def __ne__(self, other):
19567 
    return not (self == other)
3553 chandransh 19568 
 
19569 
class addDelayReason_args:
19570 
  """
19571 
  Attributes:
19572 
   - orderId
19573 
   - delayReason
3986 chandransh 19574 
   - furtherDelay
4647 rajveer 19575 
   - delayReasonText
3553 chandransh 19576 
  """
19577 
 
19578 
  thrift_spec = (
19579 
    None, # 0
19580 
    (1, TType.I64, 'orderId', None, None, ), # 1
19581 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 19582 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 19583 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 19584 
  )
19585 
 
4647 rajveer 19586 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 19587 
    self.orderId = orderId
19588 
    self.delayReason = delayReason
3986 chandransh 19589 
    self.furtherDelay = furtherDelay
4647 rajveer 19590 
    self.delayReasonText = delayReasonText
3553 chandransh 19591 
 
19592 
  def read(self, iprot):
19593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19595 
      return
19596 
    iprot.readStructBegin()
19597 
    while True:
19598 
      (fname, ftype, fid) = iprot.readFieldBegin()
19599 
      if ftype == TType.STOP:
19600 
        break
19601 
      if fid == 1:
19602 
        if ftype == TType.I64:
19603 
          self.orderId = iprot.readI64();
19604 
        else:
19605 
          iprot.skip(ftype)
19606 
      elif fid == 2:
19607 
        if ftype == TType.I32:
19608 
          self.delayReason = iprot.readI32();
19609 
        else:
19610 
          iprot.skip(ftype)
3986 chandransh 19611 
      elif fid == 3:
19612 
        if ftype == TType.I64:
19613 
          self.furtherDelay = iprot.readI64();
19614 
        else:
19615 
          iprot.skip(ftype)
4647 rajveer 19616 
      elif fid == 4:
19617 
        if ftype == TType.STRING:
19618 
          self.delayReasonText = iprot.readString();
19619 
        else:
19620 
          iprot.skip(ftype)
3553 chandransh 19621 
      else:
19622 
        iprot.skip(ftype)
19623 
      iprot.readFieldEnd()
19624 
    iprot.readStructEnd()
19625 
 
19626 
  def write(self, oprot):
19627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19629 
      return
19630 
    oprot.writeStructBegin('addDelayReason_args')
19631 
    if self.orderId is not None:
19632 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19633 
      oprot.writeI64(self.orderId)
19634 
      oprot.writeFieldEnd()
19635 
    if self.delayReason is not None:
19636 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
19637 
      oprot.writeI32(self.delayReason)
19638 
      oprot.writeFieldEnd()
3986 chandransh 19639 
    if self.furtherDelay is not None:
19640 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
19641 
      oprot.writeI64(self.furtherDelay)
19642 
      oprot.writeFieldEnd()
4647 rajveer 19643 
    if self.delayReasonText is not None:
19644 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
19645 
      oprot.writeString(self.delayReasonText)
19646 
      oprot.writeFieldEnd()
3553 chandransh 19647 
    oprot.writeFieldStop()
19648 
    oprot.writeStructEnd()
19649 
 
19650 
  def validate(self):
19651 
    return
19652 
 
19653 
 
19654 
  def __repr__(self):
19655 
    L = ['%s=%r' % (key, value)
19656 
      for key, value in self.__dict__.iteritems()]
19657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19658 
 
19659 
  def __eq__(self, other):
19660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19661 
 
19662 
  def __ne__(self, other):
19663 
    return not (self == other)
19664 
 
19665 
class addDelayReason_result:
19666 
  """
19667 
  Attributes:
19668 
   - success
19669 
   - ex
19670 
  """
19671 
 
19672 
  thrift_spec = (
19673 
    (0, TType.BOOL, 'success', None, None, ), # 0
19674 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19675 
  )
19676 
 
19677 
  def __init__(self, success=None, ex=None,):
19678 
    self.success = success
19679 
    self.ex = ex
19680 
 
19681 
  def read(self, iprot):
19682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19684 
      return
19685 
    iprot.readStructBegin()
19686 
    while True:
19687 
      (fname, ftype, fid) = iprot.readFieldBegin()
19688 
      if ftype == TType.STOP:
19689 
        break
19690 
      if fid == 0:
19691 
        if ftype == TType.BOOL:
19692 
          self.success = iprot.readBool();
19693 
        else:
19694 
          iprot.skip(ftype)
19695 
      elif fid == 1:
19696 
        if ftype == TType.STRUCT:
19697 
          self.ex = TransactionServiceException()
19698 
          self.ex.read(iprot)
19699 
        else:
19700 
          iprot.skip(ftype)
19701 
      else:
19702 
        iprot.skip(ftype)
19703 
      iprot.readFieldEnd()
19704 
    iprot.readStructEnd()
19705 
 
19706 
  def write(self, oprot):
19707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19709 
      return
19710 
    oprot.writeStructBegin('addDelayReason_result')
19711 
    if self.success is not None:
19712 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19713 
      oprot.writeBool(self.success)
19714 
      oprot.writeFieldEnd()
19715 
    if self.ex is not None:
19716 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19717 
      self.ex.write(oprot)
19718 
      oprot.writeFieldEnd()
19719 
    oprot.writeFieldStop()
19720 
    oprot.writeStructEnd()
19721 
 
19722 
  def validate(self):
19723 
    return
19724 
 
19725 
 
19726 
  def __repr__(self):
19727 
    L = ['%s=%r' % (key, value)
19728 
      for key, value in self.__dict__.iteritems()]
19729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19730 
 
19731 
  def __eq__(self, other):
19732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19733 
 
19734 
  def __ne__(self, other):
19735 
    return not (self == other)
3956 chandransh 19736 
 
19737 
class reconcileCodCollection_args:
19738 
  """
19739 
  Attributes:
19740 
   - collectedAmountMap
19741 
   - xferBy
19742 
   - xferTxnId
19743 
   - xferDate
19744 
  """
19745 
 
19746 
  thrift_spec = (
19747 
    None, # 0
19748 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
19749 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
19750 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
19751 
    (4, TType.I64, 'xferDate', None, None, ), # 4
19752 
  )
19753 
 
19754 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
19755 
    self.collectedAmountMap = collectedAmountMap
19756 
    self.xferBy = xferBy
19757 
    self.xferTxnId = xferTxnId
19758 
    self.xferDate = xferDate
19759 
 
19760 
  def read(self, iprot):
19761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19763 
      return
19764 
    iprot.readStructBegin()
19765 
    while True:
19766 
      (fname, ftype, fid) = iprot.readFieldBegin()
19767 
      if ftype == TType.STOP:
19768 
        break
19769 
      if fid == 1:
19770 
        if ftype == TType.MAP:
19771 
          self.collectedAmountMap = {}
6188 rajveer 19772 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
19773 
          for _i457 in xrange(_size453):
19774 
            _key458 = iprot.readString();
19775 
            _val459 = iprot.readDouble();
19776 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 19777 
          iprot.readMapEnd()
19778 
        else:
19779 
          iprot.skip(ftype)
19780 
      elif fid == 2:
19781 
        if ftype == TType.STRING:
19782 
          self.xferBy = iprot.readString();
19783 
        else:
19784 
          iprot.skip(ftype)
19785 
      elif fid == 3:
19786 
        if ftype == TType.STRING:
19787 
          self.xferTxnId = iprot.readString();
19788 
        else:
19789 
          iprot.skip(ftype)
19790 
      elif fid == 4:
19791 
        if ftype == TType.I64:
19792 
          self.xferDate = iprot.readI64();
19793 
        else:
19794 
          iprot.skip(ftype)
19795 
      else:
19796 
        iprot.skip(ftype)
19797 
      iprot.readFieldEnd()
19798 
    iprot.readStructEnd()
19799 
 
19800 
  def write(self, oprot):
19801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19803 
      return
19804 
    oprot.writeStructBegin('reconcileCodCollection_args')
19805 
    if self.collectedAmountMap is not None:
19806 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
19807 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 19808 
      for kiter460,viter461 in self.collectedAmountMap.items():
19809 
        oprot.writeString(kiter460)
19810 
        oprot.writeDouble(viter461)
3956 chandransh 19811 
      oprot.writeMapEnd()
19812 
      oprot.writeFieldEnd()
19813 
    if self.xferBy is not None:
19814 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
19815 
      oprot.writeString(self.xferBy)
19816 
      oprot.writeFieldEnd()
19817 
    if self.xferTxnId is not None:
19818 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
19819 
      oprot.writeString(self.xferTxnId)
19820 
      oprot.writeFieldEnd()
19821 
    if self.xferDate is not None:
19822 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
19823 
      oprot.writeI64(self.xferDate)
19824 
      oprot.writeFieldEnd()
19825 
    oprot.writeFieldStop()
19826 
    oprot.writeStructEnd()
19827 
 
19828 
  def validate(self):
19829 
    return
19830 
 
19831 
 
19832 
  def __repr__(self):
19833 
    L = ['%s=%r' % (key, value)
19834 
      for key, value in self.__dict__.iteritems()]
19835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19836 
 
19837 
  def __eq__(self, other):
19838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19839 
 
19840 
  def __ne__(self, other):
19841 
    return not (self == other)
19842 
 
19843 
class reconcileCodCollection_result:
19844 
  """
19845 
  Attributes:
19846 
   - success
19847 
   - ex
19848 
  """
19849 
 
19850 
  thrift_spec = (
19851 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
19852 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19853 
  )
19854 
 
19855 
  def __init__(self, success=None, ex=None,):
19856 
    self.success = success
19857 
    self.ex = ex
19858 
 
19859 
  def read(self, iprot):
19860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19862 
      return
19863 
    iprot.readStructBegin()
19864 
    while True:
19865 
      (fname, ftype, fid) = iprot.readFieldBegin()
19866 
      if ftype == TType.STOP:
19867 
        break
19868 
      if fid == 0:
19869 
        if ftype == TType.MAP:
19870 
          self.success = {}
6188 rajveer 19871 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
19872 
          for _i466 in xrange(_size462):
19873 
            _key467 = iprot.readString();
19874 
            _val468 = iprot.readString();
19875 
            self.success[_key467] = _val468
3956 chandransh 19876 
          iprot.readMapEnd()
19877 
        else:
19878 
          iprot.skip(ftype)
19879 
      elif fid == 1:
19880 
        if ftype == TType.STRUCT:
19881 
          self.ex = TransactionServiceException()
19882 
          self.ex.read(iprot)
19883 
        else:
19884 
          iprot.skip(ftype)
19885 
      else:
19886 
        iprot.skip(ftype)
19887 
      iprot.readFieldEnd()
19888 
    iprot.readStructEnd()
19889 
 
19890 
  def write(self, oprot):
19891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19893 
      return
19894 
    oprot.writeStructBegin('reconcileCodCollection_result')
19895 
    if self.success is not None:
19896 
      oprot.writeFieldBegin('success', TType.MAP, 0)
19897 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 19898 
      for kiter469,viter470 in self.success.items():
19899 
        oprot.writeString(kiter469)
19900 
        oprot.writeString(viter470)
3956 chandransh 19901 
      oprot.writeMapEnd()
19902 
      oprot.writeFieldEnd()
19903 
    if self.ex is not None:
19904 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19905 
      self.ex.write(oprot)
19906 
      oprot.writeFieldEnd()
19907 
    oprot.writeFieldStop()
19908 
    oprot.writeStructEnd()
19909 
 
19910 
  def validate(self):
19911 
    return
19912 
 
19913 
 
19914 
  def __repr__(self):
19915 
    L = ['%s=%r' % (key, value)
19916 
      for key, value in self.__dict__.iteritems()]
19917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19918 
 
19919 
  def __eq__(self, other):
19920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19921 
 
19922 
  def __ne__(self, other):
19923 
    return not (self == other)
4008 mandeep.dh 19924 
 
19925 
class getTransactionsRequiringExtraProcessing_args:
19926 
  """
19927 
  Attributes:
19928 
   - category
19929 
  """
19930 
 
19931 
  thrift_spec = (
19932 
    None, # 0
19933 
    (1, TType.I32, 'category', None, None, ), # 1
19934 
  )
19935 
 
19936 
  def __init__(self, category=None,):
19937 
    self.category = category
19938 
 
19939 
  def read(self, iprot):
19940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19942 
      return
19943 
    iprot.readStructBegin()
19944 
    while True:
19945 
      (fname, ftype, fid) = iprot.readFieldBegin()
19946 
      if ftype == TType.STOP:
19947 
        break
19948 
      if fid == 1:
19949 
        if ftype == TType.I32:
19950 
          self.category = iprot.readI32();
19951 
        else:
19952 
          iprot.skip(ftype)
19953 
      else:
19954 
        iprot.skip(ftype)
19955 
      iprot.readFieldEnd()
19956 
    iprot.readStructEnd()
19957 
 
19958 
  def write(self, oprot):
19959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19961 
      return
19962 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
19963 
    if self.category is not None:
19964 
      oprot.writeFieldBegin('category', TType.I32, 1)
19965 
      oprot.writeI32(self.category)
19966 
      oprot.writeFieldEnd()
19967 
    oprot.writeFieldStop()
19968 
    oprot.writeStructEnd()
19969 
 
19970 
  def validate(self):
19971 
    return
19972 
 
19973 
 
19974 
  def __repr__(self):
19975 
    L = ['%s=%r' % (key, value)
19976 
      for key, value in self.__dict__.iteritems()]
19977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19978 
 
19979 
  def __eq__(self, other):
19980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19981 
 
19982 
  def __ne__(self, other):
19983 
    return not (self == other)
19984 
 
19985 
class getTransactionsRequiringExtraProcessing_result:
19986 
  """
19987 
  Attributes:
19988 
   - success
19989 
  """
19990 
 
19991 
  thrift_spec = (
19992 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
19993 
  )
19994 
 
19995 
  def __init__(self, success=None,):
19996 
    self.success = success
19997 
 
19998 
  def read(self, iprot):
19999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20001 
      return
20002 
    iprot.readStructBegin()
20003 
    while True:
20004 
      (fname, ftype, fid) = iprot.readFieldBegin()
20005 
      if ftype == TType.STOP:
20006 
        break
20007 
      if fid == 0:
20008 
        if ftype == TType.LIST:
20009 
          self.success = []
6188 rajveer 20010 
          (_etype474, _size471) = iprot.readListBegin()
20011 
          for _i475 in xrange(_size471):
20012 
            _elem476 = iprot.readI64();
20013 
            self.success.append(_elem476)
4008 mandeep.dh 20014 
          iprot.readListEnd()
20015 
        else:
20016 
          iprot.skip(ftype)
20017 
      else:
20018 
        iprot.skip(ftype)
20019 
      iprot.readFieldEnd()
20020 
    iprot.readStructEnd()
20021 
 
20022 
  def write(self, oprot):
20023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20025 
      return
20026 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
20027 
    if self.success is not None:
20028 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20029 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 20030 
      for iter477 in self.success:
20031 
        oprot.writeI64(iter477)
4008 mandeep.dh 20032 
      oprot.writeListEnd()
20033 
      oprot.writeFieldEnd()
20034 
    oprot.writeFieldStop()
20035 
    oprot.writeStructEnd()
20036 
 
20037 
  def validate(self):
20038 
    return
20039 
 
20040 
 
20041 
  def __repr__(self):
20042 
    L = ['%s=%r' % (key, value)
20043 
      for key, value in self.__dict__.iteritems()]
20044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20045 
 
20046 
  def __eq__(self, other):
20047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20048 
 
20049 
  def __ne__(self, other):
20050 
    return not (self == other)
20051 
 
20052 
class markTransactionAsProcessed_args:
20053 
  """
20054 
  Attributes:
20055 
   - transactionId
20056 
   - category
20057 
  """
20058 
 
20059 
  thrift_spec = (
20060 
    None, # 0
20061 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20062 
    (2, TType.I32, 'category', None, None, ), # 2
20063 
  )
20064 
 
20065 
  def __init__(self, transactionId=None, category=None,):
20066 
    self.transactionId = transactionId
20067 
    self.category = category
20068 
 
20069 
  def read(self, iprot):
20070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20072 
      return
20073 
    iprot.readStructBegin()
20074 
    while True:
20075 
      (fname, ftype, fid) = iprot.readFieldBegin()
20076 
      if ftype == TType.STOP:
20077 
        break
20078 
      if fid == 1:
20079 
        if ftype == TType.I64:
20080 
          self.transactionId = iprot.readI64();
20081 
        else:
20082 
          iprot.skip(ftype)
20083 
      elif fid == 2:
20084 
        if ftype == TType.I32:
20085 
          self.category = iprot.readI32();
20086 
        else:
20087 
          iprot.skip(ftype)
20088 
      else:
20089 
        iprot.skip(ftype)
20090 
      iprot.readFieldEnd()
20091 
    iprot.readStructEnd()
20092 
 
20093 
  def write(self, oprot):
20094 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20095 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20096 
      return
20097 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
20098 
    if self.transactionId is not None:
20099 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20100 
      oprot.writeI64(self.transactionId)
20101 
      oprot.writeFieldEnd()
20102 
    if self.category is not None:
20103 
      oprot.writeFieldBegin('category', TType.I32, 2)
20104 
      oprot.writeI32(self.category)
20105 
      oprot.writeFieldEnd()
20106 
    oprot.writeFieldStop()
20107 
    oprot.writeStructEnd()
20108 
 
20109 
  def validate(self):
20110 
    return
20111 
 
20112 
 
20113 
  def __repr__(self):
20114 
    L = ['%s=%r' % (key, value)
20115 
      for key, value in self.__dict__.iteritems()]
20116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20117 
 
20118 
  def __eq__(self, other):
20119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20120 
 
20121 
  def __ne__(self, other):
20122 
    return not (self == other)
20123 
 
20124 
class markTransactionAsProcessed_result:
20125 
 
20126 
  thrift_spec = (
20127 
  )
20128 
 
20129 
  def read(self, iprot):
20130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20132 
      return
20133 
    iprot.readStructBegin()
20134 
    while True:
20135 
      (fname, ftype, fid) = iprot.readFieldBegin()
20136 
      if ftype == TType.STOP:
20137 
        break
20138 
      else:
20139 
        iprot.skip(ftype)
20140 
      iprot.readFieldEnd()
20141 
    iprot.readStructEnd()
20142 
 
20143 
  def write(self, oprot):
20144 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20145 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20146 
      return
20147 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
20148 
    oprot.writeFieldStop()
20149 
    oprot.writeStructEnd()
20150 
 
20151 
  def validate(self):
20152 
    return
20153 
 
20154 
 
20155 
  def __repr__(self):
20156 
    L = ['%s=%r' % (key, value)
20157 
      for key, value in self.__dict__.iteritems()]
20158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20159 
 
20160 
  def __eq__(self, other):
20161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20162 
 
20163 
  def __ne__(self, other):
20164 
    return not (self == other)
4018 chandransh 20165 
 
20166 
class getItemWiseRiskyOrdersCount_args:
20167 
 
20168 
  thrift_spec = (
20169 
  )
20170 
 
20171 
  def read(self, iprot):
20172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20174 
      return
20175 
    iprot.readStructBegin()
20176 
    while True:
20177 
      (fname, ftype, fid) = iprot.readFieldBegin()
20178 
      if ftype == TType.STOP:
20179 
        break
20180 
      else:
20181 
        iprot.skip(ftype)
20182 
      iprot.readFieldEnd()
20183 
    iprot.readStructEnd()
20184 
 
20185 
  def write(self, oprot):
20186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20188 
      return
20189 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
20190 
    oprot.writeFieldStop()
20191 
    oprot.writeStructEnd()
20192 
 
20193 
  def validate(self):
20194 
    return
20195 
 
20196 
 
20197 
  def __repr__(self):
20198 
    L = ['%s=%r' % (key, value)
20199 
      for key, value in self.__dict__.iteritems()]
20200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20201 
 
20202 
  def __eq__(self, other):
20203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20204 
 
20205 
  def __ne__(self, other):
20206 
    return not (self == other)
20207 
 
20208 
class getItemWiseRiskyOrdersCount_result:
20209 
  """
20210 
  Attributes:
20211 
   - success
20212 
  """
20213 
 
20214 
  thrift_spec = (
20215 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
20216 
  )
20217 
 
20218 
  def __init__(self, success=None,):
20219 
    self.success = success
20220 
 
20221 
  def read(self, iprot):
20222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20224 
      return
20225 
    iprot.readStructBegin()
20226 
    while True:
20227 
      (fname, ftype, fid) = iprot.readFieldBegin()
20228 
      if ftype == TType.STOP:
20229 
        break
20230 
      if fid == 0:
20231 
        if ftype == TType.MAP:
20232 
          self.success = {}
6188 rajveer 20233 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
20234 
          for _i482 in xrange(_size478):
20235 
            _key483 = iprot.readI64();
20236 
            _val484 = iprot.readI64();
20237 
            self.success[_key483] = _val484
4018 chandransh 20238 
          iprot.readMapEnd()
20239 
        else:
20240 
          iprot.skip(ftype)
20241 
      else:
20242 
        iprot.skip(ftype)
20243 
      iprot.readFieldEnd()
20244 
    iprot.readStructEnd()
20245 
 
20246 
  def write(self, oprot):
20247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20249 
      return
20250 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
20251 
    if self.success is not None:
20252 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20253 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 20254 
      for kiter485,viter486 in self.success.items():
20255 
        oprot.writeI64(kiter485)
20256 
        oprot.writeI64(viter486)
4018 chandransh 20257 
      oprot.writeMapEnd()
20258 
      oprot.writeFieldEnd()
20259 
    oprot.writeFieldStop()
20260 
    oprot.writeStructEnd()
20261 
 
20262 
  def validate(self):
20263 
    return
20264 
 
20265 
 
20266 
  def __repr__(self):
20267 
    L = ['%s=%r' % (key, value)
20268 
      for key, value in self.__dict__.iteritems()]
20269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20270 
 
20271 
  def __eq__(self, other):
20272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20273 
 
20274 
  def __ne__(self, other):
20275 
    return not (self == other)
4247 rajveer 20276 
 
4295 varun.gupt 20277 
class getOrdersForItemIds_args:
20278 
  """
20279 
  Attributes:
20280 
   - itemIds
20281 
  """
20282 
 
20283 
  thrift_spec = (
20284 
    None, # 0
20285 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20286 
  )
20287 
 
20288 
  def __init__(self, itemIds=None,):
20289 
    self.itemIds = itemIds
20290 
 
20291 
  def read(self, iprot):
20292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20294 
      return
20295 
    iprot.readStructBegin()
20296 
    while True:
20297 
      (fname, ftype, fid) = iprot.readFieldBegin()
20298 
      if ftype == TType.STOP:
20299 
        break
20300 
      if fid == 1:
20301 
        if ftype == TType.LIST:
20302 
          self.itemIds = []
6188 rajveer 20303 
          (_etype490, _size487) = iprot.readListBegin()
20304 
          for _i491 in xrange(_size487):
20305 
            _elem492 = iprot.readI64();
20306 
            self.itemIds.append(_elem492)
4295 varun.gupt 20307 
          iprot.readListEnd()
20308 
        else:
20309 
          iprot.skip(ftype)
20310 
      else:
20311 
        iprot.skip(ftype)
20312 
      iprot.readFieldEnd()
20313 
    iprot.readStructEnd()
20314 
 
20315 
  def write(self, oprot):
20316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20318 
      return
20319 
    oprot.writeStructBegin('getOrdersForItemIds_args')
20320 
    if self.itemIds is not None:
20321 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20322 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 20323 
      for iter493 in self.itemIds:
20324 
        oprot.writeI64(iter493)
4295 varun.gupt 20325 
      oprot.writeListEnd()
20326 
      oprot.writeFieldEnd()
20327 
    oprot.writeFieldStop()
20328 
    oprot.writeStructEnd()
20329 
 
20330 
  def validate(self):
20331 
    return
20332 
 
20333 
 
20334 
  def __repr__(self):
20335 
    L = ['%s=%r' % (key, value)
20336 
      for key, value in self.__dict__.iteritems()]
20337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20338 
 
20339 
  def __eq__(self, other):
20340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20341 
 
20342 
  def __ne__(self, other):
20343 
    return not (self == other)
20344 
 
20345 
class getOrdersForItemIds_result:
20346 
  """
20347 
  Attributes:
20348 
   - success
20349 
  """
20350 
 
20351 
  thrift_spec = (
20352 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20353 
  )
20354 
 
20355 
  def __init__(self, success=None,):
20356 
    self.success = success
20357 
 
20358 
  def read(self, iprot):
20359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20361 
      return
20362 
    iprot.readStructBegin()
20363 
    while True:
20364 
      (fname, ftype, fid) = iprot.readFieldBegin()
20365 
      if ftype == TType.STOP:
20366 
        break
20367 
      if fid == 0:
20368 
        if ftype == TType.LIST:
20369 
          self.success = []
6188 rajveer 20370 
          (_etype497, _size494) = iprot.readListBegin()
20371 
          for _i498 in xrange(_size494):
20372 
            _elem499 = Order()
20373 
            _elem499.read(iprot)
20374 
            self.success.append(_elem499)
4295 varun.gupt 20375 
          iprot.readListEnd()
20376 
        else:
20377 
          iprot.skip(ftype)
20378 
      else:
20379 
        iprot.skip(ftype)
20380 
      iprot.readFieldEnd()
20381 
    iprot.readStructEnd()
20382 
 
20383 
  def write(self, oprot):
20384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20386 
      return
20387 
    oprot.writeStructBegin('getOrdersForItemIds_result')
20388 
    if self.success is not None:
20389 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20390 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20391 
      for iter500 in self.success:
20392 
        iter500.write(oprot)
4295 varun.gupt 20393 
      oprot.writeListEnd()
20394 
      oprot.writeFieldEnd()
20395 
    oprot.writeFieldStop()
20396 
    oprot.writeStructEnd()
20397 
 
20398 
  def validate(self):
20399 
    return
20400 
 
20401 
 
20402 
  def __repr__(self):
20403 
    L = ['%s=%r' % (key, value)
20404 
      for key, value in self.__dict__.iteritems()]
20405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20406 
 
20407 
  def __eq__(self, other):
20408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20409 
 
20410 
  def __ne__(self, other):
20411 
    return not (self == other)
20412 
 
4247 rajveer 20413 
class markOrderCancellationRequestReceived_args:
20414 
  """
20415 
  Attributes:
20416 
   - orderId
20417 
  """
20418 
 
20419 
  thrift_spec = (
20420 
    None, # 0
20421 
    (1, TType.I64, 'orderId', None, None, ), # 1
20422 
  )
20423 
 
20424 
  def __init__(self, orderId=None,):
20425 
    self.orderId = orderId
20426 
 
20427 
  def read(self, iprot):
20428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20430 
      return
20431 
    iprot.readStructBegin()
20432 
    while True:
20433 
      (fname, ftype, fid) = iprot.readFieldBegin()
20434 
      if ftype == TType.STOP:
20435 
        break
20436 
      if fid == 1:
20437 
        if ftype == TType.I64:
20438 
          self.orderId = iprot.readI64();
20439 
        else:
20440 
          iprot.skip(ftype)
20441 
      else:
20442 
        iprot.skip(ftype)
20443 
      iprot.readFieldEnd()
20444 
    iprot.readStructEnd()
20445 
 
20446 
  def write(self, oprot):
20447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20449 
      return
20450 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
20451 
    if self.orderId is not None:
20452 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20453 
      oprot.writeI64(self.orderId)
20454 
      oprot.writeFieldEnd()
20455 
    oprot.writeFieldStop()
20456 
    oprot.writeStructEnd()
20457 
 
20458 
  def validate(self):
20459 
    return
20460 
 
20461 
 
20462 
  def __repr__(self):
20463 
    L = ['%s=%r' % (key, value)
20464 
      for key, value in self.__dict__.iteritems()]
20465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20466 
 
20467 
  def __eq__(self, other):
20468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20469 
 
20470 
  def __ne__(self, other):
20471 
    return not (self == other)
20472 
 
20473 
class markOrderCancellationRequestReceived_result:
20474 
  """
20475 
  Attributes:
20476 
   - ex
20477 
  """
20478 
 
20479 
  thrift_spec = (
20480 
    None, # 0
20481 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20482 
  )
20483 
 
20484 
  def __init__(self, ex=None,):
20485 
    self.ex = ex
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 == 1:
20497 
        if ftype == TType.STRUCT:
20498 
          self.ex = TransactionServiceException()
20499 
          self.ex.read(iprot)
20500 
        else:
20501 
          iprot.skip(ftype)
20502 
      else:
20503 
        iprot.skip(ftype)
20504 
      iprot.readFieldEnd()
20505 
    iprot.readStructEnd()
20506 
 
20507 
  def write(self, oprot):
20508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20510 
      return
20511 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20512 
    if self.ex is not None:
20513 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20514 
      self.ex.write(oprot)
20515 
      oprot.writeFieldEnd()
20516 
    oprot.writeFieldStop()
20517 
    oprot.writeStructEnd()
20518 
 
20519 
  def validate(self):
20520 
    return
20521 
 
20522 
 
20523 
  def __repr__(self):
20524 
    L = ['%s=%r' % (key, value)
20525 
      for key, value in self.__dict__.iteritems()]
20526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20527 
 
20528 
  def __eq__(self, other):
20529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20530 
 
20531 
  def __ne__(self, other):
20532 
    return not (self == other)
20533 
 
20534 
class markOrderCancellationRequestConfirmed_args:
20535 
  """
20536 
  Attributes:
20537 
   - orderId
20538 
  """
20539 
 
20540 
  thrift_spec = (
20541 
    None, # 0
20542 
    (1, TType.I64, 'orderId', None, None, ), # 1
20543 
  )
20544 
 
20545 
  def __init__(self, orderId=None,):
20546 
    self.orderId = orderId
20547 
 
20548 
  def read(self, iprot):
20549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20551 
      return
20552 
    iprot.readStructBegin()
20553 
    while True:
20554 
      (fname, ftype, fid) = iprot.readFieldBegin()
20555 
      if ftype == TType.STOP:
20556 
        break
20557 
      if fid == 1:
20558 
        if ftype == TType.I64:
20559 
          self.orderId = iprot.readI64();
20560 
        else:
20561 
          iprot.skip(ftype)
20562 
      else:
20563 
        iprot.skip(ftype)
20564 
      iprot.readFieldEnd()
20565 
    iprot.readStructEnd()
20566 
 
20567 
  def write(self, oprot):
20568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20570 
      return
20571 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
20572 
    if self.orderId is not None:
20573 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20574 
      oprot.writeI64(self.orderId)
20575 
      oprot.writeFieldEnd()
20576 
    oprot.writeFieldStop()
20577 
    oprot.writeStructEnd()
20578 
 
20579 
  def validate(self):
20580 
    return
20581 
 
20582 
 
20583 
  def __repr__(self):
20584 
    L = ['%s=%r' % (key, value)
20585 
      for key, value in self.__dict__.iteritems()]
20586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20587 
 
20588 
  def __eq__(self, other):
20589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20590 
 
20591 
  def __ne__(self, other):
20592 
    return not (self == other)
20593 
 
20594 
class markOrderCancellationRequestConfirmed_result:
20595 
  """
20596 
  Attributes:
20597 
   - ex
20598 
  """
20599 
 
20600 
  thrift_spec = (
20601 
    None, # 0
20602 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20603 
  )
20604 
 
20605 
  def __init__(self, ex=None,):
20606 
    self.ex = ex
20607 
 
20608 
  def read(self, iprot):
20609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20611 
      return
20612 
    iprot.readStructBegin()
20613 
    while True:
20614 
      (fname, ftype, fid) = iprot.readFieldBegin()
20615 
      if ftype == TType.STOP:
20616 
        break
20617 
      if fid == 1:
20618 
        if ftype == TType.STRUCT:
20619 
          self.ex = TransactionServiceException()
20620 
          self.ex.read(iprot)
20621 
        else:
20622 
          iprot.skip(ftype)
20623 
      else:
20624 
        iprot.skip(ftype)
20625 
      iprot.readFieldEnd()
20626 
    iprot.readStructEnd()
20627 
 
20628 
  def write(self, oprot):
20629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20631 
      return
20632 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
20633 
    if self.ex is not None:
20634 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20635 
      self.ex.write(oprot)
20636 
      oprot.writeFieldEnd()
20637 
    oprot.writeFieldStop()
20638 
    oprot.writeStructEnd()
20639 
 
20640 
  def validate(self):
20641 
    return
20642 
 
20643 
 
20644 
  def __repr__(self):
20645 
    L = ['%s=%r' % (key, value)
20646 
      for key, value in self.__dict__.iteritems()]
20647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20648 
 
20649 
  def __eq__(self, other):
20650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20651 
 
20652 
  def __ne__(self, other):
20653 
    return not (self == other)
20654 
 
20655 
class markOrderCancellationRequestDenied_args:
20656 
  """
20657 
  Attributes:
20658 
   - orderId
20659 
  """
20660 
 
20661 
  thrift_spec = (
20662 
    None, # 0
20663 
    (1, TType.I64, 'orderId', None, None, ), # 1
20664 
  )
20665 
 
20666 
  def __init__(self, orderId=None,):
20667 
    self.orderId = orderId
20668 
 
20669 
  def read(self, iprot):
20670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20672 
      return
20673 
    iprot.readStructBegin()
20674 
    while True:
20675 
      (fname, ftype, fid) = iprot.readFieldBegin()
20676 
      if ftype == TType.STOP:
20677 
        break
20678 
      if fid == 1:
20679 
        if ftype == TType.I64:
20680 
          self.orderId = iprot.readI64();
20681 
        else:
20682 
          iprot.skip(ftype)
20683 
      else:
20684 
        iprot.skip(ftype)
20685 
      iprot.readFieldEnd()
20686 
    iprot.readStructEnd()
20687 
 
20688 
  def write(self, oprot):
20689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20691 
      return
20692 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
20693 
    if self.orderId is not None:
20694 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20695 
      oprot.writeI64(self.orderId)
20696 
      oprot.writeFieldEnd()
20697 
    oprot.writeFieldStop()
20698 
    oprot.writeStructEnd()
20699 
 
20700 
  def validate(self):
20701 
    return
20702 
 
20703 
 
20704 
  def __repr__(self):
20705 
    L = ['%s=%r' % (key, value)
20706 
      for key, value in self.__dict__.iteritems()]
20707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20708 
 
20709 
  def __eq__(self, other):
20710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20711 
 
20712 
  def __ne__(self, other):
20713 
    return not (self == other)
20714 
 
20715 
class markOrderCancellationRequestDenied_result:
20716 
  """
20717 
  Attributes:
20718 
   - ex
20719 
  """
20720 
 
20721 
  thrift_spec = (
20722 
    None, # 0
20723 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20724 
  )
20725 
 
20726 
  def __init__(self, ex=None,):
20727 
    self.ex = ex
20728 
 
20729 
  def read(self, iprot):
20730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20732 
      return
20733 
    iprot.readStructBegin()
20734 
    while True:
20735 
      (fname, ftype, fid) = iprot.readFieldBegin()
20736 
      if ftype == TType.STOP:
20737 
        break
20738 
      if fid == 1:
20739 
        if ftype == TType.STRUCT:
20740 
          self.ex = TransactionServiceException()
20741 
          self.ex.read(iprot)
20742 
        else:
20743 
          iprot.skip(ftype)
20744 
      else:
20745 
        iprot.skip(ftype)
20746 
      iprot.readFieldEnd()
20747 
    iprot.readStructEnd()
20748 
 
20749 
  def write(self, oprot):
20750 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20751 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20752 
      return
20753 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
20754 
    if self.ex is not None:
20755 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20756 
      self.ex.write(oprot)
20757 
      oprot.writeFieldEnd()
20758 
    oprot.writeFieldStop()
20759 
    oprot.writeStructEnd()
20760 
 
20761 
  def validate(self):
20762 
    return
20763 
 
20764 
 
20765 
  def __repr__(self):
20766 
    L = ['%s=%r' % (key, value)
20767 
      for key, value in self.__dict__.iteritems()]
20768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20769 
 
20770 
  def __eq__(self, other):
20771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20772 
 
20773 
  def __ne__(self, other):
20774 
    return not (self == other)
20775 
 
4258 rajveer 20776 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 20777 
  """
20778 
  Attributes:
4258 rajveer 20779 
   - transactionId
4247 rajveer 20780 
  """
20781 
 
20782 
  thrift_spec = (
20783 
    None, # 0
4258 rajveer 20784 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 20785 
  )
20786 
 
4258 rajveer 20787 
  def __init__(self, transactionId=None,):
20788 
    self.transactionId = transactionId
4247 rajveer 20789 
 
20790 
  def read(self, iprot):
20791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20793 
      return
20794 
    iprot.readStructBegin()
20795 
    while True:
20796 
      (fname, ftype, fid) = iprot.readFieldBegin()
20797 
      if ftype == TType.STOP:
20798 
        break
20799 
      if fid == 1:
20800 
        if ftype == TType.I64:
4258 rajveer 20801 
          self.transactionId = iprot.readI64();
4247 rajveer 20802 
        else:
20803 
          iprot.skip(ftype)
20804 
      else:
20805 
        iprot.skip(ftype)
20806 
      iprot.readFieldEnd()
20807 
    iprot.readStructEnd()
20808 
 
20809 
  def write(self, oprot):
20810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20812 
      return
4258 rajveer 20813 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
20814 
    if self.transactionId is not None:
20815 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20816 
      oprot.writeI64(self.transactionId)
4247 rajveer 20817 
      oprot.writeFieldEnd()
20818 
    oprot.writeFieldStop()
20819 
    oprot.writeStructEnd()
20820 
 
20821 
  def validate(self):
20822 
    return
20823 
 
20824 
 
20825 
  def __repr__(self):
20826 
    L = ['%s=%r' % (key, value)
20827 
      for key, value in self.__dict__.iteritems()]
20828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20829 
 
20830 
  def __eq__(self, other):
20831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20832 
 
20833 
  def __ne__(self, other):
20834 
    return not (self == other)
20835 
 
4258 rajveer 20836 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 20837 
  """
20838 
  Attributes:
20839 
   - ex
20840 
  """
20841 
 
20842 
  thrift_spec = (
20843 
    None, # 0
20844 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20845 
  )
20846 
 
20847 
  def __init__(self, ex=None,):
20848 
    self.ex = ex
20849 
 
20850 
  def read(self, iprot):
20851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20853 
      return
20854 
    iprot.readStructBegin()
20855 
    while True:
20856 
      (fname, ftype, fid) = iprot.readFieldBegin()
20857 
      if ftype == TType.STOP:
20858 
        break
20859 
      if fid == 1:
20860 
        if ftype == TType.STRUCT:
20861 
          self.ex = TransactionServiceException()
20862 
          self.ex.read(iprot)
20863 
        else:
20864 
          iprot.skip(ftype)
20865 
      else:
20866 
        iprot.skip(ftype)
20867 
      iprot.readFieldEnd()
20868 
    iprot.readStructEnd()
20869 
 
20870 
  def write(self, oprot):
20871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20873 
      return
4258 rajveer 20874 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 20875 
    if self.ex is not None:
20876 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20877 
      self.ex.write(oprot)
20878 
      oprot.writeFieldEnd()
20879 
    oprot.writeFieldStop()
20880 
    oprot.writeStructEnd()
20881 
 
20882 
  def validate(self):
20883 
    return
20884 
 
20885 
 
20886 
  def __repr__(self):
20887 
    L = ['%s=%r' % (key, value)
20888 
      for key, value in self.__dict__.iteritems()]
20889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20890 
 
20891 
  def __eq__(self, other):
20892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20893 
 
20894 
  def __ne__(self, other):
20895 
    return not (self == other)
4259 anupam.sin 20896 
 
20897 
class refundTransaction_args:
20898 
  """
20899 
  Attributes:
20900 
   - transactionId
20901 
   - refundedBy
20902 
   - reason
20903 
  """
20904 
 
20905 
  thrift_spec = (
20906 
    None, # 0
20907 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20908 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
20909 
    (3, TType.STRING, 'reason', None, None, ), # 3
20910 
  )
20911 
 
20912 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
20913 
    self.transactionId = transactionId
20914 
    self.refundedBy = refundedBy
20915 
    self.reason = reason
20916 
 
20917 
  def read(self, iprot):
20918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20920 
      return
20921 
    iprot.readStructBegin()
20922 
    while True:
20923 
      (fname, ftype, fid) = iprot.readFieldBegin()
20924 
      if ftype == TType.STOP:
20925 
        break
20926 
      if fid == 1:
20927 
        if ftype == TType.I64:
20928 
          self.transactionId = iprot.readI64();
20929 
        else:
20930 
          iprot.skip(ftype)
20931 
      elif fid == 2:
20932 
        if ftype == TType.STRING:
20933 
          self.refundedBy = iprot.readString();
20934 
        else:
20935 
          iprot.skip(ftype)
20936 
      elif fid == 3:
20937 
        if ftype == TType.STRING:
20938 
          self.reason = iprot.readString();
20939 
        else:
20940 
          iprot.skip(ftype)
20941 
      else:
20942 
        iprot.skip(ftype)
20943 
      iprot.readFieldEnd()
20944 
    iprot.readStructEnd()
20945 
 
20946 
  def write(self, oprot):
20947 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20948 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20949 
      return
20950 
    oprot.writeStructBegin('refundTransaction_args')
20951 
    if self.transactionId is not None:
20952 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20953 
      oprot.writeI64(self.transactionId)
20954 
      oprot.writeFieldEnd()
20955 
    if self.refundedBy is not None:
20956 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
20957 
      oprot.writeString(self.refundedBy)
20958 
      oprot.writeFieldEnd()
20959 
    if self.reason is not None:
20960 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
20961 
      oprot.writeString(self.reason)
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 refundTransaction_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('refundTransaction_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)
4285 rajveer 21041 
 
4324 mandeep.dh 21042 
class updateShipmentAddress_args:
21043 
  """
21044 
  Attributes:
21045 
   - orderId
21046 
   - addressId
21047 
  """
21048 
 
21049 
  thrift_spec = (
21050 
    None, # 0
21051 
    (1, TType.I64, 'orderId', None, None, ), # 1
21052 
    (2, TType.I64, 'addressId', None, None, ), # 2
21053 
  )
21054 
 
21055 
  def __init__(self, orderId=None, addressId=None,):
21056 
    self.orderId = orderId
21057 
    self.addressId = addressId
21058 
 
21059 
  def read(self, iprot):
21060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21062 
      return
21063 
    iprot.readStructBegin()
21064 
    while True:
21065 
      (fname, ftype, fid) = iprot.readFieldBegin()
21066 
      if ftype == TType.STOP:
21067 
        break
21068 
      if fid == 1:
21069 
        if ftype == TType.I64:
21070 
          self.orderId = iprot.readI64();
21071 
        else:
21072 
          iprot.skip(ftype)
21073 
      elif fid == 2:
21074 
        if ftype == TType.I64:
21075 
          self.addressId = iprot.readI64();
21076 
        else:
21077 
          iprot.skip(ftype)
21078 
      else:
21079 
        iprot.skip(ftype)
21080 
      iprot.readFieldEnd()
21081 
    iprot.readStructEnd()
21082 
 
21083 
  def write(self, oprot):
21084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21086 
      return
21087 
    oprot.writeStructBegin('updateShipmentAddress_args')
21088 
    if self.orderId is not None:
21089 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21090 
      oprot.writeI64(self.orderId)
21091 
      oprot.writeFieldEnd()
21092 
    if self.addressId is not None:
21093 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
21094 
      oprot.writeI64(self.addressId)
21095 
      oprot.writeFieldEnd()
21096 
    oprot.writeFieldStop()
21097 
    oprot.writeStructEnd()
21098 
 
21099 
  def validate(self):
21100 
    return
21101 
 
21102 
 
21103 
  def __repr__(self):
21104 
    L = ['%s=%r' % (key, value)
21105 
      for key, value in self.__dict__.iteritems()]
21106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21107 
 
21108 
  def __eq__(self, other):
21109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21110 
 
21111 
  def __ne__(self, other):
21112 
    return not (self == other)
21113 
 
21114 
class updateShipmentAddress_result:
21115 
  """
21116 
  Attributes:
21117 
   - ex
21118 
  """
21119 
 
21120 
  thrift_spec = (
21121 
    None, # 0
21122 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21123 
  )
21124 
 
21125 
  def __init__(self, ex=None,):
21126 
    self.ex = ex
21127 
 
21128 
  def read(self, iprot):
21129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21131 
      return
21132 
    iprot.readStructBegin()
21133 
    while True:
21134 
      (fname, ftype, fid) = iprot.readFieldBegin()
21135 
      if ftype == TType.STOP:
21136 
        break
21137 
      if fid == 1:
21138 
        if ftype == TType.STRUCT:
21139 
          self.ex = TransactionServiceException()
21140 
          self.ex.read(iprot)
21141 
        else:
21142 
          iprot.skip(ftype)
21143 
      else:
21144 
        iprot.skip(ftype)
21145 
      iprot.readFieldEnd()
21146 
    iprot.readStructEnd()
21147 
 
21148 
  def write(self, oprot):
21149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21151 
      return
21152 
    oprot.writeStructBegin('updateShipmentAddress_result')
21153 
    if self.ex is not None:
21154 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21155 
      self.ex.write(oprot)
21156 
      oprot.writeFieldEnd()
21157 
    oprot.writeFieldStop()
21158 
    oprot.writeStructEnd()
21159 
 
21160 
  def validate(self):
21161 
    return
21162 
 
21163 
 
21164 
  def __repr__(self):
21165 
    L = ['%s=%r' % (key, value)
21166 
      for key, value in self.__dict__.iteritems()]
21167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21168 
 
21169 
  def __eq__(self, other):
21170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21171 
 
21172 
  def __ne__(self, other):
21173 
    return not (self == other)
21174 
 
4285 rajveer 21175 
class acceptOrdersForItemId_args:
21176 
  """
21177 
  Attributes:
21178 
   - itemId
21179 
   - inventory
21180 
  """
21181 
 
21182 
  thrift_spec = (
21183 
    None, # 0
21184 
    (1, TType.I64, 'itemId', None, None, ), # 1
21185 
    (2, TType.I64, 'inventory', None, None, ), # 2
21186 
  )
21187 
 
21188 
  def __init__(self, itemId=None, inventory=None,):
21189 
    self.itemId = itemId
21190 
    self.inventory = inventory
21191 
 
21192 
  def read(self, iprot):
21193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21195 
      return
21196 
    iprot.readStructBegin()
21197 
    while True:
21198 
      (fname, ftype, fid) = iprot.readFieldBegin()
21199 
      if ftype == TType.STOP:
21200 
        break
21201 
      if fid == 1:
21202 
        if ftype == TType.I64:
21203 
          self.itemId = iprot.readI64();
21204 
        else:
21205 
          iprot.skip(ftype)
21206 
      elif fid == 2:
21207 
        if ftype == TType.I64:
21208 
          self.inventory = iprot.readI64();
21209 
        else:
21210 
          iprot.skip(ftype)
21211 
      else:
21212 
        iprot.skip(ftype)
21213 
      iprot.readFieldEnd()
21214 
    iprot.readStructEnd()
21215 
 
21216 
  def write(self, oprot):
21217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21219 
      return
21220 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
21221 
    if self.itemId is not None:
21222 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21223 
      oprot.writeI64(self.itemId)
21224 
      oprot.writeFieldEnd()
21225 
    if self.inventory is not None:
21226 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
21227 
      oprot.writeI64(self.inventory)
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 acceptOrdersForItemId_result:
21248 
  """
21249 
  Attributes:
21250 
   - success
21251 
   - ex
21252 
  """
21253 
 
21254 
  thrift_spec = (
21255 
    (0, TType.BOOL, 'success', None, None, ), # 0
21256 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21257 
  )
21258 
 
21259 
  def __init__(self, success=None, ex=None,):
21260 
    self.success = success
21261 
    self.ex = ex
21262 
 
21263 
  def read(self, iprot):
21264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21266 
      return
21267 
    iprot.readStructBegin()
21268 
    while True:
21269 
      (fname, ftype, fid) = iprot.readFieldBegin()
21270 
      if ftype == TType.STOP:
21271 
        break
21272 
      if fid == 0:
21273 
        if ftype == TType.BOOL:
21274 
          self.success = iprot.readBool();
21275 
        else:
21276 
          iprot.skip(ftype)
21277 
      elif fid == 1:
21278 
        if ftype == TType.STRUCT:
21279 
          self.ex = TransactionServiceException()
21280 
          self.ex.read(iprot)
21281 
        else:
21282 
          iprot.skip(ftype)
21283 
      else:
21284 
        iprot.skip(ftype)
21285 
      iprot.readFieldEnd()
21286 
    iprot.readStructEnd()
21287 
 
21288 
  def write(self, oprot):
21289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21291 
      return
21292 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
21293 
    if self.success is not None:
21294 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21295 
      oprot.writeBool(self.success)
21296 
      oprot.writeFieldEnd()
21297 
    if self.ex is not None:
21298 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21299 
      self.ex.write(oprot)
21300 
      oprot.writeFieldEnd()
21301 
    oprot.writeFieldStop()
21302 
    oprot.writeStructEnd()
21303 
 
21304 
  def validate(self):
21305 
    return
21306 
 
21307 
 
21308 
  def __repr__(self):
21309 
    L = ['%s=%r' % (key, value)
21310 
      for key, value in self.__dict__.iteritems()]
21311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21312 
 
21313 
  def __eq__(self, other):
21314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21315 
 
21316 
  def __ne__(self, other):
21317 
    return not (self == other)
4303 rajveer 21318 
 
21319 
class markOrdersAsPORaised_args:
21320 
  """
21321 
  Attributes:
21322 
   - vendorId
21323 
   - itemId
21324 
   - quantity
21325 
   - estimate
4369 rajveer 21326 
   - isReminder
4303 rajveer 21327 
  """
21328 
 
21329 
  thrift_spec = (
21330 
    None, # 0
21331 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21332 
    (2, TType.I64, 'itemId', None, None, ), # 2
21333 
    (3, TType.I64, 'quantity', None, None, ), # 3
21334 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21335 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21336 
  )
21337 
 
4369 rajveer 21338 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21339 
    self.vendorId = vendorId
21340 
    self.itemId = itemId
21341 
    self.quantity = quantity
21342 
    self.estimate = estimate
4369 rajveer 21343 
    self.isReminder = isReminder
4303 rajveer 21344 
 
21345 
  def read(self, iprot):
21346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21348 
      return
21349 
    iprot.readStructBegin()
21350 
    while True:
21351 
      (fname, ftype, fid) = iprot.readFieldBegin()
21352 
      if ftype == TType.STOP:
21353 
        break
21354 
      if fid == 1:
21355 
        if ftype == TType.I64:
21356 
          self.vendorId = iprot.readI64();
21357 
        else:
21358 
          iprot.skip(ftype)
21359 
      elif fid == 2:
21360 
        if ftype == TType.I64:
21361 
          self.itemId = iprot.readI64();
21362 
        else:
21363 
          iprot.skip(ftype)
21364 
      elif fid == 3:
21365 
        if ftype == TType.I64:
21366 
          self.quantity = iprot.readI64();
21367 
        else:
21368 
          iprot.skip(ftype)
21369 
      elif fid == 4:
21370 
        if ftype == TType.I64:
21371 
          self.estimate = iprot.readI64();
21372 
        else:
21373 
          iprot.skip(ftype)
4369 rajveer 21374 
      elif fid == 5:
21375 
        if ftype == TType.BOOL:
21376 
          self.isReminder = iprot.readBool();
21377 
        else:
21378 
          iprot.skip(ftype)
4303 rajveer 21379 
      else:
21380 
        iprot.skip(ftype)
21381 
      iprot.readFieldEnd()
21382 
    iprot.readStructEnd()
21383 
 
21384 
  def write(self, oprot):
21385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21387 
      return
21388 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
21389 
    if self.vendorId is not None:
21390 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21391 
      oprot.writeI64(self.vendorId)
21392 
      oprot.writeFieldEnd()
21393 
    if self.itemId is not None:
21394 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21395 
      oprot.writeI64(self.itemId)
21396 
      oprot.writeFieldEnd()
21397 
    if self.quantity is not None:
21398 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21399 
      oprot.writeI64(self.quantity)
21400 
      oprot.writeFieldEnd()
21401 
    if self.estimate is not None:
21402 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21403 
      oprot.writeI64(self.estimate)
21404 
      oprot.writeFieldEnd()
4369 rajveer 21405 
    if self.isReminder is not None:
21406 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21407 
      oprot.writeBool(self.isReminder)
21408 
      oprot.writeFieldEnd()
4303 rajveer 21409 
    oprot.writeFieldStop()
21410 
    oprot.writeStructEnd()
21411 
 
21412 
  def validate(self):
21413 
    return
21414 
 
21415 
 
21416 
  def __repr__(self):
21417 
    L = ['%s=%r' % (key, value)
21418 
      for key, value in self.__dict__.iteritems()]
21419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21420 
 
21421 
  def __eq__(self, other):
21422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21423 
 
21424 
  def __ne__(self, other):
21425 
    return not (self == other)
21426 
 
21427 
class markOrdersAsPORaised_result:
21428 
  """
21429 
  Attributes:
21430 
   - ex
21431 
  """
21432 
 
21433 
  thrift_spec = (
21434 
    None, # 0
21435 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21436 
  )
21437 
 
21438 
  def __init__(self, ex=None,):
21439 
    self.ex = ex
21440 
 
21441 
  def read(self, iprot):
21442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21444 
      return
21445 
    iprot.readStructBegin()
21446 
    while True:
21447 
      (fname, ftype, fid) = iprot.readFieldBegin()
21448 
      if ftype == TType.STOP:
21449 
        break
21450 
      if fid == 1:
21451 
        if ftype == TType.STRUCT:
21452 
          self.ex = TransactionServiceException()
21453 
          self.ex.read(iprot)
21454 
        else:
21455 
          iprot.skip(ftype)
21456 
      else:
21457 
        iprot.skip(ftype)
21458 
      iprot.readFieldEnd()
21459 
    iprot.readStructEnd()
21460 
 
21461 
  def write(self, oprot):
21462 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21463 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21464 
      return
21465 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
21466 
    if self.ex is not None:
21467 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21468 
      self.ex.write(oprot)
21469 
      oprot.writeFieldEnd()
21470 
    oprot.writeFieldStop()
21471 
    oprot.writeStructEnd()
21472 
 
21473 
  def validate(self):
21474 
    return
21475 
 
21476 
 
21477 
  def __repr__(self):
21478 
    L = ['%s=%r' % (key, value)
21479 
      for key, value in self.__dict__.iteritems()]
21480 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21481 
 
21482 
  def __eq__(self, other):
21483 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21484 
 
21485 
  def __ne__(self, other):
21486 
    return not (self == other)
21487 
 
21488 
class markOrdersAsReversalInitiated_args:
21489 
  """
21490 
  Attributes:
21491 
   - vendorId
21492 
   - itemId
21493 
   - quantity
21494 
   - estimate
4369 rajveer 21495 
   - isReminder
4303 rajveer 21496 
  """
21497 
 
21498 
  thrift_spec = (
21499 
    None, # 0
21500 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21501 
    (2, TType.I64, 'itemId', None, None, ), # 2
21502 
    (3, TType.I64, 'quantity', None, None, ), # 3
21503 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21504 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21505 
  )
21506 
 
4369 rajveer 21507 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21508 
    self.vendorId = vendorId
21509 
    self.itemId = itemId
21510 
    self.quantity = quantity
21511 
    self.estimate = estimate
4369 rajveer 21512 
    self.isReminder = isReminder
4303 rajveer 21513 
 
21514 
  def read(self, iprot):
21515 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21516 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21517 
      return
21518 
    iprot.readStructBegin()
21519 
    while True:
21520 
      (fname, ftype, fid) = iprot.readFieldBegin()
21521 
      if ftype == TType.STOP:
21522 
        break
21523 
      if fid == 1:
21524 
        if ftype == TType.I64:
21525 
          self.vendorId = iprot.readI64();
21526 
        else:
21527 
          iprot.skip(ftype)
21528 
      elif fid == 2:
21529 
        if ftype == TType.I64:
21530 
          self.itemId = iprot.readI64();
21531 
        else:
21532 
          iprot.skip(ftype)
21533 
      elif fid == 3:
21534 
        if ftype == TType.I64:
21535 
          self.quantity = iprot.readI64();
21536 
        else:
21537 
          iprot.skip(ftype)
21538 
      elif fid == 4:
21539 
        if ftype == TType.I64:
21540 
          self.estimate = iprot.readI64();
21541 
        else:
21542 
          iprot.skip(ftype)
4369 rajveer 21543 
      elif fid == 5:
21544 
        if ftype == TType.BOOL:
21545 
          self.isReminder = iprot.readBool();
21546 
        else:
21547 
          iprot.skip(ftype)
4303 rajveer 21548 
      else:
21549 
        iprot.skip(ftype)
21550 
      iprot.readFieldEnd()
21551 
    iprot.readStructEnd()
21552 
 
21553 
  def write(self, oprot):
21554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21556 
      return
21557 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
21558 
    if self.vendorId is not None:
21559 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21560 
      oprot.writeI64(self.vendorId)
21561 
      oprot.writeFieldEnd()
21562 
    if self.itemId is not None:
21563 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21564 
      oprot.writeI64(self.itemId)
21565 
      oprot.writeFieldEnd()
21566 
    if self.quantity is not None:
21567 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21568 
      oprot.writeI64(self.quantity)
21569 
      oprot.writeFieldEnd()
21570 
    if self.estimate is not None:
21571 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21572 
      oprot.writeI64(self.estimate)
21573 
      oprot.writeFieldEnd()
4369 rajveer 21574 
    if self.isReminder is not None:
21575 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21576 
      oprot.writeBool(self.isReminder)
21577 
      oprot.writeFieldEnd()
4303 rajveer 21578 
    oprot.writeFieldStop()
21579 
    oprot.writeStructEnd()
21580 
 
21581 
  def validate(self):
21582 
    return
21583 
 
21584 
 
21585 
  def __repr__(self):
21586 
    L = ['%s=%r' % (key, value)
21587 
      for key, value in self.__dict__.iteritems()]
21588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21589 
 
21590 
  def __eq__(self, other):
21591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21592 
 
21593 
  def __ne__(self, other):
21594 
    return not (self == other)
21595 
 
21596 
class markOrdersAsReversalInitiated_result:
21597 
  """
21598 
  Attributes:
21599 
   - ex
21600 
  """
21601 
 
21602 
  thrift_spec = (
21603 
    None, # 0
21604 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21605 
  )
21606 
 
21607 
  def __init__(self, ex=None,):
21608 
    self.ex = ex
21609 
 
21610 
  def read(self, iprot):
21611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21613 
      return
21614 
    iprot.readStructBegin()
21615 
    while True:
21616 
      (fname, ftype, fid) = iprot.readFieldBegin()
21617 
      if ftype == TType.STOP:
21618 
        break
21619 
      if fid == 1:
21620 
        if ftype == TType.STRUCT:
21621 
          self.ex = TransactionServiceException()
21622 
          self.ex.read(iprot)
21623 
        else:
21624 
          iprot.skip(ftype)
21625 
      else:
21626 
        iprot.skip(ftype)
21627 
      iprot.readFieldEnd()
21628 
    iprot.readStructEnd()
21629 
 
21630 
  def write(self, oprot):
21631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21633 
      return
21634 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
21635 
    if self.ex is not None:
21636 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21637 
      self.ex.write(oprot)
21638 
      oprot.writeFieldEnd()
21639 
    oprot.writeFieldStop()
21640 
    oprot.writeStructEnd()
21641 
 
21642 
  def validate(self):
21643 
    return
21644 
 
21645 
 
21646 
  def __repr__(self):
21647 
    L = ['%s=%r' % (key, value)
21648 
      for key, value in self.__dict__.iteritems()]
21649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21650 
 
21651 
  def __eq__(self, other):
21652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21653 
 
21654 
  def __ne__(self, other):
21655 
    return not (self == other)
21656 
 
21657 
class markOrdersAsNotAvailabke_args:
21658 
  """
21659 
  Attributes:
21660 
   - vendorId
21661 
   - itemId
21662 
   - quantity
21663 
   - estimate
4369 rajveer 21664 
   - isReminder
4303 rajveer 21665 
  """
21666 
 
21667 
  thrift_spec = (
21668 
    None, # 0
21669 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21670 
    (2, TType.I64, 'itemId', None, None, ), # 2
21671 
    (3, TType.I64, 'quantity', None, None, ), # 3
21672 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21673 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21674 
  )
21675 
 
4369 rajveer 21676 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21677 
    self.vendorId = vendorId
21678 
    self.itemId = itemId
21679 
    self.quantity = quantity
21680 
    self.estimate = estimate
4369 rajveer 21681 
    self.isReminder = isReminder
4303 rajveer 21682 
 
21683 
  def read(self, iprot):
21684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21686 
      return
21687 
    iprot.readStructBegin()
21688 
    while True:
21689 
      (fname, ftype, fid) = iprot.readFieldBegin()
21690 
      if ftype == TType.STOP:
21691 
        break
21692 
      if fid == 1:
21693 
        if ftype == TType.I64:
21694 
          self.vendorId = iprot.readI64();
21695 
        else:
21696 
          iprot.skip(ftype)
21697 
      elif fid == 2:
21698 
        if ftype == TType.I64:
21699 
          self.itemId = iprot.readI64();
21700 
        else:
21701 
          iprot.skip(ftype)
21702 
      elif fid == 3:
21703 
        if ftype == TType.I64:
21704 
          self.quantity = iprot.readI64();
21705 
        else:
21706 
          iprot.skip(ftype)
21707 
      elif fid == 4:
21708 
        if ftype == TType.I64:
21709 
          self.estimate = iprot.readI64();
21710 
        else:
21711 
          iprot.skip(ftype)
4369 rajveer 21712 
      elif fid == 5:
21713 
        if ftype == TType.BOOL:
21714 
          self.isReminder = iprot.readBool();
21715 
        else:
21716 
          iprot.skip(ftype)
4303 rajveer 21717 
      else:
21718 
        iprot.skip(ftype)
21719 
      iprot.readFieldEnd()
21720 
    iprot.readStructEnd()
21721 
 
21722 
  def write(self, oprot):
21723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21725 
      return
21726 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
21727 
    if self.vendorId is not None:
21728 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21729 
      oprot.writeI64(self.vendorId)
21730 
      oprot.writeFieldEnd()
21731 
    if self.itemId is not None:
21732 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21733 
      oprot.writeI64(self.itemId)
21734 
      oprot.writeFieldEnd()
21735 
    if self.quantity is not None:
21736 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21737 
      oprot.writeI64(self.quantity)
21738 
      oprot.writeFieldEnd()
21739 
    if self.estimate is not None:
21740 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21741 
      oprot.writeI64(self.estimate)
21742 
      oprot.writeFieldEnd()
4369 rajveer 21743 
    if self.isReminder is not None:
21744 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21745 
      oprot.writeBool(self.isReminder)
21746 
      oprot.writeFieldEnd()
4303 rajveer 21747 
    oprot.writeFieldStop()
21748 
    oprot.writeStructEnd()
21749 
 
21750 
  def validate(self):
21751 
    return
21752 
 
21753 
 
21754 
  def __repr__(self):
21755 
    L = ['%s=%r' % (key, value)
21756 
      for key, value in self.__dict__.iteritems()]
21757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21758 
 
21759 
  def __eq__(self, other):
21760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21761 
 
21762 
  def __ne__(self, other):
21763 
    return not (self == other)
21764 
 
21765 
class markOrdersAsNotAvailabke_result:
21766 
  """
21767 
  Attributes:
21768 
   - ex
21769 
  """
21770 
 
21771 
  thrift_spec = (
21772 
    None, # 0
21773 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21774 
  )
21775 
 
21776 
  def __init__(self, ex=None,):
21777 
    self.ex = ex
21778 
 
21779 
  def read(self, iprot):
21780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21782 
      return
21783 
    iprot.readStructBegin()
21784 
    while True:
21785 
      (fname, ftype, fid) = iprot.readFieldBegin()
21786 
      if ftype == TType.STOP:
21787 
        break
21788 
      if fid == 1:
21789 
        if ftype == TType.STRUCT:
21790 
          self.ex = TransactionServiceException()
21791 
          self.ex.read(iprot)
21792 
        else:
21793 
          iprot.skip(ftype)
21794 
      else:
21795 
        iprot.skip(ftype)
21796 
      iprot.readFieldEnd()
21797 
    iprot.readStructEnd()
21798 
 
21799 
  def write(self, oprot):
21800 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21801 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21802 
      return
21803 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
21804 
    if self.ex is not None:
21805 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21806 
      self.ex.write(oprot)
21807 
      oprot.writeFieldEnd()
21808 
    oprot.writeFieldStop()
21809 
    oprot.writeStructEnd()
21810 
 
21811 
  def validate(self):
21812 
    return
21813 
 
21814 
 
21815 
  def __repr__(self):
21816 
    L = ['%s=%r' % (key, value)
21817 
      for key, value in self.__dict__.iteritems()]
21818 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21819 
 
21820 
  def __eq__(self, other):
21821 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21822 
 
21823 
  def __ne__(self, other):
21824 
    return not (self == other)
4369 rajveer 21825 
 
21826 
class markOrdersAsTimeout_args:
21827 
  """
21828 
  Attributes:
21829 
   - vendorId
21830 
  """
21831 
 
21832 
  thrift_spec = (
21833 
    None, # 0
21834 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21835 
  )
21836 
 
21837 
  def __init__(self, vendorId=None,):
21838 
    self.vendorId = vendorId
21839 
 
21840 
  def read(self, iprot):
21841 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21842 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21843 
      return
21844 
    iprot.readStructBegin()
21845 
    while True:
21846 
      (fname, ftype, fid) = iprot.readFieldBegin()
21847 
      if ftype == TType.STOP:
21848 
        break
21849 
      if fid == 1:
21850 
        if ftype == TType.I64:
21851 
          self.vendorId = iprot.readI64();
21852 
        else:
21853 
          iprot.skip(ftype)
21854 
      else:
21855 
        iprot.skip(ftype)
21856 
      iprot.readFieldEnd()
21857 
    iprot.readStructEnd()
21858 
 
21859 
  def write(self, oprot):
21860 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21861 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21862 
      return
21863 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
21864 
    if self.vendorId is not None:
21865 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21866 
      oprot.writeI64(self.vendorId)
21867 
      oprot.writeFieldEnd()
21868 
    oprot.writeFieldStop()
21869 
    oprot.writeStructEnd()
21870 
 
21871 
  def validate(self):
21872 
    return
21873 
 
21874 
 
21875 
  def __repr__(self):
21876 
    L = ['%s=%r' % (key, value)
21877 
      for key, value in self.__dict__.iteritems()]
21878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21879 
 
21880 
  def __eq__(self, other):
21881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21882 
 
21883 
  def __ne__(self, other):
21884 
    return not (self == other)
21885 
 
21886 
class markOrdersAsTimeout_result:
21887 
  """
21888 
  Attributes:
21889 
   - success
21890 
   - ex
21891 
  """
21892 
 
21893 
  thrift_spec = (
21894 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
21895 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21896 
  )
21897 
 
21898 
  def __init__(self, success=None, ex=None,):
21899 
    self.success = success
21900 
    self.ex = ex
21901 
 
21902 
  def read(self, iprot):
21903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21905 
      return
21906 
    iprot.readStructBegin()
21907 
    while True:
21908 
      (fname, ftype, fid) = iprot.readFieldBegin()
21909 
      if ftype == TType.STOP:
21910 
        break
21911 
      if fid == 0:
21912 
        if ftype == TType.MAP:
21913 
          self.success = {}
6188 rajveer 21914 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
21915 
          for _i505 in xrange(_size501):
21916 
            _key506 = iprot.readI32();
21917 
            _val507 = TimeoutSummary()
21918 
            _val507.read(iprot)
21919 
            self.success[_key506] = _val507
4369 rajveer 21920 
          iprot.readMapEnd()
21921 
        else:
21922 
          iprot.skip(ftype)
21923 
      elif fid == 1:
21924 
        if ftype == TType.STRUCT:
21925 
          self.ex = TransactionServiceException()
21926 
          self.ex.read(iprot)
21927 
        else:
21928 
          iprot.skip(ftype)
21929 
      else:
21930 
        iprot.skip(ftype)
21931 
      iprot.readFieldEnd()
21932 
    iprot.readStructEnd()
21933 
 
21934 
  def write(self, oprot):
21935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21937 
      return
21938 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
21939 
    if self.success is not None:
21940 
      oprot.writeFieldBegin('success', TType.MAP, 0)
21941 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 21942 
      for kiter508,viter509 in self.success.items():
21943 
        oprot.writeI32(kiter508)
21944 
        viter509.write(oprot)
4369 rajveer 21945 
      oprot.writeMapEnd()
21946 
      oprot.writeFieldEnd()
21947 
    if self.ex is not None:
21948 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21949 
      self.ex.write(oprot)
21950 
      oprot.writeFieldEnd()
21951 
    oprot.writeFieldStop()
21952 
    oprot.writeStructEnd()
21953 
 
21954 
  def validate(self):
21955 
    return
21956 
 
21957 
 
21958 
  def __repr__(self):
21959 
    L = ['%s=%r' % (key, value)
21960 
      for key, value in self.__dict__.iteritems()]
21961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21962 
 
21963 
  def __eq__(self, other):
21964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21965 
 
21966 
  def __ne__(self, other):
21967 
    return not (self == other)
4386 anupam.sin 21968 
 
4662 rajveer 21969 
class markOrderAsLostInTransit_args:
21970 
  """
21971 
  Attributes:
21972 
   - orderId
21973 
  """
21974 
 
21975 
  thrift_spec = (
21976 
    None, # 0
21977 
    (1, TType.I64, 'orderId', None, None, ), # 1
21978 
  )
21979 
 
21980 
  def __init__(self, orderId=None,):
21981 
    self.orderId = orderId
21982 
 
21983 
  def read(self, iprot):
21984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21986 
      return
21987 
    iprot.readStructBegin()
21988 
    while True:
21989 
      (fname, ftype, fid) = iprot.readFieldBegin()
21990 
      if ftype == TType.STOP:
21991 
        break
21992 
      if fid == 1:
21993 
        if ftype == TType.I64:
21994 
          self.orderId = iprot.readI64();
21995 
        else:
21996 
          iprot.skip(ftype)
21997 
      else:
21998 
        iprot.skip(ftype)
21999 
      iprot.readFieldEnd()
22000 
    iprot.readStructEnd()
22001 
 
22002 
  def write(self, oprot):
22003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22005 
      return
22006 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
22007 
    if self.orderId is not None:
22008 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22009 
      oprot.writeI64(self.orderId)
22010 
      oprot.writeFieldEnd()
22011 
    oprot.writeFieldStop()
22012 
    oprot.writeStructEnd()
22013 
 
22014 
  def validate(self):
22015 
    return
22016 
 
22017 
 
22018 
  def __repr__(self):
22019 
    L = ['%s=%r' % (key, value)
22020 
      for key, value in self.__dict__.iteritems()]
22021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22022 
 
22023 
  def __eq__(self, other):
22024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22025 
 
22026 
  def __ne__(self, other):
22027 
    return not (self == other)
22028 
 
22029 
class markOrderAsLostInTransit_result:
22030 
  """
22031 
  Attributes:
22032 
   - success
22033 
   - ex
22034 
  """
22035 
 
22036 
  thrift_spec = (
22037 
    (0, TType.BOOL, 'success', None, None, ), # 0
22038 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22039 
  )
22040 
 
22041 
  def __init__(self, success=None, ex=None,):
22042 
    self.success = success
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 == 0:
22055 
        if ftype == TType.BOOL:
22056 
          self.success = iprot.readBool();
22057 
        else:
22058 
          iprot.skip(ftype)
22059 
      elif fid == 1:
22060 
        if ftype == TType.STRUCT:
22061 
          self.ex = TransactionServiceException()
22062 
          self.ex.read(iprot)
22063 
        else:
22064 
          iprot.skip(ftype)
22065 
      else:
22066 
        iprot.skip(ftype)
22067 
      iprot.readFieldEnd()
22068 
    iprot.readStructEnd()
22069 
 
22070 
  def write(self, oprot):
22071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22073 
      return
22074 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
22075 
    if self.success is not None:
22076 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22077 
      oprot.writeBool(self.success)
22078 
      oprot.writeFieldEnd()
22079 
    if self.ex is not None:
22080 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22081 
      self.ex.write(oprot)
22082 
      oprot.writeFieldEnd()
22083 
    oprot.writeFieldStop()
22084 
    oprot.writeStructEnd()
22085 
 
22086 
  def validate(self):
22087 
    return
22088 
 
22089 
 
22090 
  def __repr__(self):
22091 
    L = ['%s=%r' % (key, value)
22092 
      for key, value in self.__dict__.iteritems()]
22093 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22094 
 
22095 
  def __eq__(self, other):
22096 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22097 
 
22098 
  def __ne__(self, other):
22099 
    return not (self == other)
22100 
 
4386 anupam.sin 22101 
class getOrderForAwb_args:
22102 
  """
22103 
  Attributes:
22104 
   - awb
22105 
  """
22106 
 
22107 
  thrift_spec = (
22108 
    None, # 0
22109 
    (1, TType.STRING, 'awb', None, None, ), # 1
22110 
  )
22111 
 
22112 
  def __init__(self, awb=None,):
22113 
    self.awb = awb
22114 
 
22115 
  def read(self, iprot):
22116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22118 
      return
22119 
    iprot.readStructBegin()
22120 
    while True:
22121 
      (fname, ftype, fid) = iprot.readFieldBegin()
22122 
      if ftype == TType.STOP:
22123 
        break
22124 
      if fid == 1:
22125 
        if ftype == TType.STRING:
22126 
          self.awb = iprot.readString();
22127 
        else:
22128 
          iprot.skip(ftype)
22129 
      else:
22130 
        iprot.skip(ftype)
22131 
      iprot.readFieldEnd()
22132 
    iprot.readStructEnd()
22133 
 
22134 
  def write(self, oprot):
22135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22137 
      return
22138 
    oprot.writeStructBegin('getOrderForAwb_args')
22139 
    if self.awb is not None:
22140 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
22141 
      oprot.writeString(self.awb)
22142 
      oprot.writeFieldEnd()
22143 
    oprot.writeFieldStop()
22144 
    oprot.writeStructEnd()
22145 
 
22146 
  def validate(self):
22147 
    return
22148 
 
22149 
 
22150 
  def __repr__(self):
22151 
    L = ['%s=%r' % (key, value)
22152 
      for key, value in self.__dict__.iteritems()]
22153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22154 
 
22155 
  def __eq__(self, other):
22156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22157 
 
22158 
  def __ne__(self, other):
22159 
    return not (self == other)
22160 
 
22161 
class getOrderForAwb_result:
22162 
  """
22163 
  Attributes:
22164 
   - success
22165 
   - ex
22166 
  """
22167 
 
22168 
  thrift_spec = (
22169 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
22170 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22171 
  )
22172 
 
22173 
  def __init__(self, success=None, ex=None,):
22174 
    self.success = success
22175 
    self.ex = ex
22176 
 
22177 
  def read(self, iprot):
22178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22180 
      return
22181 
    iprot.readStructBegin()
22182 
    while True:
22183 
      (fname, ftype, fid) = iprot.readFieldBegin()
22184 
      if ftype == TType.STOP:
22185 
        break
22186 
      if fid == 0:
22187 
        if ftype == TType.STRUCT:
22188 
          self.success = Order()
22189 
          self.success.read(iprot)
22190 
        else:
22191 
          iprot.skip(ftype)
22192 
      elif fid == 1:
22193 
        if ftype == TType.STRUCT:
22194 
          self.ex = TransactionServiceException()
22195 
          self.ex.read(iprot)
22196 
        else:
22197 
          iprot.skip(ftype)
22198 
      else:
22199 
        iprot.skip(ftype)
22200 
      iprot.readFieldEnd()
22201 
    iprot.readStructEnd()
22202 
 
22203 
  def write(self, oprot):
22204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22206 
      return
22207 
    oprot.writeStructBegin('getOrderForAwb_result')
22208 
    if self.success is not None:
22209 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22210 
      self.success.write(oprot)
22211 
      oprot.writeFieldEnd()
22212 
    if self.ex is not None:
22213 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22214 
      self.ex.write(oprot)
22215 
      oprot.writeFieldEnd()
22216 
    oprot.writeFieldStop()
22217 
    oprot.writeStructEnd()
22218 
 
22219 
  def validate(self):
22220 
    return
22221 
 
22222 
 
22223 
  def __repr__(self):
22224 
    L = ['%s=%r' % (key, value)
22225 
      for key, value in self.__dict__.iteritems()]
22226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22227 
 
22228 
  def __eq__(self, other):
22229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22230 
 
22231 
  def __ne__(self, other):
22232 
    return not (self == other)
4506 phani.kuma 22233 
 
22234 
class getOrdersForProviderForStatus_args:
22235 
  """
22236 
  Attributes:
22237 
   - logistics_provider_id
4910 phani.kuma 22238 
   - order_status_list
4506 phani.kuma 22239 
  """
22240 
 
22241 
  thrift_spec = (
22242 
    None, # 0
22243 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 22244 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 22245 
  )
22246 
 
4910 phani.kuma 22247 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 22248 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 22249 
    self.order_status_list = order_status_list
4506 phani.kuma 22250 
 
22251 
  def read(self, iprot):
22252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22254 
      return
22255 
    iprot.readStructBegin()
22256 
    while True:
22257 
      (fname, ftype, fid) = iprot.readFieldBegin()
22258 
      if ftype == TType.STOP:
22259 
        break
22260 
      if fid == 1:
22261 
        if ftype == TType.I64:
22262 
          self.logistics_provider_id = iprot.readI64();
22263 
        else:
22264 
          iprot.skip(ftype)
22265 
      elif fid == 2:
4910 phani.kuma 22266 
        if ftype == TType.LIST:
22267 
          self.order_status_list = []
6188 rajveer 22268 
          (_etype513, _size510) = iprot.readListBegin()
22269 
          for _i514 in xrange(_size510):
22270 
            _elem515 = iprot.readI32();
22271 
            self.order_status_list.append(_elem515)
4910 phani.kuma 22272 
          iprot.readListEnd()
4506 phani.kuma 22273 
        else:
22274 
          iprot.skip(ftype)
22275 
      else:
22276 
        iprot.skip(ftype)
22277 
      iprot.readFieldEnd()
22278 
    iprot.readStructEnd()
22279 
 
22280 
  def write(self, oprot):
22281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22283 
      return
22284 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
22285 
    if self.logistics_provider_id is not None:
22286 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
22287 
      oprot.writeI64(self.logistics_provider_id)
22288 
      oprot.writeFieldEnd()
4910 phani.kuma 22289 
    if self.order_status_list is not None:
22290 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
22291 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 22292 
      for iter516 in self.order_status_list:
22293 
        oprot.writeI32(iter516)
4910 phani.kuma 22294 
      oprot.writeListEnd()
4506 phani.kuma 22295 
      oprot.writeFieldEnd()
22296 
    oprot.writeFieldStop()
22297 
    oprot.writeStructEnd()
22298 
 
22299 
  def validate(self):
22300 
    return
22301 
 
22302 
 
22303 
  def __repr__(self):
22304 
    L = ['%s=%r' % (key, value)
22305 
      for key, value in self.__dict__.iteritems()]
22306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22307 
 
22308 
  def __eq__(self, other):
22309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22310 
 
22311 
  def __ne__(self, other):
22312 
    return not (self == other)
22313 
 
22314 
class getOrdersForProviderForStatus_result:
22315 
  """
22316 
  Attributes:
22317 
   - success
22318 
   - ex
22319 
  """
22320 
 
22321 
  thrift_spec = (
22322 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22323 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22324 
  )
22325 
 
22326 
  def __init__(self, success=None, ex=None,):
22327 
    self.success = success
22328 
    self.ex = ex
22329 
 
22330 
  def read(self, iprot):
22331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22333 
      return
22334 
    iprot.readStructBegin()
22335 
    while True:
22336 
      (fname, ftype, fid) = iprot.readFieldBegin()
22337 
      if ftype == TType.STOP:
22338 
        break
22339 
      if fid == 0:
22340 
        if ftype == TType.LIST:
22341 
          self.success = []
6188 rajveer 22342 
          (_etype520, _size517) = iprot.readListBegin()
22343 
          for _i521 in xrange(_size517):
22344 
            _elem522 = Order()
22345 
            _elem522.read(iprot)
22346 
            self.success.append(_elem522)
4506 phani.kuma 22347 
          iprot.readListEnd()
22348 
        else:
22349 
          iprot.skip(ftype)
22350 
      elif fid == 1:
22351 
        if ftype == TType.STRUCT:
22352 
          self.ex = TransactionServiceException()
22353 
          self.ex.read(iprot)
22354 
        else:
22355 
          iprot.skip(ftype)
22356 
      else:
22357 
        iprot.skip(ftype)
22358 
      iprot.readFieldEnd()
22359 
    iprot.readStructEnd()
22360 
 
22361 
  def write(self, oprot):
22362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22364 
      return
22365 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
22366 
    if self.success is not None:
22367 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22368 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22369 
      for iter523 in self.success:
22370 
        iter523.write(oprot)
4506 phani.kuma 22371 
      oprot.writeListEnd()
22372 
      oprot.writeFieldEnd()
22373 
    if self.ex is not None:
22374 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22375 
      self.ex.write(oprot)
22376 
      oprot.writeFieldEnd()
22377 
    oprot.writeFieldStop()
22378 
    oprot.writeStructEnd()
22379 
 
22380 
  def validate(self):
22381 
    return
22382 
 
22383 
 
22384 
  def __repr__(self):
22385 
    L = ['%s=%r' % (key, value)
22386 
      for key, value in self.__dict__.iteritems()]
22387 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22388 
 
22389 
  def __eq__(self, other):
22390 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22391 
 
22392 
  def __ne__(self, other):
22393 
    return not (self == other)
4600 varun.gupt 22394 
 
22395 
class getBilledOrdersForVendor_args:
22396 
  """
22397 
  Attributes:
22398 
   - vendorId
22399 
   - billingDateFrom
22400 
   - billingDateTo
22401 
  """
22402 
 
22403 
  thrift_spec = (
22404 
    None, # 0
22405 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22406 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
22407 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
22408 
  )
22409 
 
22410 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
22411 
    self.vendorId = vendorId
22412 
    self.billingDateFrom = billingDateFrom
22413 
    self.billingDateTo = billingDateTo
22414 
 
22415 
  def read(self, iprot):
22416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22418 
      return
22419 
    iprot.readStructBegin()
22420 
    while True:
22421 
      (fname, ftype, fid) = iprot.readFieldBegin()
22422 
      if ftype == TType.STOP:
22423 
        break
22424 
      if fid == 1:
22425 
        if ftype == TType.I64:
22426 
          self.vendorId = iprot.readI64();
22427 
        else:
22428 
          iprot.skip(ftype)
22429 
      elif fid == 2:
22430 
        if ftype == TType.I64:
22431 
          self.billingDateFrom = iprot.readI64();
22432 
        else:
22433 
          iprot.skip(ftype)
22434 
      elif fid == 3:
22435 
        if ftype == TType.I64:
22436 
          self.billingDateTo = iprot.readI64();
22437 
        else:
22438 
          iprot.skip(ftype)
22439 
      else:
22440 
        iprot.skip(ftype)
22441 
      iprot.readFieldEnd()
22442 
    iprot.readStructEnd()
22443 
 
22444 
  def write(self, oprot):
22445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22447 
      return
22448 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
22449 
    if self.vendorId is not None:
22450 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22451 
      oprot.writeI64(self.vendorId)
22452 
      oprot.writeFieldEnd()
22453 
    if self.billingDateFrom is not None:
22454 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
22455 
      oprot.writeI64(self.billingDateFrom)
22456 
      oprot.writeFieldEnd()
22457 
    if self.billingDateTo is not None:
22458 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
22459 
      oprot.writeI64(self.billingDateTo)
22460 
      oprot.writeFieldEnd()
22461 
    oprot.writeFieldStop()
22462 
    oprot.writeStructEnd()
22463 
 
22464 
  def validate(self):
22465 
    return
22466 
 
22467 
 
22468 
  def __repr__(self):
22469 
    L = ['%s=%r' % (key, value)
22470 
      for key, value in self.__dict__.iteritems()]
22471 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22472 
 
22473 
  def __eq__(self, other):
22474 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22475 
 
22476 
  def __ne__(self, other):
22477 
    return not (self == other)
22478 
 
22479 
class getBilledOrdersForVendor_result:
22480 
  """
22481 
  Attributes:
22482 
   - success
22483 
   - ex
22484 
  """
22485 
 
22486 
  thrift_spec = (
22487 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22488 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22489 
  )
22490 
 
22491 
  def __init__(self, success=None, ex=None,):
22492 
    self.success = success
22493 
    self.ex = ex
22494 
 
22495 
  def read(self, iprot):
22496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22498 
      return
22499 
    iprot.readStructBegin()
22500 
    while True:
22501 
      (fname, ftype, fid) = iprot.readFieldBegin()
22502 
      if ftype == TType.STOP:
22503 
        break
22504 
      if fid == 0:
22505 
        if ftype == TType.LIST:
22506 
          self.success = []
6188 rajveer 22507 
          (_etype527, _size524) = iprot.readListBegin()
22508 
          for _i528 in xrange(_size524):
22509 
            _elem529 = Order()
22510 
            _elem529.read(iprot)
22511 
            self.success.append(_elem529)
4600 varun.gupt 22512 
          iprot.readListEnd()
22513 
        else:
22514 
          iprot.skip(ftype)
22515 
      elif fid == 1:
22516 
        if ftype == TType.STRUCT:
22517 
          self.ex = TransactionServiceException()
22518 
          self.ex.read(iprot)
22519 
        else:
22520 
          iprot.skip(ftype)
22521 
      else:
22522 
        iprot.skip(ftype)
22523 
      iprot.readFieldEnd()
22524 
    iprot.readStructEnd()
22525 
 
22526 
  def write(self, oprot):
22527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22529 
      return
22530 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
22531 
    if self.success is not None:
22532 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22533 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22534 
      for iter530 in self.success:
22535 
        iter530.write(oprot)
4600 varun.gupt 22536 
      oprot.writeListEnd()
22537 
      oprot.writeFieldEnd()
22538 
    if self.ex is not None:
22539 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22540 
      self.ex.write(oprot)
22541 
      oprot.writeFieldEnd()
22542 
    oprot.writeFieldStop()
22543 
    oprot.writeStructEnd()
22544 
 
22545 
  def validate(self):
22546 
    return
22547 
 
22548 
 
22549 
  def __repr__(self):
22550 
    L = ['%s=%r' % (key, value)
22551 
      for key, value in self.__dict__.iteritems()]
22552 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22553 
 
22554 
  def __eq__(self, other):
22555 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22556 
 
22557 
  def __ne__(self, other):
22558 
    return not (self == other)
22559 
 
4607 rajveer 22560 
class getSlippedSippingDateOrders_args:
22561 
 
22562 
  thrift_spec = (
22563 
  )
22564 
 
22565 
  def read(self, iprot):
22566 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22567 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22568 
      return
22569 
    iprot.readStructBegin()
22570 
    while True:
22571 
      (fname, ftype, fid) = iprot.readFieldBegin()
22572 
      if ftype == TType.STOP:
22573 
        break
22574 
      else:
22575 
        iprot.skip(ftype)
22576 
      iprot.readFieldEnd()
22577 
    iprot.readStructEnd()
22578 
 
22579 
  def write(self, oprot):
22580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22582 
      return
22583 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
22584 
    oprot.writeFieldStop()
22585 
    oprot.writeStructEnd()
22586 
 
22587 
  def validate(self):
22588 
    return
22589 
 
22590 
 
22591 
  def __repr__(self):
22592 
    L = ['%s=%r' % (key, value)
22593 
      for key, value in self.__dict__.iteritems()]
22594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22595 
 
22596 
  def __eq__(self, other):
22597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22598 
 
22599 
  def __ne__(self, other):
22600 
    return not (self == other)
22601 
 
22602 
class getSlippedSippingDateOrders_result:
22603 
  """
22604 
  Attributes:
22605 
   - success
22606 
   - ex
22607 
  """
22608 
 
22609 
  thrift_spec = (
22610 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22611 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22612 
  )
22613 
 
22614 
  def __init__(self, success=None, ex=None,):
22615 
    self.success = success
22616 
    self.ex = ex
22617 
 
22618 
  def read(self, iprot):
22619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22621 
      return
22622 
    iprot.readStructBegin()
22623 
    while True:
22624 
      (fname, ftype, fid) = iprot.readFieldBegin()
22625 
      if ftype == TType.STOP:
22626 
        break
22627 
      if fid == 0:
22628 
        if ftype == TType.LIST:
22629 
          self.success = []
6188 rajveer 22630 
          (_etype534, _size531) = iprot.readListBegin()
22631 
          for _i535 in xrange(_size531):
22632 
            _elem536 = Order()
22633 
            _elem536.read(iprot)
22634 
            self.success.append(_elem536)
4607 rajveer 22635 
          iprot.readListEnd()
22636 
        else:
22637 
          iprot.skip(ftype)
22638 
      elif fid == 1:
22639 
        if ftype == TType.STRUCT:
22640 
          self.ex = TransactionServiceException()
22641 
          self.ex.read(iprot)
22642 
        else:
22643 
          iprot.skip(ftype)
22644 
      else:
22645 
        iprot.skip(ftype)
22646 
      iprot.readFieldEnd()
22647 
    iprot.readStructEnd()
22648 
 
22649 
  def write(self, oprot):
22650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22652 
      return
22653 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22654 
    if self.success is not None:
22655 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22656 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22657 
      for iter537 in self.success:
22658 
        iter537.write(oprot)
4607 rajveer 22659 
      oprot.writeListEnd()
22660 
      oprot.writeFieldEnd()
22661 
    if self.ex is not None:
22662 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22663 
      self.ex.write(oprot)
22664 
      oprot.writeFieldEnd()
22665 
    oprot.writeFieldStop()
22666 
    oprot.writeStructEnd()
22667 
 
22668 
  def validate(self):
22669 
    return
22670 
 
22671 
 
22672 
  def __repr__(self):
22673 
    L = ['%s=%r' % (key, value)
22674 
      for key, value in self.__dict__.iteritems()]
22675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22676 
 
22677 
  def __eq__(self, other):
22678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22679 
 
22680 
  def __ne__(self, other):
22681 
    return not (self == other)
22682 
 
4709 rajveer 22683 
class getCancelledOrders_args:
22684 
  """
22685 
  Attributes:
22686 
   - cancelDateFrom
22687 
   - cancelDateTo
22688 
  """
22689 
 
22690 
  thrift_spec = (
22691 
    None, # 0
22692 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
22693 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
22694 
  )
22695 
 
22696 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
22697 
    self.cancelDateFrom = cancelDateFrom
22698 
    self.cancelDateTo = cancelDateTo
22699 
 
22700 
  def read(self, iprot):
22701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22703 
      return
22704 
    iprot.readStructBegin()
22705 
    while True:
22706 
      (fname, ftype, fid) = iprot.readFieldBegin()
22707 
      if ftype == TType.STOP:
22708 
        break
22709 
      if fid == 1:
22710 
        if ftype == TType.I64:
22711 
          self.cancelDateFrom = iprot.readI64();
22712 
        else:
22713 
          iprot.skip(ftype)
22714 
      elif fid == 2:
22715 
        if ftype == TType.I64:
22716 
          self.cancelDateTo = iprot.readI64();
22717 
        else:
22718 
          iprot.skip(ftype)
22719 
      else:
22720 
        iprot.skip(ftype)
22721 
      iprot.readFieldEnd()
22722 
    iprot.readStructEnd()
22723 
 
22724 
  def write(self, oprot):
22725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22727 
      return
22728 
    oprot.writeStructBegin('getCancelledOrders_args')
22729 
    if self.cancelDateFrom is not None:
22730 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
22731 
      oprot.writeI64(self.cancelDateFrom)
22732 
      oprot.writeFieldEnd()
22733 
    if self.cancelDateTo is not None:
22734 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
22735 
      oprot.writeI64(self.cancelDateTo)
22736 
      oprot.writeFieldEnd()
22737 
    oprot.writeFieldStop()
22738 
    oprot.writeStructEnd()
22739 
 
22740 
  def validate(self):
22741 
    return
22742 
 
22743 
 
22744 
  def __repr__(self):
22745 
    L = ['%s=%r' % (key, value)
22746 
      for key, value in self.__dict__.iteritems()]
22747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22748 
 
22749 
  def __eq__(self, other):
22750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22751 
 
22752 
  def __ne__(self, other):
22753 
    return not (self == other)
22754 
 
22755 
class getCancelledOrders_result:
22756 
  """
22757 
  Attributes:
22758 
   - success
22759 
   - ex
22760 
  """
22761 
 
22762 
  thrift_spec = (
22763 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22764 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22765 
  )
22766 
 
22767 
  def __init__(self, success=None, ex=None,):
22768 
    self.success = success
22769 
    self.ex = ex
22770 
 
22771 
  def read(self, iprot):
22772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22774 
      return
22775 
    iprot.readStructBegin()
22776 
    while True:
22777 
      (fname, ftype, fid) = iprot.readFieldBegin()
22778 
      if ftype == TType.STOP:
22779 
        break
22780 
      if fid == 0:
22781 
        if ftype == TType.LIST:
22782 
          self.success = []
6188 rajveer 22783 
          (_etype541, _size538) = iprot.readListBegin()
22784 
          for _i542 in xrange(_size538):
22785 
            _elem543 = Order()
22786 
            _elem543.read(iprot)
22787 
            self.success.append(_elem543)
4709 rajveer 22788 
          iprot.readListEnd()
22789 
        else:
22790 
          iprot.skip(ftype)
22791 
      elif fid == 1:
22792 
        if ftype == TType.STRUCT:
22793 
          self.ex = TransactionServiceException()
22794 
          self.ex.read(iprot)
22795 
        else:
22796 
          iprot.skip(ftype)
22797 
      else:
22798 
        iprot.skip(ftype)
22799 
      iprot.readFieldEnd()
22800 
    iprot.readStructEnd()
22801 
 
22802 
  def write(self, oprot):
22803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22805 
      return
22806 
    oprot.writeStructBegin('getCancelledOrders_result')
22807 
    if self.success is not None:
22808 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22809 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22810 
      for iter544 in self.success:
22811 
        iter544.write(oprot)
4709 rajveer 22812 
      oprot.writeListEnd()
22813 
      oprot.writeFieldEnd()
22814 
    if self.ex is not None:
22815 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22816 
      self.ex.write(oprot)
22817 
      oprot.writeFieldEnd()
22818 
    oprot.writeFieldStop()
22819 
    oprot.writeStructEnd()
22820 
 
22821 
  def validate(self):
22822 
    return
22823 
 
22824 
 
22825 
  def __repr__(self):
22826 
    L = ['%s=%r' % (key, value)
22827 
      for key, value in self.__dict__.iteritems()]
22828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22829 
 
22830 
  def __eq__(self, other):
22831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22832 
 
22833 
  def __ne__(self, other):
22834 
    return not (self == other)
22835 
 
4600 varun.gupt 22836 
class saveBluedartSettlements_args:
22837 
  """
22838 
  Attributes:
22839 
   - mapAWBAndAmount
22840 
  """
22841 
 
22842 
  thrift_spec = (
22843 
    None, # 0
22844 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
22845 
  )
22846 
 
22847 
  def __init__(self, mapAWBAndAmount=None,):
22848 
    self.mapAWBAndAmount = mapAWBAndAmount
22849 
 
22850 
  def read(self, iprot):
22851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22853 
      return
22854 
    iprot.readStructBegin()
22855 
    while True:
22856 
      (fname, ftype, fid) = iprot.readFieldBegin()
22857 
      if ftype == TType.STOP:
22858 
        break
22859 
      if fid == 1:
22860 
        if ftype == TType.MAP:
22861 
          self.mapAWBAndAmount = {}
6188 rajveer 22862 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
22863 
          for _i549 in xrange(_size545):
22864 
            _key550 = iprot.readI64();
22865 
            _val551 = iprot.readDouble();
22866 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 22867 
          iprot.readMapEnd()
22868 
        else:
22869 
          iprot.skip(ftype)
22870 
      else:
22871 
        iprot.skip(ftype)
22872 
      iprot.readFieldEnd()
22873 
    iprot.readStructEnd()
22874 
 
22875 
  def write(self, oprot):
22876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22878 
      return
22879 
    oprot.writeStructBegin('saveBluedartSettlements_args')
22880 
    if self.mapAWBAndAmount is not None:
22881 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
22882 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 22883 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
22884 
        oprot.writeI64(kiter552)
22885 
        oprot.writeDouble(viter553)
4600 varun.gupt 22886 
      oprot.writeMapEnd()
22887 
      oprot.writeFieldEnd()
22888 
    oprot.writeFieldStop()
22889 
    oprot.writeStructEnd()
22890 
 
22891 
  def validate(self):
22892 
    return
22893 
 
22894 
 
22895 
  def __repr__(self):
22896 
    L = ['%s=%r' % (key, value)
22897 
      for key, value in self.__dict__.iteritems()]
22898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22899 
 
22900 
  def __eq__(self, other):
22901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22902 
 
22903 
  def __ne__(self, other):
22904 
    return not (self == other)
22905 
 
22906 
class saveBluedartSettlements_result:
22907 
  """
22908 
  Attributes:
22909 
   - ex
22910 
  """
22911 
 
22912 
  thrift_spec = (
22913 
    None, # 0
22914 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22915 
  )
22916 
 
22917 
  def __init__(self, ex=None,):
22918 
    self.ex = ex
22919 
 
22920 
  def read(self, iprot):
22921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22923 
      return
22924 
    iprot.readStructBegin()
22925 
    while True:
22926 
      (fname, ftype, fid) = iprot.readFieldBegin()
22927 
      if ftype == TType.STOP:
22928 
        break
22929 
      if fid == 1:
22930 
        if ftype == TType.STRUCT:
22931 
          self.ex = TransactionServiceException()
22932 
          self.ex.read(iprot)
22933 
        else:
22934 
          iprot.skip(ftype)
22935 
      else:
22936 
        iprot.skip(ftype)
22937 
      iprot.readFieldEnd()
22938 
    iprot.readStructEnd()
22939 
 
22940 
  def write(self, oprot):
22941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22943 
      return
22944 
    oprot.writeStructBegin('saveBluedartSettlements_result')
22945 
    if self.ex is not None:
22946 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22947 
      self.ex.write(oprot)
22948 
      oprot.writeFieldEnd()
22949 
    oprot.writeFieldStop()
22950 
    oprot.writeStructEnd()
22951 
 
22952 
  def validate(self):
22953 
    return
22954 
 
22955 
 
22956 
  def __repr__(self):
22957 
    L = ['%s=%r' % (key, value)
22958 
      for key, value in self.__dict__.iteritems()]
22959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22960 
 
22961 
  def __eq__(self, other):
22962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22963 
 
22964 
  def __ne__(self, other):
22965 
    return not (self == other)
22966 
 
22967 
class savePaymentSettlements_args:
22968 
  """
22969 
  Attributes:
22970 
   - settlementDate
22971 
   - paymentGatewayId
4905 varun.gupt 22972 
   - referenceId
4600 varun.gupt 22973 
   - serviceTax
22974 
   - otherCharges
22975 
   - netCollection
22976 
  """
22977 
 
22978 
  thrift_spec = (
22979 
    None, # 0
22980 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
22981 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 22982 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 22983 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
22984 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
22985 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
22986 
  )
22987 
 
4905 varun.gupt 22988 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 22989 
    self.settlementDate = settlementDate
22990 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 22991 
    self.referenceId = referenceId
4600 varun.gupt 22992 
    self.serviceTax = serviceTax
22993 
    self.otherCharges = otherCharges
22994 
    self.netCollection = netCollection
22995 
 
22996 
  def read(self, iprot):
22997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22999 
      return
23000 
    iprot.readStructBegin()
23001 
    while True:
23002 
      (fname, ftype, fid) = iprot.readFieldBegin()
23003 
      if ftype == TType.STOP:
23004 
        break
23005 
      if fid == 1:
23006 
        if ftype == TType.I64:
23007 
          self.settlementDate = iprot.readI64();
23008 
        else:
23009 
          iprot.skip(ftype)
23010 
      elif fid == 2:
23011 
        if ftype == TType.I64:
23012 
          self.paymentGatewayId = iprot.readI64();
23013 
        else:
23014 
          iprot.skip(ftype)
23015 
      elif fid == 3:
23016 
        if ftype == TType.I64:
4905 varun.gupt 23017 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23018 
        else:
23019 
          iprot.skip(ftype)
23020 
      elif fid == 4:
23021 
        if ftype == TType.DOUBLE:
23022 
          self.serviceTax = iprot.readDouble();
23023 
        else:
23024 
          iprot.skip(ftype)
23025 
      elif fid == 5:
23026 
        if ftype == TType.DOUBLE:
23027 
          self.otherCharges = iprot.readDouble();
23028 
        else:
23029 
          iprot.skip(ftype)
23030 
      elif fid == 6:
23031 
        if ftype == TType.DOUBLE:
23032 
          self.netCollection = iprot.readDouble();
23033 
        else:
23034 
          iprot.skip(ftype)
23035 
      else:
23036 
        iprot.skip(ftype)
23037 
      iprot.readFieldEnd()
23038 
    iprot.readStructEnd()
23039 
 
23040 
  def write(self, oprot):
23041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23043 
      return
23044 
    oprot.writeStructBegin('savePaymentSettlements_args')
23045 
    if self.settlementDate is not None:
23046 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
23047 
      oprot.writeI64(self.settlementDate)
23048 
      oprot.writeFieldEnd()
23049 
    if self.paymentGatewayId is not None:
23050 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
23051 
      oprot.writeI64(self.paymentGatewayId)
23052 
      oprot.writeFieldEnd()
4905 varun.gupt 23053 
    if self.referenceId is not None:
23054 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
23055 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23056 
      oprot.writeFieldEnd()
23057 
    if self.serviceTax is not None:
23058 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
23059 
      oprot.writeDouble(self.serviceTax)
23060 
      oprot.writeFieldEnd()
23061 
    if self.otherCharges is not None:
23062 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
23063 
      oprot.writeDouble(self.otherCharges)
23064 
      oprot.writeFieldEnd()
23065 
    if self.netCollection is not None:
23066 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
23067 
      oprot.writeDouble(self.netCollection)
23068 
      oprot.writeFieldEnd()
23069 
    oprot.writeFieldStop()
23070 
    oprot.writeStructEnd()
23071 
 
23072 
  def validate(self):
23073 
    return
23074 
 
23075 
 
23076 
  def __repr__(self):
23077 
    L = ['%s=%r' % (key, value)
23078 
      for key, value in self.__dict__.iteritems()]
23079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23080 
 
23081 
  def __eq__(self, other):
23082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23083 
 
23084 
  def __ne__(self, other):
23085 
    return not (self == other)
23086 
 
23087 
class savePaymentSettlements_result:
23088 
  """
23089 
  Attributes:
23090 
   - ex
23091 
  """
23092 
 
23093 
  thrift_spec = (
23094 
    None, # 0
23095 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23096 
  )
23097 
 
23098 
  def __init__(self, ex=None,):
23099 
    self.ex = ex
23100 
 
23101 
  def read(self, iprot):
23102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23104 
      return
23105 
    iprot.readStructBegin()
23106 
    while True:
23107 
      (fname, ftype, fid) = iprot.readFieldBegin()
23108 
      if ftype == TType.STOP:
23109 
        break
23110 
      if fid == 1:
23111 
        if ftype == TType.STRUCT:
23112 
          self.ex = TransactionServiceException()
23113 
          self.ex.read(iprot)
23114 
        else:
23115 
          iprot.skip(ftype)
23116 
      else:
23117 
        iprot.skip(ftype)
23118 
      iprot.readFieldEnd()
23119 
    iprot.readStructEnd()
23120 
 
23121 
  def write(self, oprot):
23122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23124 
      return
23125 
    oprot.writeStructBegin('savePaymentSettlements_result')
23126 
    if self.ex is not None:
23127 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23128 
      self.ex.write(oprot)
23129 
      oprot.writeFieldEnd()
23130 
    oprot.writeFieldStop()
23131 
    oprot.writeStructEnd()
23132 
 
23133 
  def validate(self):
23134 
    return
23135 
 
23136 
 
23137 
  def __repr__(self):
23138 
    L = ['%s=%r' % (key, value)
23139 
      for key, value in self.__dict__.iteritems()]
23140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23141 
 
23142 
  def __eq__(self, other):
23143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23144 
 
23145 
  def __ne__(self, other):
23146 
    return not (self == other)
23147 
 
23148 
class saveEBSSettlementSummary_args:
23149 
  """
23150 
  Attributes:
23151 
   - settlementId
23152 
   - settlementDate
23153 
   - transactionDateFrom
23154 
   - transactionDateTo
23155 
   - amount
23156 
  """
23157 
 
23158 
  thrift_spec = (
23159 
    None, # 0
23160 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23161 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
23162 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
23163 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
23164 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
23165 
  )
23166 
 
23167 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
23168 
    self.settlementId = settlementId
23169 
    self.settlementDate = settlementDate
23170 
    self.transactionDateFrom = transactionDateFrom
23171 
    self.transactionDateTo = transactionDateTo
23172 
    self.amount = amount
23173 
 
23174 
  def read(self, iprot):
23175 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23176 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23177 
      return
23178 
    iprot.readStructBegin()
23179 
    while True:
23180 
      (fname, ftype, fid) = iprot.readFieldBegin()
23181 
      if ftype == TType.STOP:
23182 
        break
23183 
      if fid == 1:
23184 
        if ftype == TType.I64:
23185 
          self.settlementId = iprot.readI64();
23186 
        else:
23187 
          iprot.skip(ftype)
23188 
      elif fid == 2:
23189 
        if ftype == TType.I64:
23190 
          self.settlementDate = iprot.readI64();
23191 
        else:
23192 
          iprot.skip(ftype)
23193 
      elif fid == 3:
23194 
        if ftype == TType.I64:
23195 
          self.transactionDateFrom = iprot.readI64();
23196 
        else:
23197 
          iprot.skip(ftype)
23198 
      elif fid == 4:
23199 
        if ftype == TType.I64:
23200 
          self.transactionDateTo = iprot.readI64();
23201 
        else:
23202 
          iprot.skip(ftype)
23203 
      elif fid == 5:
23204 
        if ftype == TType.DOUBLE:
23205 
          self.amount = iprot.readDouble();
23206 
        else:
23207 
          iprot.skip(ftype)
23208 
      else:
23209 
        iprot.skip(ftype)
23210 
      iprot.readFieldEnd()
23211 
    iprot.readStructEnd()
23212 
 
23213 
  def write(self, oprot):
23214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23216 
      return
23217 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
23218 
    if self.settlementId is not None:
23219 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23220 
      oprot.writeI64(self.settlementId)
23221 
      oprot.writeFieldEnd()
23222 
    if self.settlementDate is not None:
23223 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
23224 
      oprot.writeI64(self.settlementDate)
23225 
      oprot.writeFieldEnd()
23226 
    if self.transactionDateFrom is not None:
23227 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
23228 
      oprot.writeI64(self.transactionDateFrom)
23229 
      oprot.writeFieldEnd()
23230 
    if self.transactionDateTo is not None:
23231 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
23232 
      oprot.writeI64(self.transactionDateTo)
23233 
      oprot.writeFieldEnd()
23234 
    if self.amount is not None:
23235 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
23236 
      oprot.writeDouble(self.amount)
23237 
      oprot.writeFieldEnd()
23238 
    oprot.writeFieldStop()
23239 
    oprot.writeStructEnd()
23240 
 
23241 
  def validate(self):
23242 
    return
23243 
 
23244 
 
23245 
  def __repr__(self):
23246 
    L = ['%s=%r' % (key, value)
23247 
      for key, value in self.__dict__.iteritems()]
23248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23249 
 
23250 
  def __eq__(self, other):
23251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23252 
 
23253 
  def __ne__(self, other):
23254 
    return not (self == other)
23255 
 
23256 
class saveEBSSettlementSummary_result:
23257 
  """
23258 
  Attributes:
23259 
   - ex
23260 
  """
23261 
 
23262 
  thrift_spec = (
23263 
    None, # 0
23264 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23265 
  )
23266 
 
23267 
  def __init__(self, ex=None,):
23268 
    self.ex = ex
23269 
 
23270 
  def read(self, iprot):
23271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23273 
      return
23274 
    iprot.readStructBegin()
23275 
    while True:
23276 
      (fname, ftype, fid) = iprot.readFieldBegin()
23277 
      if ftype == TType.STOP:
23278 
        break
23279 
      if fid == 1:
23280 
        if ftype == TType.STRUCT:
23281 
          self.ex = TransactionServiceException()
23282 
          self.ex.read(iprot)
23283 
        else:
23284 
          iprot.skip(ftype)
23285 
      else:
23286 
        iprot.skip(ftype)
23287 
      iprot.readFieldEnd()
23288 
    iprot.readStructEnd()
23289 
 
23290 
  def write(self, oprot):
23291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23293 
      return
23294 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
23295 
    if self.ex is not None:
23296 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23297 
      self.ex.write(oprot)
23298 
      oprot.writeFieldEnd()
23299 
    oprot.writeFieldStop()
23300 
    oprot.writeStructEnd()
23301 
 
23302 
  def validate(self):
23303 
    return
23304 
 
23305 
 
23306 
  def __repr__(self):
23307 
    L = ['%s=%r' % (key, value)
23308 
      for key, value in self.__dict__.iteritems()]
23309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23310 
 
23311 
  def __eq__(self, other):
23312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23313 
 
23314 
  def __ne__(self, other):
23315 
    return not (self == other)
23316 
 
5386 phani.kuma 23317 
class getSettlementForPrepaid_args:
4600 varun.gupt 23318 
  """
23319 
  Attributes:
5189 varun.gupt 23320 
   - referenceId
23321 
   - isRefund
4600 varun.gupt 23322 
  """
23323 
 
23324 
  thrift_spec = (
23325 
    None, # 0
5189 varun.gupt 23326 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 23327 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 23328 
  )
23329 
 
5386 phani.kuma 23330 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 23331 
    self.referenceId = referenceId
23332 
    self.isRefund = isRefund
4600 varun.gupt 23333 
 
23334 
  def read(self, iprot):
23335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23337 
      return
23338 
    iprot.readStructBegin()
23339 
    while True:
23340 
      (fname, ftype, fid) = iprot.readFieldBegin()
23341 
      if ftype == TType.STOP:
23342 
        break
23343 
      if fid == 1:
23344 
        if ftype == TType.I64:
5189 varun.gupt 23345 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23346 
        else:
23347 
          iprot.skip(ftype)
5189 varun.gupt 23348 
      elif fid == 2:
23349 
        if ftype == TType.BOOL:
23350 
          self.isRefund = iprot.readBool();
23351 
        else:
23352 
          iprot.skip(ftype)
4600 varun.gupt 23353 
      else:
23354 
        iprot.skip(ftype)
23355 
      iprot.readFieldEnd()
23356 
    iprot.readStructEnd()
23357 
 
23358 
  def write(self, oprot):
23359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23361 
      return
5386 phani.kuma 23362 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 23363 
    if self.referenceId is not None:
23364 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
23365 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23366 
      oprot.writeFieldEnd()
5386 phani.kuma 23367 
    if self.isRefund is not None:
23368 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
23369 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 23370 
      oprot.writeFieldEnd()
5386 phani.kuma 23371 
    oprot.writeFieldStop()
23372 
    oprot.writeStructEnd()
23373 
 
23374 
  def validate(self):
23375 
    return
23376 
 
23377 
 
23378 
  def __repr__(self):
23379 
    L = ['%s=%r' % (key, value)
23380 
      for key, value in self.__dict__.iteritems()]
23381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23382 
 
23383 
  def __eq__(self, other):
23384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23385 
 
23386 
  def __ne__(self, other):
23387 
    return not (self == other)
23388 
 
23389 
class getSettlementForPrepaid_result:
23390 
  """
23391 
  Attributes:
23392 
   - success
23393 
   - ex
23394 
  """
23395 
 
23396 
  thrift_spec = (
23397 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23398 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23399 
  )
23400 
 
23401 
  def __init__(self, success=None, ex=None,):
23402 
    self.success = success
23403 
    self.ex = ex
23404 
 
23405 
  def read(self, iprot):
23406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23408 
      return
23409 
    iprot.readStructBegin()
23410 
    while True:
23411 
      (fname, ftype, fid) = iprot.readFieldBegin()
23412 
      if ftype == TType.STOP:
23413 
        break
23414 
      if fid == 0:
23415 
        if ftype == TType.STRUCT:
23416 
          self.success = PaymentSettlement()
23417 
          self.success.read(iprot)
23418 
        else:
23419 
          iprot.skip(ftype)
23420 
      elif fid == 1:
23421 
        if ftype == TType.STRUCT:
23422 
          self.ex = TransactionServiceException()
23423 
          self.ex.read(iprot)
23424 
        else:
23425 
          iprot.skip(ftype)
23426 
      else:
23427 
        iprot.skip(ftype)
23428 
      iprot.readFieldEnd()
23429 
    iprot.readStructEnd()
23430 
 
23431 
  def write(self, oprot):
23432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23434 
      return
23435 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
23436 
    if self.success is not None:
23437 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23438 
      self.success.write(oprot)
23439 
      oprot.writeFieldEnd()
23440 
    if self.ex is not None:
23441 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23442 
      self.ex.write(oprot)
23443 
      oprot.writeFieldEnd()
23444 
    oprot.writeFieldStop()
23445 
    oprot.writeStructEnd()
23446 
 
23447 
  def validate(self):
23448 
    return
23449 
 
23450 
 
23451 
  def __repr__(self):
23452 
    L = ['%s=%r' % (key, value)
23453 
      for key, value in self.__dict__.iteritems()]
23454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23455 
 
23456 
  def __eq__(self, other):
23457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23458 
 
23459 
  def __ne__(self, other):
23460 
    return not (self == other)
23461 
 
23462 
class getSettlementForCod_args:
23463 
  """
23464 
  Attributes:
23465 
   - orderId
23466 
   - isRefund
23467 
  """
23468 
 
23469 
  thrift_spec = (
23470 
    None, # 0
23471 
    (1, TType.I64, 'orderId', None, None, ), # 1
23472 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
23473 
  )
23474 
 
23475 
  def __init__(self, orderId=None, isRefund=None,):
23476 
    self.orderId = orderId
23477 
    self.isRefund = isRefund
23478 
 
23479 
  def read(self, iprot):
23480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23482 
      return
23483 
    iprot.readStructBegin()
23484 
    while True:
23485 
      (fname, ftype, fid) = iprot.readFieldBegin()
23486 
      if ftype == TType.STOP:
23487 
        break
23488 
      if fid == 1:
23489 
        if ftype == TType.I64:
23490 
          self.orderId = iprot.readI64();
23491 
        else:
23492 
          iprot.skip(ftype)
23493 
      elif fid == 2:
23494 
        if ftype == TType.BOOL:
23495 
          self.isRefund = iprot.readBool();
23496 
        else:
23497 
          iprot.skip(ftype)
23498 
      else:
23499 
        iprot.skip(ftype)
23500 
      iprot.readFieldEnd()
23501 
    iprot.readStructEnd()
23502 
 
23503 
  def write(self, oprot):
23504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23506 
      return
23507 
    oprot.writeStructBegin('getSettlementForCod_args')
23508 
    if self.orderId is not None:
23509 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23510 
      oprot.writeI64(self.orderId)
23511 
      oprot.writeFieldEnd()
5189 varun.gupt 23512 
    if self.isRefund is not None:
5386 phani.kuma 23513 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23514 
      oprot.writeBool(self.isRefund)
23515 
      oprot.writeFieldEnd()
4600 varun.gupt 23516 
    oprot.writeFieldStop()
23517 
    oprot.writeStructEnd()
23518 
 
23519 
  def validate(self):
23520 
    return
23521 
 
23522 
 
23523 
  def __repr__(self):
23524 
    L = ['%s=%r' % (key, value)
23525 
      for key, value in self.__dict__.iteritems()]
23526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23527 
 
23528 
  def __eq__(self, other):
23529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23530 
 
23531 
  def __ne__(self, other):
23532 
    return not (self == other)
23533 
 
5386 phani.kuma 23534 
class getSettlementForCod_result:
4600 varun.gupt 23535 
  """
23536 
  Attributes:
23537 
   - success
23538 
   - ex
23539 
  """
23540 
 
23541 
  thrift_spec = (
23542 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23543 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23544 
  )
23545 
 
23546 
  def __init__(self, success=None, ex=None,):
23547 
    self.success = success
23548 
    self.ex = ex
23549 
 
23550 
  def read(self, iprot):
23551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23553 
      return
23554 
    iprot.readStructBegin()
23555 
    while True:
23556 
      (fname, ftype, fid) = iprot.readFieldBegin()
23557 
      if ftype == TType.STOP:
23558 
        break
23559 
      if fid == 0:
23560 
        if ftype == TType.STRUCT:
23561 
          self.success = PaymentSettlement()
23562 
          self.success.read(iprot)
23563 
        else:
23564 
          iprot.skip(ftype)
23565 
      elif fid == 1:
23566 
        if ftype == TType.STRUCT:
23567 
          self.ex = TransactionServiceException()
23568 
          self.ex.read(iprot)
23569 
        else:
23570 
          iprot.skip(ftype)
23571 
      else:
23572 
        iprot.skip(ftype)
23573 
      iprot.readFieldEnd()
23574 
    iprot.readStructEnd()
23575 
 
23576 
  def write(self, oprot):
23577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23579 
      return
5386 phani.kuma 23580 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 23581 
    if self.success is not None:
23582 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23583 
      self.success.write(oprot)
23584 
      oprot.writeFieldEnd()
23585 
    if self.ex is not None:
23586 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23587 
      self.ex.write(oprot)
23588 
      oprot.writeFieldEnd()
23589 
    oprot.writeFieldStop()
23590 
    oprot.writeStructEnd()
23591 
 
23592 
  def validate(self):
23593 
    return
23594 
 
23595 
 
23596 
  def __repr__(self):
23597 
    L = ['%s=%r' % (key, value)
23598 
      for key, value in self.__dict__.iteritems()]
23599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23600 
 
23601 
  def __eq__(self, other):
23602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23603 
 
23604 
  def __ne__(self, other):
23605 
    return not (self == other)
23606 
 
23607 
class getEBSSettlementSummaries_args:
23608 
 
23609 
  thrift_spec = (
23610 
  )
23611 
 
23612 
  def read(self, iprot):
23613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23615 
      return
23616 
    iprot.readStructBegin()
23617 
    while True:
23618 
      (fname, ftype, fid) = iprot.readFieldBegin()
23619 
      if ftype == TType.STOP:
23620 
        break
23621 
      else:
23622 
        iprot.skip(ftype)
23623 
      iprot.readFieldEnd()
23624 
    iprot.readStructEnd()
23625 
 
23626 
  def write(self, oprot):
23627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23629 
      return
23630 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
23631 
    oprot.writeFieldStop()
23632 
    oprot.writeStructEnd()
23633 
 
23634 
  def validate(self):
23635 
    return
23636 
 
23637 
 
23638 
  def __repr__(self):
23639 
    L = ['%s=%r' % (key, value)
23640 
      for key, value in self.__dict__.iteritems()]
23641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23642 
 
23643 
  def __eq__(self, other):
23644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23645 
 
23646 
  def __ne__(self, other):
23647 
    return not (self == other)
23648 
 
23649 
class getEBSSettlementSummaries_result:
23650 
  """
23651 
  Attributes:
23652 
   - success
23653 
   - ex
23654 
  """
23655 
 
23656 
  thrift_spec = (
23657 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23658 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23659 
  )
23660 
 
23661 
  def __init__(self, success=None, ex=None,):
23662 
    self.success = success
23663 
    self.ex = ex
23664 
 
23665 
  def read(self, iprot):
23666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23668 
      return
23669 
    iprot.readStructBegin()
23670 
    while True:
23671 
      (fname, ftype, fid) = iprot.readFieldBegin()
23672 
      if ftype == TType.STOP:
23673 
        break
23674 
      if fid == 0:
23675 
        if ftype == TType.MAP:
23676 
          self.success = {}
6188 rajveer 23677 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
23678 
          for _i558 in xrange(_size554):
23679 
            _key559 = iprot.readI64();
23680 
            _val560 = iprot.readString();
23681 
            self.success[_key559] = _val560
4600 varun.gupt 23682 
          iprot.readMapEnd()
23683 
        else:
23684 
          iprot.skip(ftype)
23685 
      elif fid == 1:
23686 
        if ftype == TType.STRUCT:
23687 
          self.ex = TransactionServiceException()
23688 
          self.ex.read(iprot)
23689 
        else:
23690 
          iprot.skip(ftype)
23691 
      else:
23692 
        iprot.skip(ftype)
23693 
      iprot.readFieldEnd()
23694 
    iprot.readStructEnd()
23695 
 
23696 
  def write(self, oprot):
23697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23699 
      return
23700 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
23701 
    if self.success is not None:
23702 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23703 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 23704 
      for kiter561,viter562 in self.success.items():
23705 
        oprot.writeI64(kiter561)
23706 
        oprot.writeString(viter562)
4600 varun.gupt 23707 
      oprot.writeMapEnd()
23708 
      oprot.writeFieldEnd()
23709 
    if self.ex is not None:
23710 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23711 
      self.ex.write(oprot)
23712 
      oprot.writeFieldEnd()
23713 
    oprot.writeFieldStop()
23714 
    oprot.writeStructEnd()
23715 
 
23716 
  def validate(self):
23717 
    return
23718 
 
23719 
 
23720 
  def __repr__(self):
23721 
    L = ['%s=%r' % (key, value)
23722 
      for key, value in self.__dict__.iteritems()]
23723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23724 
 
23725 
  def __eq__(self, other):
23726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23727 
 
23728 
  def __ne__(self, other):
23729 
    return not (self == other)
23730 
 
23731 
class markEBSSettlementUploaded_args:
23732 
  """
23733 
  Attributes:
23734 
   - settlementId
23735 
  """
23736 
 
23737 
  thrift_spec = (
23738 
    None, # 0
23739 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23740 
  )
23741 
 
23742 
  def __init__(self, settlementId=None,):
23743 
    self.settlementId = settlementId
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.settlementId = iprot.readI64();
23757 
        else:
23758 
          iprot.skip(ftype)
23759 
      else:
23760 
        iprot.skip(ftype)
23761 
      iprot.readFieldEnd()
23762 
    iprot.readStructEnd()
23763 
 
23764 
  def write(self, oprot):
23765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23767 
      return
23768 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
23769 
    if self.settlementId is not None:
23770 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23771 
      oprot.writeI64(self.settlementId)
23772 
      oprot.writeFieldEnd()
23773 
    oprot.writeFieldStop()
23774 
    oprot.writeStructEnd()
23775 
 
23776 
  def validate(self):
23777 
    return
23778 
 
23779 
 
23780 
  def __repr__(self):
23781 
    L = ['%s=%r' % (key, value)
23782 
      for key, value in self.__dict__.iteritems()]
23783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23784 
 
23785 
  def __eq__(self, other):
23786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23787 
 
23788 
  def __ne__(self, other):
23789 
    return not (self == other)
23790 
 
23791 
class markEBSSettlementUploaded_result:
23792 
  """
23793 
  Attributes:
23794 
   - ex
23795 
  """
23796 
 
23797 
  thrift_spec = (
23798 
    None, # 0
23799 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23800 
  )
23801 
 
23802 
  def __init__(self, ex=None,):
23803 
    self.ex = ex
23804 
 
23805 
  def read(self, iprot):
23806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23808 
      return
23809 
    iprot.readStructBegin()
23810 
    while True:
23811 
      (fname, ftype, fid) = iprot.readFieldBegin()
23812 
      if ftype == TType.STOP:
23813 
        break
23814 
      if fid == 1:
23815 
        if ftype == TType.STRUCT:
23816 
          self.ex = TransactionServiceException()
23817 
          self.ex.read(iprot)
23818 
        else:
23819 
          iprot.skip(ftype)
23820 
      else:
23821 
        iprot.skip(ftype)
23822 
      iprot.readFieldEnd()
23823 
    iprot.readStructEnd()
23824 
 
23825 
  def write(self, oprot):
23826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23828 
      return
23829 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
23830 
    if self.ex is not None:
23831 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23832 
      self.ex.write(oprot)
23833 
      oprot.writeFieldEnd()
23834 
    oprot.writeFieldStop()
23835 
    oprot.writeStructEnd()
23836 
 
23837 
  def validate(self):
23838 
    return
23839 
 
23840 
 
23841 
  def __repr__(self):
23842 
    L = ['%s=%r' % (key, value)
23843 
      for key, value in self.__dict__.iteritems()]
23844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23845 
 
23846 
  def __eq__(self, other):
23847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23848 
 
23849 
  def __ne__(self, other):
23850 
    return not (self == other)
23851 
 
23852 
class getEBSSettlementDate_args:
23853 
  """
23854 
  Attributes:
23855 
   - settlementId
23856 
  """
23857 
 
23858 
  thrift_spec = (
23859 
    None, # 0
23860 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23861 
  )
23862 
 
23863 
  def __init__(self, settlementId=None,):
23864 
    self.settlementId = settlementId
23865 
 
23866 
  def read(self, iprot):
23867 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23868 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23869 
      return
23870 
    iprot.readStructBegin()
23871 
    while True:
23872 
      (fname, ftype, fid) = iprot.readFieldBegin()
23873 
      if ftype == TType.STOP:
23874 
        break
23875 
      if fid == 1:
23876 
        if ftype == TType.I64:
23877 
          self.settlementId = iprot.readI64();
23878 
        else:
23879 
          iprot.skip(ftype)
23880 
      else:
23881 
        iprot.skip(ftype)
23882 
      iprot.readFieldEnd()
23883 
    iprot.readStructEnd()
23884 
 
23885 
  def write(self, oprot):
23886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23888 
      return
23889 
    oprot.writeStructBegin('getEBSSettlementDate_args')
23890 
    if self.settlementId is not None:
23891 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23892 
      oprot.writeI64(self.settlementId)
23893 
      oprot.writeFieldEnd()
23894 
    oprot.writeFieldStop()
23895 
    oprot.writeStructEnd()
23896 
 
23897 
  def validate(self):
23898 
    return
23899 
 
23900 
 
23901 
  def __repr__(self):
23902 
    L = ['%s=%r' % (key, value)
23903 
      for key, value in self.__dict__.iteritems()]
23904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23905 
 
23906 
  def __eq__(self, other):
23907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23908 
 
23909 
  def __ne__(self, other):
23910 
    return not (self == other)
23911 
 
23912 
class getEBSSettlementDate_result:
23913 
  """
23914 
  Attributes:
23915 
   - success
23916 
   - ex
23917 
  """
23918 
 
23919 
  thrift_spec = (
23920 
    (0, TType.I64, 'success', None, None, ), # 0
23921 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23922 
  )
23923 
 
23924 
  def __init__(self, success=None, ex=None,):
23925 
    self.success = success
23926 
    self.ex = ex
23927 
 
23928 
  def read(self, iprot):
23929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23931 
      return
23932 
    iprot.readStructBegin()
23933 
    while True:
23934 
      (fname, ftype, fid) = iprot.readFieldBegin()
23935 
      if ftype == TType.STOP:
23936 
        break
23937 
      if fid == 0:
23938 
        if ftype == TType.I64:
23939 
          self.success = iprot.readI64();
23940 
        else:
23941 
          iprot.skip(ftype)
23942 
      elif fid == 1:
23943 
        if ftype == TType.STRUCT:
23944 
          self.ex = TransactionServiceException()
23945 
          self.ex.read(iprot)
23946 
        else:
23947 
          iprot.skip(ftype)
23948 
      else:
23949 
        iprot.skip(ftype)
23950 
      iprot.readFieldEnd()
23951 
    iprot.readStructEnd()
23952 
 
23953 
  def write(self, oprot):
23954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23956 
      return
23957 
    oprot.writeStructBegin('getEBSSettlementDate_result')
23958 
    if self.success is not None:
23959 
      oprot.writeFieldBegin('success', TType.I64, 0)
23960 
      oprot.writeI64(self.success)
23961 
      oprot.writeFieldEnd()
23962 
    if self.ex is not None:
23963 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23964 
      self.ex.write(oprot)
23965 
      oprot.writeFieldEnd()
23966 
    oprot.writeFieldStop()
23967 
    oprot.writeStructEnd()
23968 
 
23969 
  def validate(self):
23970 
    return
23971 
 
23972 
 
23973 
  def __repr__(self):
23974 
    L = ['%s=%r' % (key, value)
23975 
      for key, value in self.__dict__.iteritems()]
23976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23977 
 
23978 
  def __eq__(self, other):
23979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23980 
 
23981 
  def __ne__(self, other):
23982 
    return not (self == other)
4715 varun.gupt 23983 
 
23984 
class getSettlementsByDate_args:
23985 
  """
23986 
  Attributes:
23987 
   - settlementDateFrom
23988 
   - settlementDateTo
23989 
   - isRefund
23990 
  """
23991 
 
23992 
  thrift_spec = (
23993 
    None, # 0
23994 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
23995 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
23996 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
23997 
  )
23998 
 
23999 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
24000 
    self.settlementDateFrom = settlementDateFrom
24001 
    self.settlementDateTo = settlementDateTo
24002 
    self.isRefund = isRefund
24003 
 
24004 
  def read(self, iprot):
24005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24007 
      return
24008 
    iprot.readStructBegin()
24009 
    while True:
24010 
      (fname, ftype, fid) = iprot.readFieldBegin()
24011 
      if ftype == TType.STOP:
24012 
        break
24013 
      if fid == 1:
24014 
        if ftype == TType.I64:
24015 
          self.settlementDateFrom = iprot.readI64();
24016 
        else:
24017 
          iprot.skip(ftype)
24018 
      elif fid == 2:
24019 
        if ftype == TType.I64:
24020 
          self.settlementDateTo = iprot.readI64();
24021 
        else:
24022 
          iprot.skip(ftype)
24023 
      elif fid == 3:
24024 
        if ftype == TType.BOOL:
24025 
          self.isRefund = iprot.readBool();
24026 
        else:
24027 
          iprot.skip(ftype)
24028 
      else:
24029 
        iprot.skip(ftype)
24030 
      iprot.readFieldEnd()
24031 
    iprot.readStructEnd()
24032 
 
24033 
  def write(self, oprot):
24034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24036 
      return
24037 
    oprot.writeStructBegin('getSettlementsByDate_args')
24038 
    if self.settlementDateFrom is not None:
24039 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
24040 
      oprot.writeI64(self.settlementDateFrom)
24041 
      oprot.writeFieldEnd()
24042 
    if self.settlementDateTo is not None:
24043 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
24044 
      oprot.writeI64(self.settlementDateTo)
24045 
      oprot.writeFieldEnd()
24046 
    if self.isRefund is not None:
24047 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
24048 
      oprot.writeBool(self.isRefund)
24049 
      oprot.writeFieldEnd()
24050 
    oprot.writeFieldStop()
24051 
    oprot.writeStructEnd()
24052 
 
24053 
  def validate(self):
24054 
    return
24055 
 
24056 
 
24057 
  def __repr__(self):
24058 
    L = ['%s=%r' % (key, value)
24059 
      for key, value in self.__dict__.iteritems()]
24060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24061 
 
24062 
  def __eq__(self, other):
24063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24064 
 
24065 
  def __ne__(self, other):
24066 
    return not (self == other)
24067 
 
24068 
class getSettlementsByDate_result:
24069 
  """
24070 
  Attributes:
24071 
   - success
24072 
   - ex
24073 
  """
24074 
 
24075 
  thrift_spec = (
24076 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
24077 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24078 
  )
24079 
 
24080 
  def __init__(self, success=None, ex=None,):
24081 
    self.success = success
24082 
    self.ex = ex
24083 
 
24084 
  def read(self, iprot):
24085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24087 
      return
24088 
    iprot.readStructBegin()
24089 
    while True:
24090 
      (fname, ftype, fid) = iprot.readFieldBegin()
24091 
      if ftype == TType.STOP:
24092 
        break
24093 
      if fid == 0:
24094 
        if ftype == TType.LIST:
24095 
          self.success = []
6188 rajveer 24096 
          (_etype566, _size563) = iprot.readListBegin()
24097 
          for _i567 in xrange(_size563):
24098 
            _elem568 = PaymentSettlement()
24099 
            _elem568.read(iprot)
24100 
            self.success.append(_elem568)
4715 varun.gupt 24101 
          iprot.readListEnd()
24102 
        else:
24103 
          iprot.skip(ftype)
24104 
      elif fid == 1:
24105 
        if ftype == TType.STRUCT:
24106 
          self.ex = TransactionServiceException()
24107 
          self.ex.read(iprot)
24108 
        else:
24109 
          iprot.skip(ftype)
24110 
      else:
24111 
        iprot.skip(ftype)
24112 
      iprot.readFieldEnd()
24113 
    iprot.readStructEnd()
24114 
 
24115 
  def write(self, oprot):
24116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24118 
      return
24119 
    oprot.writeStructBegin('getSettlementsByDate_result')
24120 
    if self.success is not None:
24121 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24122 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24123 
      for iter569 in self.success:
24124 
        iter569.write(oprot)
4715 varun.gupt 24125 
      oprot.writeListEnd()
24126 
      oprot.writeFieldEnd()
24127 
    if self.ex is not None:
24128 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24129 
      self.ex.write(oprot)
24130 
      oprot.writeFieldEnd()
24131 
    oprot.writeFieldStop()
24132 
    oprot.writeStructEnd()
24133 
 
24134 
  def validate(self):
24135 
    return
24136 
 
24137 
 
24138 
  def __repr__(self):
24139 
    L = ['%s=%r' % (key, value)
24140 
      for key, value in self.__dict__.iteritems()]
24141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24142 
 
24143 
  def __eq__(self, other):
24144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24145 
 
24146 
  def __ne__(self, other):
24147 
    return not (self == other)
24148 
 
24149 
class getReshippedOrderIds_args:
24150 
  """
24151 
  Attributes:
24152 
   - orderIds
24153 
  """
24154 
 
24155 
  thrift_spec = (
24156 
    None, # 0
24157 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
24158 
  )
24159 
 
24160 
  def __init__(self, orderIds=None,):
24161 
    self.orderIds = orderIds
24162 
 
24163 
  def read(self, iprot):
24164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24166 
      return
24167 
    iprot.readStructBegin()
24168 
    while True:
24169 
      (fname, ftype, fid) = iprot.readFieldBegin()
24170 
      if ftype == TType.STOP:
24171 
        break
24172 
      if fid == 1:
24173 
        if ftype == TType.LIST:
24174 
          self.orderIds = []
6188 rajveer 24175 
          (_etype573, _size570) = iprot.readListBegin()
24176 
          for _i574 in xrange(_size570):
24177 
            _elem575 = iprot.readI64();
24178 
            self.orderIds.append(_elem575)
4715 varun.gupt 24179 
          iprot.readListEnd()
24180 
        else:
24181 
          iprot.skip(ftype)
24182 
      else:
24183 
        iprot.skip(ftype)
24184 
      iprot.readFieldEnd()
24185 
    iprot.readStructEnd()
24186 
 
24187 
  def write(self, oprot):
24188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24190 
      return
24191 
    oprot.writeStructBegin('getReshippedOrderIds_args')
24192 
    if self.orderIds is not None:
24193 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
24194 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 24195 
      for iter576 in self.orderIds:
24196 
        oprot.writeI64(iter576)
4715 varun.gupt 24197 
      oprot.writeListEnd()
24198 
      oprot.writeFieldEnd()
24199 
    oprot.writeFieldStop()
24200 
    oprot.writeStructEnd()
24201 
 
24202 
  def validate(self):
24203 
    return
24204 
 
24205 
 
24206 
  def __repr__(self):
24207 
    L = ['%s=%r' % (key, value)
24208 
      for key, value in self.__dict__.iteritems()]
24209 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24210 
 
24211 
  def __eq__(self, other):
24212 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24213 
 
24214 
  def __ne__(self, other):
24215 
    return not (self == other)
24216 
 
24217 
class getReshippedOrderIds_result:
24218 
  """
24219 
  Attributes:
24220 
   - success
24221 
   - ex
24222 
  """
24223 
 
24224 
  thrift_spec = (
24225 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24226 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24227 
  )
24228 
 
24229 
  def __init__(self, success=None, ex=None,):
24230 
    self.success = success
24231 
    self.ex = ex
24232 
 
24233 
  def read(self, iprot):
24234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24236 
      return
24237 
    iprot.readStructBegin()
24238 
    while True:
24239 
      (fname, ftype, fid) = iprot.readFieldBegin()
24240 
      if ftype == TType.STOP:
24241 
        break
24242 
      if fid == 0:
24243 
        if ftype == TType.LIST:
24244 
          self.success = []
6188 rajveer 24245 
          (_etype580, _size577) = iprot.readListBegin()
24246 
          for _i581 in xrange(_size577):
24247 
            _elem582 = iprot.readI64();
24248 
            self.success.append(_elem582)
4715 varun.gupt 24249 
          iprot.readListEnd()
24250 
        else:
24251 
          iprot.skip(ftype)
24252 
      elif fid == 1:
24253 
        if ftype == TType.STRUCT:
24254 
          self.ex = TransactionServiceException()
24255 
          self.ex.read(iprot)
24256 
        else:
24257 
          iprot.skip(ftype)
24258 
      else:
24259 
        iprot.skip(ftype)
24260 
      iprot.readFieldEnd()
24261 
    iprot.readStructEnd()
24262 
 
24263 
  def write(self, oprot):
24264 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24265 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24266 
      return
24267 
    oprot.writeStructBegin('getReshippedOrderIds_result')
24268 
    if self.success is not None:
24269 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24270 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24271 
      for iter583 in self.success:
24272 
        oprot.writeI64(iter583)
4715 varun.gupt 24273 
      oprot.writeListEnd()
24274 
      oprot.writeFieldEnd()
24275 
    if self.ex is not None:
24276 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24277 
      self.ex.write(oprot)
24278 
      oprot.writeFieldEnd()
24279 
    oprot.writeFieldStop()
24280 
    oprot.writeStructEnd()
24281 
 
24282 
  def validate(self):
24283 
    return
24284 
 
24285 
 
24286 
  def __repr__(self):
24287 
    L = ['%s=%r' % (key, value)
24288 
      for key, value in self.__dict__.iteritems()]
24289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24290 
 
24291 
  def __eq__(self, other):
24292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24293 
 
24294 
  def __ne__(self, other):
24295 
    return not (self == other)
4757 mandeep.dh 24296 
 
5481 phani.kuma 24297 
class getBilledOrders_args:
4875 varun.gupt 24298 
  """
24299 
  Attributes:
24300 
   - vendorId
5481 phani.kuma 24301 
   - onlyVendorNotPaid
24302 
   - billingDateFrom
24303 
   - billingDateTo
4875 varun.gupt 24304 
  """
24305 
 
24306 
  thrift_spec = (
24307 
    None, # 0
24308 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 24309 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
24310 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
24311 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 24312 
  )
24313 
 
5481 phani.kuma 24314 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 24315 
    self.vendorId = vendorId
5481 phani.kuma 24316 
    self.onlyVendorNotPaid = onlyVendorNotPaid
24317 
    self.billingDateFrom = billingDateFrom
24318 
    self.billingDateTo = billingDateTo
4875 varun.gupt 24319 
 
24320 
  def read(self, iprot):
24321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24323 
      return
24324 
    iprot.readStructBegin()
24325 
    while True:
24326 
      (fname, ftype, fid) = iprot.readFieldBegin()
24327 
      if ftype == TType.STOP:
24328 
        break
24329 
      if fid == 1:
24330 
        if ftype == TType.I64:
24331 
          self.vendorId = iprot.readI64();
24332 
        else:
24333 
          iprot.skip(ftype)
5481 phani.kuma 24334 
      elif fid == 2:
24335 
        if ftype == TType.BOOL:
24336 
          self.onlyVendorNotPaid = iprot.readBool();
24337 
        else:
24338 
          iprot.skip(ftype)
24339 
      elif fid == 3:
24340 
        if ftype == TType.I64:
24341 
          self.billingDateFrom = iprot.readI64();
24342 
        else:
24343 
          iprot.skip(ftype)
24344 
      elif fid == 4:
24345 
        if ftype == TType.I64:
24346 
          self.billingDateTo = iprot.readI64();
24347 
        else:
24348 
          iprot.skip(ftype)
4875 varun.gupt 24349 
      else:
24350 
        iprot.skip(ftype)
24351 
      iprot.readFieldEnd()
24352 
    iprot.readStructEnd()
24353 
 
24354 
  def write(self, oprot):
24355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24357 
      return
5481 phani.kuma 24358 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 24359 
    if self.vendorId is not None:
24360 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
24361 
      oprot.writeI64(self.vendorId)
24362 
      oprot.writeFieldEnd()
5481 phani.kuma 24363 
    if self.onlyVendorNotPaid is not None:
24364 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
24365 
      oprot.writeBool(self.onlyVendorNotPaid)
24366 
      oprot.writeFieldEnd()
24367 
    if self.billingDateFrom is not None:
24368 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
24369 
      oprot.writeI64(self.billingDateFrom)
24370 
      oprot.writeFieldEnd()
24371 
    if self.billingDateTo is not None:
24372 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
24373 
      oprot.writeI64(self.billingDateTo)
24374 
      oprot.writeFieldEnd()
4875 varun.gupt 24375 
    oprot.writeFieldStop()
24376 
    oprot.writeStructEnd()
24377 
 
24378 
  def validate(self):
24379 
    return
24380 
 
24381 
 
24382 
  def __repr__(self):
24383 
    L = ['%s=%r' % (key, value)
24384 
      for key, value in self.__dict__.iteritems()]
24385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24386 
 
24387 
  def __eq__(self, other):
24388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24389 
 
24390 
  def __ne__(self, other):
24391 
    return not (self == other)
24392 
 
5481 phani.kuma 24393 
class getBilledOrders_result:
4875 varun.gupt 24394 
  """
24395 
  Attributes:
24396 
   - success
24397 
   - ex
24398 
  """
24399 
 
24400 
  thrift_spec = (
24401 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24402 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24403 
  )
24404 
 
24405 
  def __init__(self, success=None, ex=None,):
24406 
    self.success = success
24407 
    self.ex = ex
24408 
 
24409 
  def read(self, iprot):
24410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24412 
      return
24413 
    iprot.readStructBegin()
24414 
    while True:
24415 
      (fname, ftype, fid) = iprot.readFieldBegin()
24416 
      if ftype == TType.STOP:
24417 
        break
24418 
      if fid == 0:
24419 
        if ftype == TType.LIST:
24420 
          self.success = []
6188 rajveer 24421 
          (_etype587, _size584) = iprot.readListBegin()
24422 
          for _i588 in xrange(_size584):
24423 
            _elem589 = Order()
24424 
            _elem589.read(iprot)
24425 
            self.success.append(_elem589)
4875 varun.gupt 24426 
          iprot.readListEnd()
24427 
        else:
24428 
          iprot.skip(ftype)
24429 
      elif fid == 1:
24430 
        if ftype == TType.STRUCT:
24431 
          self.ex = TransactionServiceException()
24432 
          self.ex.read(iprot)
24433 
        else:
24434 
          iprot.skip(ftype)
24435 
      else:
24436 
        iprot.skip(ftype)
24437 
      iprot.readFieldEnd()
24438 
    iprot.readStructEnd()
24439 
 
24440 
  def write(self, oprot):
24441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24443 
      return
5481 phani.kuma 24444 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 24445 
    if self.success is not None:
24446 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24447 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24448 
      for iter590 in self.success:
24449 
        iter590.write(oprot)
4875 varun.gupt 24450 
      oprot.writeListEnd()
24451 
      oprot.writeFieldEnd()
24452 
    if self.ex is not None:
24453 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24454 
      self.ex.write(oprot)
24455 
      oprot.writeFieldEnd()
24456 
    oprot.writeFieldStop()
24457 
    oprot.writeStructEnd()
24458 
 
24459 
  def validate(self):
24460 
    return
24461 
 
24462 
 
24463 
  def __repr__(self):
24464 
    L = ['%s=%r' % (key, value)
24465 
      for key, value in self.__dict__.iteritems()]
24466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24467 
 
24468 
  def __eq__(self, other):
24469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24470 
 
24471 
  def __ne__(self, other):
24472 
    return not (self == other)
5031 varun.gupt 24473 
 
24474 
class getStatusDistributionOfOrders_args:
24475 
  """
24476 
  Attributes:
24477 
   - startDate
24478 
   - endDate
24479 
  """
24480 
 
24481 
  thrift_spec = (
24482 
    None, # 0
24483 
    (1, TType.I64, 'startDate', None, None, ), # 1
24484 
    (2, TType.I64, 'endDate', None, None, ), # 2
24485 
  )
24486 
 
24487 
  def __init__(self, startDate=None, endDate=None,):
24488 
    self.startDate = startDate
24489 
    self.endDate = endDate
24490 
 
24491 
  def read(self, iprot):
24492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24494 
      return
24495 
    iprot.readStructBegin()
24496 
    while True:
24497 
      (fname, ftype, fid) = iprot.readFieldBegin()
24498 
      if ftype == TType.STOP:
24499 
        break
24500 
      if fid == 1:
24501 
        if ftype == TType.I64:
24502 
          self.startDate = iprot.readI64();
24503 
        else:
24504 
          iprot.skip(ftype)
24505 
      elif fid == 2:
24506 
        if ftype == TType.I64:
24507 
          self.endDate = iprot.readI64();
24508 
        else:
24509 
          iprot.skip(ftype)
24510 
      else:
24511 
        iprot.skip(ftype)
24512 
      iprot.readFieldEnd()
24513 
    iprot.readStructEnd()
24514 
 
24515 
  def write(self, oprot):
24516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24518 
      return
24519 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24520 
    if self.startDate is not None:
24521 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24522 
      oprot.writeI64(self.startDate)
24523 
      oprot.writeFieldEnd()
24524 
    if self.endDate is not None:
24525 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24526 
      oprot.writeI64(self.endDate)
24527 
      oprot.writeFieldEnd()
24528 
    oprot.writeFieldStop()
24529 
    oprot.writeStructEnd()
24530 
 
24531 
  def validate(self):
24532 
    return
24533 
 
24534 
 
24535 
  def __repr__(self):
24536 
    L = ['%s=%r' % (key, value)
24537 
      for key, value in self.__dict__.iteritems()]
24538 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24539 
 
24540 
  def __eq__(self, other):
24541 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24542 
 
24543 
  def __ne__(self, other):
24544 
    return not (self == other)
24545 
 
24546 
class getStatusDistributionOfOrders_result:
24547 
  """
24548 
  Attributes:
24549 
   - success
24550 
   - ex
24551 
  """
24552 
 
24553 
  thrift_spec = (
24554 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
24555 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24556 
  )
24557 
 
24558 
  def __init__(self, success=None, ex=None,):
24559 
    self.success = success
24560 
    self.ex = ex
24561 
 
24562 
  def read(self, iprot):
24563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24565 
      return
24566 
    iprot.readStructBegin()
24567 
    while True:
24568 
      (fname, ftype, fid) = iprot.readFieldBegin()
24569 
      if ftype == TType.STOP:
24570 
        break
24571 
      if fid == 0:
24572 
        if ftype == TType.MAP:
24573 
          self.success = {}
6188 rajveer 24574 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
24575 
          for _i595 in xrange(_size591):
24576 
            _key596 = iprot.readI64();
24577 
            _val597 = iprot.readI64();
24578 
            self.success[_key596] = _val597
5031 varun.gupt 24579 
          iprot.readMapEnd()
24580 
        else:
24581 
          iprot.skip(ftype)
24582 
      elif fid == 1:
24583 
        if ftype == TType.STRUCT:
24584 
          self.ex = TransactionServiceException()
24585 
          self.ex.read(iprot)
24586 
        else:
24587 
          iprot.skip(ftype)
24588 
      else:
24589 
        iprot.skip(ftype)
24590 
      iprot.readFieldEnd()
24591 
    iprot.readStructEnd()
24592 
 
24593 
  def write(self, oprot):
24594 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24595 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24596 
      return
24597 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
24598 
    if self.success is not None:
24599 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24600 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 24601 
      for kiter598,viter599 in self.success.items():
24602 
        oprot.writeI64(kiter598)
24603 
        oprot.writeI64(viter599)
5031 varun.gupt 24604 
      oprot.writeMapEnd()
24605 
      oprot.writeFieldEnd()
24606 
    if self.ex is not None:
24607 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24608 
      self.ex.write(oprot)
24609 
      oprot.writeFieldEnd()
24610 
    oprot.writeFieldStop()
24611 
    oprot.writeStructEnd()
24612 
 
24613 
  def validate(self):
24614 
    return
24615 
 
24616 
 
24617 
  def __repr__(self):
24618 
    L = ['%s=%r' % (key, value)
24619 
      for key, value in self.__dict__.iteritems()]
24620 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24621 
 
24622 
  def __eq__(self, other):
24623 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24624 
 
24625 
  def __ne__(self, other):
24626 
    return not (self == other)
5067 varun.gupt 24627 
 
24628 
class getOrderIdsForStatus_args:
24629 
  """
24630 
  Attributes:
24631 
   - status
24632 
   - startDatetime
24633 
   - endDatetime
24634 
  """
24635 
 
24636 
  thrift_spec = (
24637 
    None, # 0
24638 
    (1, TType.I64, 'status', None, None, ), # 1
24639 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
24640 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
24641 
  )
24642 
 
24643 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
24644 
    self.status = status
24645 
    self.startDatetime = startDatetime
24646 
    self.endDatetime = endDatetime
24647 
 
24648 
  def read(self, iprot):
24649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24651 
      return
24652 
    iprot.readStructBegin()
24653 
    while True:
24654 
      (fname, ftype, fid) = iprot.readFieldBegin()
24655 
      if ftype == TType.STOP:
24656 
        break
24657 
      if fid == 1:
24658 
        if ftype == TType.I64:
24659 
          self.status = iprot.readI64();
24660 
        else:
24661 
          iprot.skip(ftype)
24662 
      elif fid == 2:
24663 
        if ftype == TType.I64:
24664 
          self.startDatetime = iprot.readI64();
24665 
        else:
24666 
          iprot.skip(ftype)
24667 
      elif fid == 3:
24668 
        if ftype == TType.I64:
24669 
          self.endDatetime = iprot.readI64();
24670 
        else:
24671 
          iprot.skip(ftype)
24672 
      else:
24673 
        iprot.skip(ftype)
24674 
      iprot.readFieldEnd()
24675 
    iprot.readStructEnd()
24676 
 
24677 
  def write(self, oprot):
24678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24680 
      return
24681 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
24682 
    if self.status is not None:
24683 
      oprot.writeFieldBegin('status', TType.I64, 1)
24684 
      oprot.writeI64(self.status)
24685 
      oprot.writeFieldEnd()
24686 
    if self.startDatetime is not None:
24687 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
24688 
      oprot.writeI64(self.startDatetime)
24689 
      oprot.writeFieldEnd()
24690 
    if self.endDatetime is not None:
24691 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
24692 
      oprot.writeI64(self.endDatetime)
24693 
      oprot.writeFieldEnd()
24694 
    oprot.writeFieldStop()
24695 
    oprot.writeStructEnd()
24696 
 
24697 
  def validate(self):
24698 
    return
24699 
 
24700 
 
24701 
  def __repr__(self):
24702 
    L = ['%s=%r' % (key, value)
24703 
      for key, value in self.__dict__.iteritems()]
24704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24705 
 
24706 
  def __eq__(self, other):
24707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24708 
 
24709 
  def __ne__(self, other):
24710 
    return not (self == other)
24711 
 
24712 
class getOrderIdsForStatus_result:
24713 
  """
24714 
  Attributes:
24715 
   - success
24716 
   - ex
24717 
  """
24718 
 
24719 
  thrift_spec = (
24720 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24721 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24722 
  )
24723 
 
24724 
  def __init__(self, success=None, ex=None,):
24725 
    self.success = success
24726 
    self.ex = ex
24727 
 
24728 
  def read(self, iprot):
24729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24731 
      return
24732 
    iprot.readStructBegin()
24733 
    while True:
24734 
      (fname, ftype, fid) = iprot.readFieldBegin()
24735 
      if ftype == TType.STOP:
24736 
        break
24737 
      if fid == 0:
24738 
        if ftype == TType.LIST:
24739 
          self.success = []
6188 rajveer 24740 
          (_etype603, _size600) = iprot.readListBegin()
24741 
          for _i604 in xrange(_size600):
24742 
            _elem605 = iprot.readI64();
24743 
            self.success.append(_elem605)
5067 varun.gupt 24744 
          iprot.readListEnd()
24745 
        else:
24746 
          iprot.skip(ftype)
24747 
      elif fid == 1:
24748 
        if ftype == TType.STRUCT:
24749 
          self.ex = TransactionServiceException()
24750 
          self.ex.read(iprot)
24751 
        else:
24752 
          iprot.skip(ftype)
24753 
      else:
24754 
        iprot.skip(ftype)
24755 
      iprot.readFieldEnd()
24756 
    iprot.readStructEnd()
24757 
 
24758 
  def write(self, oprot):
24759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24761 
      return
24762 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
24763 
    if self.success is not None:
24764 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24765 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24766 
      for iter606 in self.success:
24767 
        oprot.writeI64(iter606)
5067 varun.gupt 24768 
      oprot.writeListEnd()
24769 
      oprot.writeFieldEnd()
24770 
    if self.ex is not None:
24771 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24772 
      self.ex.write(oprot)
24773 
      oprot.writeFieldEnd()
24774 
    oprot.writeFieldStop()
24775 
    oprot.writeStructEnd()
24776 
 
24777 
  def validate(self):
24778 
    return
24779 
 
24780 
 
24781 
  def __repr__(self):
24782 
    L = ['%s=%r' % (key, value)
24783 
      for key, value in self.__dict__.iteritems()]
24784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24785 
 
24786 
  def __eq__(self, other):
24787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24788 
 
24789 
  def __ne__(self, other):
24790 
    return not (self == other)
5099 varun.gupt 24791 
 
5348 anupam.sin 24792 
class updateCODAgent_args:
24793 
  """
24794 
  Attributes:
24795 
   - agent
24796 
   - orderId
24797 
  """
24798 
 
24799 
  thrift_spec = (
24800 
    None, # 0
24801 
    (1, TType.STRING, 'agent', None, None, ), # 1
24802 
    (2, TType.I64, 'orderId', None, None, ), # 2
24803 
  )
24804 
 
24805 
  def __init__(self, agent=None, orderId=None,):
24806 
    self.agent = agent
24807 
    self.orderId = orderId
24808 
 
24809 
  def read(self, iprot):
24810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24812 
      return
24813 
    iprot.readStructBegin()
24814 
    while True:
24815 
      (fname, ftype, fid) = iprot.readFieldBegin()
24816 
      if ftype == TType.STOP:
24817 
        break
24818 
      if fid == 1:
24819 
        if ftype == TType.STRING:
24820 
          self.agent = iprot.readString();
24821 
        else:
24822 
          iprot.skip(ftype)
24823 
      elif fid == 2:
24824 
        if ftype == TType.I64:
24825 
          self.orderId = iprot.readI64();
24826 
        else:
24827 
          iprot.skip(ftype)
24828 
      else:
24829 
        iprot.skip(ftype)
24830 
      iprot.readFieldEnd()
24831 
    iprot.readStructEnd()
24832 
 
24833 
  def write(self, oprot):
24834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24836 
      return
24837 
    oprot.writeStructBegin('updateCODAgent_args')
24838 
    if self.agent is not None:
24839 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
24840 
      oprot.writeString(self.agent)
24841 
      oprot.writeFieldEnd()
24842 
    if self.orderId is not None:
24843 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
24844 
      oprot.writeI64(self.orderId)
24845 
      oprot.writeFieldEnd()
24846 
    oprot.writeFieldStop()
24847 
    oprot.writeStructEnd()
24848 
 
24849 
  def validate(self):
24850 
    return
24851 
 
24852 
 
24853 
  def __repr__(self):
24854 
    L = ['%s=%r' % (key, value)
24855 
      for key, value in self.__dict__.iteritems()]
24856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24857 
 
24858 
  def __eq__(self, other):
24859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24860 
 
24861 
  def __ne__(self, other):
24862 
    return not (self == other)
24863 
 
24864 
class updateCODAgent_result:
24865 
  """
24866 
  Attributes:
24867 
   - ex
24868 
  """
24869 
 
24870 
  thrift_spec = (
24871 
    None, # 0
24872 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24873 
  )
24874 
 
24875 
  def __init__(self, ex=None,):
24876 
    self.ex = ex
24877 
 
24878 
  def read(self, iprot):
24879 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24880 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24881 
      return
24882 
    iprot.readStructBegin()
24883 
    while True:
24884 
      (fname, ftype, fid) = iprot.readFieldBegin()
24885 
      if ftype == TType.STOP:
24886 
        break
24887 
      if fid == 1:
24888 
        if ftype == TType.STRUCT:
24889 
          self.ex = TransactionServiceException()
24890 
          self.ex.read(iprot)
24891 
        else:
24892 
          iprot.skip(ftype)
24893 
      else:
24894 
        iprot.skip(ftype)
24895 
      iprot.readFieldEnd()
24896 
    iprot.readStructEnd()
24897 
 
24898 
  def write(self, oprot):
24899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24901 
      return
24902 
    oprot.writeStructBegin('updateCODAgent_result')
24903 
    if self.ex is not None:
24904 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24905 
      self.ex.write(oprot)
24906 
      oprot.writeFieldEnd()
24907 
    oprot.writeFieldStop()
24908 
    oprot.writeStructEnd()
24909 
 
24910 
  def validate(self):
24911 
    return
24912 
 
24913 
 
24914 
  def __repr__(self):
24915 
    L = ['%s=%r' % (key, value)
24916 
      for key, value in self.__dict__.iteritems()]
24917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24918 
 
24919 
  def __eq__(self, other):
24920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24921 
 
24922 
  def __ne__(self, other):
24923 
    return not (self == other)
24924 
 
5099 varun.gupt 24925 
class updateOrderAsPaidToVendor_args:
24926 
  """
24927 
  Attributes:
24928 
   - orderId
24929 
  """
24930 
 
24931 
  thrift_spec = (
24932 
    None, # 0
24933 
    (1, TType.I64, 'orderId', None, None, ), # 1
24934 
  )
24935 
 
24936 
  def __init__(self, orderId=None,):
24937 
    self.orderId = orderId
24938 
 
24939 
  def read(self, iprot):
24940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24942 
      return
24943 
    iprot.readStructBegin()
24944 
    while True:
24945 
      (fname, ftype, fid) = iprot.readFieldBegin()
24946 
      if ftype == TType.STOP:
24947 
        break
24948 
      if fid == 1:
24949 
        if ftype == TType.I64:
24950 
          self.orderId = iprot.readI64();
24951 
        else:
24952 
          iprot.skip(ftype)
24953 
      else:
24954 
        iprot.skip(ftype)
24955 
      iprot.readFieldEnd()
24956 
    iprot.readStructEnd()
24957 
 
24958 
  def write(self, oprot):
24959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24961 
      return
24962 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
24963 
    if self.orderId is not None:
24964 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
24965 
      oprot.writeI64(self.orderId)
24966 
      oprot.writeFieldEnd()
24967 
    oprot.writeFieldStop()
24968 
    oprot.writeStructEnd()
24969 
 
24970 
  def validate(self):
24971 
    return
24972 
 
24973 
 
24974 
  def __repr__(self):
24975 
    L = ['%s=%r' % (key, value)
24976 
      for key, value in self.__dict__.iteritems()]
24977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24978 
 
24979 
  def __eq__(self, other):
24980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24981 
 
24982 
  def __ne__(self, other):
24983 
    return not (self == other)
24984 
 
24985 
class updateOrderAsPaidToVendor_result:
24986 
  """
24987 
  Attributes:
24988 
   - ex
24989 
  """
24990 
 
24991 
  thrift_spec = (
24992 
    None, # 0
24993 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24994 
  )
24995 
 
24996 
  def __init__(self, ex=None,):
24997 
    self.ex = ex
24998 
 
24999 
  def read(self, iprot):
25000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25002 
      return
25003 
    iprot.readStructBegin()
25004 
    while True:
25005 
      (fname, ftype, fid) = iprot.readFieldBegin()
25006 
      if ftype == TType.STOP:
25007 
        break
25008 
      if fid == 1:
25009 
        if ftype == TType.STRUCT:
25010 
          self.ex = TransactionServiceException()
25011 
          self.ex.read(iprot)
25012 
        else:
25013 
          iprot.skip(ftype)
25014 
      else:
25015 
        iprot.skip(ftype)
25016 
      iprot.readFieldEnd()
25017 
    iprot.readStructEnd()
25018 
 
25019 
  def write(self, oprot):
25020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25022 
      return
25023 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
25024 
    if self.ex is not None:
25025 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25026 
      self.ex.write(oprot)
25027 
      oprot.writeFieldEnd()
25028 
    oprot.writeFieldStop()
25029 
    oprot.writeStructEnd()
25030 
 
25031 
  def validate(self):
25032 
    return
25033 
 
25034 
 
25035 
  def __repr__(self):
25036 
    L = ['%s=%r' % (key, value)
25037 
      for key, value in self.__dict__.iteritems()]
25038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25039 
 
25040 
  def __eq__(self, other):
25041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25042 
 
25043 
  def __ne__(self, other):
25044 
    return not (self == other)
5208 varun.gupt 25045 
 
5386 phani.kuma 25046 
class updateOrderOnlyAsPaidToVendor_args:
25047 
  """
25048 
  Attributes:
25049 
   - orderId
25050 
  """
25051 
 
25052 
  thrift_spec = (
25053 
    None, # 0
25054 
    (1, TType.I64, 'orderId', None, None, ), # 1
25055 
  )
25056 
 
25057 
  def __init__(self, orderId=None,):
25058 
    self.orderId = orderId
25059 
 
25060 
  def read(self, iprot):
25061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25063 
      return
25064 
    iprot.readStructBegin()
25065 
    while True:
25066 
      (fname, ftype, fid) = iprot.readFieldBegin()
25067 
      if ftype == TType.STOP:
25068 
        break
25069 
      if fid == 1:
25070 
        if ftype == TType.I64:
25071 
          self.orderId = iprot.readI64();
25072 
        else:
25073 
          iprot.skip(ftype)
25074 
      else:
25075 
        iprot.skip(ftype)
25076 
      iprot.readFieldEnd()
25077 
    iprot.readStructEnd()
25078 
 
25079 
  def write(self, oprot):
25080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25082 
      return
25083 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
25084 
    if self.orderId is not None:
25085 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25086 
      oprot.writeI64(self.orderId)
25087 
      oprot.writeFieldEnd()
25088 
    oprot.writeFieldStop()
25089 
    oprot.writeStructEnd()
25090 
 
25091 
  def validate(self):
25092 
    return
25093 
 
25094 
 
25095 
  def __repr__(self):
25096 
    L = ['%s=%r' % (key, value)
25097 
      for key, value in self.__dict__.iteritems()]
25098 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25099 
 
25100 
  def __eq__(self, other):
25101 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25102 
 
25103 
  def __ne__(self, other):
25104 
    return not (self == other)
25105 
 
25106 
class updateOrderOnlyAsPaidToVendor_result:
25107 
  """
25108 
  Attributes:
25109 
   - ex
25110 
  """
25111 
 
25112 
  thrift_spec = (
25113 
    None, # 0
25114 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25115 
  )
25116 
 
25117 
  def __init__(self, ex=None,):
25118 
    self.ex = ex
25119 
 
25120 
  def read(self, iprot):
25121 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25122 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25123 
      return
25124 
    iprot.readStructBegin()
25125 
    while True:
25126 
      (fname, ftype, fid) = iprot.readFieldBegin()
25127 
      if ftype == TType.STOP:
25128 
        break
25129 
      if fid == 1:
25130 
        if ftype == TType.STRUCT:
25131 
          self.ex = TransactionServiceException()
25132 
          self.ex.read(iprot)
25133 
        else:
25134 
          iprot.skip(ftype)
25135 
      else:
25136 
        iprot.skip(ftype)
25137 
      iprot.readFieldEnd()
25138 
    iprot.readStructEnd()
25139 
 
25140 
  def write(self, oprot):
25141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25143 
      return
25144 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
25145 
    if self.ex is not None:
25146 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25147 
      self.ex.write(oprot)
25148 
      oprot.writeFieldEnd()
25149 
    oprot.writeFieldStop()
25150 
    oprot.writeStructEnd()
25151 
 
25152 
  def validate(self):
25153 
    return
25154 
 
25155 
 
25156 
  def __repr__(self):
25157 
    L = ['%s=%r' % (key, value)
25158 
      for key, value in self.__dict__.iteritems()]
25159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25160 
 
25161 
  def __eq__(self, other):
25162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25163 
 
25164 
  def __ne__(self, other):
25165 
    return not (self == other)
25166 
 
5208 varun.gupt 25167 
class getRefundedOrdersMarkedPaid_args:
25168 
 
25169 
  thrift_spec = (
25170 
  )
25171 
 
25172 
  def read(self, iprot):
25173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25175 
      return
25176 
    iprot.readStructBegin()
25177 
    while True:
25178 
      (fname, ftype, fid) = iprot.readFieldBegin()
25179 
      if ftype == TType.STOP:
25180 
        break
25181 
      else:
25182 
        iprot.skip(ftype)
25183 
      iprot.readFieldEnd()
25184 
    iprot.readStructEnd()
25185 
 
25186 
  def write(self, oprot):
25187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25189 
      return
25190 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
25191 
    oprot.writeFieldStop()
25192 
    oprot.writeStructEnd()
25193 
 
25194 
  def validate(self):
25195 
    return
25196 
 
25197 
 
25198 
  def __repr__(self):
25199 
    L = ['%s=%r' % (key, value)
25200 
      for key, value in self.__dict__.iteritems()]
25201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25202 
 
25203 
  def __eq__(self, other):
25204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25205 
 
25206 
  def __ne__(self, other):
25207 
    return not (self == other)
25208 
 
25209 
class getRefundedOrdersMarkedPaid_result:
25210 
  """
25211 
  Attributes:
25212 
   - success
25213 
   - ex
25214 
  """
25215 
 
25216 
  thrift_spec = (
25217 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25218 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25219 
  )
25220 
 
25221 
  def __init__(self, success=None, ex=None,):
25222 
    self.success = success
25223 
    self.ex = ex
25224 
 
25225 
  def read(self, iprot):
25226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25228 
      return
25229 
    iprot.readStructBegin()
25230 
    while True:
25231 
      (fname, ftype, fid) = iprot.readFieldBegin()
25232 
      if ftype == TType.STOP:
25233 
        break
25234 
      if fid == 0:
25235 
        if ftype == TType.LIST:
25236 
          self.success = []
6188 rajveer 25237 
          (_etype610, _size607) = iprot.readListBegin()
25238 
          for _i611 in xrange(_size607):
25239 
            _elem612 = Order()
25240 
            _elem612.read(iprot)
25241 
            self.success.append(_elem612)
5208 varun.gupt 25242 
          iprot.readListEnd()
25243 
        else:
25244 
          iprot.skip(ftype)
25245 
      elif fid == 1:
25246 
        if ftype == TType.STRUCT:
25247 
          self.ex = TransactionServiceException()
25248 
          self.ex.read(iprot)
25249 
        else:
25250 
          iprot.skip(ftype)
25251 
      else:
25252 
        iprot.skip(ftype)
25253 
      iprot.readFieldEnd()
25254 
    iprot.readStructEnd()
25255 
 
25256 
  def write(self, oprot):
25257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25259 
      return
25260 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
25261 
    if self.success is not None:
25262 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25263 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25264 
      for iter613 in self.success:
25265 
        iter613.write(oprot)
5208 varun.gupt 25266 
      oprot.writeListEnd()
25267 
      oprot.writeFieldEnd()
25268 
    if self.ex is not None:
25269 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25270 
      self.ex.write(oprot)
25271 
      oprot.writeFieldEnd()
25272 
    oprot.writeFieldStop()
25273 
    oprot.writeStructEnd()
25274 
 
25275 
  def validate(self):
25276 
    return
25277 
 
25278 
 
25279 
  def __repr__(self):
25280 
    L = ['%s=%r' % (key, value)
25281 
      for key, value in self.__dict__.iteritems()]
25282 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25283 
 
25284 
  def __eq__(self, other):
25285 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25286 
 
25287 
  def __ne__(self, other):
25288 
    return not (self == other)
5447 anupam.sin 25289 
 
25290 
class getAllVerificationAgents_args:
25291 
  """
25292 
  Attributes:
25293 
   - minOrderId
25294 
   - maxOrderId
25295 
  """
25296 
 
25297 
  thrift_spec = (
25298 
    None, # 0
25299 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
25300 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
25301 
  )
25302 
 
25303 
  def __init__(self, minOrderId=None, maxOrderId=None,):
25304 
    self.minOrderId = minOrderId
25305 
    self.maxOrderId = maxOrderId
25306 
 
25307 
  def read(self, iprot):
25308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25310 
      return
25311 
    iprot.readStructBegin()
25312 
    while True:
25313 
      (fname, ftype, fid) = iprot.readFieldBegin()
25314 
      if ftype == TType.STOP:
25315 
        break
25316 
      if fid == 1:
25317 
        if ftype == TType.I64:
25318 
          self.minOrderId = iprot.readI64();
25319 
        else:
25320 
          iprot.skip(ftype)
25321 
      elif fid == 2:
25322 
        if ftype == TType.I64:
25323 
          self.maxOrderId = iprot.readI64();
25324 
        else:
25325 
          iprot.skip(ftype)
25326 
      else:
25327 
        iprot.skip(ftype)
25328 
      iprot.readFieldEnd()
25329 
    iprot.readStructEnd()
25330 
 
25331 
  def write(self, oprot):
25332 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25333 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25334 
      return
25335 
    oprot.writeStructBegin('getAllVerificationAgents_args')
25336 
    if self.minOrderId is not None:
25337 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
25338 
      oprot.writeI64(self.minOrderId)
25339 
      oprot.writeFieldEnd()
25340 
    if self.maxOrderId is not None:
25341 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
25342 
      oprot.writeI64(self.maxOrderId)
25343 
      oprot.writeFieldEnd()
25344 
    oprot.writeFieldStop()
25345 
    oprot.writeStructEnd()
25346 
 
25347 
  def validate(self):
25348 
    return
25349 
 
25350 
 
25351 
  def __repr__(self):
25352 
    L = ['%s=%r' % (key, value)
25353 
      for key, value in self.__dict__.iteritems()]
25354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25355 
 
25356 
  def __eq__(self, other):
25357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25358 
 
25359 
  def __ne__(self, other):
25360 
    return not (self == other)
25361 
 
25362 
class getAllVerificationAgents_result:
25363 
  """
25364 
  Attributes:
25365 
   - success
25366 
  """
25367 
 
25368 
  thrift_spec = (
25369 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
25370 
  )
25371 
 
25372 
  def __init__(self, success=None,):
25373 
    self.success = success
25374 
 
25375 
  def read(self, iprot):
25376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25378 
      return
25379 
    iprot.readStructBegin()
25380 
    while True:
25381 
      (fname, ftype, fid) = iprot.readFieldBegin()
25382 
      if ftype == TType.STOP:
25383 
        break
25384 
      if fid == 0:
25385 
        if ftype == TType.LIST:
25386 
          self.success = []
6188 rajveer 25387 
          (_etype617, _size614) = iprot.readListBegin()
25388 
          for _i618 in xrange(_size614):
25389 
            _elem619 = CODVerificationAgent()
25390 
            _elem619.read(iprot)
25391 
            self.success.append(_elem619)
5447 anupam.sin 25392 
          iprot.readListEnd()
25393 
        else:
25394 
          iprot.skip(ftype)
25395 
      else:
25396 
        iprot.skip(ftype)
25397 
      iprot.readFieldEnd()
25398 
    iprot.readStructEnd()
25399 
 
25400 
  def write(self, oprot):
25401 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25402 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25403 
      return
25404 
    oprot.writeStructBegin('getAllVerificationAgents_result')
25405 
    if self.success is not None:
25406 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25407 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25408 
      for iter620 in self.success:
25409 
        iter620.write(oprot)
5447 anupam.sin 25410 
      oprot.writeListEnd()
25411 
      oprot.writeFieldEnd()
25412 
    oprot.writeFieldStop()
25413 
    oprot.writeStructEnd()
25414 
 
25415 
  def validate(self):
25416 
    return
25417 
 
25418 
 
25419 
  def __repr__(self):
25420 
    L = ['%s=%r' % (key, value)
25421 
      for key, value in self.__dict__.iteritems()]
25422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25423 
 
25424 
  def __eq__(self, other):
25425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25426 
 
25427 
  def __ne__(self, other):
25428 
    return not (self == other)
5527 anupam.sin 25429 
 
25430 
class getAllAttributesForOrderId_args:
25431 
  """
25432 
  Attributes:
25433 
   - orderId
25434 
  """
25435 
 
25436 
  thrift_spec = (
25437 
    None, # 0
25438 
    (1, TType.I64, 'orderId', None, None, ), # 1
25439 
  )
25440 
 
25441 
  def __init__(self, orderId=None,):
25442 
    self.orderId = orderId
25443 
 
25444 
  def read(self, iprot):
25445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25447 
      return
25448 
    iprot.readStructBegin()
25449 
    while True:
25450 
      (fname, ftype, fid) = iprot.readFieldBegin()
25451 
      if ftype == TType.STOP:
25452 
        break
25453 
      if fid == 1:
25454 
        if ftype == TType.I64:
25455 
          self.orderId = iprot.readI64();
25456 
        else:
25457 
          iprot.skip(ftype)
25458 
      else:
25459 
        iprot.skip(ftype)
25460 
      iprot.readFieldEnd()
25461 
    iprot.readStructEnd()
25462 
 
25463 
  def write(self, oprot):
25464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25466 
      return
25467 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
25468 
    if self.orderId is not None:
25469 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25470 
      oprot.writeI64(self.orderId)
25471 
      oprot.writeFieldEnd()
25472 
    oprot.writeFieldStop()
25473 
    oprot.writeStructEnd()
25474 
 
25475 
  def validate(self):
25476 
    return
25477 
 
25478 
 
25479 
  def __repr__(self):
25480 
    L = ['%s=%r' % (key, value)
25481 
      for key, value in self.__dict__.iteritems()]
25482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25483 
 
25484 
  def __eq__(self, other):
25485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25486 
 
25487 
  def __ne__(self, other):
25488 
    return not (self == other)
25489 
 
25490 
class getAllAttributesForOrderId_result:
25491 
  """
25492 
  Attributes:
25493 
   - success
25494 
  """
25495 
 
25496 
  thrift_spec = (
25497 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25498 
  )
25499 
 
25500 
  def __init__(self, success=None,):
25501 
    self.success = success
25502 
 
25503 
  def read(self, iprot):
25504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25506 
      return
25507 
    iprot.readStructBegin()
25508 
    while True:
25509 
      (fname, ftype, fid) = iprot.readFieldBegin()
25510 
      if ftype == TType.STOP:
25511 
        break
25512 
      if fid == 0:
25513 
        if ftype == TType.LIST:
25514 
          self.success = []
6188 rajveer 25515 
          (_etype624, _size621) = iprot.readListBegin()
25516 
          for _i625 in xrange(_size621):
25517 
            _elem626 = Attribute()
25518 
            _elem626.read(iprot)
25519 
            self.success.append(_elem626)
5527 anupam.sin 25520 
          iprot.readListEnd()
25521 
        else:
25522 
          iprot.skip(ftype)
25523 
      else:
25524 
        iprot.skip(ftype)
25525 
      iprot.readFieldEnd()
25526 
    iprot.readStructEnd()
25527 
 
25528 
  def write(self, oprot):
25529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25531 
      return
25532 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
25533 
    if self.success is not None:
25534 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25535 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25536 
      for iter627 in self.success:
25537 
        iter627.write(oprot)
5527 anupam.sin 25538 
      oprot.writeListEnd()
25539 
      oprot.writeFieldEnd()
25540 
    oprot.writeFieldStop()
25541 
    oprot.writeStructEnd()
25542 
 
25543 
  def validate(self):
25544 
    return
25545 
 
25546 
 
25547 
  def __repr__(self):
25548 
    L = ['%s=%r' % (key, value)
25549 
      for key, value in self.__dict__.iteritems()]
25550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25551 
 
25552 
  def __eq__(self, other):
25553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25554 
 
25555 
  def __ne__(self, other):
25556 
    return not (self == other)
25557 
 
5676 rajveer 25558 
class setOrderAttributes_args:
25559 
  """
25560 
  Attributes:
25561 
   - orderId
25562 
   - attributes
25563 
  """
25564 
 
25565 
  thrift_spec = None
25566 
  def __init__(self, orderId=None, attributes=None,):
25567 
    self.orderId = orderId
25568 
    self.attributes = attributes
25569 
 
25570 
  def read(self, iprot):
25571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25573 
      return
25574 
    iprot.readStructBegin()
25575 
    while True:
25576 
      (fname, ftype, fid) = iprot.readFieldBegin()
25577 
      if ftype == TType.STOP:
25578 
        break
25579 
      if fid == 1:
25580 
        if ftype == TType.I64:
25581 
          self.orderId = iprot.readI64();
25582 
        else:
25583 
          iprot.skip(ftype)
25584 
      elif fid == -1:
25585 
        if ftype == TType.LIST:
25586 
          self.attributes = []
6188 rajveer 25587 
          (_etype631, _size628) = iprot.readListBegin()
25588 
          for _i632 in xrange(_size628):
25589 
            _elem633 = Attribute()
25590 
            _elem633.read(iprot)
25591 
            self.attributes.append(_elem633)
5676 rajveer 25592 
          iprot.readListEnd()
25593 
        else:
25594 
          iprot.skip(ftype)
25595 
      else:
25596 
        iprot.skip(ftype)
25597 
      iprot.readFieldEnd()
25598 
    iprot.readStructEnd()
25599 
 
25600 
  def write(self, oprot):
25601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25603 
      return
25604 
    oprot.writeStructBegin('setOrderAttributes_args')
25605 
    if self.attributes is not None:
25606 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
25607 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 25608 
      for iter634 in self.attributes:
25609 
        iter634.write(oprot)
5676 rajveer 25610 
      oprot.writeListEnd()
25611 
      oprot.writeFieldEnd()
25612 
    if self.orderId is not None:
25613 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25614 
      oprot.writeI64(self.orderId)
25615 
      oprot.writeFieldEnd()
25616 
    oprot.writeFieldStop()
25617 
    oprot.writeStructEnd()
25618 
 
25619 
  def validate(self):
25620 
    return
25621 
 
25622 
 
25623 
  def __repr__(self):
25624 
    L = ['%s=%r' % (key, value)
25625 
      for key, value in self.__dict__.iteritems()]
25626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25627 
 
25628 
  def __eq__(self, other):
25629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25630 
 
25631 
  def __ne__(self, other):
25632 
    return not (self == other)
25633 
 
25634 
class setOrderAttributes_result:
25635 
 
25636 
  thrift_spec = (
25637 
  )
25638 
 
25639 
  def read(self, iprot):
25640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25642 
      return
25643 
    iprot.readStructBegin()
25644 
    while True:
25645 
      (fname, ftype, fid) = iprot.readFieldBegin()
25646 
      if ftype == TType.STOP:
25647 
        break
25648 
      else:
25649 
        iprot.skip(ftype)
25650 
      iprot.readFieldEnd()
25651 
    iprot.readStructEnd()
25652 
 
25653 
  def write(self, oprot):
25654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25656 
      return
25657 
    oprot.writeStructBegin('setOrderAttributes_result')
25658 
    oprot.writeFieldStop()
25659 
    oprot.writeStructEnd()
25660 
 
25661 
  def validate(self):
25662 
    return
25663 
 
25664 
 
25665 
  def __repr__(self):
25666 
    L = ['%s=%r' % (key, value)
25667 
      for key, value in self.__dict__.iteritems()]
25668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25669 
 
25670 
  def __eq__(self, other):
25671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25672 
 
25673 
  def __ne__(self, other):
25674 
    return not (self == other)
25675 
 
5527 anupam.sin 25676 
class setOrderAttributeForTransaction_args:
25677 
  """
25678 
  Attributes:
25679 
   - transactionId
25680 
   - attribute
25681 
  """
25682 
 
25683 
  thrift_spec = None
25684 
  def __init__(self, transactionId=None, attribute=None,):
25685 
    self.transactionId = transactionId
25686 
    self.attribute = attribute
25687 
 
25688 
  def read(self, iprot):
25689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25691 
      return
25692 
    iprot.readStructBegin()
25693 
    while True:
25694 
      (fname, ftype, fid) = iprot.readFieldBegin()
25695 
      if ftype == TType.STOP:
25696 
        break
25697 
      if fid == 1:
25698 
        if ftype == TType.I64:
25699 
          self.transactionId = iprot.readI64();
25700 
        else:
25701 
          iprot.skip(ftype)
25702 
      elif fid == -1:
25703 
        if ftype == TType.STRUCT:
25704 
          self.attribute = Attribute()
25705 
          self.attribute.read(iprot)
25706 
        else:
25707 
          iprot.skip(ftype)
25708 
      else:
25709 
        iprot.skip(ftype)
25710 
      iprot.readFieldEnd()
25711 
    iprot.readStructEnd()
25712 
 
25713 
  def write(self, oprot):
25714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25716 
      return
25717 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
25718 
    if self.attribute is not None:
25719 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
25720 
      self.attribute.write(oprot)
25721 
      oprot.writeFieldEnd()
25722 
    if self.transactionId is not None:
25723 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
25724 
      oprot.writeI64(self.transactionId)
25725 
      oprot.writeFieldEnd()
25726 
    oprot.writeFieldStop()
25727 
    oprot.writeStructEnd()
25728 
 
25729 
  def validate(self):
25730 
    return
25731 
 
25732 
 
25733 
  def __repr__(self):
25734 
    L = ['%s=%r' % (key, value)
25735 
      for key, value in self.__dict__.iteritems()]
25736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25737 
 
25738 
  def __eq__(self, other):
25739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25740 
 
25741 
  def __ne__(self, other):
25742 
    return not (self == other)
25743 
 
25744 
class setOrderAttributeForTransaction_result:
25745 
 
25746 
  thrift_spec = (
25747 
  )
25748 
 
25749 
  def read(self, iprot):
25750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25752 
      return
25753 
    iprot.readStructBegin()
25754 
    while True:
25755 
      (fname, ftype, fid) = iprot.readFieldBegin()
25756 
      if ftype == TType.STOP:
25757 
        break
25758 
      else:
25759 
        iprot.skip(ftype)
25760 
      iprot.readFieldEnd()
25761 
    iprot.readStructEnd()
25762 
 
25763 
  def write(self, oprot):
25764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25766 
      return
25767 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
25768 
    oprot.writeFieldStop()
25769 
    oprot.writeStructEnd()
25770 
 
25771 
  def validate(self):
25772 
    return
25773 
 
25774 
 
25775 
  def __repr__(self):
25776 
    L = ['%s=%r' % (key, value)
25777 
      for key, value in self.__dict__.iteritems()]
25778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25779 
 
25780 
  def __eq__(self, other):
25781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25782 
 
25783 
  def __ne__(self, other):
25784 
    return not (self == other)
5553 rajveer 25785 
 
25786 
class getReceivePendingOrders_args:
25787 
  """
25788 
  Attributes:
25789 
   - storeId
25790 
  """
25791 
 
25792 
  thrift_spec = (
25793 
    None, # 0
25794 
    (1, TType.I64, 'storeId', None, None, ), # 1
25795 
  )
25796 
 
25797 
  def __init__(self, storeId=None,):
25798 
    self.storeId = storeId
25799 
 
25800 
  def read(self, iprot):
25801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25803 
      return
25804 
    iprot.readStructBegin()
25805 
    while True:
25806 
      (fname, ftype, fid) = iprot.readFieldBegin()
25807 
      if ftype == TType.STOP:
25808 
        break
25809 
      if fid == 1:
25810 
        if ftype == TType.I64:
25811 
          self.storeId = iprot.readI64();
25812 
        else:
25813 
          iprot.skip(ftype)
25814 
      else:
25815 
        iprot.skip(ftype)
25816 
      iprot.readFieldEnd()
25817 
    iprot.readStructEnd()
25818 
 
25819 
  def write(self, oprot):
25820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25822 
      return
25823 
    oprot.writeStructBegin('getReceivePendingOrders_args')
25824 
    if self.storeId is not None:
25825 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25826 
      oprot.writeI64(self.storeId)
25827 
      oprot.writeFieldEnd()
25828 
    oprot.writeFieldStop()
25829 
    oprot.writeStructEnd()
25830 
 
25831 
  def validate(self):
25832 
    return
25833 
 
25834 
 
25835 
  def __repr__(self):
25836 
    L = ['%s=%r' % (key, value)
25837 
      for key, value in self.__dict__.iteritems()]
25838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25839 
 
25840 
  def __eq__(self, other):
25841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25842 
 
25843 
  def __ne__(self, other):
25844 
    return not (self == other)
25845 
 
25846 
class getReceivePendingOrders_result:
25847 
  """
25848 
  Attributes:
25849 
   - success
25850 
  """
25851 
 
25852 
  thrift_spec = (
25853 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25854 
  )
25855 
 
25856 
  def __init__(self, success=None,):
25857 
    self.success = success
25858 
 
25859 
  def read(self, iprot):
25860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25862 
      return
25863 
    iprot.readStructBegin()
25864 
    while True:
25865 
      (fname, ftype, fid) = iprot.readFieldBegin()
25866 
      if ftype == TType.STOP:
25867 
        break
25868 
      if fid == 0:
25869 
        if ftype == TType.LIST:
25870 
          self.success = []
6188 rajveer 25871 
          (_etype638, _size635) = iprot.readListBegin()
25872 
          for _i639 in xrange(_size635):
25873 
            _elem640 = Order()
25874 
            _elem640.read(iprot)
25875 
            self.success.append(_elem640)
5553 rajveer 25876 
          iprot.readListEnd()
25877 
        else:
25878 
          iprot.skip(ftype)
25879 
      else:
25880 
        iprot.skip(ftype)
25881 
      iprot.readFieldEnd()
25882 
    iprot.readStructEnd()
25883 
 
25884 
  def write(self, oprot):
25885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25887 
      return
25888 
    oprot.writeStructBegin('getReceivePendingOrders_result')
25889 
    if self.success is not None:
25890 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25891 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25892 
      for iter641 in self.success:
25893 
        iter641.write(oprot)
5553 rajveer 25894 
      oprot.writeListEnd()
25895 
      oprot.writeFieldEnd()
25896 
    oprot.writeFieldStop()
25897 
    oprot.writeStructEnd()
25898 
 
25899 
  def validate(self):
25900 
    return
25901 
 
25902 
 
25903 
  def __repr__(self):
25904 
    L = ['%s=%r' % (key, value)
25905 
      for key, value in self.__dict__.iteritems()]
25906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25907 
 
25908 
  def __eq__(self, other):
25909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25910 
 
25911 
  def __ne__(self, other):
25912 
    return not (self == other)
25913 
 
25914 
class getReceivedAtStoreOrders_args:
25915 
  """
25916 
  Attributes:
25917 
   - storeId
25918 
  """
25919 
 
25920 
  thrift_spec = (
25921 
    None, # 0
25922 
    (1, TType.I64, 'storeId', None, None, ), # 1
25923 
  )
25924 
 
25925 
  def __init__(self, storeId=None,):
25926 
    self.storeId = storeId
25927 
 
25928 
  def read(self, iprot):
25929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25931 
      return
25932 
    iprot.readStructBegin()
25933 
    while True:
25934 
      (fname, ftype, fid) = iprot.readFieldBegin()
25935 
      if ftype == TType.STOP:
25936 
        break
25937 
      if fid == 1:
25938 
        if ftype == TType.I64:
25939 
          self.storeId = iprot.readI64();
25940 
        else:
25941 
          iprot.skip(ftype)
25942 
      else:
25943 
        iprot.skip(ftype)
25944 
      iprot.readFieldEnd()
25945 
    iprot.readStructEnd()
25946 
 
25947 
  def write(self, oprot):
25948 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25949 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25950 
      return
25951 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
25952 
    if self.storeId is not None:
25953 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25954 
      oprot.writeI64(self.storeId)
25955 
      oprot.writeFieldEnd()
25956 
    oprot.writeFieldStop()
25957 
    oprot.writeStructEnd()
25958 
 
25959 
  def validate(self):
25960 
    return
25961 
 
25962 
 
25963 
  def __repr__(self):
25964 
    L = ['%s=%r' % (key, value)
25965 
      for key, value in self.__dict__.iteritems()]
25966 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25967 
 
25968 
  def __eq__(self, other):
25969 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25970 
 
25971 
  def __ne__(self, other):
25972 
    return not (self == other)
25973 
 
25974 
class getReceivedAtStoreOrders_result:
25975 
  """
25976 
  Attributes:
25977 
   - success
25978 
  """
25979 
 
25980 
  thrift_spec = (
25981 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25982 
  )
25983 
 
25984 
  def __init__(self, success=None,):
25985 
    self.success = success
25986 
 
25987 
  def read(self, iprot):
25988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25990 
      return
25991 
    iprot.readStructBegin()
25992 
    while True:
25993 
      (fname, ftype, fid) = iprot.readFieldBegin()
25994 
      if ftype == TType.STOP:
25995 
        break
25996 
      if fid == 0:
25997 
        if ftype == TType.LIST:
25998 
          self.success = []
6188 rajveer 25999 
          (_etype645, _size642) = iprot.readListBegin()
26000 
          for _i646 in xrange(_size642):
26001 
            _elem647 = Order()
26002 
            _elem647.read(iprot)
26003 
            self.success.append(_elem647)
5553 rajveer 26004 
          iprot.readListEnd()
26005 
        else:
26006 
          iprot.skip(ftype)
26007 
      else:
26008 
        iprot.skip(ftype)
26009 
      iprot.readFieldEnd()
26010 
    iprot.readStructEnd()
26011 
 
26012 
  def write(self, oprot):
26013 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26014 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26015 
      return
26016 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
26017 
    if self.success is not None:
26018 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26019 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26020 
      for iter648 in self.success:
26021 
        iter648.write(oprot)
5553 rajveer 26022 
      oprot.writeListEnd()
26023 
      oprot.writeFieldEnd()
26024 
    oprot.writeFieldStop()
26025 
    oprot.writeStructEnd()
26026 
 
26027 
  def validate(self):
26028 
    return
26029 
 
26030 
 
26031 
  def __repr__(self):
26032 
    L = ['%s=%r' % (key, value)
26033 
      for key, value in self.__dict__.iteritems()]
26034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26035 
 
26036 
  def __eq__(self, other):
26037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26038 
 
26039 
  def __ne__(self, other):
26040 
    return not (self == other)
5593 mandeep.dh 26041 
 
5713 rajveer 26042 
class getOrdersCollectionAtStore_args:
26043 
  """
26044 
  Attributes:
26045 
   - storeId
26046 
   - fromDate
26047 
   - toDate
26048 
   - onlyCod
26049 
  """
26050 
 
26051 
  thrift_spec = (
26052 
    None, # 0
26053 
    (1, TType.I64, 'storeId', None, None, ), # 1
26054 
    (2, TType.I64, 'fromDate', None, None, ), # 2
26055 
    (3, TType.I64, 'toDate', None, None, ), # 3
26056 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
26057 
  )
26058 
 
26059 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
26060 
    self.storeId = storeId
26061 
    self.fromDate = fromDate
26062 
    self.toDate = toDate
26063 
    self.onlyCod = onlyCod
26064 
 
26065 
  def read(self, iprot):
26066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26068 
      return
26069 
    iprot.readStructBegin()
26070 
    while True:
26071 
      (fname, ftype, fid) = iprot.readFieldBegin()
26072 
      if ftype == TType.STOP:
26073 
        break
26074 
      if fid == 1:
26075 
        if ftype == TType.I64:
26076 
          self.storeId = iprot.readI64();
26077 
        else:
26078 
          iprot.skip(ftype)
26079 
      elif fid == 2:
26080 
        if ftype == TType.I64:
26081 
          self.fromDate = iprot.readI64();
26082 
        else:
26083 
          iprot.skip(ftype)
26084 
      elif fid == 3:
26085 
        if ftype == TType.I64:
26086 
          self.toDate = iprot.readI64();
26087 
        else:
26088 
          iprot.skip(ftype)
26089 
      elif fid == 4:
26090 
        if ftype == TType.BOOL:
26091 
          self.onlyCod = iprot.readBool();
26092 
        else:
26093 
          iprot.skip(ftype)
26094 
      else:
26095 
        iprot.skip(ftype)
26096 
      iprot.readFieldEnd()
26097 
    iprot.readStructEnd()
26098 
 
26099 
  def write(self, oprot):
26100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26102 
      return
26103 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
26104 
    if self.storeId is not None:
26105 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26106 
      oprot.writeI64(self.storeId)
26107 
      oprot.writeFieldEnd()
26108 
    if self.fromDate is not None:
26109 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
26110 
      oprot.writeI64(self.fromDate)
26111 
      oprot.writeFieldEnd()
26112 
    if self.toDate is not None:
26113 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
26114 
      oprot.writeI64(self.toDate)
26115 
      oprot.writeFieldEnd()
26116 
    if self.onlyCod is not None:
26117 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
26118 
      oprot.writeBool(self.onlyCod)
26119 
      oprot.writeFieldEnd()
26120 
    oprot.writeFieldStop()
26121 
    oprot.writeStructEnd()
26122 
 
26123 
  def validate(self):
26124 
    return
26125 
 
26126 
 
26127 
  def __repr__(self):
26128 
    L = ['%s=%r' % (key, value)
26129 
      for key, value in self.__dict__.iteritems()]
26130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26131 
 
26132 
  def __eq__(self, other):
26133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26134 
 
26135 
  def __ne__(self, other):
26136 
    return not (self == other)
26137 
 
26138 
class getOrdersCollectionAtStore_result:
26139 
  """
26140 
  Attributes:
26141 
   - success
26142 
  """
26143 
 
26144 
  thrift_spec = (
26145 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26146 
  )
26147 
 
26148 
  def __init__(self, success=None,):
26149 
    self.success = success
26150 
 
26151 
  def read(self, iprot):
26152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26154 
      return
26155 
    iprot.readStructBegin()
26156 
    while True:
26157 
      (fname, ftype, fid) = iprot.readFieldBegin()
26158 
      if ftype == TType.STOP:
26159 
        break
26160 
      if fid == 0:
26161 
        if ftype == TType.LIST:
26162 
          self.success = []
6188 rajveer 26163 
          (_etype652, _size649) = iprot.readListBegin()
26164 
          for _i653 in xrange(_size649):
26165 
            _elem654 = Order()
26166 
            _elem654.read(iprot)
26167 
            self.success.append(_elem654)
5713 rajveer 26168 
          iprot.readListEnd()
26169 
        else:
26170 
          iprot.skip(ftype)
26171 
      else:
26172 
        iprot.skip(ftype)
26173 
      iprot.readFieldEnd()
26174 
    iprot.readStructEnd()
26175 
 
26176 
  def write(self, oprot):
26177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26179 
      return
26180 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
26181 
    if self.success is not None:
26182 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26183 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26184 
      for iter655 in self.success:
26185 
        iter655.write(oprot)
5713 rajveer 26186 
      oprot.writeListEnd()
26187 
      oprot.writeFieldEnd()
26188 
    oprot.writeFieldStop()
26189 
    oprot.writeStructEnd()
26190 
 
26191 
  def validate(self):
26192 
    return
26193 
 
26194 
 
26195 
  def __repr__(self):
26196 
    L = ['%s=%r' % (key, value)
26197 
      for key, value in self.__dict__.iteritems()]
26198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26199 
 
26200 
  def __eq__(self, other):
26201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26202 
 
26203 
  def __ne__(self, other):
26204 
    return not (self == other)
26205 
 
5833 rajveer 26206 
class getOrderAttributeValue_args:
26207 
  """
26208 
  Attributes:
26209 
   - orderId
26210 
   - attributeName
26211 
  """
26212 
 
26213 
  thrift_spec = None
26214 
  def __init__(self, orderId=None, attributeName=None,):
26215 
    self.orderId = orderId
26216 
    self.attributeName = attributeName
26217 
 
26218 
  def read(self, iprot):
26219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26221 
      return
26222 
    iprot.readStructBegin()
26223 
    while True:
26224 
      (fname, ftype, fid) = iprot.readFieldBegin()
26225 
      if ftype == TType.STOP:
26226 
        break
26227 
      if fid == 1:
26228 
        if ftype == TType.I64:
26229 
          self.orderId = iprot.readI64();
26230 
        else:
26231 
          iprot.skip(ftype)
26232 
      elif fid == -1:
26233 
        if ftype == TType.STRING:
26234 
          self.attributeName = iprot.readString();
26235 
        else:
26236 
          iprot.skip(ftype)
26237 
      else:
26238 
        iprot.skip(ftype)
26239 
      iprot.readFieldEnd()
26240 
    iprot.readStructEnd()
26241 
 
26242 
  def write(self, oprot):
26243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26245 
      return
26246 
    oprot.writeStructBegin('getOrderAttributeValue_args')
26247 
    if self.attributeName is not None:
26248 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
26249 
      oprot.writeString(self.attributeName)
26250 
      oprot.writeFieldEnd()
26251 
    if self.orderId is not None:
26252 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26253 
      oprot.writeI64(self.orderId)
26254 
      oprot.writeFieldEnd()
26255 
    oprot.writeFieldStop()
26256 
    oprot.writeStructEnd()
26257 
 
26258 
  def validate(self):
26259 
    return
26260 
 
26261 
 
26262 
  def __repr__(self):
26263 
    L = ['%s=%r' % (key, value)
26264 
      for key, value in self.__dict__.iteritems()]
26265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26266 
 
26267 
  def __eq__(self, other):
26268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26269 
 
26270 
  def __ne__(self, other):
26271 
    return not (self == other)
26272 
 
26273 
class getOrderAttributeValue_result:
26274 
  """
26275 
  Attributes:
26276 
   - success
26277 
  """
26278 
 
26279 
  thrift_spec = (
26280 
    (0, TType.STRING, 'success', None, None, ), # 0
26281 
  )
26282 
 
26283 
  def __init__(self, success=None,):
26284 
    self.success = success
26285 
 
26286 
  def read(self, iprot):
26287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26289 
      return
26290 
    iprot.readStructBegin()
26291 
    while True:
26292 
      (fname, ftype, fid) = iprot.readFieldBegin()
26293 
      if ftype == TType.STOP:
26294 
        break
26295 
      if fid == 0:
26296 
        if ftype == TType.STRING:
26297 
          self.success = iprot.readString();
26298 
        else:
26299 
          iprot.skip(ftype)
26300 
      else:
26301 
        iprot.skip(ftype)
26302 
      iprot.readFieldEnd()
26303 
    iprot.readStructEnd()
26304 
 
26305 
  def write(self, oprot):
26306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26308 
      return
26309 
    oprot.writeStructBegin('getOrderAttributeValue_result')
26310 
    if self.success is not None:
26311 
      oprot.writeFieldBegin('success', TType.STRING, 0)
26312 
      oprot.writeString(self.success)
26313 
      oprot.writeFieldEnd()
26314 
    oprot.writeFieldStop()
26315 
    oprot.writeStructEnd()
26316 
 
26317 
  def validate(self):
26318 
    return
26319 
 
26320 
 
26321 
  def __repr__(self):
26322 
    L = ['%s=%r' % (key, value)
26323 
      for key, value in self.__dict__.iteritems()]
26324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26325 
 
26326 
  def __eq__(self, other):
26327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26328 
 
26329 
  def __ne__(self, other):
26330 
    return not (self == other)
26331 
 
6019 rajveer 26332 
class changeJacketNumber_args:
26333 
  """
26334 
  Attributes:
26335 
   - orderId
26336 
   - jacketNumber
26337 
  """
26338 
 
26339 
  thrift_spec = (
26340 
    None, # 0
26341 
    (1, TType.I64, 'orderId', None, None, ), # 1
26342 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
26343 
  )
26344 
 
26345 
  def __init__(self, orderId=None, jacketNumber=None,):
26346 
    self.orderId = orderId
26347 
    self.jacketNumber = jacketNumber
26348 
 
26349 
  def read(self, iprot):
26350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26352 
      return
26353 
    iprot.readStructBegin()
26354 
    while True:
26355 
      (fname, ftype, fid) = iprot.readFieldBegin()
26356 
      if ftype == TType.STOP:
26357 
        break
26358 
      if fid == 1:
26359 
        if ftype == TType.I64:
26360 
          self.orderId = iprot.readI64();
26361 
        else:
26362 
          iprot.skip(ftype)
26363 
      elif fid == 2:
26364 
        if ftype == TType.I64:
26365 
          self.jacketNumber = iprot.readI64();
26366 
        else:
26367 
          iprot.skip(ftype)
26368 
      else:
26369 
        iprot.skip(ftype)
26370 
      iprot.readFieldEnd()
26371 
    iprot.readStructEnd()
26372 
 
26373 
  def write(self, oprot):
26374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26376 
      return
26377 
    oprot.writeStructBegin('changeJacketNumber_args')
26378 
    if self.orderId is not None:
26379 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26380 
      oprot.writeI64(self.orderId)
26381 
      oprot.writeFieldEnd()
26382 
    if self.jacketNumber is not None:
26383 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
26384 
      oprot.writeI64(self.jacketNumber)
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 changeJacketNumber_result:
26405 
  """
26406 
  Attributes:
26407 
   - success
26408 
  """
26409 
 
26410 
  thrift_spec = (
26411 
    (0, TType.BOOL, 'success', None, 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.BOOL:
26428 
          self.success = iprot.readBool();
26429 
        else:
26430 
          iprot.skip(ftype)
26431 
      else:
26432 
        iprot.skip(ftype)
26433 
      iprot.readFieldEnd()
26434 
    iprot.readStructEnd()
26435 
 
26436 
  def write(self, oprot):
26437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26439 
      return
26440 
    oprot.writeStructBegin('changeJacketNumber_result')
26441 
    if self.success is not None:
26442 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26443 
      oprot.writeBool(self.success)
26444 
      oprot.writeFieldEnd()
26445 
    oprot.writeFieldStop()
26446 
    oprot.writeStructEnd()
26447 
 
26448 
  def validate(self):
26449 
    return
26450 
 
26451 
 
26452 
  def __repr__(self):
26453 
    L = ['%s=%r' % (key, value)
26454 
      for key, value in self.__dict__.iteritems()]
26455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26456 
 
26457 
  def __eq__(self, other):
26458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26459 
 
26460 
  def __ne__(self, other):
26461 
    return not (self == other)
26462 
 
26463 
class markOrderAsRtoInTransit_args:
26464 
  """
26465 
  Attributes:
26466 
   - orderId
26467 
  """
26468 
 
26469 
  thrift_spec = (
26470 
    None, # 0
26471 
    (1, TType.I64, 'orderId', None, None, ), # 1
26472 
  )
26473 
 
26474 
  def __init__(self, orderId=None,):
26475 
    self.orderId = orderId
26476 
 
26477 
  def read(self, iprot):
26478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26480 
      return
26481 
    iprot.readStructBegin()
26482 
    while True:
26483 
      (fname, ftype, fid) = iprot.readFieldBegin()
26484 
      if ftype == TType.STOP:
26485 
        break
26486 
      if fid == 1:
26487 
        if ftype == TType.I64:
26488 
          self.orderId = iprot.readI64();
26489 
        else:
26490 
          iprot.skip(ftype)
26491 
      else:
26492 
        iprot.skip(ftype)
26493 
      iprot.readFieldEnd()
26494 
    iprot.readStructEnd()
26495 
 
26496 
  def write(self, oprot):
26497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26499 
      return
26500 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26501 
    if self.orderId is not None:
26502 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26503 
      oprot.writeI64(self.orderId)
26504 
      oprot.writeFieldEnd()
26505 
    oprot.writeFieldStop()
26506 
    oprot.writeStructEnd()
26507 
 
26508 
  def validate(self):
26509 
    return
26510 
 
26511 
 
26512 
  def __repr__(self):
26513 
    L = ['%s=%r' % (key, value)
26514 
      for key, value in self.__dict__.iteritems()]
26515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26516 
 
26517 
  def __eq__(self, other):
26518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26519 
 
26520 
  def __ne__(self, other):
26521 
    return not (self == other)
26522 
 
26523 
class markOrderAsRtoInTransit_result:
26524 
  """
26525 
  Attributes:
26526 
   - success
26527 
  """
26528 
 
26529 
  thrift_spec = (
26530 
    (0, TType.BOOL, 'success', None, None, ), # 0
26531 
  )
26532 
 
26533 
  def __init__(self, success=None,):
26534 
    self.success = success
26535 
 
26536 
  def read(self, iprot):
26537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26539 
      return
26540 
    iprot.readStructBegin()
26541 
    while True:
26542 
      (fname, ftype, fid) = iprot.readFieldBegin()
26543 
      if ftype == TType.STOP:
26544 
        break
26545 
      if fid == 0:
26546 
        if ftype == TType.BOOL:
26547 
          self.success = iprot.readBool();
26548 
        else:
26549 
          iprot.skip(ftype)
26550 
      else:
26551 
        iprot.skip(ftype)
26552 
      iprot.readFieldEnd()
26553 
    iprot.readStructEnd()
26554 
 
26555 
  def write(self, oprot):
26556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26558 
      return
26559 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
26560 
    if self.success is not None:
26561 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26562 
      oprot.writeBool(self.success)
26563 
      oprot.writeFieldEnd()
26564 
    oprot.writeFieldStop()
26565 
    oprot.writeStructEnd()
26566 
 
26567 
  def validate(self):
26568 
    return
26569 
 
26570 
 
26571 
  def __repr__(self):
26572 
    L = ['%s=%r' % (key, value)
26573 
      for key, value in self.__dict__.iteritems()]
26574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26575 
 
26576 
  def __eq__(self, other):
26577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26578 
 
26579 
  def __ne__(self, other):
26580 
    return not (self == other)
26581 
 
5593 mandeep.dh 26582 
class acceptOrderForItem_args:
26583 
  """
26584 
  Attributes:
26585 
   - itemId
26586 
   - quantity
26587 
   - fulfilmentWarehouseId
26588 
   - billingWarehouseId
26589 
  """
26590 
 
26591 
  thrift_spec = (
26592 
    None, # 0
26593 
    (1, TType.I64, 'itemId', None, None, ), # 1
26594 
    (2, TType.I64, 'quantity', None, None, ), # 2
26595 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
26596 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
26597 
  )
26598 
 
26599 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
26600 
    self.itemId = itemId
26601 
    self.quantity = quantity
26602 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
26603 
    self.billingWarehouseId = billingWarehouseId
26604 
 
26605 
  def read(self, iprot):
26606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26608 
      return
26609 
    iprot.readStructBegin()
26610 
    while True:
26611 
      (fname, ftype, fid) = iprot.readFieldBegin()
26612 
      if ftype == TType.STOP:
26613 
        break
26614 
      if fid == 1:
26615 
        if ftype == TType.I64:
26616 
          self.itemId = iprot.readI64();
26617 
        else:
26618 
          iprot.skip(ftype)
26619 
      elif fid == 2:
26620 
        if ftype == TType.I64:
26621 
          self.quantity = iprot.readI64();
26622 
        else:
26623 
          iprot.skip(ftype)
26624 
      elif fid == 3:
26625 
        if ftype == TType.I64:
26626 
          self.fulfilmentWarehouseId = iprot.readI64();
26627 
        else:
26628 
          iprot.skip(ftype)
26629 
      elif fid == 4:
26630 
        if ftype == TType.I64:
26631 
          self.billingWarehouseId = 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('acceptOrderForItem_args')
26644 
    if self.itemId is not None:
26645 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26646 
      oprot.writeI64(self.itemId)
26647 
      oprot.writeFieldEnd()
26648 
    if self.quantity is not None:
26649 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
26650 
      oprot.writeI64(self.quantity)
26651 
      oprot.writeFieldEnd()
26652 
    if self.fulfilmentWarehouseId is not None:
26653 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26654 
      oprot.writeI64(self.fulfilmentWarehouseId)
26655 
      oprot.writeFieldEnd()
26656 
    if self.billingWarehouseId is not None:
26657 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26658 
      oprot.writeI64(self.billingWarehouseId)
26659 
      oprot.writeFieldEnd()
26660 
    oprot.writeFieldStop()
26661 
    oprot.writeStructEnd()
26662 
 
26663 
  def validate(self):
26664 
    return
26665 
 
26666 
 
26667 
  def __repr__(self):
26668 
    L = ['%s=%r' % (key, value)
26669 
      for key, value in self.__dict__.iteritems()]
26670 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26671 
 
26672 
  def __eq__(self, other):
26673 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26674 
 
26675 
  def __ne__(self, other):
26676 
    return not (self == other)
26677 
 
26678 
class acceptOrderForItem_result:
26679 
 
26680 
  thrift_spec = (
26681 
  )
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 
      else:
26693 
        iprot.skip(ftype)
26694 
      iprot.readFieldEnd()
26695 
    iprot.readStructEnd()
26696 
 
26697 
  def write(self, oprot):
26698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26700 
      return
26701 
    oprot.writeStructBegin('acceptOrderForItem_result')
26702 
    oprot.writeFieldStop()
26703 
    oprot.writeStructEnd()
26704 
 
26705 
  def validate(self):
26706 
    return
26707 
 
26708 
 
26709 
  def __repr__(self):
26710 
    L = ['%s=%r' % (key, value)
26711 
      for key, value in self.__dict__.iteritems()]
26712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26713 
 
26714 
  def __eq__(self, other):
26715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26716 
 
26717 
  def __ne__(self, other):
26718 
    return not (self == other)
6000 mandeep.dh 26719 
 
26720 
class createRechargeOrder_args:
26721 
  """
26722 
  Attributes:
26723 
   - rechargeOrder
26724 
  """
26725 
 
26726 
  thrift_spec = (
26727 
    None, # 0
26728 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
26729 
  )
26730 
 
26731 
  def __init__(self, rechargeOrder=None,):
26732 
    self.rechargeOrder = rechargeOrder
26733 
 
26734 
  def read(self, iprot):
26735 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26736 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26737 
      return
26738 
    iprot.readStructBegin()
26739 
    while True:
26740 
      (fname, ftype, fid) = iprot.readFieldBegin()
26741 
      if ftype == TType.STOP:
26742 
        break
26743 
      if fid == 1:
26744 
        if ftype == TType.STRUCT:
26745 
          self.rechargeOrder = RechargeOrder()
26746 
          self.rechargeOrder.read(iprot)
26747 
        else:
26748 
          iprot.skip(ftype)
26749 
      else:
26750 
        iprot.skip(ftype)
26751 
      iprot.readFieldEnd()
26752 
    iprot.readStructEnd()
26753 
 
26754 
  def write(self, oprot):
26755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26757 
      return
26758 
    oprot.writeStructBegin('createRechargeOrder_args')
26759 
    if self.rechargeOrder is not None:
26760 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
26761 
      self.rechargeOrder.write(oprot)
26762 
      oprot.writeFieldEnd()
26763 
    oprot.writeFieldStop()
26764 
    oprot.writeStructEnd()
26765 
 
26766 
  def validate(self):
26767 
    return
26768 
 
26769 
 
26770 
  def __repr__(self):
26771 
    L = ['%s=%r' % (key, value)
26772 
      for key, value in self.__dict__.iteritems()]
26773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26774 
 
26775 
  def __eq__(self, other):
26776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26777 
 
26778 
  def __ne__(self, other):
26779 
    return not (self == other)
26780 
 
26781 
class createRechargeOrder_result:
26782 
  """
26783 
  Attributes:
26784 
   - success
26785 
   - ex
26786 
  """
26787 
 
26788 
  thrift_spec = (
26789 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26790 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26791 
  )
26792 
 
26793 
  def __init__(self, success=None, ex=None,):
26794 
    self.success = success
26795 
    self.ex = ex
26796 
 
26797 
  def read(self, iprot):
26798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26800 
      return
26801 
    iprot.readStructBegin()
26802 
    while True:
26803 
      (fname, ftype, fid) = iprot.readFieldBegin()
26804 
      if ftype == TType.STOP:
26805 
        break
26806 
      if fid == 0:
26807 
        if ftype == TType.STRUCT:
26808 
          self.success = RechargeOrder()
26809 
          self.success.read(iprot)
26810 
        else:
26811 
          iprot.skip(ftype)
26812 
      elif fid == 1:
26813 
        if ftype == TType.STRUCT:
26814 
          self.ex = TransactionServiceException()
26815 
          self.ex.read(iprot)
26816 
        else:
26817 
          iprot.skip(ftype)
26818 
      else:
26819 
        iprot.skip(ftype)
26820 
      iprot.readFieldEnd()
26821 
    iprot.readStructEnd()
26822 
 
26823 
  def write(self, oprot):
26824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26826 
      return
26827 
    oprot.writeStructBegin('createRechargeOrder_result')
26828 
    if self.success is not None:
26829 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26830 
      self.success.write(oprot)
26831 
      oprot.writeFieldEnd()
26832 
    if self.ex is not None:
26833 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26834 
      self.ex.write(oprot)
26835 
      oprot.writeFieldEnd()
26836 
    oprot.writeFieldStop()
26837 
    oprot.writeStructEnd()
26838 
 
26839 
  def validate(self):
26840 
    return
26841 
 
26842 
 
26843 
  def __repr__(self):
26844 
    L = ['%s=%r' % (key, value)
26845 
      for key, value in self.__dict__.iteritems()]
26846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26847 
 
26848 
  def __eq__(self, other):
26849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26850 
 
26851 
  def __ne__(self, other):
26852 
    return not (self == other)
26853 
 
6031 rajveer 26854 
class getRechargeOrder_args:
26855 
  """
26856 
  Attributes:
26857 
   - rechargeRrderId
26858 
  """
26859 
 
26860 
  thrift_spec = (
26861 
    None, # 0
26862 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
26863 
  )
26864 
 
26865 
  def __init__(self, rechargeRrderId=None,):
26866 
    self.rechargeRrderId = rechargeRrderId
26867 
 
26868 
  def read(self, iprot):
26869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26871 
      return
26872 
    iprot.readStructBegin()
26873 
    while True:
26874 
      (fname, ftype, fid) = iprot.readFieldBegin()
26875 
      if ftype == TType.STOP:
26876 
        break
26877 
      if fid == 1:
26878 
        if ftype == TType.I64:
26879 
          self.rechargeRrderId = iprot.readI64();
26880 
        else:
26881 
          iprot.skip(ftype)
26882 
      else:
26883 
        iprot.skip(ftype)
26884 
      iprot.readFieldEnd()
26885 
    iprot.readStructEnd()
26886 
 
26887 
  def write(self, oprot):
26888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26890 
      return
26891 
    oprot.writeStructBegin('getRechargeOrder_args')
26892 
    if self.rechargeRrderId is not None:
26893 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
26894 
      oprot.writeI64(self.rechargeRrderId)
26895 
      oprot.writeFieldEnd()
26896 
    oprot.writeFieldStop()
26897 
    oprot.writeStructEnd()
26898 
 
26899 
  def validate(self):
26900 
    return
26901 
 
26902 
 
26903 
  def __repr__(self):
26904 
    L = ['%s=%r' % (key, value)
26905 
      for key, value in self.__dict__.iteritems()]
26906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26907 
 
26908 
  def __eq__(self, other):
26909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26910 
 
26911 
  def __ne__(self, other):
26912 
    return not (self == other)
26913 
 
26914 
class getRechargeOrder_result:
26915 
  """
26916 
  Attributes:
26917 
   - success
26918 
   - ex
26919 
  """
26920 
 
26921 
  thrift_spec = (
26922 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26923 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26924 
  )
26925 
 
26926 
  def __init__(self, success=None, ex=None,):
26927 
    self.success = success
26928 
    self.ex = ex
26929 
 
26930 
  def read(self, iprot):
26931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26933 
      return
26934 
    iprot.readStructBegin()
26935 
    while True:
26936 
      (fname, ftype, fid) = iprot.readFieldBegin()
26937 
      if ftype == TType.STOP:
26938 
        break
26939 
      if fid == 0:
26940 
        if ftype == TType.STRUCT:
26941 
          self.success = RechargeOrder()
26942 
          self.success.read(iprot)
26943 
        else:
26944 
          iprot.skip(ftype)
26945 
      elif fid == 1:
26946 
        if ftype == TType.STRUCT:
26947 
          self.ex = TransactionServiceException()
26948 
          self.ex.read(iprot)
26949 
        else:
26950 
          iprot.skip(ftype)
26951 
      else:
26952 
        iprot.skip(ftype)
26953 
      iprot.readFieldEnd()
26954 
    iprot.readStructEnd()
26955 
 
26956 
  def write(self, oprot):
26957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26959 
      return
26960 
    oprot.writeStructBegin('getRechargeOrder_result')
26961 
    if self.success is not None:
26962 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26963 
      self.success.write(oprot)
26964 
      oprot.writeFieldEnd()
26965 
    if self.ex is not None:
26966 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26967 
      self.ex.write(oprot)
26968 
      oprot.writeFieldEnd()
26969 
    oprot.writeFieldStop()
26970 
    oprot.writeStructEnd()
26971 
 
26972 
  def validate(self):
26973 
    return
26974 
 
26975 
 
26976 
  def __repr__(self):
26977 
    L = ['%s=%r' % (key, value)
26978 
      for key, value in self.__dict__.iteritems()]
26979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26980 
 
26981 
  def __eq__(self, other):
26982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26983 
 
26984 
  def __ne__(self, other):
26985 
    return not (self == other)
26986 
 
26987 
class getRechargeOrders_args:
26988 
  """
26989 
  Attributes:
26990 
   - userId
26991 
  """
26992 
 
26993 
  thrift_spec = (
26994 
    None, # 0
26995 
    (1, TType.I64, 'userId', None, None, ), # 1
26996 
  )
26997 
 
26998 
  def __init__(self, userId=None,):
26999 
    self.userId = userId
27000 
 
27001 
  def read(self, iprot):
27002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27004 
      return
27005 
    iprot.readStructBegin()
27006 
    while True:
27007 
      (fname, ftype, fid) = iprot.readFieldBegin()
27008 
      if ftype == TType.STOP:
27009 
        break
27010 
      if fid == 1:
27011 
        if ftype == TType.I64:
27012 
          self.userId = iprot.readI64();
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('getRechargeOrders_args')
27025 
    if self.userId is not None:
27026 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27027 
      oprot.writeI64(self.userId)
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 getRechargeOrders_result:
27048 
  """
27049 
  Attributes:
27050 
   - success
27051 
  """
27052 
 
27053 
  thrift_spec = (
27054 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27055 
  )
27056 
 
27057 
  def __init__(self, success=None,):
27058 
    self.success = success
27059 
 
27060 
  def read(self, iprot):
27061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27063 
      return
27064 
    iprot.readStructBegin()
27065 
    while True:
27066 
      (fname, ftype, fid) = iprot.readFieldBegin()
27067 
      if ftype == TType.STOP:
27068 
        break
27069 
      if fid == 0:
27070 
        if ftype == TType.LIST:
27071 
          self.success = []
6188 rajveer 27072 
          (_etype659, _size656) = iprot.readListBegin()
27073 
          for _i660 in xrange(_size656):
27074 
            _elem661 = RechargeOrder()
27075 
            _elem661.read(iprot)
27076 
            self.success.append(_elem661)
6031 rajveer 27077 
          iprot.readListEnd()
27078 
        else:
27079 
          iprot.skip(ftype)
27080 
      else:
27081 
        iprot.skip(ftype)
27082 
      iprot.readFieldEnd()
27083 
    iprot.readStructEnd()
27084 
 
27085 
  def write(self, oprot):
27086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27088 
      return
27089 
    oprot.writeStructBegin('getRechargeOrders_result')
27090 
    if self.success is not None:
27091 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27092 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27093 
      for iter662 in self.success:
27094 
        iter662.write(oprot)
6031 rajveer 27095 
      oprot.writeListEnd()
27096 
      oprot.writeFieldEnd()
27097 
    oprot.writeFieldStop()
27098 
    oprot.writeStructEnd()
27099 
 
27100 
  def validate(self):
27101 
    return
27102 
 
27103 
 
27104 
  def __repr__(self):
27105 
    L = ['%s=%r' % (key, value)
27106 
      for key, value in self.__dict__.iteritems()]
27107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27108 
 
27109 
  def __eq__(self, other):
27110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27111 
 
27112 
  def __ne__(self, other):
27113 
    return not (self == other)
27114 
 
6000 mandeep.dh 27115 
class updateRechargeOrderStatus_args:
27116 
  """
27117 
  Attributes:
27118 
   - rechargeOrderId
27119 
   - rechargeOrderStatus
27120 
  """
27121 
 
27122 
  thrift_spec = (
27123 
    None, # 0
27124 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
27125 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
27126 
  )
27127 
 
27128 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
27129 
    self.rechargeOrderId = rechargeOrderId
27130 
    self.rechargeOrderStatus = rechargeOrderStatus
27131 
 
27132 
  def read(self, iprot):
27133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27135 
      return
27136 
    iprot.readStructBegin()
27137 
    while True:
27138 
      (fname, ftype, fid) = iprot.readFieldBegin()
27139 
      if ftype == TType.STOP:
27140 
        break
27141 
      if fid == 1:
27142 
        if ftype == TType.I64:
27143 
          self.rechargeOrderId = iprot.readI64();
27144 
        else:
27145 
          iprot.skip(ftype)
27146 
      elif fid == 2:
27147 
        if ftype == TType.I32:
27148 
          self.rechargeOrderStatus = iprot.readI32();
27149 
        else:
27150 
          iprot.skip(ftype)
27151 
      else:
27152 
        iprot.skip(ftype)
27153 
      iprot.readFieldEnd()
27154 
    iprot.readStructEnd()
27155 
 
27156 
  def write(self, oprot):
27157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27159 
      return
27160 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
27161 
    if self.rechargeOrderId is not None:
27162 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27163 
      oprot.writeI64(self.rechargeOrderId)
27164 
      oprot.writeFieldEnd()
27165 
    if self.rechargeOrderStatus is not None:
27166 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
27167 
      oprot.writeI32(self.rechargeOrderStatus)
27168 
      oprot.writeFieldEnd()
27169 
    oprot.writeFieldStop()
27170 
    oprot.writeStructEnd()
27171 
 
27172 
  def validate(self):
27173 
    return
27174 
 
27175 
 
27176 
  def __repr__(self):
27177 
    L = ['%s=%r' % (key, value)
27178 
      for key, value in self.__dict__.iteritems()]
27179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27180 
 
27181 
  def __eq__(self, other):
27182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27183 
 
27184 
  def __ne__(self, other):
27185 
    return not (self == other)
27186 
 
27187 
class updateRechargeOrderStatus_result:
27188 
  """
27189 
  Attributes:
6031 rajveer 27190 
   - success
6000 mandeep.dh 27191 
   - ex
27192 
  """
27193 
 
27194 
  thrift_spec = (
6031 rajveer 27195 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27196 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27197 
  )
27198 
 
6031 rajveer 27199 
  def __init__(self, success=None, ex=None,):
27200 
    self.success = success
6000 mandeep.dh 27201 
    self.ex = ex
27202 
 
27203 
  def read(self, iprot):
27204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27206 
      return
27207 
    iprot.readStructBegin()
27208 
    while True:
27209 
      (fname, ftype, fid) = iprot.readFieldBegin()
27210 
      if ftype == TType.STOP:
27211 
        break
6031 rajveer 27212 
      if fid == 0:
27213 
        if ftype == TType.BOOL:
27214 
          self.success = iprot.readBool();
27215 
        else:
27216 
          iprot.skip(ftype)
27217 
      elif fid == 1:
6000 mandeep.dh 27218 
        if ftype == TType.STRUCT:
27219 
          self.ex = TransactionServiceException()
27220 
          self.ex.read(iprot)
27221 
        else:
27222 
          iprot.skip(ftype)
27223 
      else:
27224 
        iprot.skip(ftype)
27225 
      iprot.readFieldEnd()
27226 
    iprot.readStructEnd()
27227 
 
27228 
  def write(self, oprot):
27229 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27230 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27231 
      return
27232 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 27233 
    if self.success is not None:
27234 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27235 
      oprot.writeBool(self.success)
27236 
      oprot.writeFieldEnd()
6000 mandeep.dh 27237 
    if self.ex is not None:
27238 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27239 
      self.ex.write(oprot)
27240 
      oprot.writeFieldEnd()
27241 
    oprot.writeFieldStop()
27242 
    oprot.writeStructEnd()
27243 
 
27244 
  def validate(self):
27245 
    return
27246 
 
27247 
 
27248 
  def __repr__(self):
27249 
    L = ['%s=%r' % (key, value)
27250 
      for key, value in self.__dict__.iteritems()]
27251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27252 
 
27253 
  def __eq__(self, other):
27254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27255 
 
27256 
  def __ne__(self, other):
27257 
    return not (self == other)
27258 
 
27259 
class activateRechargeTxn_args:
27260 
  """
27261 
  Attributes:
6031 rajveer 27262 
   - rechargeOrderId
6000 mandeep.dh 27263 
  """
27264 
 
27265 
  thrift_spec = (
27266 
    None, # 0
6031 rajveer 27267 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 27268 
  )
27269 
 
6031 rajveer 27270 
  def __init__(self, rechargeOrderId=None,):
27271 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 27272 
 
27273 
  def read(self, iprot):
27274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27276 
      return
27277 
    iprot.readStructBegin()
27278 
    while True:
27279 
      (fname, ftype, fid) = iprot.readFieldBegin()
27280 
      if ftype == TType.STOP:
27281 
        break
27282 
      if fid == 1:
6031 rajveer 27283 
        if ftype == TType.I64:
27284 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 27285 
        else:
27286 
          iprot.skip(ftype)
27287 
      else:
27288 
        iprot.skip(ftype)
27289 
      iprot.readFieldEnd()
27290 
    iprot.readStructEnd()
27291 
 
27292 
  def write(self, oprot):
27293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27295 
      return
27296 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 27297 
    if self.rechargeOrderId is not None:
27298 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27299 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 27300 
      oprot.writeFieldEnd()
27301 
    oprot.writeFieldStop()
27302 
    oprot.writeStructEnd()
27303 
 
27304 
  def validate(self):
27305 
    return
27306 
 
27307 
 
27308 
  def __repr__(self):
27309 
    L = ['%s=%r' % (key, value)
27310 
      for key, value in self.__dict__.iteritems()]
27311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27312 
 
27313 
  def __eq__(self, other):
27314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27315 
 
27316 
  def __ne__(self, other):
27317 
    return not (self == other)
27318 
 
27319 
class activateRechargeTxn_result:
27320 
  """
27321 
  Attributes:
27322 
   - success
27323 
   - ex
27324 
  """
27325 
 
27326 
  thrift_spec = (
6031 rajveer 27327 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27328 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27329 
  )
27330 
 
27331 
  def __init__(self, success=None, ex=None,):
27332 
    self.success = success
27333 
    self.ex = ex
27334 
 
27335 
  def read(self, iprot):
27336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27338 
      return
27339 
    iprot.readStructBegin()
27340 
    while True:
27341 
      (fname, ftype, fid) = iprot.readFieldBegin()
27342 
      if ftype == TType.STOP:
27343 
        break
27344 
      if fid == 0:
6031 rajveer 27345 
        if ftype == TType.BOOL:
27346 
          self.success = iprot.readBool();
6000 mandeep.dh 27347 
        else:
27348 
          iprot.skip(ftype)
27349 
      elif fid == 1:
27350 
        if ftype == TType.STRUCT:
27351 
          self.ex = TransactionServiceException()
27352 
          self.ex.read(iprot)
27353 
        else:
27354 
          iprot.skip(ftype)
27355 
      else:
27356 
        iprot.skip(ftype)
27357 
      iprot.readFieldEnd()
27358 
    iprot.readStructEnd()
27359 
 
27360 
  def write(self, oprot):
27361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27363 
      return
27364 
    oprot.writeStructBegin('activateRechargeTxn_result')
27365 
    if self.success is not None:
6031 rajveer 27366 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27367 
      oprot.writeBool(self.success)
6000 mandeep.dh 27368 
      oprot.writeFieldEnd()
27369 
    if self.ex is not None:
27370 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27371 
      self.ex.write(oprot)
27372 
      oprot.writeFieldEnd()
27373 
    oprot.writeFieldStop()
27374 
    oprot.writeStructEnd()
27375 
 
27376 
  def validate(self):
27377 
    return
27378 
 
27379 
 
27380 
  def __repr__(self):
27381 
    L = ['%s=%r' % (key, value)
27382 
      for key, value in self.__dict__.iteritems()]
27383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27384 
 
27385 
  def __eq__(self, other):
27386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27387 
 
27388 
  def __ne__(self, other):
27389 
    return not (self == other)
27390 
 
6031 rajveer 27391 
class getUserWallet_args:
6000 mandeep.dh 27392 
  """
27393 
  Attributes:
6031 rajveer 27394 
   - userId
6000 mandeep.dh 27395 
  """
27396 
 
27397 
  thrift_spec = (
27398 
    None, # 0
6031 rajveer 27399 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27400 
  )
27401 
 
6031 rajveer 27402 
  def __init__(self, userId=None,):
27403 
    self.userId = userId
6000 mandeep.dh 27404 
 
27405 
  def read(self, iprot):
27406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27408 
      return
27409 
    iprot.readStructBegin()
27410 
    while True:
27411 
      (fname, ftype, fid) = iprot.readFieldBegin()
27412 
      if ftype == TType.STOP:
27413 
        break
27414 
      if fid == 1:
27415 
        if ftype == TType.I64:
6031 rajveer 27416 
          self.userId = iprot.readI64();
6000 mandeep.dh 27417 
        else:
27418 
          iprot.skip(ftype)
27419 
      else:
27420 
        iprot.skip(ftype)
27421 
      iprot.readFieldEnd()
27422 
    iprot.readStructEnd()
27423 
 
27424 
  def write(self, oprot):
27425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27427 
      return
6031 rajveer 27428 
    oprot.writeStructBegin('getUserWallet_args')
27429 
    if self.userId is not None:
27430 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27431 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27432 
      oprot.writeFieldEnd()
27433 
    oprot.writeFieldStop()
27434 
    oprot.writeStructEnd()
27435 
 
27436 
  def validate(self):
27437 
    return
27438 
 
27439 
 
27440 
  def __repr__(self):
27441 
    L = ['%s=%r' % (key, value)
27442 
      for key, value in self.__dict__.iteritems()]
27443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27444 
 
27445 
  def __eq__(self, other):
27446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27447 
 
27448 
  def __ne__(self, other):
27449 
    return not (self == other)
27450 
 
6031 rajveer 27451 
class getUserWallet_result:
6000 mandeep.dh 27452 
  """
27453 
  Attributes:
27454 
   - success
27455 
  """
27456 
 
27457 
  thrift_spec = (
6031 rajveer 27458 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 27459 
  )
27460 
 
27461 
  def __init__(self, success=None,):
27462 
    self.success = success
27463 
 
27464 
  def read(self, iprot):
27465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27467 
      return
27468 
    iprot.readStructBegin()
27469 
    while True:
27470 
      (fname, ftype, fid) = iprot.readFieldBegin()
27471 
      if ftype == TType.STOP:
27472 
        break
27473 
      if fid == 0:
6031 rajveer 27474 
        if ftype == TType.STRUCT:
27475 
          self.success = UserWallet()
27476 
          self.success.read(iprot)
6000 mandeep.dh 27477 
        else:
27478 
          iprot.skip(ftype)
27479 
      else:
27480 
        iprot.skip(ftype)
27481 
      iprot.readFieldEnd()
27482 
    iprot.readStructEnd()
27483 
 
27484 
  def write(self, oprot):
27485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27487 
      return
6031 rajveer 27488 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27489 
    if self.success is not None:
6031 rajveer 27490 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27491 
      self.success.write(oprot)
6000 mandeep.dh 27492 
      oprot.writeFieldEnd()
27493 
    oprot.writeFieldStop()
27494 
    oprot.writeStructEnd()
27495 
 
27496 
  def validate(self):
27497 
    return
27498 
 
27499 
 
27500 
  def __repr__(self):
27501 
    L = ['%s=%r' % (key, value)
27502 
      for key, value in self.__dict__.iteritems()]
27503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27504 
 
27505 
  def __eq__(self, other):
27506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27507 
 
27508 
  def __ne__(self, other):
27509 
    return not (self == other)
27510 
 
6031 rajveer 27511 
class getUserWalletHistory_args:
6000 mandeep.dh 27512 
  """
27513 
  Attributes:
6031 rajveer 27514 
   - userId
6000 mandeep.dh 27515 
  """
27516 
 
27517 
  thrift_spec = (
27518 
    None, # 0
6031 rajveer 27519 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27520 
  )
27521 
 
6031 rajveer 27522 
  def __init__(self, userId=None,):
27523 
    self.userId = userId
6000 mandeep.dh 27524 
 
27525 
  def read(self, iprot):
27526 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27527 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27528 
      return
27529 
    iprot.readStructBegin()
27530 
    while True:
27531 
      (fname, ftype, fid) = iprot.readFieldBegin()
27532 
      if ftype == TType.STOP:
27533 
        break
27534 
      if fid == 1:
27535 
        if ftype == TType.I64:
6031 rajveer 27536 
          self.userId = iprot.readI64();
6000 mandeep.dh 27537 
        else:
27538 
          iprot.skip(ftype)
27539 
      else:
27540 
        iprot.skip(ftype)
27541 
      iprot.readFieldEnd()
27542 
    iprot.readStructEnd()
27543 
 
27544 
  def write(self, oprot):
27545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27547 
      return
6031 rajveer 27548 
    oprot.writeStructBegin('getUserWalletHistory_args')
27549 
    if self.userId is not None:
27550 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27551 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27552 
      oprot.writeFieldEnd()
27553 
    oprot.writeFieldStop()
27554 
    oprot.writeStructEnd()
27555 
 
27556 
  def validate(self):
27557 
    return
27558 
 
27559 
 
27560 
  def __repr__(self):
27561 
    L = ['%s=%r' % (key, value)
27562 
      for key, value in self.__dict__.iteritems()]
27563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27564 
 
27565 
  def __eq__(self, other):
27566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27567 
 
27568 
  def __ne__(self, other):
27569 
    return not (self == other)
27570 
 
6031 rajveer 27571 
class getUserWalletHistory_result:
6000 mandeep.dh 27572 
  """
27573 
  Attributes:
27574 
   - success
27575 
  """
27576 
 
27577 
  thrift_spec = (
6031 rajveer 27578 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 27579 
  )
27580 
 
27581 
  def __init__(self, success=None,):
27582 
    self.success = success
27583 
 
27584 
  def read(self, iprot):
27585 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27586 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27587 
      return
27588 
    iprot.readStructBegin()
27589 
    while True:
27590 
      (fname, ftype, fid) = iprot.readFieldBegin()
27591 
      if ftype == TType.STOP:
27592 
        break
27593 
      if fid == 0:
27594 
        if ftype == TType.LIST:
27595 
          self.success = []
6188 rajveer 27596 
          (_etype666, _size663) = iprot.readListBegin()
27597 
          for _i667 in xrange(_size663):
27598 
            _elem668 = UserWalletHistory()
27599 
            _elem668.read(iprot)
27600 
            self.success.append(_elem668)
6000 mandeep.dh 27601 
          iprot.readListEnd()
27602 
        else:
27603 
          iprot.skip(ftype)
27604 
      else:
27605 
        iprot.skip(ftype)
27606 
      iprot.readFieldEnd()
27607 
    iprot.readStructEnd()
27608 
 
27609 
  def write(self, oprot):
27610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27612 
      return
6031 rajveer 27613 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 27614 
    if self.success is not None:
27615 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27616 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27617 
      for iter669 in self.success:
27618 
        iter669.write(oprot)
6000 mandeep.dh 27619 
      oprot.writeListEnd()
27620 
      oprot.writeFieldEnd()
27621 
    oprot.writeFieldStop()
27622 
    oprot.writeStructEnd()
27623 
 
27624 
  def validate(self):
27625 
    return
27626 
 
27627 
 
27628 
  def __repr__(self):
27629 
    L = ['%s=%r' % (key, value)
27630 
      for key, value in self.__dict__.iteritems()]
27631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27632 
 
27633 
  def __eq__(self, other):
27634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27635 
 
27636 
  def __ne__(self, other):
27637 
    return not (self == other)
6048 rajveer 27638 
 
6050 anupam.sin 27639 
class getRechargeOrdersForTransaction_args:
27640 
  """
27641 
  Attributes:
27642 
   - txnId
27643 
  """
27644 
 
27645 
  thrift_spec = (
27646 
    None, # 0
27647 
    (1, TType.I64, 'txnId', None, None, ), # 1
27648 
  )
27649 
 
27650 
  def __init__(self, txnId=None,):
27651 
    self.txnId = txnId
27652 
 
27653 
  def read(self, iprot):
27654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27656 
      return
27657 
    iprot.readStructBegin()
27658 
    while True:
27659 
      (fname, ftype, fid) = iprot.readFieldBegin()
27660 
      if ftype == TType.STOP:
27661 
        break
27662 
      if fid == 1:
27663 
        if ftype == TType.I64:
27664 
          self.txnId = iprot.readI64();
27665 
        else:
27666 
          iprot.skip(ftype)
27667 
      else:
27668 
        iprot.skip(ftype)
27669 
      iprot.readFieldEnd()
27670 
    iprot.readStructEnd()
27671 
 
27672 
  def write(self, oprot):
27673 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27674 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27675 
      return
27676 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
27677 
    if self.txnId is not None:
27678 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
27679 
      oprot.writeI64(self.txnId)
27680 
      oprot.writeFieldEnd()
27681 
    oprot.writeFieldStop()
27682 
    oprot.writeStructEnd()
27683 
 
27684 
  def validate(self):
27685 
    return
27686 
 
27687 
 
27688 
  def __repr__(self):
27689 
    L = ['%s=%r' % (key, value)
27690 
      for key, value in self.__dict__.iteritems()]
27691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27692 
 
27693 
  def __eq__(self, other):
27694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27695 
 
27696 
  def __ne__(self, other):
27697 
    return not (self == other)
27698 
 
27699 
class getRechargeOrdersForTransaction_result:
27700 
  """
27701 
  Attributes:
27702 
   - success
27703 
   - ex
27704 
  """
27705 
 
27706 
  thrift_spec = (
27707 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27708 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27709 
  )
27710 
 
27711 
  def __init__(self, success=None, ex=None,):
27712 
    self.success = success
27713 
    self.ex = ex
27714 
 
27715 
  def read(self, iprot):
27716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27718 
      return
27719 
    iprot.readStructBegin()
27720 
    while True:
27721 
      (fname, ftype, fid) = iprot.readFieldBegin()
27722 
      if ftype == TType.STOP:
27723 
        break
27724 
      if fid == 0:
27725 
        if ftype == TType.STRUCT:
27726 
          self.success = RechargeOrder()
27727 
          self.success.read(iprot)
27728 
        else:
27729 
          iprot.skip(ftype)
27730 
      elif fid == 1:
27731 
        if ftype == TType.STRUCT:
27732 
          self.ex = TransactionServiceException()
27733 
          self.ex.read(iprot)
27734 
        else:
27735 
          iprot.skip(ftype)
27736 
      else:
27737 
        iprot.skip(ftype)
27738 
      iprot.readFieldEnd()
27739 
    iprot.readStructEnd()
27740 
 
27741 
  def write(self, oprot):
27742 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27743 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27744 
      return
27745 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
27746 
    if self.success is not None:
27747 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27748 
      self.success.write(oprot)
27749 
      oprot.writeFieldEnd()
27750 
    if self.ex is not None:
27751 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27752 
      self.ex.write(oprot)
27753 
      oprot.writeFieldEnd()
27754 
    oprot.writeFieldStop()
27755 
    oprot.writeStructEnd()
27756 
 
27757 
  def validate(self):
27758 
    return
27759 
 
27760 
 
27761 
  def __repr__(self):
27762 
    L = ['%s=%r' % (key, value)
27763 
      for key, value in self.__dict__.iteritems()]
27764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27765 
 
27766 
  def __eq__(self, other):
27767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27768 
 
27769 
  def __ne__(self, other):
27770 
    return not (self == other)
27771 
 
6048 rajveer 27772 
class getServiceProviders_args:
27773 
  """
27774 
  Attributes:
27775 
   - rechargeType
6206 rajveer 27776 
   - onlyActive
6048 rajveer 27777 
  """
27778 
 
27779 
  thrift_spec = (
27780 
    None, # 0
27781 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 27782 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 27783 
  )
27784 
 
6206 rajveer 27785 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 27786 
    self.rechargeType = rechargeType
6206 rajveer 27787 
    self.onlyActive = onlyActive
6048 rajveer 27788 
 
27789 
  def read(self, iprot):
27790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27792 
      return
27793 
    iprot.readStructBegin()
27794 
    while True:
27795 
      (fname, ftype, fid) = iprot.readFieldBegin()
27796 
      if ftype == TType.STOP:
27797 
        break
27798 
      if fid == 1:
27799 
        if ftype == TType.I32:
27800 
          self.rechargeType = iprot.readI32();
27801 
        else:
27802 
          iprot.skip(ftype)
6206 rajveer 27803 
      elif fid == 2:
27804 
        if ftype == TType.BOOL:
27805 
          self.onlyActive = iprot.readBool();
27806 
        else:
27807 
          iprot.skip(ftype)
6048 rajveer 27808 
      else:
27809 
        iprot.skip(ftype)
27810 
      iprot.readFieldEnd()
27811 
    iprot.readStructEnd()
27812 
 
27813 
  def write(self, oprot):
27814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27816 
      return
27817 
    oprot.writeStructBegin('getServiceProviders_args')
27818 
    if self.rechargeType is not None:
27819 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27820 
      oprot.writeI32(self.rechargeType)
27821 
      oprot.writeFieldEnd()
6206 rajveer 27822 
    if self.onlyActive is not None:
27823 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
27824 
      oprot.writeBool(self.onlyActive)
27825 
      oprot.writeFieldEnd()
6048 rajveer 27826 
    oprot.writeFieldStop()
27827 
    oprot.writeStructEnd()
27828 
 
27829 
  def validate(self):
27830 
    return
27831 
 
27832 
 
27833 
  def __repr__(self):
27834 
    L = ['%s=%r' % (key, value)
27835 
      for key, value in self.__dict__.iteritems()]
27836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27837 
 
27838 
  def __eq__(self, other):
27839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27840 
 
27841 
  def __ne__(self, other):
27842 
    return not (self == other)
27843 
 
27844 
class getServiceProviders_result:
27845 
  """
27846 
  Attributes:
27847 
   - success
27848 
  """
27849 
 
27850 
  thrift_spec = (
27851 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
27852 
  )
27853 
 
27854 
  def __init__(self, success=None,):
27855 
    self.success = success
27856 
 
27857 
  def read(self, iprot):
27858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27860 
      return
27861 
    iprot.readStructBegin()
27862 
    while True:
27863 
      (fname, ftype, fid) = iprot.readFieldBegin()
27864 
      if ftype == TType.STOP:
27865 
        break
27866 
      if fid == 0:
27867 
        if ftype == TType.MAP:
27868 
          self.success = {}
6188 rajveer 27869 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
27870 
          for _i674 in xrange(_size670):
27871 
            _key675 = iprot.readI64();
27872 
            _val676 = iprot.readString();
27873 
            self.success[_key675] = _val676
6048 rajveer 27874 
          iprot.readMapEnd()
27875 
        else:
27876 
          iprot.skip(ftype)
27877 
      else:
27878 
        iprot.skip(ftype)
27879 
      iprot.readFieldEnd()
27880 
    iprot.readStructEnd()
27881 
 
27882 
  def write(self, oprot):
27883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27885 
      return
27886 
    oprot.writeStructBegin('getServiceProviders_result')
27887 
    if self.success is not None:
27888 
      oprot.writeFieldBegin('success', TType.MAP, 0)
27889 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 27890 
      for kiter677,viter678 in self.success.items():
27891 
        oprot.writeI64(kiter677)
27892 
        oprot.writeString(viter678)
6048 rajveer 27893 
      oprot.writeMapEnd()
27894 
      oprot.writeFieldEnd()
27895 
    oprot.writeFieldStop()
27896 
    oprot.writeStructEnd()
27897 
 
27898 
  def validate(self):
27899 
    return
27900 
 
27901 
 
27902 
  def __repr__(self):
27903 
    L = ['%s=%r' % (key, value)
27904 
      for key, value in self.__dict__.iteritems()]
27905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27906 
 
27907 
  def __eq__(self, other):
27908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27909 
 
27910 
  def __ne__(self, other):
27911 
    return not (self == other)
27912 
 
27913 
class getServiceProviderForDevice_args:
27914 
  """
27915 
  Attributes:
6049 rajveer 27916 
   - rechargeType
6048 rajveer 27917 
   - deviceNumber
27918 
  """
27919 
 
27920 
  thrift_spec = (
27921 
    None, # 0
6049 rajveer 27922 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
27923 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 27924 
  )
27925 
 
6049 rajveer 27926 
  def __init__(self, rechargeType=None, deviceNumber=None,):
27927 
    self.rechargeType = rechargeType
6048 rajveer 27928 
    self.deviceNumber = deviceNumber
27929 
 
27930 
  def read(self, iprot):
27931 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27932 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27933 
      return
27934 
    iprot.readStructBegin()
27935 
    while True:
27936 
      (fname, ftype, fid) = iprot.readFieldBegin()
27937 
      if ftype == TType.STOP:
27938 
        break
27939 
      if fid == 1:
6049 rajveer 27940 
        if ftype == TType.I32:
27941 
          self.rechargeType = iprot.readI32();
27942 
        else:
27943 
          iprot.skip(ftype)
27944 
      elif fid == 2:
6048 rajveer 27945 
        if ftype == TType.STRING:
27946 
          self.deviceNumber = iprot.readString();
27947 
        else:
27948 
          iprot.skip(ftype)
27949 
      else:
27950 
        iprot.skip(ftype)
27951 
      iprot.readFieldEnd()
27952 
    iprot.readStructEnd()
27953 
 
27954 
  def write(self, oprot):
27955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27957 
      return
27958 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 27959 
    if self.rechargeType is not None:
27960 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27961 
      oprot.writeI32(self.rechargeType)
27962 
      oprot.writeFieldEnd()
6048 rajveer 27963 
    if self.deviceNumber is not None:
6049 rajveer 27964 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 27965 
      oprot.writeString(self.deviceNumber)
27966 
      oprot.writeFieldEnd()
27967 
    oprot.writeFieldStop()
27968 
    oprot.writeStructEnd()
27969 
 
27970 
  def validate(self):
27971 
    return
27972 
 
27973 
 
27974 
  def __repr__(self):
27975 
    L = ['%s=%r' % (key, value)
27976 
      for key, value in self.__dict__.iteritems()]
27977 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27978 
 
27979 
  def __eq__(self, other):
27980 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27981 
 
27982 
  def __ne__(self, other):
27983 
    return not (self == other)
27984 
 
27985 
class getServiceProviderForDevice_result:
27986 
  """
27987 
  Attributes:
27988 
   - success
27989 
  """
27990 
 
27991 
  thrift_spec = (
6289 anupam.sin 27992 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 27993 
  )
27994 
 
27995 
  def __init__(self, success=None,):
27996 
    self.success = success
27997 
 
27998 
  def read(self, iprot):
27999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28001 
      return
28002 
    iprot.readStructBegin()
28003 
    while True:
28004 
      (fname, ftype, fid) = iprot.readFieldBegin()
28005 
      if ftype == TType.STOP:
28006 
        break
28007 
      if fid == 0:
6289 anupam.sin 28008 
        if ftype == TType.STRUCT:
28009 
          self.success = DeviceNumberInfo()
28010 
          self.success.read(iprot)
6048 rajveer 28011 
        else:
28012 
          iprot.skip(ftype)
28013 
      else:
28014 
        iprot.skip(ftype)
28015 
      iprot.readFieldEnd()
28016 
    iprot.readStructEnd()
28017 
 
28018 
  def write(self, oprot):
28019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28021 
      return
28022 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
28023 
    if self.success is not None:
6289 anupam.sin 28024 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28025 
      self.success.write(oprot)
6048 rajveer 28026 
      oprot.writeFieldEnd()
28027 
    oprot.writeFieldStop()
28028 
    oprot.writeStructEnd()
28029 
 
28030 
  def validate(self):
28031 
    return
28032 
 
28033 
 
28034 
  def __repr__(self):
28035 
    L = ['%s=%r' % (key, value)
28036 
      for key, value in self.__dict__.iteritems()]
28037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28038 
 
28039 
  def __eq__(self, other):
28040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28041 
 
28042 
  def __ne__(self, other):
28043 
    return not (self == other)
6094 rajveer 28044 
 
6269 rajveer 28045 
class validateRecharge_args:
28046 
  """
28047 
  Attributes:
28048 
   - rechargeType
28049 
   - deviceNumber
6307 anupam.sin 28050 
   - userSelectedProviderId
6591 anupam.sin 28051 
   - clientAddress
6269 rajveer 28052 
  """
28053 
 
28054 
  thrift_spec = (
28055 
    None, # 0
28056 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28057 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 28058 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6591 anupam.sin 28059 
    (4, TType.STRING, 'clientAddress', None, None, ), # 4
6269 rajveer 28060 
  )
28061 
 
6591 anupam.sin 28062 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None, clientAddress=None,):
6269 rajveer 28063 
    self.rechargeType = rechargeType
28064 
    self.deviceNumber = deviceNumber
6307 anupam.sin 28065 
    self.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 28066 
    self.clientAddress = clientAddress
6269 rajveer 28067 
 
28068 
  def read(self, iprot):
28069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28071 
      return
28072 
    iprot.readStructBegin()
28073 
    while True:
28074 
      (fname, ftype, fid) = iprot.readFieldBegin()
28075 
      if ftype == TType.STOP:
28076 
        break
28077 
      if fid == 1:
28078 
        if ftype == TType.I32:
28079 
          self.rechargeType = iprot.readI32();
28080 
        else:
28081 
          iprot.skip(ftype)
28082 
      elif fid == 2:
28083 
        if ftype == TType.STRING:
28084 
          self.deviceNumber = iprot.readString();
28085 
        else:
28086 
          iprot.skip(ftype)
6307 anupam.sin 28087 
      elif fid == 3:
28088 
        if ftype == TType.I64:
28089 
          self.userSelectedProviderId = iprot.readI64();
28090 
        else:
28091 
          iprot.skip(ftype)
6591 anupam.sin 28092 
      elif fid == 4:
28093 
        if ftype == TType.STRING:
28094 
          self.clientAddress = iprot.readString();
28095 
        else:
28096 
          iprot.skip(ftype)
6269 rajveer 28097 
      else:
28098 
        iprot.skip(ftype)
28099 
      iprot.readFieldEnd()
28100 
    iprot.readStructEnd()
28101 
 
28102 
  def write(self, oprot):
28103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28105 
      return
28106 
    oprot.writeStructBegin('validateRecharge_args')
28107 
    if self.rechargeType is not None:
28108 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28109 
      oprot.writeI32(self.rechargeType)
28110 
      oprot.writeFieldEnd()
28111 
    if self.deviceNumber is not None:
28112 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
28113 
      oprot.writeString(self.deviceNumber)
28114 
      oprot.writeFieldEnd()
6307 anupam.sin 28115 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 28116 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 28117 
      oprot.writeI64(self.userSelectedProviderId)
28118 
      oprot.writeFieldEnd()
6591 anupam.sin 28119 
    if self.clientAddress is not None:
28120 
      oprot.writeFieldBegin('clientAddress', TType.STRING, 4)
28121 
      oprot.writeString(self.clientAddress)
28122 
      oprot.writeFieldEnd()
6269 rajveer 28123 
    oprot.writeFieldStop()
28124 
    oprot.writeStructEnd()
28125 
 
28126 
  def validate(self):
28127 
    return
28128 
 
28129 
 
28130 
  def __repr__(self):
28131 
    L = ['%s=%r' % (key, value)
28132 
      for key, value in self.__dict__.iteritems()]
28133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28134 
 
28135 
  def __eq__(self, other):
28136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28137 
 
28138 
  def __ne__(self, other):
28139 
    return not (self == other)
28140 
 
28141 
class validateRecharge_result:
28142 
  """
28143 
  Attributes:
28144 
   - success
28145 
  """
28146 
 
28147 
  thrift_spec = (
28148 
    (0, TType.STRING, 'success', None, None, ), # 0
28149 
  )
28150 
 
28151 
  def __init__(self, success=None,):
28152 
    self.success = success
28153 
 
28154 
  def read(self, iprot):
28155 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28156 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28157 
      return
28158 
    iprot.readStructBegin()
28159 
    while True:
28160 
      (fname, ftype, fid) = iprot.readFieldBegin()
28161 
      if ftype == TType.STOP:
28162 
        break
28163 
      if fid == 0:
28164 
        if ftype == TType.STRING:
28165 
          self.success = iprot.readString();
28166 
        else:
28167 
          iprot.skip(ftype)
28168 
      else:
28169 
        iprot.skip(ftype)
28170 
      iprot.readFieldEnd()
28171 
    iprot.readStructEnd()
28172 
 
28173 
  def write(self, oprot):
28174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28176 
      return
28177 
    oprot.writeStructBegin('validateRecharge_result')
28178 
    if self.success is not None:
28179 
      oprot.writeFieldBegin('success', TType.STRING, 0)
28180 
      oprot.writeString(self.success)
28181 
      oprot.writeFieldEnd()
28182 
    oprot.writeFieldStop()
28183 
    oprot.writeStructEnd()
28184 
 
28185 
  def validate(self):
28186 
    return
28187 
 
28188 
 
28189 
  def __repr__(self):
28190 
    L = ['%s=%r' % (key, value)
28191 
      for key, value in self.__dict__.iteritems()]
28192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28193 
 
28194 
  def __eq__(self, other):
28195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28196 
 
28197 
  def __ne__(self, other):
28198 
    return not (self == other)
28199 
 
6094 rajveer 28200 
class getRechargeOrdersForDevice_args:
28201 
  """
28202 
  Attributes:
28203 
   - deviceNumber
28204 
  """
28205 
 
28206 
  thrift_spec = (
28207 
    None, # 0
28208 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
28209 
  )
28210 
 
28211 
  def __init__(self, deviceNumber=None,):
28212 
    self.deviceNumber = deviceNumber
28213 
 
28214 
  def read(self, iprot):
28215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28217 
      return
28218 
    iprot.readStructBegin()
28219 
    while True:
28220 
      (fname, ftype, fid) = iprot.readFieldBegin()
28221 
      if ftype == TType.STOP:
28222 
        break
28223 
      if fid == 1:
28224 
        if ftype == TType.STRING:
28225 
          self.deviceNumber = iprot.readString();
28226 
        else:
28227 
          iprot.skip(ftype)
28228 
      else:
28229 
        iprot.skip(ftype)
28230 
      iprot.readFieldEnd()
28231 
    iprot.readStructEnd()
28232 
 
28233 
  def write(self, oprot):
28234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28236 
      return
28237 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
28238 
    if self.deviceNumber is not None:
28239 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
28240 
      oprot.writeString(self.deviceNumber)
28241 
      oprot.writeFieldEnd()
28242 
    oprot.writeFieldStop()
28243 
    oprot.writeStructEnd()
28244 
 
28245 
  def validate(self):
28246 
    return
28247 
 
28248 
 
28249 
  def __repr__(self):
28250 
    L = ['%s=%r' % (key, value)
28251 
      for key, value in self.__dict__.iteritems()]
28252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28253 
 
28254 
  def __eq__(self, other):
28255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28256 
 
28257 
  def __ne__(self, other):
28258 
    return not (self == other)
28259 
 
28260 
class getRechargeOrdersForDevice_result:
28261 
  """
28262 
  Attributes:
28263 
   - success
28264 
  """
28265 
 
28266 
  thrift_spec = (
28267 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28268 
  )
28269 
 
28270 
  def __init__(self, success=None,):
28271 
    self.success = success
28272 
 
28273 
  def read(self, iprot):
28274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28276 
      return
28277 
    iprot.readStructBegin()
28278 
    while True:
28279 
      (fname, ftype, fid) = iprot.readFieldBegin()
28280 
      if ftype == TType.STOP:
28281 
        break
28282 
      if fid == 0:
28283 
        if ftype == TType.LIST:
28284 
          self.success = []
6188 rajveer 28285 
          (_etype682, _size679) = iprot.readListBegin()
28286 
          for _i683 in xrange(_size679):
28287 
            _elem684 = RechargeOrder()
28288 
            _elem684.read(iprot)
28289 
            self.success.append(_elem684)
6094 rajveer 28290 
          iprot.readListEnd()
28291 
        else:
28292 
          iprot.skip(ftype)
28293 
      else:
28294 
        iprot.skip(ftype)
28295 
      iprot.readFieldEnd()
28296 
    iprot.readStructEnd()
28297 
 
28298 
  def write(self, oprot):
28299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28301 
      return
28302 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
28303 
    if self.success is not None:
28304 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28305 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28306 
      for iter685 in self.success:
28307 
        iter685.write(oprot)
6094 rajveer 28308 
      oprot.writeListEnd()
28309 
      oprot.writeFieldEnd()
28310 
    oprot.writeFieldStop()
28311 
    oprot.writeStructEnd()
28312 
 
28313 
  def validate(self):
28314 
    return
28315 
 
28316 
 
28317 
  def __repr__(self):
28318 
    L = ['%s=%r' % (key, value)
28319 
      for key, value in self.__dict__.iteritems()]
28320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28321 
 
28322 
  def __eq__(self, other):
28323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28324 
 
28325 
  def __ne__(self, other):
28326 
    return not (self == other)
28327 
 
28328 
class addAmountToWallet_args:
28329 
  """
28330 
  Attributes:
28331 
   - userId
28332 
   - orderId
28333 
   - amount
28334 
  """
28335 
 
28336 
  thrift_spec = (
28337 
    None, # 0
28338 
    (1, TType.I64, 'userId', None, None, ), # 1
28339 
    (2, TType.I64, 'orderId', None, None, ), # 2
28340 
    (3, TType.I64, 'amount', None, None, ), # 3
28341 
  )
28342 
 
28343 
  def __init__(self, userId=None, orderId=None, amount=None,):
28344 
    self.userId = userId
28345 
    self.orderId = orderId
28346 
    self.amount = amount
28347 
 
28348 
  def read(self, iprot):
28349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28351 
      return
28352 
    iprot.readStructBegin()
28353 
    while True:
28354 
      (fname, ftype, fid) = iprot.readFieldBegin()
28355 
      if ftype == TType.STOP:
28356 
        break
28357 
      if fid == 1:
28358 
        if ftype == TType.I64:
28359 
          self.userId = iprot.readI64();
28360 
        else:
28361 
          iprot.skip(ftype)
28362 
      elif fid == 2:
28363 
        if ftype == TType.I64:
28364 
          self.orderId = iprot.readI64();
28365 
        else:
28366 
          iprot.skip(ftype)
28367 
      elif fid == 3:
28368 
        if ftype == TType.I64:
28369 
          self.amount = iprot.readI64();
28370 
        else:
28371 
          iprot.skip(ftype)
28372 
      else:
28373 
        iprot.skip(ftype)
28374 
      iprot.readFieldEnd()
28375 
    iprot.readStructEnd()
28376 
 
28377 
  def write(self, oprot):
28378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28380 
      return
28381 
    oprot.writeStructBegin('addAmountToWallet_args')
28382 
    if self.userId is not None:
28383 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28384 
      oprot.writeI64(self.userId)
28385 
      oprot.writeFieldEnd()
28386 
    if self.orderId is not None:
28387 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
28388 
      oprot.writeI64(self.orderId)
28389 
      oprot.writeFieldEnd()
28390 
    if self.amount is not None:
28391 
      oprot.writeFieldBegin('amount', TType.I64, 3)
28392 
      oprot.writeI64(self.amount)
28393 
      oprot.writeFieldEnd()
28394 
    oprot.writeFieldStop()
28395 
    oprot.writeStructEnd()
28396 
 
28397 
  def validate(self):
28398 
    return
28399 
 
28400 
 
28401 
  def __repr__(self):
28402 
    L = ['%s=%r' % (key, value)
28403 
      for key, value in self.__dict__.iteritems()]
28404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28405 
 
28406 
  def __eq__(self, other):
28407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28408 
 
28409 
  def __ne__(self, other):
28410 
    return not (self == other)
28411 
 
28412 
class addAmountToWallet_result:
28413 
 
28414 
  thrift_spec = (
28415 
  )
28416 
 
28417 
  def read(self, iprot):
28418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28420 
      return
28421 
    iprot.readStructBegin()
28422 
    while True:
28423 
      (fname, ftype, fid) = iprot.readFieldBegin()
28424 
      if ftype == TType.STOP:
28425 
        break
28426 
      else:
28427 
        iprot.skip(ftype)
28428 
      iprot.readFieldEnd()
28429 
    iprot.readStructEnd()
28430 
 
28431 
  def write(self, oprot):
28432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28434 
      return
28435 
    oprot.writeStructBegin('addAmountToWallet_result')
28436 
    oprot.writeFieldStop()
28437 
    oprot.writeStructEnd()
28438 
 
28439 
  def validate(self):
28440 
    return
28441 
 
28442 
 
28443 
  def __repr__(self):
28444 
    L = ['%s=%r' % (key, value)
28445 
      for key, value in self.__dict__.iteritems()]
28446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28447 
 
28448 
  def __eq__(self, other):
28449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28450 
 
28451 
  def __ne__(self, other):
28452 
    return not (self == other)
6154 rajveer 28453 
 
6188 rajveer 28454 
class getRechargeStatistics_args:
28455 
 
28456 
  thrift_spec = (
28457 
  )
28458 
 
28459 
  def read(self, iprot):
28460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28462 
      return
28463 
    iprot.readStructBegin()
28464 
    while True:
28465 
      (fname, ftype, fid) = iprot.readFieldBegin()
28466 
      if ftype == TType.STOP:
28467 
        break
28468 
      else:
28469 
        iprot.skip(ftype)
28470 
      iprot.readFieldEnd()
28471 
    iprot.readStructEnd()
28472 
 
28473 
  def write(self, oprot):
28474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28476 
      return
28477 
    oprot.writeStructBegin('getRechargeStatistics_args')
28478 
    oprot.writeFieldStop()
28479 
    oprot.writeStructEnd()
28480 
 
28481 
  def validate(self):
28482 
    return
28483 
 
28484 
 
28485 
  def __repr__(self):
28486 
    L = ['%s=%r' % (key, value)
28487 
      for key, value in self.__dict__.iteritems()]
28488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28489 
 
28490 
  def __eq__(self, other):
28491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28492 
 
28493 
  def __ne__(self, other):
28494 
    return not (self == other)
28495 
 
28496 
class getRechargeStatistics_result:
28497 
  """
28498 
  Attributes:
28499 
   - success
28500 
  """
28501 
 
28502 
  thrift_spec = (
28503 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
28504 
  )
28505 
 
28506 
  def __init__(self, success=None,):
28507 
    self.success = success
28508 
 
28509 
  def read(self, iprot):
28510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28512 
      return
28513 
    iprot.readStructBegin()
28514 
    while True:
28515 
      (fname, ftype, fid) = iprot.readFieldBegin()
28516 
      if ftype == TType.STOP:
28517 
        break
28518 
      if fid == 0:
28519 
        if ftype == TType.STRUCT:
28520 
          self.success = RechargeStatistics()
28521 
          self.success.read(iprot)
28522 
        else:
28523 
          iprot.skip(ftype)
28524 
      else:
28525 
        iprot.skip(ftype)
28526 
      iprot.readFieldEnd()
28527 
    iprot.readStructEnd()
28528 
 
28529 
  def write(self, oprot):
28530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28532 
      return
28533 
    oprot.writeStructBegin('getRechargeStatistics_result')
28534 
    if self.success is not None:
28535 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28536 
      self.success.write(oprot)
28537 
      oprot.writeFieldEnd()
28538 
    oprot.writeFieldStop()
28539 
    oprot.writeStructEnd()
28540 
 
28541 
  def validate(self):
28542 
    return
28543 
 
28544 
 
28545 
  def __repr__(self):
28546 
    L = ['%s=%r' % (key, value)
28547 
      for key, value in self.__dict__.iteritems()]
28548 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28549 
 
28550 
  def __eq__(self, other):
28551 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28552 
 
28553 
  def __ne__(self, other):
28554 
    return not (self == other)
28555 
 
6154 rajveer 28556 
class getRechargeOrdersForStatus_args:
28557 
  """
28558 
  Attributes:
28559 
   - status
28560 
  """
28561 
 
28562 
  thrift_spec = (
28563 
    None, # 0
28564 
    (1, TType.I64, 'status', None, None, ), # 1
28565 
  )
28566 
 
28567 
  def __init__(self, status=None,):
28568 
    self.status = status
28569 
 
28570 
  def read(self, iprot):
28571 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28572 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28573 
      return
28574 
    iprot.readStructBegin()
28575 
    while True:
28576 
      (fname, ftype, fid) = iprot.readFieldBegin()
28577 
      if ftype == TType.STOP:
28578 
        break
28579 
      if fid == 1:
28580 
        if ftype == TType.I64:
28581 
          self.status = iprot.readI64();
28582 
        else:
28583 
          iprot.skip(ftype)
28584 
      else:
28585 
        iprot.skip(ftype)
28586 
      iprot.readFieldEnd()
28587 
    iprot.readStructEnd()
28588 
 
28589 
  def write(self, oprot):
28590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28592 
      return
28593 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
28594 
    if self.status is not None:
28595 
      oprot.writeFieldBegin('status', TType.I64, 1)
28596 
      oprot.writeI64(self.status)
28597 
      oprot.writeFieldEnd()
28598 
    oprot.writeFieldStop()
28599 
    oprot.writeStructEnd()
28600 
 
28601 
  def validate(self):
28602 
    return
28603 
 
28604 
 
28605 
  def __repr__(self):
28606 
    L = ['%s=%r' % (key, value)
28607 
      for key, value in self.__dict__.iteritems()]
28608 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28609 
 
28610 
  def __eq__(self, other):
28611 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28612 
 
28613 
  def __ne__(self, other):
28614 
    return not (self == other)
28615 
 
28616 
class getRechargeOrdersForStatus_result:
28617 
  """
28618 
  Attributes:
28619 
   - success
28620 
  """
28621 
 
28622 
  thrift_spec = (
28623 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28624 
  )
28625 
 
28626 
  def __init__(self, success=None,):
28627 
    self.success = success
28628 
 
28629 
  def read(self, iprot):
28630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28632 
      return
28633 
    iprot.readStructBegin()
28634 
    while True:
28635 
      (fname, ftype, fid) = iprot.readFieldBegin()
28636 
      if ftype == TType.STOP:
28637 
        break
28638 
      if fid == 0:
28639 
        if ftype == TType.LIST:
28640 
          self.success = []
6188 rajveer 28641 
          (_etype689, _size686) = iprot.readListBegin()
28642 
          for _i690 in xrange(_size686):
28643 
            _elem691 = RechargeOrder()
28644 
            _elem691.read(iprot)
28645 
            self.success.append(_elem691)
6154 rajveer 28646 
          iprot.readListEnd()
28647 
        else:
28648 
          iprot.skip(ftype)
28649 
      else:
28650 
        iprot.skip(ftype)
28651 
      iprot.readFieldEnd()
28652 
    iprot.readStructEnd()
28653 
 
28654 
  def write(self, oprot):
28655 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28656 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28657 
      return
28658 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
28659 
    if self.success is not None:
28660 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28661 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28662 
      for iter692 in self.success:
28663 
        iter692.write(oprot)
6154 rajveer 28664 
      oprot.writeListEnd()
28665 
      oprot.writeFieldEnd()
28666 
    oprot.writeFieldStop()
28667 
    oprot.writeStructEnd()
28668 
 
28669 
  def validate(self):
28670 
    return
28671 
 
28672 
 
28673 
  def __repr__(self):
28674 
    L = ['%s=%r' % (key, value)
28675 
      for key, value in self.__dict__.iteritems()]
28676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28677 
 
28678 
  def __eq__(self, other):
28679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28680 
 
28681 
  def __ne__(self, other):
28682 
    return not (self == other)
6159 rajveer 28683 
 
28684 
class getPlansForOperator_args:
28685 
  """
28686 
  Attributes:
28687 
   - operatorId
28688 
  """
28689 
 
28690 
  thrift_spec = (
28691 
    None, # 0
28692 
    (1, TType.I64, 'operatorId', None, None, ), # 1
28693 
  )
28694 
 
28695 
  def __init__(self, operatorId=None,):
28696 
    self.operatorId = operatorId
28697 
 
28698 
  def read(self, iprot):
28699 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28700 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28701 
      return
28702 
    iprot.readStructBegin()
28703 
    while True:
28704 
      (fname, ftype, fid) = iprot.readFieldBegin()
28705 
      if ftype == TType.STOP:
28706 
        break
28707 
      if fid == 1:
28708 
        if ftype == TType.I64:
28709 
          self.operatorId = iprot.readI64();
28710 
        else:
28711 
          iprot.skip(ftype)
28712 
      else:
28713 
        iprot.skip(ftype)
28714 
      iprot.readFieldEnd()
28715 
    iprot.readStructEnd()
28716 
 
28717 
  def write(self, oprot):
28718 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28719 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28720 
      return
28721 
    oprot.writeStructBegin('getPlansForOperator_args')
28722 
    if self.operatorId is not None:
28723 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28724 
      oprot.writeI64(self.operatorId)
28725 
      oprot.writeFieldEnd()
28726 
    oprot.writeFieldStop()
28727 
    oprot.writeStructEnd()
28728 
 
28729 
  def validate(self):
28730 
    return
28731 
 
28732 
 
28733 
  def __repr__(self):
28734 
    L = ['%s=%r' % (key, value)
28735 
      for key, value in self.__dict__.iteritems()]
28736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28737 
 
28738 
  def __eq__(self, other):
28739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28740 
 
28741 
  def __ne__(self, other):
28742 
    return not (self == other)
28743 
 
28744 
class getPlansForOperator_result:
28745 
  """
28746 
  Attributes:
28747 
   - success
28748 
  """
28749 
 
28750 
  thrift_spec = (
28751 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
28752 
  )
28753 
 
28754 
  def __init__(self, success=None,):
28755 
    self.success = success
28756 
 
28757 
  def read(self, iprot):
28758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28760 
      return
28761 
    iprot.readStructBegin()
28762 
    while True:
28763 
      (fname, ftype, fid) = iprot.readFieldBegin()
28764 
      if ftype == TType.STOP:
28765 
        break
28766 
      if fid == 0:
28767 
        if ftype == TType.LIST:
28768 
          self.success = []
6188 rajveer 28769 
          (_etype696, _size693) = iprot.readListBegin()
28770 
          for _i697 in xrange(_size693):
28771 
            _elem698 = RechargePlan()
28772 
            _elem698.read(iprot)
28773 
            self.success.append(_elem698)
6159 rajveer 28774 
          iprot.readListEnd()
28775 
        else:
28776 
          iprot.skip(ftype)
28777 
      else:
28778 
        iprot.skip(ftype)
28779 
      iprot.readFieldEnd()
28780 
    iprot.readStructEnd()
28781 
 
28782 
  def write(self, oprot):
28783 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28784 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28785 
      return
28786 
    oprot.writeStructBegin('getPlansForOperator_result')
28787 
    if self.success is not None:
28788 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28789 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28790 
      for iter699 in self.success:
28791 
        iter699.write(oprot)
6159 rajveer 28792 
      oprot.writeListEnd()
28793 
      oprot.writeFieldEnd()
28794 
    oprot.writeFieldStop()
28795 
    oprot.writeStructEnd()
28796 
 
28797 
  def validate(self):
28798 
    return
28799 
 
28800 
 
28801 
  def __repr__(self):
28802 
    L = ['%s=%r' % (key, value)
28803 
      for key, value in self.__dict__.iteritems()]
28804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28805 
 
28806 
  def __eq__(self, other):
28807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28808 
 
28809 
  def __ne__(self, other):
28810 
    return not (self == other)
6289 anupam.sin 28811 
 
28812 
class getRechargeDenominations_args:
28813 
  """
28814 
  Attributes:
28815 
   - operatorId
6307 anupam.sin 28816 
   - circleCode
6289 anupam.sin 28817 
   - denominationType
28818 
  """
28819 
 
28820 
  thrift_spec = (
28821 
    None, # 0
28822 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 28823 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 28824 
    (3, TType.I32, 'denominationType', None, None, ), # 3
28825 
  )
28826 
 
6307 anupam.sin 28827 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 28828 
    self.operatorId = operatorId
6307 anupam.sin 28829 
    self.circleCode = circleCode
6289 anupam.sin 28830 
    self.denominationType = denominationType
28831 
 
28832 
  def read(self, iprot):
28833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28835 
      return
28836 
    iprot.readStructBegin()
28837 
    while True:
28838 
      (fname, ftype, fid) = iprot.readFieldBegin()
28839 
      if ftype == TType.STOP:
28840 
        break
28841 
      if fid == 1:
28842 
        if ftype == TType.I64:
28843 
          self.operatorId = iprot.readI64();
28844 
        else:
28845 
          iprot.skip(ftype)
28846 
      elif fid == 2:
28847 
        if ftype == TType.STRING:
6307 anupam.sin 28848 
          self.circleCode = iprot.readString();
6289 anupam.sin 28849 
        else:
28850 
          iprot.skip(ftype)
28851 
      elif fid == 3:
28852 
        if ftype == TType.I32:
28853 
          self.denominationType = iprot.readI32();
28854 
        else:
28855 
          iprot.skip(ftype)
28856 
      else:
28857 
        iprot.skip(ftype)
28858 
      iprot.readFieldEnd()
28859 
    iprot.readStructEnd()
28860 
 
28861 
  def write(self, oprot):
28862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28864 
      return
28865 
    oprot.writeStructBegin('getRechargeDenominations_args')
28866 
    if self.operatorId is not None:
28867 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28868 
      oprot.writeI64(self.operatorId)
28869 
      oprot.writeFieldEnd()
6307 anupam.sin 28870 
    if self.circleCode is not None:
28871 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
28872 
      oprot.writeString(self.circleCode)
6289 anupam.sin 28873 
      oprot.writeFieldEnd()
28874 
    if self.denominationType is not None:
28875 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
28876 
      oprot.writeI32(self.denominationType)
28877 
      oprot.writeFieldEnd()
28878 
    oprot.writeFieldStop()
28879 
    oprot.writeStructEnd()
28880 
 
28881 
  def validate(self):
28882 
    return
28883 
 
28884 
 
28885 
  def __repr__(self):
28886 
    L = ['%s=%r' % (key, value)
28887 
      for key, value in self.__dict__.iteritems()]
28888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28889 
 
28890 
  def __eq__(self, other):
28891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28892 
 
28893 
  def __ne__(self, other):
28894 
    return not (self == other)
28895 
 
28896 
class getRechargeDenominations_result:
28897 
  """
28898 
  Attributes:
28899 
   - success
28900 
   - ex
28901 
  """
28902 
 
28903 
  thrift_spec = (
28904 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
28905 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
28906 
  )
28907 
 
28908 
  def __init__(self, success=None, ex=None,):
28909 
    self.success = success
28910 
    self.ex = ex
28911 
 
28912 
  def read(self, iprot):
28913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28915 
      return
28916 
    iprot.readStructBegin()
28917 
    while True:
28918 
      (fname, ftype, fid) = iprot.readFieldBegin()
28919 
      if ftype == TType.STOP:
28920 
        break
28921 
      if fid == 0:
28922 
        if ftype == TType.LIST:
28923 
          self.success = []
28924 
          (_etype703, _size700) = iprot.readListBegin()
28925 
          for _i704 in xrange(_size700):
28926 
            _elem705 = RechargeDenomination()
28927 
            _elem705.read(iprot)
28928 
            self.success.append(_elem705)
28929 
          iprot.readListEnd()
28930 
        else:
28931 
          iprot.skip(ftype)
28932 
      elif fid == 1:
28933 
        if ftype == TType.STRUCT:
28934 
          self.ex = TransactionServiceException()
28935 
          self.ex.read(iprot)
28936 
        else:
28937 
          iprot.skip(ftype)
28938 
      else:
28939 
        iprot.skip(ftype)
28940 
      iprot.readFieldEnd()
28941 
    iprot.readStructEnd()
28942 
 
28943 
  def write(self, oprot):
28944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28946 
      return
28947 
    oprot.writeStructBegin('getRechargeDenominations_result')
28948 
    if self.success is not None:
28949 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28950 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
28951 
      for iter706 in self.success:
28952 
        iter706.write(oprot)
28953 
      oprot.writeListEnd()
28954 
      oprot.writeFieldEnd()
28955 
    if self.ex is not None:
28956 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
28957 
      self.ex.write(oprot)
28958 
      oprot.writeFieldEnd()
28959 
    oprot.writeFieldStop()
28960 
    oprot.writeStructEnd()
28961 
 
28962 
  def validate(self):
28963 
    return
28964 
 
28965 
 
28966 
  def __repr__(self):
28967 
    L = ['%s=%r' % (key, value)
28968 
      for key, value in self.__dict__.iteritems()]
28969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28970 
 
28971 
  def __eq__(self, other):
28972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28973 
 
28974 
  def __ne__(self, other):
28975 
    return not (self == other)
6371 rajveer 28976 
 
28977 
class updateAvailabilityStatus_args:
28978 
  """
28979 
  Attributes:
28980 
   - operatorId
28981 
   - circleId
28982 
   - isAvailable
28983 
  """
28984 
 
28985 
  thrift_spec = (
28986 
    None, # 0
28987 
    (1, TType.I64, 'operatorId', None, None, ), # 1
28988 
    (2, TType.I64, 'circleId', None, None, ), # 2
28989 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
28990 
  )
28991 
 
28992 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
28993 
    self.operatorId = operatorId
28994 
    self.circleId = circleId
28995 
    self.isAvailable = isAvailable
28996 
 
28997 
  def read(self, iprot):
28998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29000 
      return
29001 
    iprot.readStructBegin()
29002 
    while True:
29003 
      (fname, ftype, fid) = iprot.readFieldBegin()
29004 
      if ftype == TType.STOP:
29005 
        break
29006 
      if fid == 1:
29007 
        if ftype == TType.I64:
29008 
          self.operatorId = iprot.readI64();
29009 
        else:
29010 
          iprot.skip(ftype)
29011 
      elif fid == 2:
29012 
        if ftype == TType.I64:
29013 
          self.circleId = iprot.readI64();
29014 
        else:
29015 
          iprot.skip(ftype)
29016 
      elif fid == 3:
29017 
        if ftype == TType.BOOL:
29018 
          self.isAvailable = iprot.readBool();
29019 
        else:
29020 
          iprot.skip(ftype)
29021 
      else:
29022 
        iprot.skip(ftype)
29023 
      iprot.readFieldEnd()
29024 
    iprot.readStructEnd()
29025 
 
29026 
  def write(self, oprot):
29027 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29028 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29029 
      return
29030 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
29031 
    if self.operatorId is not None:
29032 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29033 
      oprot.writeI64(self.operatorId)
29034 
      oprot.writeFieldEnd()
29035 
    if self.circleId is not None:
29036 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
29037 
      oprot.writeI64(self.circleId)
29038 
      oprot.writeFieldEnd()
29039 
    if self.isAvailable is not None:
29040 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
29041 
      oprot.writeBool(self.isAvailable)
29042 
      oprot.writeFieldEnd()
29043 
    oprot.writeFieldStop()
29044 
    oprot.writeStructEnd()
29045 
 
29046 
  def validate(self):
29047 
    return
29048 
 
29049 
 
29050 
  def __repr__(self):
29051 
    L = ['%s=%r' % (key, value)
29052 
      for key, value in self.__dict__.iteritems()]
29053 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29054 
 
29055 
  def __eq__(self, other):
29056 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29057 
 
29058 
  def __ne__(self, other):
29059 
    return not (self == other)
29060 
 
29061 
class updateAvailabilityStatus_result:
29062 
 
29063 
  thrift_spec = (
29064 
  )
29065 
 
29066 
  def read(self, iprot):
29067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29069 
      return
29070 
    iprot.readStructBegin()
29071 
    while True:
29072 
      (fname, ftype, fid) = iprot.readFieldBegin()
29073 
      if ftype == TType.STOP:
29074 
        break
29075 
      else:
29076 
        iprot.skip(ftype)
29077 
      iprot.readFieldEnd()
29078 
    iprot.readStructEnd()
29079 
 
29080 
  def write(self, oprot):
29081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29083 
      return
29084 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
29085 
    oprot.writeFieldStop()
29086 
    oprot.writeStructEnd()
29087 
 
29088 
  def validate(self):
29089 
    return
29090 
 
29091 
 
29092 
  def __repr__(self):
29093 
    L = ['%s=%r' % (key, value)
29094 
      for key, value in self.__dict__.iteritems()]
29095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29096 
 
29097 
  def __eq__(self, other):
29098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29099 
 
29100 
  def __ne__(self, other):
29101 
    return not (self == other)
6389 rajveer 29102 
 
29103 
class getAvailableEmiSchemes_args:
29104 
 
29105 
  thrift_spec = (
29106 
  )
29107 
 
29108 
  def read(self, iprot):
29109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29111 
      return
29112 
    iprot.readStructBegin()
29113 
    while True:
29114 
      (fname, ftype, fid) = iprot.readFieldBegin()
29115 
      if ftype == TType.STOP:
29116 
        break
29117 
      else:
29118 
        iprot.skip(ftype)
29119 
      iprot.readFieldEnd()
29120 
    iprot.readStructEnd()
29121 
 
29122 
  def write(self, oprot):
29123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29125 
      return
29126 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
29127 
    oprot.writeFieldStop()
29128 
    oprot.writeStructEnd()
29129 
 
29130 
  def validate(self):
29131 
    return
29132 
 
29133 
 
29134 
  def __repr__(self):
29135 
    L = ['%s=%r' % (key, value)
29136 
      for key, value in self.__dict__.iteritems()]
29137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29138 
 
29139 
  def __eq__(self, other):
29140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29141 
 
29142 
  def __ne__(self, other):
29143 
    return not (self == other)
29144 
 
29145 
class getAvailableEmiSchemes_result:
29146 
  """
29147 
  Attributes:
29148 
   - success
29149 
  """
29150 
 
29151 
  thrift_spec = (
29152 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
29153 
  )
29154 
 
29155 
  def __init__(self, success=None,):
29156 
    self.success = success
29157 
 
29158 
  def read(self, iprot):
29159 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29160 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29161 
      return
29162 
    iprot.readStructBegin()
29163 
    while True:
29164 
      (fname, ftype, fid) = iprot.readFieldBegin()
29165 
      if ftype == TType.STOP:
29166 
        break
29167 
      if fid == 0:
29168 
        if ftype == TType.LIST:
29169 
          self.success = []
29170 
          (_etype710, _size707) = iprot.readListBegin()
29171 
          for _i711 in xrange(_size707):
29172 
            _elem712 = EmiScheme()
29173 
            _elem712.read(iprot)
29174 
            self.success.append(_elem712)
29175 
          iprot.readListEnd()
29176 
        else:
29177 
          iprot.skip(ftype)
29178 
      else:
29179 
        iprot.skip(ftype)
29180 
      iprot.readFieldEnd()
29181 
    iprot.readStructEnd()
29182 
 
29183 
  def write(self, oprot):
29184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29186 
      return
29187 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
29188 
    if self.success is not None:
29189 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29190 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29191 
      for iter713 in self.success:
29192 
        iter713.write(oprot)
29193 
      oprot.writeListEnd()
29194 
      oprot.writeFieldEnd()
29195 
    oprot.writeFieldStop()
29196 
    oprot.writeStructEnd()
29197 
 
29198 
  def validate(self):
29199 
    return
29200 
 
29201 
 
29202 
  def __repr__(self):
29203 
    L = ['%s=%r' % (key, value)
29204 
      for key, value in self.__dict__.iteritems()]
29205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29206 
 
29207 
  def __eq__(self, other):
29208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29209 
 
29210 
  def __ne__(self, other):
29211 
    return not (self == other)
29212 
 
29213 
class getMiscCharges_args:
29214 
  """
29215 
  Attributes:
29216 
   - transactionId
29217 
  """
29218 
 
29219 
  thrift_spec = (
29220 
    None, # 0
29221 
    (1, TType.I64, 'transactionId', None, None, ), # 1
29222 
  )
29223 
 
29224 
  def __init__(self, transactionId=None,):
29225 
    self.transactionId = transactionId
29226 
 
29227 
  def read(self, iprot):
29228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29230 
      return
29231 
    iprot.readStructBegin()
29232 
    while True:
29233 
      (fname, ftype, fid) = iprot.readFieldBegin()
29234 
      if ftype == TType.STOP:
29235 
        break
29236 
      if fid == 1:
29237 
        if ftype == TType.I64:
29238 
          self.transactionId = iprot.readI64();
29239 
        else:
29240 
          iprot.skip(ftype)
29241 
      else:
29242 
        iprot.skip(ftype)
29243 
      iprot.readFieldEnd()
29244 
    iprot.readStructEnd()
29245 
 
29246 
  def write(self, oprot):
29247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29249 
      return
29250 
    oprot.writeStructBegin('getMiscCharges_args')
29251 
    if self.transactionId is not None:
29252 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
29253 
      oprot.writeI64(self.transactionId)
29254 
      oprot.writeFieldEnd()
29255 
    oprot.writeFieldStop()
29256 
    oprot.writeStructEnd()
29257 
 
29258 
  def validate(self):
29259 
    return
29260 
 
29261 
 
29262 
  def __repr__(self):
29263 
    L = ['%s=%r' % (key, value)
29264 
      for key, value in self.__dict__.iteritems()]
29265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29266 
 
29267 
  def __eq__(self, other):
29268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29269 
 
29270 
  def __ne__(self, other):
29271 
    return not (self == other)
29272 
 
29273 
class getMiscCharges_result:
29274 
  """
29275 
  Attributes:
29276 
   - success
29277 
  """
29278 
 
29279 
  thrift_spec = (
6412 rajveer 29280 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 29281 
  )
29282 
 
29283 
  def __init__(self, success=None,):
29284 
    self.success = success
29285 
 
29286 
  def read(self, iprot):
29287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29289 
      return
29290 
    iprot.readStructBegin()
29291 
    while True:
29292 
      (fname, ftype, fid) = iprot.readFieldBegin()
29293 
      if ftype == TType.STOP:
29294 
        break
29295 
      if fid == 0:
29296 
        if ftype == TType.MAP:
29297 
          self.success = {}
29298 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
29299 
          for _i718 in xrange(_size714):
29300 
            _key719 = iprot.readI64();
6412 rajveer 29301 
            _val720 = iprot.readDouble();
6389 rajveer 29302 
            self.success[_key719] = _val720
29303 
          iprot.readMapEnd()
29304 
        else:
29305 
          iprot.skip(ftype)
29306 
      else:
29307 
        iprot.skip(ftype)
29308 
      iprot.readFieldEnd()
29309 
    iprot.readStructEnd()
29310 
 
29311 
  def write(self, oprot):
29312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29314 
      return
29315 
    oprot.writeStructBegin('getMiscCharges_result')
29316 
    if self.success is not None:
29317 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 29318 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 29319 
      for kiter721,viter722 in self.success.items():
29320 
        oprot.writeI64(kiter721)
6412 rajveer 29321 
        oprot.writeDouble(viter722)
6389 rajveer 29322 
      oprot.writeMapEnd()
29323 
      oprot.writeFieldEnd()
29324 
    oprot.writeFieldStop()
29325 
    oprot.writeStructEnd()
29326 
 
29327 
  def validate(self):
29328 
    return
29329 
 
29330 
 
29331 
  def __repr__(self):
29332 
    L = ['%s=%r' % (key, value)
29333 
      for key, value in self.__dict__.iteritems()]
29334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29335 
 
29336 
  def __eq__(self, other):
29337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29338 
 
29339 
  def __ne__(self, other):
29340 
    return not (self == other)
6507 anupam.sin 29341 
 
29342 
class refundRechargeOrder_args:
29343 
  """
29344 
  Attributes:
29345 
   - rechargeOrderId
29346 
  """
29347 
 
29348 
  thrift_spec = (
29349 
    None, # 0
29350 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
29351 
  )
29352 
 
29353 
  def __init__(self, rechargeOrderId=None,):
29354 
    self.rechargeOrderId = rechargeOrderId
29355 
 
29356 
  def read(self, iprot):
29357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29359 
      return
29360 
    iprot.readStructBegin()
29361 
    while True:
29362 
      (fname, ftype, fid) = iprot.readFieldBegin()
29363 
      if ftype == TType.STOP:
29364 
        break
29365 
      if fid == 1:
29366 
        if ftype == TType.I64:
29367 
          self.rechargeOrderId = iprot.readI64();
29368 
        else:
29369 
          iprot.skip(ftype)
29370 
      else:
29371 
        iprot.skip(ftype)
29372 
      iprot.readFieldEnd()
29373 
    iprot.readStructEnd()
29374 
 
29375 
  def write(self, oprot):
29376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29378 
      return
29379 
    oprot.writeStructBegin('refundRechargeOrder_args')
29380 
    if self.rechargeOrderId is not None:
29381 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
29382 
      oprot.writeI64(self.rechargeOrderId)
29383 
      oprot.writeFieldEnd()
29384 
    oprot.writeFieldStop()
29385 
    oprot.writeStructEnd()
29386 
 
29387 
  def validate(self):
29388 
    return
29389 
 
29390 
 
29391 
  def __repr__(self):
29392 
    L = ['%s=%r' % (key, value)
29393 
      for key, value in self.__dict__.iteritems()]
29394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29395 
 
29396 
  def __eq__(self, other):
29397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29398 
 
29399 
  def __ne__(self, other):
29400 
    return not (self == other)
29401 
 
29402 
class refundRechargeOrder_result:
29403 
  """
29404 
  Attributes:
29405 
   - success
29406 
   - ex
29407 
  """
29408 
 
29409 
  thrift_spec = (
29410 
    (0, TType.BOOL, 'success', None, None, ), # 0
29411 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29412 
  )
29413 
 
29414 
  def __init__(self, success=None, ex=None,):
29415 
    self.success = success
29416 
    self.ex = ex
29417 
 
29418 
  def read(self, iprot):
29419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29421 
      return
29422 
    iprot.readStructBegin()
29423 
    while True:
29424 
      (fname, ftype, fid) = iprot.readFieldBegin()
29425 
      if ftype == TType.STOP:
29426 
        break
29427 
      if fid == 0:
29428 
        if ftype == TType.BOOL:
29429 
          self.success = iprot.readBool();
29430 
        else:
29431 
          iprot.skip(ftype)
29432 
      elif fid == 1:
29433 
        if ftype == TType.STRUCT:
29434 
          self.ex = TransactionServiceException()
29435 
          self.ex.read(iprot)
29436 
        else:
29437 
          iprot.skip(ftype)
29438 
      else:
29439 
        iprot.skip(ftype)
29440 
      iprot.readFieldEnd()
29441 
    iprot.readStructEnd()
29442 
 
29443 
  def write(self, oprot):
29444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29446 
      return
29447 
    oprot.writeStructBegin('refundRechargeOrder_result')
29448 
    if self.success is not None:
29449 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
29450 
      oprot.writeBool(self.success)
29451 
      oprot.writeFieldEnd()
29452 
    if self.ex is not None:
29453 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29454 
      self.ex.write(oprot)
29455 
      oprot.writeFieldEnd()
29456 
    oprot.writeFieldStop()
29457 
    oprot.writeStructEnd()
29458 
 
29459 
  def validate(self):
29460 
    return
29461 
 
29462 
 
29463 
  def __repr__(self):
29464 
    L = ['%s=%r' % (key, value)
29465 
      for key, value in self.__dict__.iteritems()]
29466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29467 
 
29468 
  def __eq__(self, other):
29469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29470 
 
29471 
  def __ne__(self, other):
29472 
    return not (self == other)