Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
3431 rajveer 2 
# Autogenerated by Thrift Compiler (0.7.0)
94 ashish 3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
3431 rajveer 12 
from thrift.protocol import TBinaryProtocol, TProtocol
94 ashish 13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  def createTransaction(self, transaction):
21 
    """
22 
    Parameters:
23 
     - transaction
24 
    """
25 
    pass
26 
 
27 
  def getTransaction(self, id):
28 
    """
29 
    Parameters:
30 
     - id
31 
    """
32 
    pass
33 
 
34 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
35 
    """
36 
    Parameters:
37 
     - customerId
38 
     - from_date
39 
     - to_date
40 
     - status
41 
    """
42 
    pass
43 
 
132 ashish 44 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
45 
    """
46 
    Parameters:
47 
     - shoppingCartId
48 
    """
49 
    pass
50 
 
94 ashish 51 
  def getTransactionStatus(self, transactionId):
52 
    """
53 
    Parameters:
54 
     - transactionId
55 
    """
56 
    pass
57 
 
5527 anupam.sin 58 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 59 
    """
60 
    Parameters:
61 
     - transactionId
62 
     - status
63 
     - description
5527 anupam.sin 64 
     - pickUp
65 
     - orderType
94 ashish 66 
    """
67 
    pass
68 
 
1398 varun.gupt 69 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 70 
    """
71 
    Parameters:
72 
     - transactionId
73 
    """
74 
    pass
75 
 
4801 anupam.sin 76 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 77 
    """
78 
    Parameters:
4801 anupam.sin 79 
     - statuses
483 rajveer 80 
     - from_date
81 
     - to_date
82 
     - warehouse_id
94 ashish 83 
    """
84 
    pass
85 
 
4133 chandransh 86 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
87 
    """
88 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
89 
    Pass the status as null and the limit as 0 to ignore them.
90 
 
91 
    Parameters:
92 
     - statuses
93 
     - offset
94 
     - limit
95 
     - warehouse_id
96 
    """
97 
    pass
98 
 
99 
  def getOrderCount(self, statuses, warehouseId):
100 
    """
101 
    Returns the count of orders with the given statuses assigned to the given warehouse.
102 
 
103 
    Parameters:
104 
     - statuses
105 
     - warehouseId
106 
    """
107 
    pass
108 
 
999 varun.gupt 109 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
110 
    """
1132 chandransh 111 
    Returns orders within a range of their billing dates
3431 rajveer 112 
 
999 varun.gupt 113 
    Parameters:
114 
     - status
115 
     - start_billing_date
116 
     - end_billing_date
117 
     - warehouse_id
118 
    """
119 
    pass
120 
 
3451 chandransh 121 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 122 
    """
123 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 124 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
125 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 126 
 
3427 chandransh 127 
    Parameters:
128 
     - fromShippingDate
129 
     - toShippingDate
130 
     - providerId
131 
     - warehouseId
3451 chandransh 132 
     - cod
3427 chandransh 133 
    """
134 
    pass
135 
 
1382 varun.gupt 136 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
137 
    """
138 
    Returns order ids for orders which can be returned
3431 rajveer 139 
 
1382 varun.gupt 140 
    Parameters:
141 
     - customer_id
142 
     - limit
143 
    """
144 
    pass
145 
 
146 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
147 
    """
148 
    Returns order ids for orders which can be cancelled
3431 rajveer 149 
 
1382 varun.gupt 150 
    Parameters:
151 
     - customer_id
152 
     - limit
153 
    """
154 
    pass
155 
 
483 rajveer 156 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 157 
    """
158 
    Parameters:
483 rajveer 159 
     - orderId
160 
     - status
161 
     - description
94 ashish 162 
    """
163 
    pass
164 
 
1528 ankur.sing 165 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 166 
    """
1528 ankur.sing 167 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
168 
    only user who owns the transaction can view its order details.
3431 rajveer 169 
 
94 ashish 170 
    Parameters:
171 
     - transactionId
1528 ankur.sing 172 
     - customerId
94 ashish 173 
    """
174 
    pass
175 
 
3014 chandransh 176 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 177 
    """
3014 chandransh 178 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
179 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 180 
 
94 ashish 181 
    Parameters:
483 rajveer 182 
     - customerId
183 
     - from_date
184 
     - to_date
3014 chandransh 185 
     - statuses
94 ashish 186 
    """
187 
    pass
188 
 
483 rajveer 189 
  def createOrder(self, order):
94 ashish 190 
    """
191 
    Parameters:
483 rajveer 192 
     - order
94 ashish 193 
    """
194 
    pass
195 
 
483 rajveer 196 
  def getOrder(self, id):
94 ashish 197 
    """
198 
    Parameters:
483 rajveer 199 
     - id
94 ashish 200 
    """
201 
    pass
202 
 
483 rajveer 203 
  def getLineItemsForOrder(self, orderId):
94 ashish 204 
    """
205 
    Parameters:
483 rajveer 206 
     - orderId
94 ashish 207 
    """
208 
    pass
209 
 
4999 phani.kuma 210 
  def getOrderList(self, order_ids):
211 
    """
212 
    Parameters:
213 
     - order_ids
214 
    """
215 
    pass
216 
 
5386 phani.kuma 217 
  def getOrderListForVendor(self, order_ids, vendorId):
218 
    """
219 
    Parameters:
220 
     - order_ids
221 
     - vendorId
222 
    """
223 
    pass
224 
 
1528 ankur.sing 225 
  def getOrderForCustomer(self, orderId, customerId):
226 
    """
227 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
228 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 229 
 
1528 ankur.sing 230 
    Parameters:
231 
     - orderId
232 
     - customerId
233 
    """
234 
    pass
235 
 
4444 rajveer 236 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 237 
    """
238 
    Parameters:
4394 rajveer 239 
     - type
4444 rajveer 240 
     - warehouseId
4394 rajveer 241 
     - status
242 
     - timestamp
3064 chandransh 243 
    """
244 
    pass
245 
 
4444 rajveer 246 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 247 
    """
248 
    Parameters:
249 
     - type
4444 rajveer 250 
     - warehouseId
4394 rajveer 251 
     - description
3064 chandransh 252 
    """
253 
    pass
254 
 
4444 rajveer 255 
  def markAlertsAsSeen(self, warehouseId):
256 
    """
257 
    Parameters:
258 
     - warehouseId
259 
    """
260 
    pass
261 
 
3064 chandransh 262 
  def getValidOrderCount(self, ):
263 
    """
264 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
265 
    """
266 
    pass
267 
 
268 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
269 
    """
270 
    Returns the number of distinct customers who have done successful transactions
271 
    """
272 
    pass
273 
 
274 
  def getValidOrdersAmountRange(self, ):
275 
    """
276 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
277 
    List contains two values, first minimum amount and second maximum amount.
278 
    """
279 
    pass
280 
 
5874 rajveer 281 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 282 
    """
283 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
284 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 285 
 
3064 chandransh 286 
    Parameters:
287 
     - limit
5874 rajveer 288 
     - onlyStore
3064 chandransh 289 
    """
290 
    pass
291 
 
1220 chandransh 292 
  def batchOrders(self, warehouseId):
293 
    """
294 
    Create a batch of all the pending orders for the given warehouse.
295 
    The returned list is orderd by created_timestamp.
296 
    If there are no pending orders, an empty list is returned.
3431 rajveer 297 
 
1220 chandransh 298 
    Parameters:
299 
     - warehouseId
300 
    """
301 
    pass
302 
 
1208 chandransh 303 
  def markOrderAsOutOfStock(self, orderId):
304 
    """
305 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 306 
 
1208 chandransh 307 
    Parameters:
308 
     - orderId
309 
    """
310 
    pass
311 
 
3064 chandransh 312 
  def verifyOrder(self, orderId):
759 chandransh 313 
    """
3064 chandransh 314 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
315 
    timestamp. It is intended to be used for COD orders but can be harmlessly
316 
    used for all other orders as well.
317 
    Throws an exception if no such order exists.
3431 rajveer 318 
 
759 chandransh 319 
    Parameters:
3064 chandransh 320 
     - orderId
321 
    """
322 
    pass
323 
 
324 
  def acceptOrder(self, orderId):
325 
    """
326 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
327 
    given order is not a COD order, it also captures the payment if the same has
328 
    not been captured.
329 
    Throws an exception if no such order exists.
3431 rajveer 330 
 
3064 chandransh 331 
    Parameters:
332 
     - orderId
333 
    """
334 
    pass
335 
 
5110 mandeep.dh 336 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 337 
    """
338 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 339 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
3064 chandransh 340 
    the IMEI no. if a -1 is supplied.
341 
    Also, it generates an invoice number for the order, marks the order as
342 
    BILLED and sets the billing timestamp.
343 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 344 
 
3064 chandransh 345 
    Parameters:
346 
     - orderId
4283 anupam.sin 347 
     - invoice_number
4658 mandeep.dh 348 
     - serialNumber
3064 chandransh 349 
     - itemNumber
4283 anupam.sin 350 
     - billed_by
351 
     - jacketNumber
3064 chandransh 352 
     - billingType
5110 mandeep.dh 353 
     - fulfilmentWarehouseId
4763 rajveer 354 
     - authorize
3064 chandransh 355 
    """
356 
    pass
357 
 
6756 amar.kumar 358 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 359 
    """
360 
    Add the invoice number to the order.
361 
 
362 
    Parameters:
363 
     - orderId
364 
     - invoiceNumber
4763 rajveer 365 
     - color
6756 amar.kumar 366 
     - serialNumber
367 
     - itemNumber
4579 rajveer 368 
    """
369 
    pass
370 
 
4910 phani.kuma 371 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
3064 chandransh 372 
    """
373 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 374 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
4410 rajveer 375 
 
376 
    Parameters:
377 
     - warehouseId
378 
     - providerId
379 
     - cod
4910 phani.kuma 380 
     - orderIds
4410 rajveer 381 
    """
382 
    pass
383 
 
5713 rajveer 384 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 385 
    """
386 
    Parameters:
387 
     - providerId
388 
     - orderIds
5713 rajveer 389 
     - awbs
5676 rajveer 390 
    """
391 
    pass
392 
 
4910 phani.kuma 393 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 394 
    """
4910 phani.kuma 395 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
396 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 397 
 
3064 chandransh 398 
    Parameters:
759 chandransh 399 
     - providerId
4910 phani.kuma 400 
     - pickupDetails
759 chandransh 401 
    """
402 
    pass
403 
 
4910 phani.kuma 404 
  def getOrdersNotPickedUp(self, providerId):
1113 chandransh 405 
    """
406 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 407 
 
1113 chandransh 408 
    Parameters:
409 
     - providerId
410 
    """
411 
    pass
412 
 
1132 chandransh 413 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
414 
    """
415 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
416 
    the name of the receiver.
417 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 418 
 
1132 chandransh 419 
    Parameters:
420 
     - providerId
421 
     - deliveredOrders
422 
    """
423 
    pass
424 
 
4910 phani.kuma 425 
  def markAsRTOrders(self, providerId, returnedOrders):
1135 chandransh 426 
    """
4910 phani.kuma 427 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
1135 chandransh 428 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 429 
 
1135 chandransh 430 
    Parameters:
431 
     - providerId
432 
     - returnedOrders
433 
    """
434 
    pass
435 
 
4910 phani.kuma 436 
  def getRTOrders(self, providerId):
437 
    """
438 
    Returns a list of orders that were returned by courier.
439 
 
440 
    Parameters:
441 
     - providerId
442 
    """
443 
    pass
444 
 
1246 chandransh 445 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
446 
    """
447 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 448 
 
1246 chandransh 449 
    Parameters:
450 
     - providerId
451 
     - undeliveredOrders
452 
    """
453 
    pass
454 
 
4910 phani.kuma 455 
  def getNonDeliveredOrdersbyCourier(self, providerId):
456 
    """
457 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
458 
 
459 
    Parameters:
460 
     - providerId
461 
    """
462 
    pass
463 
 
464 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
465 
    """
466 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
467 
 
468 
    Parameters:
469 
     - providerId
470 
     - local_connected_orders
471 
    """
472 
    pass
473 
 
474 
  def getOrdersNotLocalConnected(self, providerId):
475 
    """
476 
    Returns a list of orders that were picked up or shipped but pending local connection.
477 
 
478 
    Parameters:
479 
     - providerId
480 
    """
481 
    pass
482 
 
483 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
484 
    """
485 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
486 
 
487 
    Parameters:
488 
     - providerId
489 
     - destination_city_reached_orders
490 
    """
491 
    pass
492 
 
493 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
494 
    """
495 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
496 
 
497 
    Parameters:
498 
     - providerId
499 
     - first_atdl_orders
500 
    """
501 
    pass
502 
 
1408 ankur.sing 503 
  def getUndeliveredOrders(self, providerId, warehouseId):
504 
    """
505 
    Returns the list of orders whose delivery time has passed but have not been
506 
    delivered yet for the given provider and warehouse. To get a complete list of
507 
    undelivered orders, pass them as -1.
508 
    Returns an empty list if no such orders exist.
3431 rajveer 509 
 
1408 ankur.sing 510 
    Parameters:
511 
     - providerId
512 
     - warehouseId
513 
    """
514 
    pass
515 
 
4783 phani.kuma 516 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
517 
    """
518 
    Returns the list of orders whose expected delivery date has passed but have not been
519 
    delivered yet.
520 
    Returns an empty list if no such orders exist.
521 
    """
522 
    pass
523 
 
2536 chandransh 524 
  def toggleDOAFlag(self, orderId):
525 
    """
526 
    Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
527 
    Returns the final flag status.
528 
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
3431 rajveer 529 
 
2536 chandransh 530 
    Parameters:
531 
     - orderId
532 
    """
533 
    pass
1886 ankur.sing 534 
 
4712 rajveer 535 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
536 
    """
537 
    Parameters:
538 
     - orderId
539 
     - deliveryTimestamp
540 
     - receiver
541 
    """
542 
    pass
543 
 
5553 rajveer 544 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
545 
    """
546 
    Parameters:
547 
     - orderId
548 
     - deliveryTimestamp
549 
    """
550 
    pass
551 
 
4454 rajveer 552 
  def markOrderDoaRequestReceived(self, orderId):
553 
    """
554 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
555 
 
556 
    Parameters:
557 
     - orderId
558 
    """
559 
    pass
560 
 
561 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
562 
    """
563 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
564 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
565 
 
566 
    Parameters:
567 
     - orderId
568 
     - isAuthorized
569 
    """
570 
    pass
571 
 
4488 rajveer 572 
  def markOrderReturnRequestReceived(self, orderId):
573 
    """
574 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
575 
 
576 
    Parameters:
577 
     - orderId
578 
    """
579 
    pass
580 
 
581 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
582 
    """
583 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
584 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
585 
 
586 
    Parameters:
587 
     - orderId
588 
     - isAuthorized
589 
    """
590 
    pass
591 
 
4579 rajveer 592 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 593 
    """
594 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 595 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
596 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 597 
    For any other status, it returns false.
598 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 599 
 
2536 chandransh 600 
    Parameters:
601 
     - orderId
4579 rajveer 602 
     - providerId
2536 chandransh 603 
    """
604 
    pass
605 
 
4602 rajveer 606 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 607 
    """
4452 rajveer 608 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 609 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
610 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
611 
    	3. Returns true
2591 chandransh 612 
    If the order is in any other status, it returns false.
2536 chandransh 613 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 614 
 
2536 chandransh 615 
    Parameters:
616 
     - orderId
617 
     - pickupNumber
4602 rajveer 618 
     - providerId
2536 chandransh 619 
    """
620 
    pass
621 
 
2764 chandransh 622 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
623 
    """
624 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 625 
 
2764 chandransh 626 
    Parameters:
627 
     - providerId
628 
     - pickupDetails
629 
    """
630 
    pass
631 
 
4910 phani.kuma 632 
  def getDoasNotPickedUp(self, providerId):
633 
    """
634 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
635 
 
636 
    Parameters:
637 
     - providerId
638 
    """
639 
    pass
640 
 
4741 phani.kuma 641 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
642 
    """
643 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
644 
 
645 
    Parameters:
646 
     - providerId
647 
     - pickupDetails
648 
    """
649 
    pass
650 
 
4910 phani.kuma 651 
  def getReturnOrdersNotPickedUp(self, providerId):
652 
    """
653 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
654 
 
655 
    Parameters:
656 
     - providerId
657 
    """
658 
    pass
659 
 
4479 rajveer 660 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 661 
    """
4452 rajveer 662 
    If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
4484 rajveer 663 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 664 
    If the order is in any other state, it returns false.
665 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 666 
 
2591 chandransh 667 
    Parameters:
668 
     - orderId
4479 rajveer 669 
     - receiveCondition
2591 chandransh 670 
    """
671 
    pass
2536 chandransh 672 
 
2591 chandransh 673 
  def validateDoa(self, orderId, isValid):
674 
    """
4452 rajveer 675 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 676 
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
2591 chandransh 677 
    If the order is in any other state, it returns false.
678 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 679 
 
2591 chandransh 680 
    Parameters:
681 
     - orderId
682 
     - isValid
683 
    """
684 
    pass
685 
 
4495 rajveer 686 
  def validateReturnProduct(self, orderId, isUsable):
687 
    """
688 
    Parameters:
689 
     - orderId
690 
     - isUsable
691 
    """
692 
    pass
693 
 
2616 chandransh 694 
  def reshipOrder(self, orderId):
695 
    """
4484 rajveer 696 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 697 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 698 
    	2. Marks the current order as one of the final states RTO_RESHIPPED and DOA_INVALID_RESHIPPED depending on what state the order started in.
2616 chandransh 699 
 
700 
    If the order is in DOA_CERT_VALID state, it does the following:
701 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
702 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 703 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 704 
 
2616 chandransh 705 
    Returns the id of the newly created order.
3431 rajveer 706 
 
2616 chandransh 707 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 708 
 
2616 chandransh 709 
    Parameters:
710 
     - orderId
711 
    """
712 
    pass
2591 chandransh 713 
 
3226 chandransh 714 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 715 
    """
4484 rajveer 716 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 717 
    	1. Creates a refund request for batch processing.
718 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 719 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 720 
 
2616 chandransh 721 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
722 
    	1. Creates a refund request for batch processing.
3226 chandransh 723 
    	2. Cancels the reservation of the item in the warehouse.
724 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 725 
 
3226 chandransh 726 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
727 
    	1. Cancels the reservation of the item in the warehouse.
728 
    	2. Marks the current order as CANCELED.
729 
 
730 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
731 
 
2616 chandransh 732 
    Returns True if it is successful, False otherwise.
3431 rajveer 733 
 
2616 chandransh 734 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 735 
 
2616 chandransh 736 
    Parameters:
737 
     - orderId
3226 chandransh 738 
     - refundedBy
739 
     - reason
2616 chandransh 740 
    """
741 
    pass
742 
 
2690 chandransh 743 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
744 
    """
745 
    Get all return orders created between the from and to dates for the given warehouse.
746 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 747 
 
2690 chandransh 748 
    Parameters:
749 
     - warehouseId
750 
     - fromDate
751 
     - toDate
752 
    """
753 
    pass
2616 chandransh 754 
 
5481 phani.kuma 755 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
756 
    """
757 
    Get all return orders created between the from and to dates.
758 
 
759 
    Parameters:
760 
     - onlyNotProcessed
761 
     - fromDate
762 
     - toDate
763 
    """
764 
    pass
765 
 
2700 chandransh 766 
  def getReturnOrder(self, id):
767 
    """
768 
    Returns the ReturnOrder corresponding to the given id.
769 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 770 
 
2700 chandransh 771 
    Parameters:
772 
     - id
773 
    """
774 
    pass
775 
 
2690 chandransh 776 
  def processReturn(self, returnOrderId):
777 
    """
778 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 779 
 
2690 chandransh 780 
    Parameters:
781 
     - returnOrderId
782 
    """
783 
    pass
784 
 
3451 chandransh 785 
  def updateWeight(self, orderId, weight):
786 
    """
787 
    Set the weight of the given order to the provided value. Will attempt to update the weight of the item in the catalog as well.
2819 chandransh 788 
 
3451 chandransh 789 
    Parameters:
790 
     - orderId
791 
     - weight
792 
    """
793 
    pass
794 
 
3469 chandransh 795 
  def changeItem(self, orderId, itemId):
796 
    """
797 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
798 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 799 
 
3469 chandransh 800 
    Parameters:
801 
     - orderId
802 
     - itemId
803 
    """
804 
    pass
805 
 
806 
  def shiftToWarehouse(self, orderId, warehouseId):
807 
    """
808 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
809 
 
810 
    Parameters:
811 
     - orderId
812 
     - warehouseId
813 
    """
814 
    pass
815 
 
4647 rajveer 816 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 817 
    """
818 
    Adds the given delay reason to the given order.
3986 chandransh 819 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 820 
    Raises an exception if no order with the given id can be found.
3469 chandransh 821 
 
3553 chandransh 822 
    Parameters:
823 
     - orderId
824 
     - delayReason
3986 chandransh 825 
     - furtherDelay
4647 rajveer 826 
     - delayReasonText
3553 chandransh 827 
    """
828 
    pass
829 
 
3956 chandransh 830 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
831 
    """
832 
    Marks the COD orders with given AWB nos. as having been processed.
833 
    Updates the captured amount for the corresponding payment.
3553 chandransh 834 
 
3956 chandransh 835 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
836 
    1. There is no order corresponding to an AWB number.
837 
    2. The captured amount for a payment exceeds the total payment.
838 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
839 
 
840 
    Parameters:
841 
     - collectedAmountMap
842 
     - xferBy
843 
     - xferTxnId
844 
     - xferDate
845 
    """
846 
    pass
847 
 
4008 mandeep.dh 848 
  def getTransactionsRequiringExtraProcessing(self, category):
849 
    """
4065 mandeep.dh 850 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 851 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 852 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 853 
 
4008 mandeep.dh 854 
    Parameters:
855 
     - category
856 
    """
857 
    pass
858 
 
859 
  def markTransactionAsProcessed(self, transactionId, category):
860 
    """
861 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 862 
    It essentially deletes the transaction id record for a particular
863 
    processing type category (if present) from DB.
864 
    This is currently used by CRM application.
4008 mandeep.dh 865 
 
866 
    Parameters:
867 
     - transactionId
868 
     - category
869 
    """
870 
    pass
871 
 
4018 chandransh 872 
  def getItemWiseRiskyOrdersCount(self, ):
873 
    """
874 
    Returns a map containing the number of risky orders keyed by item id. A risky order
875 
    is defined as one whose shipping date is about to expire.
876 
    """
877 
    pass
4008 mandeep.dh 878 
 
4295 varun.gupt 879 
  def getOrdersForItemIds(self, itemIds):
880 
    """
881 
    Returns a list of all orders which have items with given id
882 
 
883 
    Parameters:
884 
     - itemIds
885 
    """
886 
    pass
887 
 
4247 rajveer 888 
  def markOrderCancellationRequestReceived(self, orderId):
889 
    """
890 
    Mark order as cancellation request received. If customer sends request of cancellation of
891 
    a particular order, this method will be called. It will just change status of the order
892 
    depending on its current status. It also records the previous status, so that we can move
893 
    back to that status if cancellation request is denied.
4018 chandransh 894 
 
4247 rajveer 895 
    Parameters:
896 
     - orderId
897 
    """
898 
    pass
899 
 
900 
  def markOrderCancellationRequestConfirmed(self, orderId):
901 
    """
902 
    If we decide to to cancel order, CRM will call this method to move the status of order to
903 
    cancellation request confirmed. After this OM will be able to cancel the order.
904 
 
905 
    Parameters:
906 
     - orderId
907 
    """
908 
    pass
909 
 
910 
  def markOrderCancellationRequestDenied(self, orderId):
911 
    """
912 
    If we decide to not to cancel order, we will move the order ro previous status.
913 
 
914 
    Parameters:
915 
     - orderId
916 
    """
917 
    pass
918 
 
4258 rajveer 919 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 920 
    """
4258 rajveer 921 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
922 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 923 
 
924 
    Parameters:
4258 rajveer 925 
     - transactionId
4247 rajveer 926 
    """
927 
    pass
928 
 
4259 anupam.sin 929 
  def refundTransaction(self, transactionId, refundedBy, reason):
930 
    """
931 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
932 
    need to be cancelled
4247 rajveer 933 
 
4259 anupam.sin 934 
    Parameters:
935 
     - transactionId
936 
     - refundedBy
937 
     - reason
938 
    """
939 
    pass
940 
 
4324 mandeep.dh 941 
  def updateShipmentAddress(self, orderId, addressId):
942 
    """
943 
    Updates shipment address of an order. Delivery and shipping date estimates
944 
    etc. are also updated here.
945 
 
946 
    Throws TransactionServiceException in case address change is not
947 
    possible due to certain reasons such as new pincode in address is
948 
    not serviceable etc.
949 
 
950 
    Parameters:
951 
     - orderId
952 
     - addressId
953 
    """
954 
    pass
955 
 
4285 rajveer 956 
  def acceptOrdersForItemId(self, itemId, inventory):
957 
    """
958 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
959 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 960 
 
4285 rajveer 961 
    Parameters:
962 
     - itemId
963 
     - inventory
964 
    """
965 
    pass
966 
 
4369 rajveer 967 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 968 
    """
969 
    Parameters:
970 
     - vendorId
971 
     - itemId
972 
     - quantity
973 
     - estimate
4369 rajveer 974 
     - isReminder
4303 rajveer 975 
    """
976 
    pass
4285 rajveer 977 
 
4369 rajveer 978 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 979 
    """
980 
    Parameters:
981 
     - vendorId
982 
     - itemId
983 
     - quantity
984 
     - estimate
4369 rajveer 985 
     - isReminder
4303 rajveer 986 
    """
987 
    pass
988 
 
4369 rajveer 989 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 990 
    """
991 
    Parameters:
992 
     - vendorId
993 
     - itemId
994 
     - quantity
995 
     - estimate
4369 rajveer 996 
     - isReminder
4303 rajveer 997 
    """
998 
    pass
999 
 
4369 rajveer 1000 
  def markOrdersAsTimeout(self, vendorId):
1001 
    """
1002 
    Parameters:
1003 
     - vendorId
1004 
    """
1005 
    pass
4303 rajveer 1006 
 
4662 rajveer 1007 
  def markOrderAsLostInTransit(self, orderId):
1008 
    """
1009 
    Mark order as LOST_IN_TRANSIT
1010 
 
1011 
    Parameters:
1012 
     - orderId
1013 
    """
1014 
    pass
1015 
 
4386 anupam.sin 1016 
  def getOrderForAwb(self, awb):
1017 
    """
1018 
    Returns the order corresponding to an AWB number
4369 rajveer 1019 
 
4386 anupam.sin 1020 
    Parameters:
1021 
     - awb
1022 
    """
1023 
    pass
1024 
 
4910 phani.kuma 1025 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 1026 
    """
4910 phani.kuma 1027 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 1028 
 
4506 phani.kuma 1029 
    Parameters:
1030 
     - logistics_provider_id
4910 phani.kuma 1031 
     - order_status_list
4506 phani.kuma 1032 
    """
1033 
    pass
1034 
 
4600 varun.gupt 1035 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
1036 
    """
1037 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 1038 
 
4600 varun.gupt 1039 
    Parameters:
1040 
     - vendorId
1041 
     - billingDateFrom
1042 
     - billingDateTo
1043 
    """
1044 
    pass
1045 
 
4607 rajveer 1046 
  def getSlippedSippingDateOrders(self, ):
1047 
    pass
1048 
 
4709 rajveer 1049 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
1050 
    """
1051 
    Parameters:
1052 
     - cancelDateFrom
1053 
     - cancelDateTo
1054 
    """
1055 
    pass
1056 
 
4600 varun.gupt 1057 
  def saveBluedartSettlements(self, mapAWBAndAmount):
1058 
    """
1059 
    Parameters:
1060 
     - mapAWBAndAmount
1061 
    """
1062 
    pass
1063 
 
4905 varun.gupt 1064 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 1065 
    """
1066 
    Parameters:
1067 
     - settlementDate
1068 
     - paymentGatewayId
4905 varun.gupt 1069 
     - referenceId
4600 varun.gupt 1070 
     - serviceTax
1071 
     - otherCharges
1072 
     - netCollection
1073 
    """
1074 
    pass
1075 
 
1076 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
1077 
    """
1078 
    Parameters:
1079 
     - settlementId
1080 
     - settlementDate
1081 
     - transactionDateFrom
1082 
     - transactionDateTo
1083 
     - amount
1084 
    """
1085 
    pass
1086 
 
5386 phani.kuma 1087 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 1088 
    """
1089 
    Parameters:
5189 varun.gupt 1090 
     - referenceId
1091 
     - isRefund
4600 varun.gupt 1092 
    """
1093 
    pass
1094 
 
5386 phani.kuma 1095 
  def getSettlementForCod(self, orderId, isRefund):
1096 
    """
1097 
    Parameters:
1098 
     - orderId
1099 
     - isRefund
1100 
    """
1101 
    pass
1102 
 
4600 varun.gupt 1103 
  def getEBSSettlementSummaries(self, ):
1104 
    pass
1105 
 
1106 
  def markEBSSettlementUploaded(self, settlementId):
1107 
    """
1108 
    Parameters:
1109 
     - settlementId
1110 
    """
1111 
    pass
1112 
 
1113 
  def getEBSSettlementDate(self, settlementId):
1114 
    """
1115 
    Parameters:
1116 
     - settlementId
1117 
    """
1118 
    pass
1119 
 
4715 varun.gupt 1120 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
1121 
    """
1122 
    Parameters:
1123 
     - settlementDateFrom
1124 
     - settlementDateTo
1125 
     - isRefund
1126 
    """
1127 
    pass
4600 varun.gupt 1128 
 
4715 varun.gupt 1129 
  def getReshippedOrderIds(self, orderIds):
1130 
    """
1131 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
1132 
 
1133 
    Parameters:
1134 
     - orderIds
1135 
    """
1136 
    pass
1137 
 
5481 phani.kuma 1138 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 1139 
    """
1140 
    Parameters:
1141 
     - vendorId
5481 phani.kuma 1142 
     - onlyVendorNotPaid
1143 
     - billingDateFrom
1144 
     - billingDateTo
4875 varun.gupt 1145 
    """
1146 
    pass
4757 mandeep.dh 1147 
 
5031 varun.gupt 1148 
  def getStatusDistributionOfOrders(self, startDate, endDate):
1149 
    """
1150 
    Parameters:
1151 
     - startDate
1152 
     - endDate
1153 
    """
1154 
    pass
4875 varun.gupt 1155 
 
5067 varun.gupt 1156 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
1157 
    """
1158 
    Parameters:
1159 
     - status
1160 
     - startDatetime
1161 
     - endDatetime
1162 
    """
1163 
    pass
5031 varun.gupt 1164 
 
5348 anupam.sin 1165 
  def updateCODAgent(self, agent, orderId):
1166 
    """
1167 
    Updates the agent who handled the COD verification call
1168 
 
1169 
    Parameters:
1170 
     - agent
1171 
     - orderId
1172 
    """
1173 
    pass
1174 
 
5099 varun.gupt 1175 
  def updateOrderAsPaidToVendor(self, orderId):
1176 
    """
1177 
    Parameters:
1178 
     - orderId
1179 
    """
1180 
    pass
5067 varun.gupt 1181 
 
5386 phani.kuma 1182 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
1183 
    """
1184 
    Parameters:
1185 
     - orderId
1186 
    """
1187 
    pass
1188 
 
5208 varun.gupt 1189 
  def getRefundedOrdersMarkedPaid(self, ):
1190 
    pass
5099 varun.gupt 1191 
 
5447 anupam.sin 1192 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
1193 
    """
1194 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 1195 
 
5447 anupam.sin 1196 
 
1197 
    Parameters:
1198 
     - minOrderId
1199 
     - maxOrderId
1200 
    """
1201 
    pass
1202 
 
5527 anupam.sin 1203 
  def getAllAttributesForOrderId(self, orderId):
1204 
    """
1205 
    gets all attributes for a given orderId
5447 anupam.sin 1206 
 
5527 anupam.sin 1207 
    Parameters:
1208 
     - orderId
1209 
    """
1210 
    pass
1211 
 
5676 rajveer 1212 
  def setOrderAttributes(self, orderId, attributes):
1213 
    """
1214 
    sets attributes for an order
1215 
 
1216 
    Parameters:
1217 
     - orderId
1218 
     - attributes
1219 
    """
1220 
    pass
1221 
 
5527 anupam.sin 1222 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
1223 
    """
1224 
    sets attributes for all orders in a transaction
1225 
 
1226 
    Parameters:
1227 
     - transactionId
1228 
     - attribute
1229 
    """
1230 
    pass
1231 
 
5553 rajveer 1232 
  def getReceivePendingOrders(self, storeId):
1233 
    """
1234 
    Parameters:
1235 
     - storeId
1236 
    """
1237 
    pass
5527 anupam.sin 1238 
 
5553 rajveer 1239 
  def getReceivedAtStoreOrders(self, storeId):
1240 
    """
1241 
    Parameters:
1242 
     - storeId
1243 
    """
1244 
    pass
1245 
 
5713 rajveer 1246 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
1247 
    """
1248 
    Parameters:
1249 
     - storeId
1250 
     - fromDate
1251 
     - toDate
1252 
     - onlyCod
1253 
    """
1254 
    pass
1255 
 
5833 rajveer 1256 
  def getOrderAttributeValue(self, orderId, attributeName):
1257 
    """
1258 
    Parameters:
1259 
     - orderId
1260 
     - attributeName
1261 
    """
1262 
    pass
1263 
 
6019 rajveer 1264 
  def changeJacketNumber(self, orderId, jacketNumber):
1265 
    """
1266 
    Parameters:
1267 
     - orderId
1268 
     - jacketNumber
1269 
    """
1270 
    pass
1271 
 
1272 
  def markOrderAsRtoInTransit(self, orderId):
1273 
    """
1274 
    Parameters:
1275 
     - orderId
1276 
    """
1277 
    pass
1278 
 
5593 mandeep.dh 1279 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
1280 
    """
1281 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
1282 
    invoked while scanning IN of items.
5553 rajveer 1283 
 
5593 mandeep.dh 1284 
    Parameters:
1285 
     - itemId
1286 
     - quantity
1287 
     - fulfilmentWarehouseId
1288 
     - billingWarehouseId
1289 
    """
1290 
    pass
1291 
 
6000 mandeep.dh 1292 
  def createRechargeOrder(self, rechargeOrder):
1293 
    """
1294 
    Parameters:
1295 
     - rechargeOrder
1296 
    """
1297 
    pass
5593 mandeep.dh 1298 
 
6031 rajveer 1299 
  def getRechargeOrder(self, rechargeRrderId):
1300 
    """
1301 
    Parameters:
1302 
     - rechargeRrderId
1303 
    """
1304 
    pass
1305 
 
1306 
  def getRechargeOrders(self, userId):
1307 
    """
1308 
    Parameters:
1309 
     - userId
1310 
    """
1311 
    pass
1312 
 
6000 mandeep.dh 1313 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
1314 
    """
1315 
    Parameters:
1316 
     - rechargeOrderId
1317 
     - rechargeOrderStatus
1318 
    """
1319 
    pass
1320 
 
6031 rajveer 1321 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 1322 
    """
1323 
    Parameters:
6031 rajveer 1324 
     - rechargeOrderId
6000 mandeep.dh 1325 
    """
1326 
    pass
1327 
 
6031 rajveer 1328 
  def getUserWallet(self, userId):
6000 mandeep.dh 1329 
    """
1330 
    Parameters:
6031 rajveer 1331 
     - userId
6000 mandeep.dh 1332 
    """
1333 
    pass
1334 
 
6031 rajveer 1335 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 1336 
    """
1337 
    Parameters:
6031 rajveer 1338 
     - userId
6000 mandeep.dh 1339 
    """
1340 
    pass
1341 
 
6050 anupam.sin 1342 
  def getRechargeOrdersForTransaction(self, txnId):
1343 
    """
1344 
    Returns a recharge order for a given transactionId
1345 
 
1346 
    Parameters:
1347 
     - txnId
1348 
    """
1349 
    pass
1350 
 
6206 rajveer 1351 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 1352 
    """
1353 
    Parameters:
1354 
     - rechargeType
6206 rajveer 1355 
     - onlyActive
6048 rajveer 1356 
    """
1357 
    pass
6000 mandeep.dh 1358 
 
6049 rajveer 1359 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 1360 
    """
1361 
    Parameters:
6049 rajveer 1362 
     - rechargeType
6048 rajveer 1363 
     - deviceNumber
1364 
    """
1365 
    pass
1366 
 
6591 anupam.sin 1367 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 1368 
    """
1369 
    Parameters:
1370 
     - rechargeType
1371 
     - deviceNumber
6307 anupam.sin 1372 
     - userSelectedProviderId
6591 anupam.sin 1373 
     - clientAddress
6269 rajveer 1374 
    """
1375 
    pass
1376 
 
6094 rajveer 1377 
  def getRechargeOrdersForDevice(self, deviceNumber):
1378 
    """
1379 
    Parameters:
1380 
     - deviceNumber
1381 
    """
1382 
    pass
6048 rajveer 1383 
 
6094 rajveer 1384 
  def addAmountToWallet(self, userId, orderId, amount):
1385 
    """
1386 
    Parameters:
1387 
     - userId
1388 
     - orderId
1389 
     - amount
1390 
    """
1391 
    pass
1392 
 
6188 rajveer 1393 
  def getRechargeStatistics(self, ):
1394 
    pass
1395 
 
6154 rajveer 1396 
  def getRechargeOrdersForStatus(self, status):
1397 
    """
1398 
    Parameters:
1399 
     - status
1400 
    """
1401 
    pass
6094 rajveer 1402 
 
6159 rajveer 1403 
  def getPlansForOperator(self, operatorId):
1404 
    """
1405 
    Parameters:
1406 
     - operatorId
1407 
    """
1408 
    pass
6154 rajveer 1409 
 
6307 anupam.sin 1410 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 1411 
    """
1412 
    Returns denominations for a given operator and circle
6159 rajveer 1413 
 
6289 anupam.sin 1414 
    Parameters:
1415 
     - operatorId
6307 anupam.sin 1416 
     - circleCode
6289 anupam.sin 1417 
     - denominationType
1418 
    """
1419 
    pass
1420 
 
6371 rajveer 1421 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
1422 
    """
1423 
    Parameters:
1424 
     - operatorId
1425 
     - circleId
1426 
     - isAvailable
1427 
    """
1428 
    pass
6289 anupam.sin 1429 
 
6389 rajveer 1430 
  def getAvailableEmiSchemes(self, ):
1431 
    pass
6371 rajveer 1432 
 
6389 rajveer 1433 
  def getMiscCharges(self, transactionId):
1434 
    """
1435 
    Parameters:
1436 
     - transactionId
1437 
    """
1438 
    pass
1439 
 
6507 anupam.sin 1440 
  def refundRechargeOrder(self, rechargeOrderId):
1441 
    """
1442 
    Parameters:
1443 
     - rechargeOrderId
1444 
    """
1445 
    pass
6389 rajveer 1446 
 
6821 amar.kumar 1447 
  def getPhysicalOrders(self, fromDate, toDate):
1448 
    """
1449 
    Parameters:
1450 
     - fromDate
1451 
     - toDate
1452 
    """
1453 
    pass
6507 anupam.sin 1454 
 
6906 rajveer 1455 
  def getDocument(self, docType, docSource):
1456 
    """
1457 
    Parameters:
1458 
     - docType
1459 
     - docSource
1460 
    """
1461 
    pass
6821 amar.kumar 1462 
 
6985 anupam.sin 1463 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
1464 
    """
1465 
    Parameters:
1466 
     - orderId
1467 
     - line1
1468 
     - line2
1469 
     - city
1470 
     - state
1471 
     - pin
1472 
    """
1473 
    pass
6906 rajveer 1474 
 
6985 anupam.sin 1475 
 
3376 rajveer 1476 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1477 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1478 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1479 
 
1480 
  def createTransaction(self, transaction):
1481 
    """
1482 
    Parameters:
1483 
     - transaction
1484 
    """
1485 
    self.send_createTransaction(transaction)
132 ashish 1486 
    return self.recv_createTransaction()
94 ashish 1487 
 
1488 
  def send_createTransaction(self, transaction):
1489 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1490 
    args = createTransaction_args()
1491 
    args.transaction = transaction
1492 
    args.write(self._oprot)
1493 
    self._oprot.writeMessageEnd()
1494 
    self._oprot.trans.flush()
1495 
 
1496 
  def recv_createTransaction(self, ):
1497 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1498 
    if mtype == TMessageType.EXCEPTION:
1499 
      x = TApplicationException()
1500 
      x.read(self._iprot)
1501 
      self._iprot.readMessageEnd()
1502 
      raise x
1503 
    result = createTransaction_result()
1504 
    result.read(self._iprot)
1505 
    self._iprot.readMessageEnd()
3431 rajveer 1506 
    if result.success is not None:
132 ashish 1507 
      return result.success
3431 rajveer 1508 
    if result.ex is not None:
94 ashish 1509 
      raise result.ex
132 ashish 1510 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1511 
 
1512 
  def getTransaction(self, id):
1513 
    """
1514 
    Parameters:
1515 
     - id
1516 
    """
1517 
    self.send_getTransaction(id)
1518 
    return self.recv_getTransaction()
1519 
 
1520 
  def send_getTransaction(self, id):
1521 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1522 
    args = getTransaction_args()
1523 
    args.id = id
1524 
    args.write(self._oprot)
1525 
    self._oprot.writeMessageEnd()
1526 
    self._oprot.trans.flush()
1527 
 
1528 
  def recv_getTransaction(self, ):
1529 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1530 
    if mtype == TMessageType.EXCEPTION:
1531 
      x = TApplicationException()
1532 
      x.read(self._iprot)
1533 
      self._iprot.readMessageEnd()
1534 
      raise x
1535 
    result = getTransaction_result()
1536 
    result.read(self._iprot)
1537 
    self._iprot.readMessageEnd()
3431 rajveer 1538 
    if result.success is not None:
94 ashish 1539 
      return result.success
3431 rajveer 1540 
    if result.ex is not None:
94 ashish 1541 
      raise result.ex
1542 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1543 
 
1544 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1545 
    """
1546 
    Parameters:
1547 
     - customerId
1548 
     - from_date
1549 
     - to_date
1550 
     - status
1551 
    """
1552 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1553 
    return self.recv_getTransactionsForCustomer()
1554 
 
1555 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1556 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1557 
    args = getTransactionsForCustomer_args()
1558 
    args.customerId = customerId
1559 
    args.from_date = from_date
1560 
    args.to_date = to_date
1561 
    args.status = status
1562 
    args.write(self._oprot)
1563 
    self._oprot.writeMessageEnd()
1564 
    self._oprot.trans.flush()
1565 
 
1566 
  def recv_getTransactionsForCustomer(self, ):
1567 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1568 
    if mtype == TMessageType.EXCEPTION:
1569 
      x = TApplicationException()
1570 
      x.read(self._iprot)
1571 
      self._iprot.readMessageEnd()
1572 
      raise x
1573 
    result = getTransactionsForCustomer_result()
1574 
    result.read(self._iprot)
1575 
    self._iprot.readMessageEnd()
3431 rajveer 1576 
    if result.success is not None:
94 ashish 1577 
      return result.success
3431 rajveer 1578 
    if result.ex is not None:
94 ashish 1579 
      raise result.ex
1580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1581 
 
132 ashish 1582 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1583 
    """
1584 
    Parameters:
1585 
     - shoppingCartId
1586 
    """
1587 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1588 
    return self.recv_getTransactionsForShoppingCartId()
1589 
 
1590 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1591 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1592 
    args = getTransactionsForShoppingCartId_args()
1593 
    args.shoppingCartId = shoppingCartId
1594 
    args.write(self._oprot)
1595 
    self._oprot.writeMessageEnd()
1596 
    self._oprot.trans.flush()
1597 
 
1598 
  def recv_getTransactionsForShoppingCartId(self, ):
1599 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1600 
    if mtype == TMessageType.EXCEPTION:
1601 
      x = TApplicationException()
1602 
      x.read(self._iprot)
1603 
      self._iprot.readMessageEnd()
1604 
      raise x
1605 
    result = getTransactionsForShoppingCartId_result()
1606 
    result.read(self._iprot)
1607 
    self._iprot.readMessageEnd()
3431 rajveer 1608 
    if result.success is not None:
132 ashish 1609 
      return result.success
3431 rajveer 1610 
    if result.ex is not None:
132 ashish 1611 
      raise result.ex
1612 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1613 
 
94 ashish 1614 
  def getTransactionStatus(self, transactionId):
1615 
    """
1616 
    Parameters:
1617 
     - transactionId
1618 
    """
1619 
    self.send_getTransactionStatus(transactionId)
1620 
    return self.recv_getTransactionStatus()
1621 
 
1622 
  def send_getTransactionStatus(self, transactionId):
1623 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1624 
    args = getTransactionStatus_args()
1625 
    args.transactionId = transactionId
1626 
    args.write(self._oprot)
1627 
    self._oprot.writeMessageEnd()
1628 
    self._oprot.trans.flush()
1629 
 
1630 
  def recv_getTransactionStatus(self, ):
1631 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1632 
    if mtype == TMessageType.EXCEPTION:
1633 
      x = TApplicationException()
1634 
      x.read(self._iprot)
1635 
      self._iprot.readMessageEnd()
1636 
      raise x
1637 
    result = getTransactionStatus_result()
1638 
    result.read(self._iprot)
1639 
    self._iprot.readMessageEnd()
3431 rajveer 1640 
    if result.success is not None:
94 ashish 1641 
      return result.success
3431 rajveer 1642 
    if result.ex is not None:
94 ashish 1643 
      raise result.ex
1644 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1645 
 
5527 anupam.sin 1646 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1647 
    """
1648 
    Parameters:
1649 
     - transactionId
1650 
     - status
1651 
     - description
5527 anupam.sin 1652 
     - pickUp
1653 
     - orderType
94 ashish 1654 
    """
5527 anupam.sin 1655 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1656 
    return self.recv_changeTransactionStatus()
1657 
 
5527 anupam.sin 1658 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1659 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1660 
    args = changeTransactionStatus_args()
1661 
    args.transactionId = transactionId
1662 
    args.status = status
1663 
    args.description = description
5527 anupam.sin 1664 
    args.pickUp = pickUp
1665 
    args.orderType = orderType
94 ashish 1666 
    args.write(self._oprot)
1667 
    self._oprot.writeMessageEnd()
1668 
    self._oprot.trans.flush()
1669 
 
1670 
  def recv_changeTransactionStatus(self, ):
1671 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1672 
    if mtype == TMessageType.EXCEPTION:
1673 
      x = TApplicationException()
1674 
      x.read(self._iprot)
1675 
      self._iprot.readMessageEnd()
1676 
      raise x
1677 
    result = changeTransactionStatus_result()
1678 
    result.read(self._iprot)
1679 
    self._iprot.readMessageEnd()
3431 rajveer 1680 
    if result.success is not None:
94 ashish 1681 
      return result.success
3431 rajveer 1682 
    if result.ex is not None:
94 ashish 1683 
      raise result.ex
1684 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1685 
 
1398 varun.gupt 1686 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1687 
    """
1688 
    Parameters:
1689 
     - transactionId
1690 
    """
1398 varun.gupt 1691 
    self.send_enqueueTransactionInfoEmail(transactionId)
1692 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1693 
 
1398 varun.gupt 1694 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1695 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1696 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1697 
    args.transactionId = transactionId
1698 
    args.write(self._oprot)
1699 
    self._oprot.writeMessageEnd()
1700 
    self._oprot.trans.flush()
1701 
 
1398 varun.gupt 1702 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1703 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1704 
    if mtype == TMessageType.EXCEPTION:
1705 
      x = TApplicationException()
1706 
      x.read(self._iprot)
1707 
      self._iprot.readMessageEnd()
1708 
      raise x
1398 varun.gupt 1709 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1710 
    result.read(self._iprot)
1711 
    self._iprot.readMessageEnd()
3431 rajveer 1712 
    if result.success is not None:
1382 varun.gupt 1713 
      return result.success
3431 rajveer 1714 
    if result.ex is not None:
1382 varun.gupt 1715 
      raise result.ex
1398 varun.gupt 1716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1717 
 
4801 anupam.sin 1718 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1719 
    """
1720 
    Parameters:
4801 anupam.sin 1721 
     - statuses
483 rajveer 1722 
     - from_date
1723 
     - to_date
1724 
     - warehouse_id
94 ashish 1725 
    """
4801 anupam.sin 1726 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1727 
    return self.recv_getAllOrders()
94 ashish 1728 
 
4801 anupam.sin 1729 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1730 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1731 
    args = getAllOrders_args()
4801 anupam.sin 1732 
    args.statuses = statuses
483 rajveer 1733 
    args.from_date = from_date
1734 
    args.to_date = to_date
1735 
    args.warehouse_id = warehouse_id
94 ashish 1736 
    args.write(self._oprot)
1737 
    self._oprot.writeMessageEnd()
1738 
    self._oprot.trans.flush()
1739 
 
483 rajveer 1740 
  def recv_getAllOrders(self, ):
94 ashish 1741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1742 
    if mtype == TMessageType.EXCEPTION:
1743 
      x = TApplicationException()
1744 
      x.read(self._iprot)
1745 
      self._iprot.readMessageEnd()
1746 
      raise x
483 rajveer 1747 
    result = getAllOrders_result()
94 ashish 1748 
    result.read(self._iprot)
1749 
    self._iprot.readMessageEnd()
3431 rajveer 1750 
    if result.success is not None:
94 ashish 1751 
      return result.success
3431 rajveer 1752 
    if result.ex is not None:
94 ashish 1753 
      raise result.ex
483 rajveer 1754 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1755 
 
4133 chandransh 1756 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1757 
    """
1758 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1759 
    Pass the status as null and the limit as 0 to ignore them.
1760 
 
1761 
    Parameters:
1762 
     - statuses
1763 
     - offset
1764 
     - limit
1765 
     - warehouse_id
1766 
    """
1767 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1768 
    return self.recv_getOrdersInBatch()
1769 
 
1770 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1771 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1772 
    args = getOrdersInBatch_args()
1773 
    args.statuses = statuses
1774 
    args.offset = offset
1775 
    args.limit = limit
1776 
    args.warehouse_id = warehouse_id
1777 
    args.write(self._oprot)
1778 
    self._oprot.writeMessageEnd()
1779 
    self._oprot.trans.flush()
1780 
 
1781 
  def recv_getOrdersInBatch(self, ):
1782 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1783 
    if mtype == TMessageType.EXCEPTION:
1784 
      x = TApplicationException()
1785 
      x.read(self._iprot)
1786 
      self._iprot.readMessageEnd()
1787 
      raise x
1788 
    result = getOrdersInBatch_result()
1789 
    result.read(self._iprot)
1790 
    self._iprot.readMessageEnd()
1791 
    if result.success is not None:
1792 
      return result.success
1793 
    if result.ex is not None:
1794 
      raise result.ex
1795 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1796 
 
1797 
  def getOrderCount(self, statuses, warehouseId):
1798 
    """
1799 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1800 
 
1801 
    Parameters:
1802 
     - statuses
1803 
     - warehouseId
1804 
    """
1805 
    self.send_getOrderCount(statuses, warehouseId)
1806 
    return self.recv_getOrderCount()
1807 
 
1808 
  def send_getOrderCount(self, statuses, warehouseId):
1809 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1810 
    args = getOrderCount_args()
1811 
    args.statuses = statuses
1812 
    args.warehouseId = warehouseId
1813 
    args.write(self._oprot)
1814 
    self._oprot.writeMessageEnd()
1815 
    self._oprot.trans.flush()
1816 
 
1817 
  def recv_getOrderCount(self, ):
1818 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1819 
    if mtype == TMessageType.EXCEPTION:
1820 
      x = TApplicationException()
1821 
      x.read(self._iprot)
1822 
      self._iprot.readMessageEnd()
1823 
      raise x
1824 
    result = getOrderCount_result()
1825 
    result.read(self._iprot)
1826 
    self._iprot.readMessageEnd()
1827 
    if result.success is not None:
1828 
      return result.success
1829 
    if result.ex is not None:
1830 
      raise result.ex
1831 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1832 
 
999 varun.gupt 1833 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1834 
    """
1132 chandransh 1835 
    Returns orders within a range of their billing dates
3431 rajveer 1836 
 
999 varun.gupt 1837 
    Parameters:
1838 
     - status
1839 
     - start_billing_date
1840 
     - end_billing_date
1841 
     - warehouse_id
1842 
    """
1843 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1844 
    return self.recv_getOrdersByBillingDate()
1845 
 
1846 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1847 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1848 
    args = getOrdersByBillingDate_args()
1849 
    args.status = status
1850 
    args.start_billing_date = start_billing_date
1851 
    args.end_billing_date = end_billing_date
1852 
    args.warehouse_id = warehouse_id
1853 
    args.write(self._oprot)
1854 
    self._oprot.writeMessageEnd()
1855 
    self._oprot.trans.flush()
1856 
 
1857 
  def recv_getOrdersByBillingDate(self, ):
1858 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1859 
    if mtype == TMessageType.EXCEPTION:
1860 
      x = TApplicationException()
1861 
      x.read(self._iprot)
1862 
      self._iprot.readMessageEnd()
1863 
      raise x
1864 
    result = getOrdersByBillingDate_result()
1865 
    result.read(self._iprot)
1866 
    self._iprot.readMessageEnd()
3431 rajveer 1867 
    if result.success is not None:
999 varun.gupt 1868 
      return result.success
3431 rajveer 1869 
    if result.ex is not None:
999 varun.gupt 1870 
      raise result.ex
1871 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1872 
 
3451 chandransh 1873 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1874 
    """
1875 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1876 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1877 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1878 
 
3427 chandransh 1879 
    Parameters:
1880 
     - fromShippingDate
1881 
     - toShippingDate
1882 
     - providerId
1883 
     - warehouseId
3451 chandransh 1884 
     - cod
3427 chandransh 1885 
    """
3451 chandransh 1886 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1887 
    return self.recv_getOrdersByShippingDate()
1888 
 
3451 chandransh 1889 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1890 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1891 
    args = getOrdersByShippingDate_args()
1892 
    args.fromShippingDate = fromShippingDate
1893 
    args.toShippingDate = toShippingDate
1894 
    args.providerId = providerId
1895 
    args.warehouseId = warehouseId
3451 chandransh 1896 
    args.cod = cod
3427 chandransh 1897 
    args.write(self._oprot)
1898 
    self._oprot.writeMessageEnd()
1899 
    self._oprot.trans.flush()
1900 
 
1901 
  def recv_getOrdersByShippingDate(self, ):
1902 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1903 
    if mtype == TMessageType.EXCEPTION:
1904 
      x = TApplicationException()
1905 
      x.read(self._iprot)
1906 
      self._iprot.readMessageEnd()
1907 
      raise x
1908 
    result = getOrdersByShippingDate_result()
1909 
    result.read(self._iprot)
1910 
    self._iprot.readMessageEnd()
3431 rajveer 1911 
    if result.success is not None:
3427 chandransh 1912 
      return result.success
3431 rajveer 1913 
    if result.ex is not None:
3427 chandransh 1914 
      raise result.ex
1915 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1916 
 
1382 varun.gupt 1917 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1918 
    """
1919 
    Returns order ids for orders which can be returned
3431 rajveer 1920 
 
1382 varun.gupt 1921 
    Parameters:
1922 
     - customer_id
1923 
     - limit
1924 
    """
1925 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1926 
    return self.recv_getReturnableOrdersForCustomer()
1927 
 
1928 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1929 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1930 
    args = getReturnableOrdersForCustomer_args()
1931 
    args.customer_id = customer_id
1932 
    args.limit = limit
1933 
    args.write(self._oprot)
1934 
    self._oprot.writeMessageEnd()
1935 
    self._oprot.trans.flush()
1936 
 
1937 
  def recv_getReturnableOrdersForCustomer(self, ):
1938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1939 
    if mtype == TMessageType.EXCEPTION:
1940 
      x = TApplicationException()
1941 
      x.read(self._iprot)
1942 
      self._iprot.readMessageEnd()
1943 
      raise x
1944 
    result = getReturnableOrdersForCustomer_result()
1945 
    result.read(self._iprot)
1946 
    self._iprot.readMessageEnd()
3431 rajveer 1947 
    if result.success is not None:
1382 varun.gupt 1948 
      return result.success
3431 rajveer 1949 
    if result.ex is not None:
1382 varun.gupt 1950 
      raise result.ex
1951 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1952 
 
1953 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1954 
    """
1955 
    Returns order ids for orders which can be cancelled
3431 rajveer 1956 
 
1382 varun.gupt 1957 
    Parameters:
1958 
     - customer_id
1959 
     - limit
1960 
    """
1961 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1962 
    return self.recv_getCancellableOrdersForCustomer()
1963 
 
1964 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1965 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1966 
    args = getCancellableOrdersForCustomer_args()
1967 
    args.customer_id = customer_id
1968 
    args.limit = limit
1969 
    args.write(self._oprot)
1970 
    self._oprot.writeMessageEnd()
1971 
    self._oprot.trans.flush()
1972 
 
1973 
  def recv_getCancellableOrdersForCustomer(self, ):
1974 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1975 
    if mtype == TMessageType.EXCEPTION:
1976 
      x = TApplicationException()
1977 
      x.read(self._iprot)
1978 
      self._iprot.readMessageEnd()
1979 
      raise x
1980 
    result = getCancellableOrdersForCustomer_result()
1981 
    result.read(self._iprot)
1982 
    self._iprot.readMessageEnd()
3431 rajveer 1983 
    if result.success is not None:
1382 varun.gupt 1984 
      return result.success
3431 rajveer 1985 
    if result.ex is not None:
1382 varun.gupt 1986 
      raise result.ex
1987 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1988 
 
483 rajveer 1989 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1990 
    """
1991 
    Parameters:
483 rajveer 1992 
     - orderId
1993 
     - status
1994 
     - description
94 ashish 1995 
    """
483 rajveer 1996 
    self.send_changeOrderStatus(orderId, status, description)
1997 
    return self.recv_changeOrderStatus()
94 ashish 1998 
 
483 rajveer 1999 
  def send_changeOrderStatus(self, orderId, status, description):
2000 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
2001 
    args = changeOrderStatus_args()
2002 
    args.orderId = orderId
2003 
    args.status = status
2004 
    args.description = description
94 ashish 2005 
    args.write(self._oprot)
2006 
    self._oprot.writeMessageEnd()
2007 
    self._oprot.trans.flush()
2008 
 
483 rajveer 2009 
  def recv_changeOrderStatus(self, ):
94 ashish 2010 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2011 
    if mtype == TMessageType.EXCEPTION:
2012 
      x = TApplicationException()
2013 
      x.read(self._iprot)
2014 
      self._iprot.readMessageEnd()
2015 
      raise x
483 rajveer 2016 
    result = changeOrderStatus_result()
94 ashish 2017 
    result.read(self._iprot)
2018 
    self._iprot.readMessageEnd()
3431 rajveer 2019 
    if result.success is not None:
94 ashish 2020 
      return result.success
3431 rajveer 2021 
    if result.ex is not None:
94 ashish 2022 
      raise result.ex
483 rajveer 2023 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 2024 
 
1528 ankur.sing 2025 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 2026 
    """
1528 ankur.sing 2027 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
2028 
    only user who owns the transaction can view its order details.
3431 rajveer 2029 
 
94 ashish 2030 
    Parameters:
2031 
     - transactionId
1528 ankur.sing 2032 
     - customerId
94 ashish 2033 
    """
1528 ankur.sing 2034 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2035 
    return self.recv_getOrdersForTransaction()
94 ashish 2036 
 
1528 ankur.sing 2037 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2038 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2039 
    args = getOrdersForTransaction_args()
94 ashish 2040 
    args.transactionId = transactionId
1528 ankur.sing 2041 
    args.customerId = customerId
94 ashish 2042 
    args.write(self._oprot)
2043 
    self._oprot.writeMessageEnd()
2044 
    self._oprot.trans.flush()
2045 
 
483 rajveer 2046 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2047 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2048 
    if mtype == TMessageType.EXCEPTION:
2049 
      x = TApplicationException()
2050 
      x.read(self._iprot)
2051 
      self._iprot.readMessageEnd()
2052 
      raise x
483 rajveer 2053 
    result = getOrdersForTransaction_result()
94 ashish 2054 
    result.read(self._iprot)
2055 
    self._iprot.readMessageEnd()
3431 rajveer 2056 
    if result.success is not None:
94 ashish 2057 
      return result.success
3431 rajveer 2058 
    if result.ex is not None:
94 ashish 2059 
      raise result.ex
483 rajveer 2060 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2061 
 
3014 chandransh 2062 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2063 
    """
3014 chandransh 2064 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2065 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2066 
 
94 ashish 2067 
    Parameters:
483 rajveer 2068 
     - customerId
2069 
     - from_date
2070 
     - to_date
3014 chandransh 2071 
     - statuses
94 ashish 2072 
    """
3014 chandransh 2073 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2074 
    return self.recv_getOrdersForCustomer()
94 ashish 2075 
 
3014 chandransh 2076 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2077 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2078 
    args = getOrdersForCustomer_args()
2079 
    args.customerId = customerId
2080 
    args.from_date = from_date
2081 
    args.to_date = to_date
3014 chandransh 2082 
    args.statuses = statuses
94 ashish 2083 
    args.write(self._oprot)
2084 
    self._oprot.writeMessageEnd()
2085 
    self._oprot.trans.flush()
2086 
 
483 rajveer 2087 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2088 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2089 
    if mtype == TMessageType.EXCEPTION:
2090 
      x = TApplicationException()
2091 
      x.read(self._iprot)
2092 
      self._iprot.readMessageEnd()
2093 
      raise x
483 rajveer 2094 
    result = getOrdersForCustomer_result()
94 ashish 2095 
    result.read(self._iprot)
2096 
    self._iprot.readMessageEnd()
3431 rajveer 2097 
    if result.success is not None:
94 ashish 2098 
      return result.success
3431 rajveer 2099 
    if result.ex is not None:
94 ashish 2100 
      raise result.ex
483 rajveer 2101 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2102 
 
483 rajveer 2103 
  def createOrder(self, order):
94 ashish 2104 
    """
2105 
    Parameters:
483 rajveer 2106 
     - order
94 ashish 2107 
    """
483 rajveer 2108 
    self.send_createOrder(order)
2109 
    return self.recv_createOrder()
94 ashish 2110 
 
483 rajveer 2111 
  def send_createOrder(self, order):
2112 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2113 
    args = createOrder_args()
2114 
    args.order = order
94 ashish 2115 
    args.write(self._oprot)
2116 
    self._oprot.writeMessageEnd()
2117 
    self._oprot.trans.flush()
2118 
 
483 rajveer 2119 
  def recv_createOrder(self, ):
94 ashish 2120 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2121 
    if mtype == TMessageType.EXCEPTION:
2122 
      x = TApplicationException()
2123 
      x.read(self._iprot)
2124 
      self._iprot.readMessageEnd()
2125 
      raise x
483 rajveer 2126 
    result = createOrder_result()
94 ashish 2127 
    result.read(self._iprot)
2128 
    self._iprot.readMessageEnd()
3431 rajveer 2129 
    if result.success is not None:
94 ashish 2130 
      return result.success
3431 rajveer 2131 
    if result.ex is not None:
94 ashish 2132 
      raise result.ex
483 rajveer 2133 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2134 
 
483 rajveer 2135 
  def getOrder(self, id):
94 ashish 2136 
    """
2137 
    Parameters:
483 rajveer 2138 
     - id
94 ashish 2139 
    """
483 rajveer 2140 
    self.send_getOrder(id)
2141 
    return self.recv_getOrder()
94 ashish 2142 
 
483 rajveer 2143 
  def send_getOrder(self, id):
2144 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2145 
    args = getOrder_args()
2146 
    args.id = id
94 ashish 2147 
    args.write(self._oprot)
2148 
    self._oprot.writeMessageEnd()
2149 
    self._oprot.trans.flush()
2150 
 
483 rajveer 2151 
  def recv_getOrder(self, ):
94 ashish 2152 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2153 
    if mtype == TMessageType.EXCEPTION:
2154 
      x = TApplicationException()
2155 
      x.read(self._iprot)
2156 
      self._iprot.readMessageEnd()
2157 
      raise x
483 rajveer 2158 
    result = getOrder_result()
94 ashish 2159 
    result.read(self._iprot)
2160 
    self._iprot.readMessageEnd()
3431 rajveer 2161 
    if result.success is not None:
94 ashish 2162 
      return result.success
3431 rajveer 2163 
    if result.ex is not None:
94 ashish 2164 
      raise result.ex
483 rajveer 2165 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2166 
 
483 rajveer 2167 
  def getLineItemsForOrder(self, orderId):
94 ashish 2168 
    """
2169 
    Parameters:
483 rajveer 2170 
     - orderId
94 ashish 2171 
    """
483 rajveer 2172 
    self.send_getLineItemsForOrder(orderId)
2173 
    return self.recv_getLineItemsForOrder()
94 ashish 2174 
 
483 rajveer 2175 
  def send_getLineItemsForOrder(self, orderId):
2176 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2177 
    args = getLineItemsForOrder_args()
2178 
    args.orderId = orderId
94 ashish 2179 
    args.write(self._oprot)
2180 
    self._oprot.writeMessageEnd()
2181 
    self._oprot.trans.flush()
2182 
 
483 rajveer 2183 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2184 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2185 
    if mtype == TMessageType.EXCEPTION:
2186 
      x = TApplicationException()
2187 
      x.read(self._iprot)
2188 
      self._iprot.readMessageEnd()
2189 
      raise x
483 rajveer 2190 
    result = getLineItemsForOrder_result()
94 ashish 2191 
    result.read(self._iprot)
2192 
    self._iprot.readMessageEnd()
3431 rajveer 2193 
    if result.success is not None:
94 ashish 2194 
      return result.success
3431 rajveer 2195 
    if result.ex is not None:
94 ashish 2196 
      raise result.ex
483 rajveer 2197 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2198 
 
4999 phani.kuma 2199 
  def getOrderList(self, order_ids):
2200 
    """
2201 
    Parameters:
2202 
     - order_ids
2203 
    """
2204 
    self.send_getOrderList(order_ids)
2205 
    return self.recv_getOrderList()
2206 
 
2207 
  def send_getOrderList(self, order_ids):
2208 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2209 
    args = getOrderList_args()
2210 
    args.order_ids = order_ids
2211 
    args.write(self._oprot)
2212 
    self._oprot.writeMessageEnd()
2213 
    self._oprot.trans.flush()
2214 
 
2215 
  def recv_getOrderList(self, ):
2216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2217 
    if mtype == TMessageType.EXCEPTION:
2218 
      x = TApplicationException()
2219 
      x.read(self._iprot)
2220 
      self._iprot.readMessageEnd()
2221 
      raise x
2222 
    result = getOrderList_result()
2223 
    result.read(self._iprot)
2224 
    self._iprot.readMessageEnd()
2225 
    if result.success is not None:
2226 
      return result.success
2227 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2228 
 
5386 phani.kuma 2229 
  def getOrderListForVendor(self, order_ids, vendorId):
2230 
    """
2231 
    Parameters:
2232 
     - order_ids
2233 
     - vendorId
2234 
    """
2235 
    self.send_getOrderListForVendor(order_ids, vendorId)
2236 
    return self.recv_getOrderListForVendor()
2237 
 
2238 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2239 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2240 
    args = getOrderListForVendor_args()
2241 
    args.order_ids = order_ids
2242 
    args.vendorId = vendorId
2243 
    args.write(self._oprot)
2244 
    self._oprot.writeMessageEnd()
2245 
    self._oprot.trans.flush()
2246 
 
2247 
  def recv_getOrderListForVendor(self, ):
2248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2249 
    if mtype == TMessageType.EXCEPTION:
2250 
      x = TApplicationException()
2251 
      x.read(self._iprot)
2252 
      self._iprot.readMessageEnd()
2253 
      raise x
2254 
    result = getOrderListForVendor_result()
2255 
    result.read(self._iprot)
2256 
    self._iprot.readMessageEnd()
2257 
    if result.success is not None:
2258 
      return result.success
2259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2260 
 
1528 ankur.sing 2261 
  def getOrderForCustomer(self, orderId, customerId):
2262 
    """
2263 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2264 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2265 
 
1528 ankur.sing 2266 
    Parameters:
2267 
     - orderId
2268 
     - customerId
2269 
    """
2270 
    self.send_getOrderForCustomer(orderId, customerId)
2271 
    return self.recv_getOrderForCustomer()
2272 
 
2273 
  def send_getOrderForCustomer(self, orderId, customerId):
2274 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2275 
    args = getOrderForCustomer_args()
2276 
    args.orderId = orderId
2277 
    args.customerId = customerId
2278 
    args.write(self._oprot)
2279 
    self._oprot.writeMessageEnd()
2280 
    self._oprot.trans.flush()
2281 
 
2282 
  def recv_getOrderForCustomer(self, ):
2283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2284 
    if mtype == TMessageType.EXCEPTION:
2285 
      x = TApplicationException()
2286 
      x.read(self._iprot)
2287 
      self._iprot.readMessageEnd()
2288 
      raise x
2289 
    result = getOrderForCustomer_result()
2290 
    result.read(self._iprot)
2291 
    self._iprot.readMessageEnd()
3431 rajveer 2292 
    if result.success is not None:
1528 ankur.sing 2293 
      return result.success
3431 rajveer 2294 
    if result.ex is not None:
1528 ankur.sing 2295 
      raise result.ex
2296 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2297 
 
4444 rajveer 2298 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2299 
    """
2300 
    Parameters:
4394 rajveer 2301 
     - type
4444 rajveer 2302 
     - warehouseId
4394 rajveer 2303 
     - status
2304 
     - timestamp
3064 chandransh 2305 
    """
4444 rajveer 2306 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2307 
    return self.recv_getAlerts()
2308 
 
4444 rajveer 2309 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2310 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2311 
    args = getAlerts_args()
4394 rajveer 2312 
    args.type = type
4444 rajveer 2313 
    args.warehouseId = warehouseId
4394 rajveer 2314 
    args.status = status
2315 
    args.timestamp = timestamp
3064 chandransh 2316 
    args.write(self._oprot)
2317 
    self._oprot.writeMessageEnd()
2318 
    self._oprot.trans.flush()
2319 
 
2320 
  def recv_getAlerts(self, ):
2321 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2322 
    if mtype == TMessageType.EXCEPTION:
2323 
      x = TApplicationException()
2324 
      x.read(self._iprot)
2325 
      self._iprot.readMessageEnd()
2326 
      raise x
2327 
    result = getAlerts_result()
2328 
    result.read(self._iprot)
2329 
    self._iprot.readMessageEnd()
3431 rajveer 2330 
    if result.success is not None:
3064 chandransh 2331 
      return result.success
2332 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2333 
 
4444 rajveer 2334 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2335 
    """
2336 
    Parameters:
2337 
     - type
4444 rajveer 2338 
     - warehouseId
4394 rajveer 2339 
     - description
3064 chandransh 2340 
    """
4444 rajveer 2341 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2342 
    self.recv_addAlert()
3064 chandransh 2343 
 
4444 rajveer 2344 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2345 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2346 
    args = addAlert_args()
3064 chandransh 2347 
    args.type = type
4444 rajveer 2348 
    args.warehouseId = warehouseId
4394 rajveer 2349 
    args.description = description
3064 chandransh 2350 
    args.write(self._oprot)
2351 
    self._oprot.writeMessageEnd()
2352 
    self._oprot.trans.flush()
2353 
 
4394 rajveer 2354 
  def recv_addAlert(self, ):
3064 chandransh 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
4394 rajveer 2361 
    result = addAlert_result()
3064 chandransh 2362 
    result.read(self._iprot)
2363 
    self._iprot.readMessageEnd()
2364 
    return
2365 
 
4444 rajveer 2366 
  def markAlertsAsSeen(self, warehouseId):
2367 
    """
2368 
    Parameters:
2369 
     - warehouseId
2370 
    """
2371 
    self.send_markAlertsAsSeen(warehouseId)
2372 
    self.recv_markAlertsAsSeen()
2373 
 
2374 
  def send_markAlertsAsSeen(self, warehouseId):
2375 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2376 
    args = markAlertsAsSeen_args()
2377 
    args.warehouseId = warehouseId
2378 
    args.write(self._oprot)
2379 
    self._oprot.writeMessageEnd()
2380 
    self._oprot.trans.flush()
2381 
 
2382 
  def recv_markAlertsAsSeen(self, ):
2383 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2384 
    if mtype == TMessageType.EXCEPTION:
2385 
      x = TApplicationException()
2386 
      x.read(self._iprot)
2387 
      self._iprot.readMessageEnd()
2388 
      raise x
2389 
    result = markAlertsAsSeen_result()
2390 
    result.read(self._iprot)
2391 
    self._iprot.readMessageEnd()
2392 
    return
2393 
 
3064 chandransh 2394 
  def getValidOrderCount(self, ):
2395 
    """
2396 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2397 
    """
2398 
    self.send_getValidOrderCount()
2399 
    return self.recv_getValidOrderCount()
2400 
 
2401 
  def send_getValidOrderCount(self, ):
2402 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2403 
    args = getValidOrderCount_args()
2404 
    args.write(self._oprot)
2405 
    self._oprot.writeMessageEnd()
2406 
    self._oprot.trans.flush()
2407 
 
2408 
  def recv_getValidOrderCount(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 = getValidOrderCount_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, "getValidOrderCount failed: unknown result");
2421 
 
2422 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2423 
    """
2424 
    Returns the number of distinct customers who have done successful transactions
2425 
    """
2426 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2427 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2428 
 
2429 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2430 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2431 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2432 
    args.write(self._oprot)
2433 
    self._oprot.writeMessageEnd()
2434 
    self._oprot.trans.flush()
2435 
 
2436 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2437 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2438 
    if mtype == TMessageType.EXCEPTION:
2439 
      x = TApplicationException()
2440 
      x.read(self._iprot)
2441 
      self._iprot.readMessageEnd()
2442 
      raise x
2443 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2444 
    result.read(self._iprot)
2445 
    self._iprot.readMessageEnd()
3431 rajveer 2446 
    if result.success is not None:
3064 chandransh 2447 
      return result.success
2448 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2449 
 
2450 
  def getValidOrdersAmountRange(self, ):
2451 
    """
2452 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2453 
    List contains two values, first minimum amount and second maximum amount.
2454 
    """
2455 
    self.send_getValidOrdersAmountRange()
2456 
    return self.recv_getValidOrdersAmountRange()
2457 
 
2458 
  def send_getValidOrdersAmountRange(self, ):
2459 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2460 
    args = getValidOrdersAmountRange_args()
2461 
    args.write(self._oprot)
2462 
    self._oprot.writeMessageEnd()
2463 
    self._oprot.trans.flush()
2464 
 
2465 
  def recv_getValidOrdersAmountRange(self, ):
2466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2467 
    if mtype == TMessageType.EXCEPTION:
2468 
      x = TApplicationException()
2469 
      x.read(self._iprot)
2470 
      self._iprot.readMessageEnd()
2471 
      raise x
2472 
    result = getValidOrdersAmountRange_result()
2473 
    result.read(self._iprot)
2474 
    self._iprot.readMessageEnd()
3431 rajveer 2475 
    if result.success is not None:
3064 chandransh 2476 
      return result.success
2477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2478 
 
5874 rajveer 2479 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2480 
    """
2481 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2482 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2483 
 
3064 chandransh 2484 
    Parameters:
2485 
     - limit
5874 rajveer 2486 
     - onlyStore
3064 chandransh 2487 
    """
5874 rajveer 2488 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2489 
    return self.recv_getValidOrders()
2490 
 
5874 rajveer 2491 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2492 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2493 
    args = getValidOrders_args()
2494 
    args.limit = limit
5874 rajveer 2495 
    args.onlyStore = onlyStore
3064 chandransh 2496 
    args.write(self._oprot)
2497 
    self._oprot.writeMessageEnd()
2498 
    self._oprot.trans.flush()
2499 
 
2500 
  def recv_getValidOrders(self, ):
2501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2502 
    if mtype == TMessageType.EXCEPTION:
2503 
      x = TApplicationException()
2504 
      x.read(self._iprot)
2505 
      self._iprot.readMessageEnd()
2506 
      raise x
2507 
    result = getValidOrders_result()
2508 
    result.read(self._iprot)
2509 
    self._iprot.readMessageEnd()
3431 rajveer 2510 
    if result.success is not None:
3064 chandransh 2511 
      return result.success
2512 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2513 
 
1220 chandransh 2514 
  def batchOrders(self, warehouseId):
2515 
    """
2516 
    Create a batch of all the pending orders for the given warehouse.
2517 
    The returned list is orderd by created_timestamp.
2518 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2519 
 
1220 chandransh 2520 
    Parameters:
2521 
     - warehouseId
2522 
    """
2523 
    self.send_batchOrders(warehouseId)
2524 
    return self.recv_batchOrders()
2525 
 
2526 
  def send_batchOrders(self, warehouseId):
2527 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2528 
    args = batchOrders_args()
2529 
    args.warehouseId = warehouseId
2530 
    args.write(self._oprot)
2531 
    self._oprot.writeMessageEnd()
2532 
    self._oprot.trans.flush()
2533 
 
2534 
  def recv_batchOrders(self, ):
2535 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2536 
    if mtype == TMessageType.EXCEPTION:
2537 
      x = TApplicationException()
2538 
      x.read(self._iprot)
2539 
      self._iprot.readMessageEnd()
2540 
      raise x
2541 
    result = batchOrders_result()
2542 
    result.read(self._iprot)
2543 
    self._iprot.readMessageEnd()
3431 rajveer 2544 
    if result.success is not None:
1220 chandransh 2545 
      return result.success
3431 rajveer 2546 
    if result.ex is not None:
1220 chandransh 2547 
      raise result.ex
2548 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2549 
 
1208 chandransh 2550 
  def markOrderAsOutOfStock(self, orderId):
2551 
    """
2552 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2553 
 
1208 chandransh 2554 
    Parameters:
2555 
     - orderId
2556 
    """
2557 
    self.send_markOrderAsOutOfStock(orderId)
2558 
    return self.recv_markOrderAsOutOfStock()
2559 
 
2560 
  def send_markOrderAsOutOfStock(self, orderId):
2561 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2562 
    args = markOrderAsOutOfStock_args()
2563 
    args.orderId = orderId
2564 
    args.write(self._oprot)
2565 
    self._oprot.writeMessageEnd()
2566 
    self._oprot.trans.flush()
2567 
 
2568 
  def recv_markOrderAsOutOfStock(self, ):
2569 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2570 
    if mtype == TMessageType.EXCEPTION:
2571 
      x = TApplicationException()
2572 
      x.read(self._iprot)
2573 
      self._iprot.readMessageEnd()
2574 
      raise x
2575 
    result = markOrderAsOutOfStock_result()
2576 
    result.read(self._iprot)
2577 
    self._iprot.readMessageEnd()
3431 rajveer 2578 
    if result.success is not None:
1208 chandransh 2579 
      return result.success
3431 rajveer 2580 
    if result.ex is not None:
1208 chandransh 2581 
      raise result.ex
2582 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2583 
 
3064 chandransh 2584 
  def verifyOrder(self, orderId):
759 chandransh 2585 
    """
3064 chandransh 2586 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2587 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2588 
    used for all other orders as well.
2589 
    Throws an exception if no such order exists.
3431 rajveer 2590 
 
759 chandransh 2591 
    Parameters:
3064 chandransh 2592 
     - orderId
759 chandransh 2593 
    """
3064 chandransh 2594 
    self.send_verifyOrder(orderId)
2595 
    return self.recv_verifyOrder()
759 chandransh 2596 
 
3064 chandransh 2597 
  def send_verifyOrder(self, orderId):
2598 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2599 
    args = verifyOrder_args()
2600 
    args.orderId = orderId
759 chandransh 2601 
    args.write(self._oprot)
2602 
    self._oprot.writeMessageEnd()
2603 
    self._oprot.trans.flush()
2604 
 
3064 chandransh 2605 
  def recv_verifyOrder(self, ):
759 chandransh 2606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2607 
    if mtype == TMessageType.EXCEPTION:
2608 
      x = TApplicationException()
2609 
      x.read(self._iprot)
2610 
      self._iprot.readMessageEnd()
2611 
      raise x
3064 chandransh 2612 
    result = verifyOrder_result()
759 chandransh 2613 
    result.read(self._iprot)
2614 
    self._iprot.readMessageEnd()
3431 rajveer 2615 
    if result.success is not None:
759 chandransh 2616 
      return result.success
3431 rajveer 2617 
    if result.ex is not None:
759 chandransh 2618 
      raise result.ex
3064 chandransh 2619 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2620 
 
3064 chandransh 2621 
  def acceptOrder(self, orderId):
1113 chandransh 2622 
    """
3064 chandransh 2623 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2624 
    given order is not a COD order, it also captures the payment if the same has
2625 
    not been captured.
2626 
    Throws an exception if no such order exists.
3431 rajveer 2627 
 
1113 chandransh 2628 
    Parameters:
3064 chandransh 2629 
     - orderId
1113 chandransh 2630 
    """
3064 chandransh 2631 
    self.send_acceptOrder(orderId)
2632 
    return self.recv_acceptOrder()
1113 chandransh 2633 
 
3064 chandransh 2634 
  def send_acceptOrder(self, orderId):
2635 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2636 
    args = acceptOrder_args()
2637 
    args.orderId = orderId
1113 chandransh 2638 
    args.write(self._oprot)
2639 
    self._oprot.writeMessageEnd()
2640 
    self._oprot.trans.flush()
2641 
 
3064 chandransh 2642 
  def recv_acceptOrder(self, ):
1113 chandransh 2643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2644 
    if mtype == TMessageType.EXCEPTION:
2645 
      x = TApplicationException()
2646 
      x.read(self._iprot)
2647 
      self._iprot.readMessageEnd()
2648 
      raise x
3064 chandransh 2649 
    result = acceptOrder_result()
1113 chandransh 2650 
    result.read(self._iprot)
2651 
    self._iprot.readMessageEnd()
3431 rajveer 2652 
    if result.success is not None:
1113 chandransh 2653 
      return result.success
3431 rajveer 2654 
    if result.ex is not None:
1113 chandransh 2655 
      raise result.ex
3064 chandransh 2656 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2657 
 
5110 mandeep.dh 2658 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2659 
    """
3064 chandransh 2660 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2661 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2662 
    the IMEI no. if a -1 is supplied.
2663 
    Also, it generates an invoice number for the order, marks the order as
2664 
    BILLED and sets the billing timestamp.
2665 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2666 
 
1135 chandransh 2667 
    Parameters:
3064 chandransh 2668 
     - orderId
2669 
     - invoice_number
4658 mandeep.dh 2670 
     - serialNumber
4283 anupam.sin 2671 
     - itemNumber
3064 chandransh 2672 
     - billed_by
4264 rajveer 2673 
     - jacketNumber
4283 anupam.sin 2674 
     - billingType
5110 mandeep.dh 2675 
     - fulfilmentWarehouseId
4763 rajveer 2676 
     - authorize
1135 chandransh 2677 
    """
5110 mandeep.dh 2678 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2679 
    return self.recv_addBillingDetails()
1135 chandransh 2680 
 
5110 mandeep.dh 2681 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2682 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2683 
    args = addBillingDetails_args()
2684 
    args.orderId = orderId
2685 
    args.invoice_number = invoice_number
4658 mandeep.dh 2686 
    args.serialNumber = serialNumber
4283 anupam.sin 2687 
    args.itemNumber = itemNumber
3064 chandransh 2688 
    args.billed_by = billed_by
4264 rajveer 2689 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2690 
    args.billingType = billingType
5110 mandeep.dh 2691 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2692 
    args.authorize = authorize
1135 chandransh 2693 
    args.write(self._oprot)
2694 
    self._oprot.writeMessageEnd()
2695 
    self._oprot.trans.flush()
2696 
 
3064 chandransh 2697 
  def recv_addBillingDetails(self, ):
1135 chandransh 2698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2699 
    if mtype == TMessageType.EXCEPTION:
2700 
      x = TApplicationException()
2701 
      x.read(self._iprot)
2702 
      self._iprot.readMessageEnd()
2703 
      raise x
3064 chandransh 2704 
    result = addBillingDetails_result()
1135 chandransh 2705 
    result.read(self._iprot)
2706 
    self._iprot.readMessageEnd()
3431 rajveer 2707 
    if result.success is not None:
3064 chandransh 2708 
      return result.success
3431 rajveer 2709 
    if result.ex is not None:
1135 chandransh 2710 
      raise result.ex
3064 chandransh 2711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2712 
 
6756 amar.kumar 2713 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2714 
    """
2715 
    Add the invoice number to the order.
2716 
 
2717 
    Parameters:
2718 
     - orderId
2719 
     - invoiceNumber
4763 rajveer 2720 
     - color
6756 amar.kumar 2721 
     - serialNumber
2722 
     - itemNumber
4579 rajveer 2723 
    """
6756 amar.kumar 2724 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color, serialNumber, itemNumber)
4579 rajveer 2725 
    self.recv_addInvoiceNumber()
2726 
 
6756 amar.kumar 2727 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2728 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2729 
    args = addInvoiceNumber_args()
2730 
    args.orderId = orderId
2731 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2732 
    args.color = color
6756 amar.kumar 2733 
    args.serialNumber = serialNumber
2734 
    args.itemNumber = itemNumber
4579 rajveer 2735 
    args.write(self._oprot)
2736 
    self._oprot.writeMessageEnd()
2737 
    self._oprot.trans.flush()
2738 
 
2739 
  def recv_addInvoiceNumber(self, ):
2740 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2741 
    if mtype == TMessageType.EXCEPTION:
2742 
      x = TApplicationException()
2743 
      x.read(self._iprot)
2744 
      self._iprot.readMessageEnd()
2745 
      raise x
2746 
    result = addInvoiceNumber_result()
2747 
    result.read(self._iprot)
2748 
    self._iprot.readMessageEnd()
2749 
    if result.ex is not None:
2750 
      raise result.ex
2751 
    return
2752 
 
4910 phani.kuma 2753 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2754 
    """
3064 chandransh 2755 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2756 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2757 
 
1408 ankur.sing 2758 
    Parameters:
3064 chandransh 2759 
     - warehouseId
1408 ankur.sing 2760 
     - providerId
3064 chandransh 2761 
     - cod
4910 phani.kuma 2762 
     - orderIds
1408 ankur.sing 2763 
    """
4910 phani.kuma 2764 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2765 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2766 
 
4910 phani.kuma 2767 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2768 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2769 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2770 
    args.warehouseId = warehouseId
1408 ankur.sing 2771 
    args.providerId = providerId
3064 chandransh 2772 
    args.cod = cod
4910 phani.kuma 2773 
    args.orderIds = orderIds
1408 ankur.sing 2774 
    args.write(self._oprot)
2775 
    self._oprot.writeMessageEnd()
2776 
    self._oprot.trans.flush()
2777 
 
4910 phani.kuma 2778 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2779 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2780 
    if mtype == TMessageType.EXCEPTION:
2781 
      x = TApplicationException()
2782 
      x.read(self._iprot)
2783 
      self._iprot.readMessageEnd()
2784 
      raise x
4910 phani.kuma 2785 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2786 
    result.read(self._iprot)
2787 
    self._iprot.readMessageEnd()
3431 rajveer 2788 
    if result.success is not None:
1408 ankur.sing 2789 
      return result.success
3431 rajveer 2790 
    if result.ex is not None:
3064 chandransh 2791 
      raise result.ex
4910 phani.kuma 2792 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2793 
 
5713 rajveer 2794 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2795 
    """
2796 
    Parameters:
2797 
     - providerId
2798 
     - orderIds
5713 rajveer 2799 
     - awbs
5676 rajveer 2800 
    """
5713 rajveer 2801 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2802 
    return self.recv_markOrdersAsReturnedFromStore()
2803 
 
5713 rajveer 2804 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2805 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2806 
    args = markOrdersAsReturnedFromStore_args()
2807 
    args.providerId = providerId
2808 
    args.orderIds = orderIds
5713 rajveer 2809 
    args.awbs = awbs
5676 rajveer 2810 
    args.write(self._oprot)
2811 
    self._oprot.writeMessageEnd()
2812 
    self._oprot.trans.flush()
2813 
 
2814 
  def recv_markOrdersAsReturnedFromStore(self, ):
2815 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2816 
    if mtype == TMessageType.EXCEPTION:
2817 
      x = TApplicationException()
2818 
      x.read(self._iprot)
2819 
      self._iprot.readMessageEnd()
2820 
      raise x
2821 
    result = markOrdersAsReturnedFromStore_result()
2822 
    result.read(self._iprot)
2823 
    self._iprot.readMessageEnd()
2824 
    if result.success is not None:
2825 
      return result.success
2826 
    if result.ex is not None:
2827 
      raise result.ex
2828 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2829 
 
4910 phani.kuma 2830 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2831 
    """
4910 phani.kuma 2832 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2833 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2834 
 
2835 
    Parameters:
2836 
     - providerId
4910 phani.kuma 2837 
     - pickupDetails
4410 rajveer 2838 
    """
4910 phani.kuma 2839 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2840 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2841 
 
4910 phani.kuma 2842 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2843 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2844 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2845 
    args.providerId = providerId
4910 phani.kuma 2846 
    args.pickupDetails = pickupDetails
4410 rajveer 2847 
    args.write(self._oprot)
2848 
    self._oprot.writeMessageEnd()
2849 
    self._oprot.trans.flush()
2850 
 
4910 phani.kuma 2851 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2852 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2853 
    if mtype == TMessageType.EXCEPTION:
2854 
      x = TApplicationException()
2855 
      x.read(self._iprot)
2856 
      self._iprot.readMessageEnd()
2857 
      raise x
4910 phani.kuma 2858 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2859 
    result.read(self._iprot)
2860 
    self._iprot.readMessageEnd()
2861 
    if result.ex is not None:
2862 
      raise result.ex
4910 phani.kuma 2863 
    return
4410 rajveer 2864 
 
4910 phani.kuma 2865 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2866 
    """
3064 chandransh 2867 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2868 
 
94 ashish 2869 
    Parameters:
3064 chandransh 2870 
     - providerId
304 ashish 2871 
    """
4910 phani.kuma 2872 
    self.send_getOrdersNotPickedUp(providerId)
2873 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2874 
 
4910 phani.kuma 2875 
  def send_getOrdersNotPickedUp(self, providerId):
2876 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2877 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2878 
    args.providerId = providerId
304 ashish 2879 
    args.write(self._oprot)
2880 
    self._oprot.writeMessageEnd()
2881 
    self._oprot.trans.flush()
2882 
 
4910 phani.kuma 2883 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2884 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2885 
    if mtype == TMessageType.EXCEPTION:
2886 
      x = TApplicationException()
2887 
      x.read(self._iprot)
2888 
      self._iprot.readMessageEnd()
2889 
      raise x
4910 phani.kuma 2890 
    result = getOrdersNotPickedUp_result()
304 ashish 2891 
    result.read(self._iprot)
2892 
    self._iprot.readMessageEnd()
3431 rajveer 2893 
    if result.success is not None:
304 ashish 2894 
      return result.success
4910 phani.kuma 2895 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2896 
 
3064 chandransh 2897 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2898 
    """
3064 chandransh 2899 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2900 
    the name of the receiver.
2901 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2902 
 
304 ashish 2903 
    Parameters:
3064 chandransh 2904 
     - providerId
2905 
     - deliveredOrders
304 ashish 2906 
    """
3064 chandransh 2907 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2908 
    self.recv_markOrdersAsDelivered()
304 ashish 2909 
 
3064 chandransh 2910 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2911 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2912 
    args = markOrdersAsDelivered_args()
2913 
    args.providerId = providerId
2914 
    args.deliveredOrders = deliveredOrders
304 ashish 2915 
    args.write(self._oprot)
2916 
    self._oprot.writeMessageEnd()
2917 
    self._oprot.trans.flush()
2918 
 
3064 chandransh 2919 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2921 
    if mtype == TMessageType.EXCEPTION:
2922 
      x = TApplicationException()
2923 
      x.read(self._iprot)
2924 
      self._iprot.readMessageEnd()
2925 
      raise x
3064 chandransh 2926 
    result = markOrdersAsDelivered_result()
304 ashish 2927 
    result.read(self._iprot)
2928 
    self._iprot.readMessageEnd()
3431 rajveer 2929 
    if result.ex is not None:
3064 chandransh 2930 
      raise result.ex
304 ashish 2931 
    return
2932 
 
4910 phani.kuma 2933 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2934 
    """
4910 phani.kuma 2935 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2936 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2937 
 
3064 chandransh 2938 
    Parameters:
2939 
     - providerId
2940 
     - returnedOrders
1596 ankur.sing 2941 
    """
4910 phani.kuma 2942 
    self.send_markAsRTOrders(providerId, returnedOrders)
2943 
    self.recv_markAsRTOrders()
304 ashish 2944 
 
4910 phani.kuma 2945 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2946 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2947 
    args = markAsRTOrders_args()
3064 chandransh 2948 
    args.providerId = providerId
2949 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2950 
    args.write(self._oprot)
2951 
    self._oprot.writeMessageEnd()
2952 
    self._oprot.trans.flush()
2953 
 
4910 phani.kuma 2954 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2956 
    if mtype == TMessageType.EXCEPTION:
2957 
      x = TApplicationException()
2958 
      x.read(self._iprot)
2959 
      self._iprot.readMessageEnd()
2960 
      raise x
4910 phani.kuma 2961 
    result = markAsRTOrders_result()
1596 ankur.sing 2962 
    result.read(self._iprot)
2963 
    self._iprot.readMessageEnd()
3431 rajveer 2964 
    if result.ex is not None:
3064 chandransh 2965 
      raise result.ex
2966 
    return
1596 ankur.sing 2967 
 
4910 phani.kuma 2968 
  def getRTOrders(self, providerId):
2969 
    """
2970 
    Returns a list of orders that were returned by courier.
2971 
 
2972 
    Parameters:
2973 
     - providerId
2974 
    """
2975 
    self.send_getRTOrders(providerId)
2976 
    return self.recv_getRTOrders()
2977 
 
2978 
  def send_getRTOrders(self, providerId):
2979 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2980 
    args = getRTOrders_args()
2981 
    args.providerId = providerId
2982 
    args.write(self._oprot)
2983 
    self._oprot.writeMessageEnd()
2984 
    self._oprot.trans.flush()
2985 
 
2986 
  def recv_getRTOrders(self, ):
2987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2988 
    if mtype == TMessageType.EXCEPTION:
2989 
      x = TApplicationException()
2990 
      x.read(self._iprot)
2991 
      self._iprot.readMessageEnd()
2992 
      raise x
2993 
    result = getRTOrders_result()
2994 
    result.read(self._iprot)
2995 
    self._iprot.readMessageEnd()
2996 
    if result.success is not None:
2997 
      return result.success
2998 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2999 
 
3064 chandransh 3000 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 3001 
    """
3064 chandransh 3002 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 3003 
 
3064 chandransh 3004 
    Parameters:
3005 
     - providerId
3006 
     - undeliveredOrders
1627 ankur.sing 3007 
    """
3064 chandransh 3008 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 3009 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 3010 
 
3064 chandransh 3011 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
3012 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
3013 
    args = updateNonDeliveryReason_args()
3014 
    args.providerId = providerId
3015 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 3016 
    args.write(self._oprot)
3017 
    self._oprot.writeMessageEnd()
3018 
    self._oprot.trans.flush()
3019 
 
3064 chandransh 3020 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 3021 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3022 
    if mtype == TMessageType.EXCEPTION:
3023 
      x = TApplicationException()
3024 
      x.read(self._iprot)
3025 
      self._iprot.readMessageEnd()
3026 
      raise x
3064 chandransh 3027 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 3028 
    result.read(self._iprot)
3029 
    self._iprot.readMessageEnd()
4910 phani.kuma 3030 
    if result.ex is not None:
3031 
      raise result.ex
3032 
    return
3033 
 
3034 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3035 
    """
3036 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3037 
 
3038 
    Parameters:
3039 
     - providerId
3040 
    """
3041 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3042 
    return self.recv_getNonDeliveredOrdersbyCourier()
3043 
 
3044 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3045 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3046 
    args = getNonDeliveredOrdersbyCourier_args()
3047 
    args.providerId = providerId
3048 
    args.write(self._oprot)
3049 
    self._oprot.writeMessageEnd()
3050 
    self._oprot.trans.flush()
3051 
 
3052 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3053 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3054 
    if mtype == TMessageType.EXCEPTION:
3055 
      x = TApplicationException()
3056 
      x.read(self._iprot)
3057 
      self._iprot.readMessageEnd()
3058 
      raise x
3059 
    result = getNonDeliveredOrdersbyCourier_result()
3060 
    result.read(self._iprot)
3061 
    self._iprot.readMessageEnd()
4581 phani.kuma 3062 
    if result.success is not None:
3063 
      return result.success
4910 phani.kuma 3064 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3065 
 
3066 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3067 
    """
3068 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3069 
 
3070 
    Parameters:
3071 
     - providerId
3072 
     - local_connected_orders
3073 
    """
3074 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3075 
    self.recv_markOrdersAsLocalConnected()
3076 
 
3077 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3078 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3079 
    args = markOrdersAsLocalConnected_args()
3080 
    args.providerId = providerId
3081 
    args.local_connected_orders = local_connected_orders
3082 
    args.write(self._oprot)
3083 
    self._oprot.writeMessageEnd()
3084 
    self._oprot.trans.flush()
3085 
 
3086 
  def recv_markOrdersAsLocalConnected(self, ):
3087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3088 
    if mtype == TMessageType.EXCEPTION:
3089 
      x = TApplicationException()
3090 
      x.read(self._iprot)
3091 
      self._iprot.readMessageEnd()
3092 
      raise x
3093 
    result = markOrdersAsLocalConnected_result()
3094 
    result.read(self._iprot)
3095 
    self._iprot.readMessageEnd()
3431 rajveer 3096 
    if result.ex is not None:
3064 chandransh 3097 
      raise result.ex
4910 phani.kuma 3098 
    return
1627 ankur.sing 3099 
 
4910 phani.kuma 3100 
  def getOrdersNotLocalConnected(self, providerId):
3101 
    """
3102 
    Returns a list of orders that were picked up or shipped but pending local connection.
3103 
 
3104 
    Parameters:
3105 
     - providerId
3106 
    """
3107 
    self.send_getOrdersNotLocalConnected(providerId)
3108 
    return self.recv_getOrdersNotLocalConnected()
3109 
 
3110 
  def send_getOrdersNotLocalConnected(self, providerId):
3111 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3112 
    args = getOrdersNotLocalConnected_args()
3113 
    args.providerId = providerId
3114 
    args.write(self._oprot)
3115 
    self._oprot.writeMessageEnd()
3116 
    self._oprot.trans.flush()
3117 
 
3118 
  def recv_getOrdersNotLocalConnected(self, ):
3119 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3120 
    if mtype == TMessageType.EXCEPTION:
3121 
      x = TApplicationException()
3122 
      x.read(self._iprot)
3123 
      self._iprot.readMessageEnd()
3124 
      raise x
3125 
    result = getOrdersNotLocalConnected_result()
3126 
    result.read(self._iprot)
3127 
    self._iprot.readMessageEnd()
3128 
    if result.success is not None:
3129 
      return result.success
3130 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3131 
 
3132 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3133 
    """
3134 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3135 
 
3136 
    Parameters:
3137 
     - providerId
3138 
     - destination_city_reached_orders
3139 
    """
3140 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3141 
    self.recv_markOrdersAsDestinationCityReached()
3142 
 
3143 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3144 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3145 
    args = markOrdersAsDestinationCityReached_args()
3146 
    args.providerId = providerId
3147 
    args.destination_city_reached_orders = destination_city_reached_orders
3148 
    args.write(self._oprot)
3149 
    self._oprot.writeMessageEnd()
3150 
    self._oprot.trans.flush()
3151 
 
3152 
  def recv_markOrdersAsDestinationCityReached(self, ):
3153 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3154 
    if mtype == TMessageType.EXCEPTION:
3155 
      x = TApplicationException()
3156 
      x.read(self._iprot)
3157 
      self._iprot.readMessageEnd()
3158 
      raise x
3159 
    result = markOrdersAsDestinationCityReached_result()
3160 
    result.read(self._iprot)
3161 
    self._iprot.readMessageEnd()
3162 
    if result.ex is not None:
3163 
      raise result.ex
3164 
    return
3165 
 
3166 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3167 
    """
3168 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3169 
 
3170 
    Parameters:
3171 
     - providerId
3172 
     - first_atdl_orders
3173 
    """
3174 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3175 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3176 
 
3177 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3178 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3179 
    args = markOrdersAsFirstDeliveryAttempted_args()
3180 
    args.providerId = providerId
3181 
    args.first_atdl_orders = first_atdl_orders
3182 
    args.write(self._oprot)
3183 
    self._oprot.writeMessageEnd()
3184 
    self._oprot.trans.flush()
3185 
 
3186 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3187 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3188 
    if mtype == TMessageType.EXCEPTION:
3189 
      x = TApplicationException()
3190 
      x.read(self._iprot)
3191 
      self._iprot.readMessageEnd()
3192 
      raise x
3193 
    result = markOrdersAsFirstDeliveryAttempted_result()
3194 
    result.read(self._iprot)
3195 
    self._iprot.readMessageEnd()
3196 
    if result.ex is not None:
3197 
      raise result.ex
3198 
    return
3199 
 
3064 chandransh 3200 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3201 
    """
3064 chandransh 3202 
    Returns the list of orders whose delivery time has passed but have not been
3203 
    delivered yet for the given provider and warehouse. To get a complete list of
3204 
    undelivered orders, pass them as -1.
3205 
    Returns an empty list if no such orders exist.
3431 rajveer 3206 
 
1886 ankur.sing 3207 
    Parameters:
3064 chandransh 3208 
     - providerId
3209 
     - warehouseId
1886 ankur.sing 3210 
    """
3064 chandransh 3211 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3212 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3213 
 
3064 chandransh 3214 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3215 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3216 
    args = getUndeliveredOrders_args()
3217 
    args.providerId = providerId
3218 
    args.warehouseId = warehouseId
1886 ankur.sing 3219 
    args.write(self._oprot)
3220 
    self._oprot.writeMessageEnd()
3221 
    self._oprot.trans.flush()
3222 
 
3064 chandransh 3223 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3225 
    if mtype == TMessageType.EXCEPTION:
3226 
      x = TApplicationException()
3227 
      x.read(self._iprot)
3228 
      self._iprot.readMessageEnd()
3229 
      raise x
3064 chandransh 3230 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3231 
    result.read(self._iprot)
3232 
    self._iprot.readMessageEnd()
3431 rajveer 3233 
    if result.success is not None:
1886 ankur.sing 3234 
      return result.success
3064 chandransh 3235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3236 
 
4783 phani.kuma 3237 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3238 
    """
3239 
    Returns the list of orders whose expected delivery date has passed but have not been
3240 
    delivered yet.
3241 
    Returns an empty list if no such orders exist.
3242 
    """
3243 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3244 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3245 
 
3246 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3247 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3248 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3249 
    args.write(self._oprot)
3250 
    self._oprot.writeMessageEnd()
3251 
    self._oprot.trans.flush()
3252 
 
3253 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3254 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3255 
    if mtype == TMessageType.EXCEPTION:
3256 
      x = TApplicationException()
3257 
      x.read(self._iprot)
3258 
      self._iprot.readMessageEnd()
3259 
      raise x
3260 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3261 
    result.read(self._iprot)
3262 
    self._iprot.readMessageEnd()
3263 
    if result.success is not None:
3264 
      return result.success
3265 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3266 
 
2536 chandransh 3267 
  def toggleDOAFlag(self, orderId):
3268 
    """
3269 
    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.
3270 
    Returns the final flag status.
3271 
    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 3272 
 
2536 chandransh 3273 
    Parameters:
3274 
     - orderId
3275 
    """
3276 
    self.send_toggleDOAFlag(orderId)
3277 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3278 
 
2536 chandransh 3279 
  def send_toggleDOAFlag(self, orderId):
3280 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3281 
    args = toggleDOAFlag_args()
3282 
    args.orderId = orderId
3283 
    args.write(self._oprot)
3284 
    self._oprot.writeMessageEnd()
3285 
    self._oprot.trans.flush()
3286 
 
3287 
  def recv_toggleDOAFlag(self, ):
3288 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3289 
    if mtype == TMessageType.EXCEPTION:
3290 
      x = TApplicationException()
3291 
      x.read(self._iprot)
3292 
      self._iprot.readMessageEnd()
3293 
      raise x
3294 
    result = toggleDOAFlag_result()
3295 
    result.read(self._iprot)
3296 
    self._iprot.readMessageEnd()
3431 rajveer 3297 
    if result.success is not None:
2536 chandransh 3298 
      return result.success
3431 rajveer 3299 
    if result.ex is not None:
2536 chandransh 3300 
      raise result.ex
3301 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3302 
 
4712 rajveer 3303 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3304 
    """
3305 
    Parameters:
3306 
     - orderId
3307 
     - deliveryTimestamp
3308 
     - receiver
3309 
    """
3310 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3311 
    self.recv_markOrderAsDelivered()
3312 
 
3313 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3314 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3315 
    args = markOrderAsDelivered_args()
3316 
    args.orderId = orderId
3317 
    args.deliveryTimestamp = deliveryTimestamp
3318 
    args.receiver = receiver
3319 
    args.write(self._oprot)
3320 
    self._oprot.writeMessageEnd()
3321 
    self._oprot.trans.flush()
3322 
 
3323 
  def recv_markOrderAsDelivered(self, ):
3324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3325 
    if mtype == TMessageType.EXCEPTION:
3326 
      x = TApplicationException()
3327 
      x.read(self._iprot)
3328 
      self._iprot.readMessageEnd()
3329 
      raise x
3330 
    result = markOrderAsDelivered_result()
3331 
    result.read(self._iprot)
3332 
    self._iprot.readMessageEnd()
3333 
    if result.ex is not None:
3334 
      raise result.ex
3335 
    return
3336 
 
5553 rajveer 3337 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3338 
    """
3339 
    Parameters:
3340 
     - orderId
3341 
     - deliveryTimestamp
3342 
    """
3343 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3344 
    self.recv_markOrderAsReceivedAtStore()
3345 
 
3346 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3347 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3348 
    args = markOrderAsReceivedAtStore_args()
3349 
    args.orderId = orderId
3350 
    args.deliveryTimestamp = deliveryTimestamp
3351 
    args.write(self._oprot)
3352 
    self._oprot.writeMessageEnd()
3353 
    self._oprot.trans.flush()
3354 
 
3355 
  def recv_markOrderAsReceivedAtStore(self, ):
3356 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3357 
    if mtype == TMessageType.EXCEPTION:
3358 
      x = TApplicationException()
3359 
      x.read(self._iprot)
3360 
      self._iprot.readMessageEnd()
3361 
      raise x
3362 
    result = markOrderAsReceivedAtStore_result()
3363 
    result.read(self._iprot)
3364 
    self._iprot.readMessageEnd()
3365 
    if result.ex is not None:
3366 
      raise result.ex
3367 
    return
3368 
 
4454 rajveer 3369 
  def markOrderDoaRequestReceived(self, orderId):
3370 
    """
3371 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3372 
 
3373 
    Parameters:
3374 
     - orderId
3375 
    """
3376 
    self.send_markOrderDoaRequestReceived(orderId)
3377 
    return self.recv_markOrderDoaRequestReceived()
3378 
 
3379 
  def send_markOrderDoaRequestReceived(self, orderId):
3380 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3381 
    args = markOrderDoaRequestReceived_args()
3382 
    args.orderId = orderId
3383 
    args.write(self._oprot)
3384 
    self._oprot.writeMessageEnd()
3385 
    self._oprot.trans.flush()
3386 
 
3387 
  def recv_markOrderDoaRequestReceived(self, ):
3388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3389 
    if mtype == TMessageType.EXCEPTION:
3390 
      x = TApplicationException()
3391 
      x.read(self._iprot)
3392 
      self._iprot.readMessageEnd()
3393 
      raise x
3394 
    result = markOrderDoaRequestReceived_result()
3395 
    result.read(self._iprot)
3396 
    self._iprot.readMessageEnd()
3397 
    if result.success is not None:
3398 
      return result.success
3399 
    if result.ex is not None:
3400 
      raise result.ex
3401 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3402 
 
3403 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3404 
    """
3405 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3406 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3407 
 
3408 
    Parameters:
3409 
     - orderId
3410 
     - isAuthorized
3411 
    """
3412 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3413 
    return self.recv_markOrderDoaRequestAuthorized()
3414 
 
3415 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3416 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3417 
    args = markOrderDoaRequestAuthorized_args()
3418 
    args.orderId = orderId
3419 
    args.isAuthorized = isAuthorized
3420 
    args.write(self._oprot)
3421 
    self._oprot.writeMessageEnd()
3422 
    self._oprot.trans.flush()
3423 
 
3424 
  def recv_markOrderDoaRequestAuthorized(self, ):
3425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3426 
    if mtype == TMessageType.EXCEPTION:
3427 
      x = TApplicationException()
3428 
      x.read(self._iprot)
3429 
      self._iprot.readMessageEnd()
3430 
      raise x
3431 
    result = markOrderDoaRequestAuthorized_result()
3432 
    result.read(self._iprot)
3433 
    self._iprot.readMessageEnd()
3434 
    if result.success is not None:
3435 
      return result.success
3436 
    if result.ex is not None:
3437 
      raise result.ex
3438 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3439 
 
4488 rajveer 3440 
  def markOrderReturnRequestReceived(self, orderId):
3441 
    """
3442 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3443 
 
3444 
    Parameters:
3445 
     - orderId
3446 
    """
3447 
    self.send_markOrderReturnRequestReceived(orderId)
3448 
    return self.recv_markOrderReturnRequestReceived()
3449 
 
3450 
  def send_markOrderReturnRequestReceived(self, orderId):
3451 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3452 
    args = markOrderReturnRequestReceived_args()
3453 
    args.orderId = orderId
3454 
    args.write(self._oprot)
3455 
    self._oprot.writeMessageEnd()
3456 
    self._oprot.trans.flush()
3457 
 
3458 
  def recv_markOrderReturnRequestReceived(self, ):
3459 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3460 
    if mtype == TMessageType.EXCEPTION:
3461 
      x = TApplicationException()
3462 
      x.read(self._iprot)
3463 
      self._iprot.readMessageEnd()
3464 
      raise x
3465 
    result = markOrderReturnRequestReceived_result()
3466 
    result.read(self._iprot)
3467 
    self._iprot.readMessageEnd()
3468 
    if result.success is not None:
3469 
      return result.success
3470 
    if result.ex is not None:
3471 
      raise result.ex
3472 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3473 
 
3474 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3475 
    """
3476 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3477 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3478 
 
3479 
    Parameters:
3480 
     - orderId
3481 
     - isAuthorized
3482 
    """
3483 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3484 
    return self.recv_markOrderReturnRequestAuthorized()
3485 
 
3486 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3487 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3488 
    args = markOrderReturnRequestAuthorized_args()
3489 
    args.orderId = orderId
3490 
    args.isAuthorized = isAuthorized
3491 
    args.write(self._oprot)
3492 
    self._oprot.writeMessageEnd()
3493 
    self._oprot.trans.flush()
3494 
 
3495 
  def recv_markOrderReturnRequestAuthorized(self, ):
3496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3497 
    if mtype == TMessageType.EXCEPTION:
3498 
      x = TApplicationException()
3499 
      x.read(self._iprot)
3500 
      self._iprot.readMessageEnd()
3501 
      raise x
3502 
    result = markOrderReturnRequestAuthorized_result()
3503 
    result.read(self._iprot)
3504 
    self._iprot.readMessageEnd()
3505 
    if result.success is not None:
3506 
      return result.success
3507 
    if result.ex is not None:
3508 
      raise result.ex
3509 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3510 
 
4579 rajveer 3511 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3512 
    """
3513 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3514 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3515 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3516 
    For any other status, it returns false.
3517 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3518 
 
2536 chandransh 3519 
    Parameters:
3520 
     - orderId
4579 rajveer 3521 
     - providerId
2536 chandransh 3522 
    """
4579 rajveer 3523 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3524 
    return self.recv_requestPickupNumber()
3525 
 
4579 rajveer 3526 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3527 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3528 
    args = requestPickupNumber_args()
3529 
    args.orderId = orderId
4579 rajveer 3530 
    args.providerId = providerId
2536 chandransh 3531 
    args.write(self._oprot)
3532 
    self._oprot.writeMessageEnd()
3533 
    self._oprot.trans.flush()
3534 
 
3535 
  def recv_requestPickupNumber(self, ):
3536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3537 
    if mtype == TMessageType.EXCEPTION:
3538 
      x = TApplicationException()
3539 
      x.read(self._iprot)
3540 
      self._iprot.readMessageEnd()
3541 
      raise x
3542 
    result = requestPickupNumber_result()
3543 
    result.read(self._iprot)
3544 
    self._iprot.readMessageEnd()
3431 rajveer 3545 
    if result.success is not None:
2536 chandransh 3546 
      return result.success
3431 rajveer 3547 
    if result.ex is not None:
2536 chandransh 3548 
      raise result.ex
3549 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3550 
 
4602 rajveer 3551 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3552 
    """
4452 rajveer 3553 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3554 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3555 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3556 
    	3. Returns true
2591 chandransh 3557 
    If the order is in any other status, it returns false.
2536 chandransh 3558 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3559 
 
2536 chandransh 3560 
    Parameters:
3561 
     - orderId
3562 
     - pickupNumber
4602 rajveer 3563 
     - providerId
2536 chandransh 3564 
    """
4602 rajveer 3565 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3566 
    return self.recv_authorizePickup()
3567 
 
4602 rajveer 3568 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3569 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3570 
    args = authorizePickup_args()
3571 
    args.orderId = orderId
3572 
    args.pickupNumber = pickupNumber
4602 rajveer 3573 
    args.providerId = providerId
2536 chandransh 3574 
    args.write(self._oprot)
3575 
    self._oprot.writeMessageEnd()
3576 
    self._oprot.trans.flush()
3577 
 
3578 
  def recv_authorizePickup(self, ):
3579 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3580 
    if mtype == TMessageType.EXCEPTION:
3581 
      x = TApplicationException()
3582 
      x.read(self._iprot)
3583 
      self._iprot.readMessageEnd()
3584 
      raise x
3585 
    result = authorizePickup_result()
3586 
    result.read(self._iprot)
3587 
    self._iprot.readMessageEnd()
3431 rajveer 3588 
    if result.success is not None:
2536 chandransh 3589 
      return result.success
3431 rajveer 3590 
    if result.ex is not None:
2536 chandransh 3591 
      raise result.ex
3592 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3593 
 
2764 chandransh 3594 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3595 
    """
3596 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3597 
 
2764 chandransh 3598 
    Parameters:
3599 
     - providerId
3600 
     - pickupDetails
3601 
    """
3602 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3603 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3604 
 
3605 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3606 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3607 
    args = markDoasAsPickedUp_args()
3608 
    args.providerId = providerId
3609 
    args.pickupDetails = pickupDetails
3610 
    args.write(self._oprot)
3611 
    self._oprot.writeMessageEnd()
3612 
    self._oprot.trans.flush()
3613 
 
3614 
  def recv_markDoasAsPickedUp(self, ):
3615 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3616 
    if mtype == TMessageType.EXCEPTION:
3617 
      x = TApplicationException()
3618 
      x.read(self._iprot)
3619 
      self._iprot.readMessageEnd()
3620 
      raise x
3621 
    result = markDoasAsPickedUp_result()
3622 
    result.read(self._iprot)
3623 
    self._iprot.readMessageEnd()
4910 phani.kuma 3624 
    return
3625 
 
3626 
  def getDoasNotPickedUp(self, providerId):
3627 
    """
3628 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3629 
 
3630 
    Parameters:
3631 
     - providerId
3632 
    """
3633 
    self.send_getDoasNotPickedUp(providerId)
3634 
    return self.recv_getDoasNotPickedUp()
3635 
 
3636 
  def send_getDoasNotPickedUp(self, providerId):
3637 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3638 
    args = getDoasNotPickedUp_args()
3639 
    args.providerId = providerId
3640 
    args.write(self._oprot)
3641 
    self._oprot.writeMessageEnd()
3642 
    self._oprot.trans.flush()
3643 
 
3644 
  def recv_getDoasNotPickedUp(self, ):
3645 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3646 
    if mtype == TMessageType.EXCEPTION:
3647 
      x = TApplicationException()
3648 
      x.read(self._iprot)
3649 
      self._iprot.readMessageEnd()
3650 
      raise x
3651 
    result = getDoasNotPickedUp_result()
3652 
    result.read(self._iprot)
3653 
    self._iprot.readMessageEnd()
3431 rajveer 3654 
    if result.success is not None:
2764 chandransh 3655 
      return result.success
4910 phani.kuma 3656 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3657 
 
4741 phani.kuma 3658 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3659 
    """
3660 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3661 
 
3662 
    Parameters:
3663 
     - providerId
3664 
     - pickupDetails
3665 
    """
3666 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3667 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3668 
 
3669 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3670 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3671 
    args = markReturnOrdersAsPickedUp_args()
3672 
    args.providerId = providerId
3673 
    args.pickupDetails = pickupDetails
3674 
    args.write(self._oprot)
3675 
    self._oprot.writeMessageEnd()
3676 
    self._oprot.trans.flush()
3677 
 
3678 
  def recv_markReturnOrdersAsPickedUp(self, ):
3679 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3680 
    if mtype == TMessageType.EXCEPTION:
3681 
      x = TApplicationException()
3682 
      x.read(self._iprot)
3683 
      self._iprot.readMessageEnd()
3684 
      raise x
3685 
    result = markReturnOrdersAsPickedUp_result()
3686 
    result.read(self._iprot)
3687 
    self._iprot.readMessageEnd()
4910 phani.kuma 3688 
    return
3689 
 
3690 
  def getReturnOrdersNotPickedUp(self, providerId):
3691 
    """
3692 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3693 
 
3694 
    Parameters:
3695 
     - providerId
3696 
    """
3697 
    self.send_getReturnOrdersNotPickedUp(providerId)
3698 
    return self.recv_getReturnOrdersNotPickedUp()
3699 
 
3700 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3701 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3702 
    args = getReturnOrdersNotPickedUp_args()
3703 
    args.providerId = providerId
3704 
    args.write(self._oprot)
3705 
    self._oprot.writeMessageEnd()
3706 
    self._oprot.trans.flush()
3707 
 
3708 
  def recv_getReturnOrdersNotPickedUp(self, ):
3709 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3710 
    if mtype == TMessageType.EXCEPTION:
3711 
      x = TApplicationException()
3712 
      x.read(self._iprot)
3713 
      self._iprot.readMessageEnd()
3714 
      raise x
3715 
    result = getReturnOrdersNotPickedUp_result()
3716 
    result.read(self._iprot)
3717 
    self._iprot.readMessageEnd()
4741 phani.kuma 3718 
    if result.success is not None:
3719 
      return result.success
4910 phani.kuma 3720 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3721 
 
4479 rajveer 3722 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3723 
    """
4452 rajveer 3724 
    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 3725 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3726 
    If the order is in any other state, it returns false.
3727 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3728 
 
2591 chandransh 3729 
    Parameters:
3730 
     - orderId
4479 rajveer 3731 
     - receiveCondition
2591 chandransh 3732 
    """
4479 rajveer 3733 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3734 
    return self.recv_receiveReturn()
2536 chandransh 3735 
 
4479 rajveer 3736 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3737 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3738 
    args = receiveReturn_args()
2591 chandransh 3739 
    args.orderId = orderId
4479 rajveer 3740 
    args.receiveCondition = receiveCondition
2591 chandransh 3741 
    args.write(self._oprot)
3742 
    self._oprot.writeMessageEnd()
3743 
    self._oprot.trans.flush()
3744 
 
2616 chandransh 3745 
  def recv_receiveReturn(self, ):
2591 chandransh 3746 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3747 
    if mtype == TMessageType.EXCEPTION:
3748 
      x = TApplicationException()
3749 
      x.read(self._iprot)
3750 
      self._iprot.readMessageEnd()
3751 
      raise x
2616 chandransh 3752 
    result = receiveReturn_result()
2591 chandransh 3753 
    result.read(self._iprot)
3754 
    self._iprot.readMessageEnd()
3431 rajveer 3755 
    if result.success is not None:
2591 chandransh 3756 
      return result.success
3431 rajveer 3757 
    if result.ex is not None:
2591 chandransh 3758 
      raise result.ex
2616 chandransh 3759 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3760 
 
3761 
  def validateDoa(self, orderId, isValid):
3762 
    """
4452 rajveer 3763 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3764 
    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 3765 
    If the order is in any other state, it returns false.
3766 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3767 
 
2591 chandransh 3768 
    Parameters:
3769 
     - orderId
3770 
     - isValid
3771 
    """
3772 
    self.send_validateDoa(orderId, isValid)
3773 
    return self.recv_validateDoa()
3774 
 
3775 
  def send_validateDoa(self, orderId, isValid):
3776 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3777 
    args = validateDoa_args()
3778 
    args.orderId = orderId
3779 
    args.isValid = isValid
3780 
    args.write(self._oprot)
3781 
    self._oprot.writeMessageEnd()
3782 
    self._oprot.trans.flush()
3783 
 
3784 
  def recv_validateDoa(self, ):
3785 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3786 
    if mtype == TMessageType.EXCEPTION:
3787 
      x = TApplicationException()
3788 
      x.read(self._iprot)
3789 
      self._iprot.readMessageEnd()
3790 
      raise x
3791 
    result = validateDoa_result()
3792 
    result.read(self._iprot)
3793 
    self._iprot.readMessageEnd()
3431 rajveer 3794 
    if result.success is not None:
2591 chandransh 3795 
      return result.success
3431 rajveer 3796 
    if result.ex is not None:
2591 chandransh 3797 
      raise result.ex
3798 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3799 
 
4495 rajveer 3800 
  def validateReturnProduct(self, orderId, isUsable):
3801 
    """
3802 
    Parameters:
3803 
     - orderId
3804 
     - isUsable
3805 
    """
3806 
    self.send_validateReturnProduct(orderId, isUsable)
3807 
    return self.recv_validateReturnProduct()
3808 
 
3809 
  def send_validateReturnProduct(self, orderId, isUsable):
3810 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3811 
    args = validateReturnProduct_args()
3812 
    args.orderId = orderId
3813 
    args.isUsable = isUsable
3814 
    args.write(self._oprot)
3815 
    self._oprot.writeMessageEnd()
3816 
    self._oprot.trans.flush()
3817 
 
3818 
  def recv_validateReturnProduct(self, ):
3819 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3820 
    if mtype == TMessageType.EXCEPTION:
3821 
      x = TApplicationException()
3822 
      x.read(self._iprot)
3823 
      self._iprot.readMessageEnd()
3824 
      raise x
3825 
    result = validateReturnProduct_result()
3826 
    result.read(self._iprot)
3827 
    self._iprot.readMessageEnd()
3828 
    if result.success is not None:
3829 
      return result.success
3830 
    if result.ex is not None:
3831 
      raise result.ex
3832 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3833 
 
2616 chandransh 3834 
  def reshipOrder(self, orderId):
3835 
    """
4484 rajveer 3836 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3837 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3838 
    	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 3839 
 
3840 
    If the order is in DOA_CERT_VALID state, it does the following:
3841 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3842 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3843 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3844 
 
2616 chandransh 3845 
    Returns the id of the newly created order.
3431 rajveer 3846 
 
2616 chandransh 3847 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3848 
 
2616 chandransh 3849 
    Parameters:
3850 
     - orderId
3851 
    """
3852 
    self.send_reshipOrder(orderId)
3853 
    return self.recv_reshipOrder()
2591 chandransh 3854 
 
2616 chandransh 3855 
  def send_reshipOrder(self, orderId):
3856 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3857 
    args = reshipOrder_args()
3858 
    args.orderId = orderId
3859 
    args.write(self._oprot)
3860 
    self._oprot.writeMessageEnd()
3861 
    self._oprot.trans.flush()
3862 
 
3863 
  def recv_reshipOrder(self, ):
3864 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3865 
    if mtype == TMessageType.EXCEPTION:
3866 
      x = TApplicationException()
3867 
      x.read(self._iprot)
3868 
      self._iprot.readMessageEnd()
3869 
      raise x
3870 
    result = reshipOrder_result()
3871 
    result.read(self._iprot)
3872 
    self._iprot.readMessageEnd()
3431 rajveer 3873 
    if result.success is not None:
2616 chandransh 3874 
      return result.success
3431 rajveer 3875 
    if result.ex is not None:
2616 chandransh 3876 
      raise result.ex
3877 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3878 
 
3226 chandransh 3879 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3880 
    """
4484 rajveer 3881 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3882 
    	1. Creates a refund request for batch processing.
3883 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3884 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3885 
 
2616 chandransh 3886 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3887 
    	1. Creates a refund request for batch processing.
3226 chandransh 3888 
    	2. Cancels the reservation of the item in the warehouse.
3889 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3890 
 
3226 chandransh 3891 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3892 
    	1. Cancels the reservation of the item in the warehouse.
3893 
    	2. Marks the current order as CANCELED.
3894 
 
3895 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3896 
 
2616 chandransh 3897 
    Returns True if it is successful, False otherwise.
3431 rajveer 3898 
 
2616 chandransh 3899 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3900 
 
2616 chandransh 3901 
    Parameters:
3902 
     - orderId
3226 chandransh 3903 
     - refundedBy
3904 
     - reason
2616 chandransh 3905 
    """
3226 chandransh 3906 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3907 
    return self.recv_refundOrder()
3908 
 
3226 chandransh 3909 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3910 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3911 
    args = refundOrder_args()
3912 
    args.orderId = orderId
3226 chandransh 3913 
    args.refundedBy = refundedBy
3914 
    args.reason = reason
2616 chandransh 3915 
    args.write(self._oprot)
3916 
    self._oprot.writeMessageEnd()
3917 
    self._oprot.trans.flush()
3918 
 
3919 
  def recv_refundOrder(self, ):
3920 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3921 
    if mtype == TMessageType.EXCEPTION:
3922 
      x = TApplicationException()
3923 
      x.read(self._iprot)
3924 
      self._iprot.readMessageEnd()
3925 
      raise x
3926 
    result = refundOrder_result()
3927 
    result.read(self._iprot)
3928 
    self._iprot.readMessageEnd()
3431 rajveer 3929 
    if result.success is not None:
2616 chandransh 3930 
      return result.success
3431 rajveer 3931 
    if result.ex is not None:
2616 chandransh 3932 
      raise result.ex
3933 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3934 
 
2690 chandransh 3935 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3936 
    """
3937 
    Get all return orders created between the from and to dates for the given warehouse.
3938 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3939 
 
2690 chandransh 3940 
    Parameters:
3941 
     - warehouseId
3942 
     - fromDate
3943 
     - toDate
3944 
    """
3945 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3946 
    return self.recv_getReturnOrders()
2616 chandransh 3947 
 
2690 chandransh 3948 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3949 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3950 
    args = getReturnOrders_args()
3951 
    args.warehouseId = warehouseId
3952 
    args.fromDate = fromDate
3953 
    args.toDate = toDate
3954 
    args.write(self._oprot)
3955 
    self._oprot.writeMessageEnd()
3956 
    self._oprot.trans.flush()
3957 
 
3958 
  def recv_getReturnOrders(self, ):
3959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3960 
    if mtype == TMessageType.EXCEPTION:
3961 
      x = TApplicationException()
3962 
      x.read(self._iprot)
3963 
      self._iprot.readMessageEnd()
3964 
      raise x
3965 
    result = getReturnOrders_result()
3966 
    result.read(self._iprot)
3967 
    self._iprot.readMessageEnd()
3431 rajveer 3968 
    if result.success is not None:
2690 chandransh 3969 
      return result.success
3970 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3971 
 
5481 phani.kuma 3972 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3973 
    """
3974 
    Get all return orders created between the from and to dates.
3975 
 
3976 
    Parameters:
3977 
     - onlyNotProcessed
3978 
     - fromDate
3979 
     - toDate
3980 
    """
3981 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3982 
    return self.recv_getAllReturnOrders()
3983 
 
3984 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3985 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3986 
    args = getAllReturnOrders_args()
3987 
    args.onlyNotProcessed = onlyNotProcessed
3988 
    args.fromDate = fromDate
3989 
    args.toDate = toDate
3990 
    args.write(self._oprot)
3991 
    self._oprot.writeMessageEnd()
3992 
    self._oprot.trans.flush()
3993 
 
3994 
  def recv_getAllReturnOrders(self, ):
3995 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3996 
    if mtype == TMessageType.EXCEPTION:
3997 
      x = TApplicationException()
3998 
      x.read(self._iprot)
3999 
      self._iprot.readMessageEnd()
4000 
      raise x
4001 
    result = getAllReturnOrders_result()
4002 
    result.read(self._iprot)
4003 
    self._iprot.readMessageEnd()
4004 
    if result.success is not None:
4005 
      return result.success
4006 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
4007 
 
2700 chandransh 4008 
  def getReturnOrder(self, id):
4009 
    """
4010 
    Returns the ReturnOrder corresponding to the given id.
4011 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 4012 
 
2700 chandransh 4013 
    Parameters:
4014 
     - id
4015 
    """
4016 
    self.send_getReturnOrder(id)
4017 
    return self.recv_getReturnOrder()
4018 
 
4019 
  def send_getReturnOrder(self, id):
4020 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
4021 
    args = getReturnOrder_args()
4022 
    args.id = id
4023 
    args.write(self._oprot)
4024 
    self._oprot.writeMessageEnd()
4025 
    self._oprot.trans.flush()
4026 
 
4027 
  def recv_getReturnOrder(self, ):
4028 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4029 
    if mtype == TMessageType.EXCEPTION:
4030 
      x = TApplicationException()
4031 
      x.read(self._iprot)
4032 
      self._iprot.readMessageEnd()
4033 
      raise x
4034 
    result = getReturnOrder_result()
4035 
    result.read(self._iprot)
4036 
    self._iprot.readMessageEnd()
3431 rajveer 4037 
    if result.success is not None:
2700 chandransh 4038 
      return result.success
3431 rajveer 4039 
    if result.ex is not None:
2700 chandransh 4040 
      raise result.ex
4041 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4042 
 
2690 chandransh 4043 
  def processReturn(self, returnOrderId):
4044 
    """
4045 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4046 
 
2690 chandransh 4047 
    Parameters:
4048 
     - returnOrderId
4049 
    """
4050 
    self.send_processReturn(returnOrderId)
4051 
    self.recv_processReturn()
4052 
 
4053 
  def send_processReturn(self, returnOrderId):
4054 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4055 
    args = processReturn_args()
4056 
    args.returnOrderId = returnOrderId
4057 
    args.write(self._oprot)
4058 
    self._oprot.writeMessageEnd()
4059 
    self._oprot.trans.flush()
4060 
 
4061 
  def recv_processReturn(self, ):
4062 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4063 
    if mtype == TMessageType.EXCEPTION:
4064 
      x = TApplicationException()
4065 
      x.read(self._iprot)
4066 
      self._iprot.readMessageEnd()
4067 
      raise x
4068 
    result = processReturn_result()
4069 
    result.read(self._iprot)
4070 
    self._iprot.readMessageEnd()
3431 rajveer 4071 
    if result.ex is not None:
2690 chandransh 4072 
      raise result.ex
4073 
    return
4074 
 
3451 chandransh 4075 
  def updateWeight(self, orderId, weight):
4076 
    """
4077 
    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 4078 
 
3451 chandransh 4079 
    Parameters:
4080 
     - orderId
4081 
     - weight
4082 
    """
4083 
    self.send_updateWeight(orderId, weight)
4084 
    return self.recv_updateWeight()
4085 
 
4086 
  def send_updateWeight(self, orderId, weight):
4087 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4088 
    args = updateWeight_args()
4089 
    args.orderId = orderId
4090 
    args.weight = weight
4091 
    args.write(self._oprot)
4092 
    self._oprot.writeMessageEnd()
4093 
    self._oprot.trans.flush()
4094 
 
4095 
  def recv_updateWeight(self, ):
4096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4097 
    if mtype == TMessageType.EXCEPTION:
4098 
      x = TApplicationException()
4099 
      x.read(self._iprot)
4100 
      self._iprot.readMessageEnd()
4101 
      raise x
4102 
    result = updateWeight_result()
4103 
    result.read(self._iprot)
4104 
    self._iprot.readMessageEnd()
4105 
    if result.success is not None:
4106 
      return result.success
4107 
    if result.ex is not None:
4108 
      raise result.ex
4109 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4110 
 
3469 chandransh 4111 
  def changeItem(self, orderId, itemId):
4112 
    """
4113 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4114 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4115 
 
3469 chandransh 4116 
    Parameters:
4117 
     - orderId
4118 
     - itemId
4119 
    """
4120 
    self.send_changeItem(orderId, itemId)
4121 
    return self.recv_changeItem()
4122 
 
4123 
  def send_changeItem(self, orderId, itemId):
4124 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4125 
    args = changeItem_args()
4126 
    args.orderId = orderId
4127 
    args.itemId = itemId
4128 
    args.write(self._oprot)
4129 
    self._oprot.writeMessageEnd()
4130 
    self._oprot.trans.flush()
4131 
 
4132 
  def recv_changeItem(self, ):
4133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4134 
    if mtype == TMessageType.EXCEPTION:
4135 
      x = TApplicationException()
4136 
      x.read(self._iprot)
4137 
      self._iprot.readMessageEnd()
4138 
      raise x
4139 
    result = changeItem_result()
4140 
    result.read(self._iprot)
4141 
    self._iprot.readMessageEnd()
4142 
    if result.success is not None:
4143 
      return result.success
4144 
    if result.ex is not None:
4145 
      raise result.ex
4146 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4147 
 
4148 
  def shiftToWarehouse(self, orderId, warehouseId):
4149 
    """
4150 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4151 
 
4152 
    Parameters:
4153 
     - orderId
4154 
     - warehouseId
4155 
    """
4156 
    self.send_shiftToWarehouse(orderId, warehouseId)
4157 
    return self.recv_shiftToWarehouse()
4158 
 
4159 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4160 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4161 
    args = shiftToWarehouse_args()
4162 
    args.orderId = orderId
4163 
    args.warehouseId = warehouseId
4164 
    args.write(self._oprot)
4165 
    self._oprot.writeMessageEnd()
4166 
    self._oprot.trans.flush()
4167 
 
4168 
  def recv_shiftToWarehouse(self, ):
4169 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4170 
    if mtype == TMessageType.EXCEPTION:
4171 
      x = TApplicationException()
4172 
      x.read(self._iprot)
4173 
      self._iprot.readMessageEnd()
4174 
      raise x
4175 
    result = shiftToWarehouse_result()
4176 
    result.read(self._iprot)
4177 
    self._iprot.readMessageEnd()
4178 
    if result.success is not None:
4179 
      return result.success
4180 
    if result.ex is not None:
4181 
      raise result.ex
4182 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4183 
 
4647 rajveer 4184 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4185 
    """
4186 
    Adds the given delay reason to the given order.
3986 chandransh 4187 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4188 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4189 
 
3553 chandransh 4190 
    Parameters:
4191 
     - orderId
4192 
     - delayReason
3986 chandransh 4193 
     - furtherDelay
4647 rajveer 4194 
     - delayReasonText
3553 chandransh 4195 
    """
4647 rajveer 4196 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4197 
    return self.recv_addDelayReason()
4198 
 
4647 rajveer 4199 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4200 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4201 
    args = addDelayReason_args()
4202 
    args.orderId = orderId
4203 
    args.delayReason = delayReason
3986 chandransh 4204 
    args.furtherDelay = furtherDelay
4647 rajveer 4205 
    args.delayReasonText = delayReasonText
3553 chandransh 4206 
    args.write(self._oprot)
4207 
    self._oprot.writeMessageEnd()
4208 
    self._oprot.trans.flush()
4209 
 
4210 
  def recv_addDelayReason(self, ):
4211 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4212 
    if mtype == TMessageType.EXCEPTION:
4213 
      x = TApplicationException()
4214 
      x.read(self._iprot)
4215 
      self._iprot.readMessageEnd()
4216 
      raise x
4217 
    result = addDelayReason_result()
4218 
    result.read(self._iprot)
4219 
    self._iprot.readMessageEnd()
4220 
    if result.success is not None:
4221 
      return result.success
4222 
    if result.ex is not None:
4223 
      raise result.ex
4224 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4225 
 
3956 chandransh 4226 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4227 
    """
4228 
    Marks the COD orders with given AWB nos. as having been processed.
4229 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4230 
 
3956 chandransh 4231 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4232 
    1. There is no order corresponding to an AWB number.
4233 
    2. The captured amount for a payment exceeds the total payment.
4234 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4235 
 
4236 
    Parameters:
4237 
     - collectedAmountMap
4238 
     - xferBy
4239 
     - xferTxnId
4240 
     - xferDate
4241 
    """
4242 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4243 
    return self.recv_reconcileCodCollection()
4244 
 
4245 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4246 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4247 
    args = reconcileCodCollection_args()
4248 
    args.collectedAmountMap = collectedAmountMap
4249 
    args.xferBy = xferBy
4250 
    args.xferTxnId = xferTxnId
4251 
    args.xferDate = xferDate
4252 
    args.write(self._oprot)
4253 
    self._oprot.writeMessageEnd()
4254 
    self._oprot.trans.flush()
4255 
 
4256 
  def recv_reconcileCodCollection(self, ):
4257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4258 
    if mtype == TMessageType.EXCEPTION:
4259 
      x = TApplicationException()
4260 
      x.read(self._iprot)
4261 
      self._iprot.readMessageEnd()
4262 
      raise x
4263 
    result = reconcileCodCollection_result()
4264 
    result.read(self._iprot)
4265 
    self._iprot.readMessageEnd()
4266 
    if result.success is not None:
4267 
      return result.success
4268 
    if result.ex is not None:
4269 
      raise result.ex
4270 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4271 
 
4008 mandeep.dh 4272 
  def getTransactionsRequiringExtraProcessing(self, category):
4273 
    """
4065 mandeep.dh 4274 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4275 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4276 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4277 
 
4008 mandeep.dh 4278 
    Parameters:
4279 
     - category
4280 
    """
4281 
    self.send_getTransactionsRequiringExtraProcessing(category)
4282 
    return self.recv_getTransactionsRequiringExtraProcessing()
4283 
 
4284 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4285 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4286 
    args = getTransactionsRequiringExtraProcessing_args()
4287 
    args.category = category
4288 
    args.write(self._oprot)
4289 
    self._oprot.writeMessageEnd()
4290 
    self._oprot.trans.flush()
4291 
 
4292 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4294 
    if mtype == TMessageType.EXCEPTION:
4295 
      x = TApplicationException()
4296 
      x.read(self._iprot)
4297 
      self._iprot.readMessageEnd()
4298 
      raise x
4299 
    result = getTransactionsRequiringExtraProcessing_result()
4300 
    result.read(self._iprot)
4301 
    self._iprot.readMessageEnd()
4302 
    if result.success is not None:
4303 
      return result.success
4304 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4305 
 
4306 
  def markTransactionAsProcessed(self, transactionId, category):
4307 
    """
4308 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4309 
    It essentially deletes the transaction id record for a particular
4310 
    processing type category (if present) from DB.
4311 
    This is currently used by CRM application.
4008 mandeep.dh 4312 
 
4313 
    Parameters:
4314 
     - transactionId
4315 
     - category
4316 
    """
4317 
    self.send_markTransactionAsProcessed(transactionId, category)
4318 
    self.recv_markTransactionAsProcessed()
4319 
 
4320 
  def send_markTransactionAsProcessed(self, transactionId, category):
4321 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4322 
    args = markTransactionAsProcessed_args()
4323 
    args.transactionId = transactionId
4324 
    args.category = category
4325 
    args.write(self._oprot)
4326 
    self._oprot.writeMessageEnd()
4327 
    self._oprot.trans.flush()
4328 
 
4329 
  def recv_markTransactionAsProcessed(self, ):
4330 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4331 
    if mtype == TMessageType.EXCEPTION:
4332 
      x = TApplicationException()
4333 
      x.read(self._iprot)
4334 
      self._iprot.readMessageEnd()
4335 
      raise x
4336 
    result = markTransactionAsProcessed_result()
4337 
    result.read(self._iprot)
4338 
    self._iprot.readMessageEnd()
4339 
    return
4340 
 
4018 chandransh 4341 
  def getItemWiseRiskyOrdersCount(self, ):
4342 
    """
4343 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4344 
    is defined as one whose shipping date is about to expire.
4345 
    """
4346 
    self.send_getItemWiseRiskyOrdersCount()
4347 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4348 
 
4018 chandransh 4349 
  def send_getItemWiseRiskyOrdersCount(self, ):
4350 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4351 
    args = getItemWiseRiskyOrdersCount_args()
4352 
    args.write(self._oprot)
4353 
    self._oprot.writeMessageEnd()
4354 
    self._oprot.trans.flush()
4355 
 
4356 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4357 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4358 
    if mtype == TMessageType.EXCEPTION:
4359 
      x = TApplicationException()
4360 
      x.read(self._iprot)
4361 
      self._iprot.readMessageEnd()
4362 
      raise x
4363 
    result = getItemWiseRiskyOrdersCount_result()
4364 
    result.read(self._iprot)
4365 
    self._iprot.readMessageEnd()
4366 
    if result.success is not None:
4367 
      return result.success
4368 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4369 
 
4295 varun.gupt 4370 
  def getOrdersForItemIds(self, itemIds):
4371 
    """
4372 
    Returns a list of all orders which have items with given id
4373 
 
4374 
    Parameters:
4375 
     - itemIds
4376 
    """
4377 
    self.send_getOrdersForItemIds(itemIds)
4378 
    return self.recv_getOrdersForItemIds()
4379 
 
4380 
  def send_getOrdersForItemIds(self, itemIds):
4381 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4382 
    args = getOrdersForItemIds_args()
4383 
    args.itemIds = itemIds
4384 
    args.write(self._oprot)
4385 
    self._oprot.writeMessageEnd()
4386 
    self._oprot.trans.flush()
4387 
 
4388 
  def recv_getOrdersForItemIds(self, ):
4389 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4390 
    if mtype == TMessageType.EXCEPTION:
4391 
      x = TApplicationException()
4392 
      x.read(self._iprot)
4393 
      self._iprot.readMessageEnd()
4394 
      raise x
4395 
    result = getOrdersForItemIds_result()
4396 
    result.read(self._iprot)
4397 
    self._iprot.readMessageEnd()
4398 
    if result.success is not None:
4399 
      return result.success
4400 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4401 
 
4247 rajveer 4402 
  def markOrderCancellationRequestReceived(self, orderId):
4403 
    """
4404 
    Mark order as cancellation request received. If customer sends request of cancellation of
4405 
    a particular order, this method will be called. It will just change status of the order
4406 
    depending on its current status. It also records the previous status, so that we can move
4407 
    back to that status if cancellation request is denied.
4018 chandransh 4408 
 
4247 rajveer 4409 
    Parameters:
4410 
     - orderId
4411 
    """
4412 
    self.send_markOrderCancellationRequestReceived(orderId)
4413 
    self.recv_markOrderCancellationRequestReceived()
4414 
 
4415 
  def send_markOrderCancellationRequestReceived(self, orderId):
4416 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4417 
    args = markOrderCancellationRequestReceived_args()
4418 
    args.orderId = orderId
4419 
    args.write(self._oprot)
4420 
    self._oprot.writeMessageEnd()
4421 
    self._oprot.trans.flush()
4422 
 
4423 
  def recv_markOrderCancellationRequestReceived(self, ):
4424 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4425 
    if mtype == TMessageType.EXCEPTION:
4426 
      x = TApplicationException()
4427 
      x.read(self._iprot)
4428 
      self._iprot.readMessageEnd()
4429 
      raise x
4430 
    result = markOrderCancellationRequestReceived_result()
4431 
    result.read(self._iprot)
4432 
    self._iprot.readMessageEnd()
4433 
    if result.ex is not None:
4434 
      raise result.ex
4435 
    return
4436 
 
4437 
  def markOrderCancellationRequestConfirmed(self, orderId):
4438 
    """
4439 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4440 
    cancellation request confirmed. After this OM will be able to cancel the order.
4441 
 
4442 
    Parameters:
4443 
     - orderId
4444 
    """
4445 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4446 
    self.recv_markOrderCancellationRequestConfirmed()
4447 
 
4448 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4449 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4450 
    args = markOrderCancellationRequestConfirmed_args()
4451 
    args.orderId = orderId
4452 
    args.write(self._oprot)
4453 
    self._oprot.writeMessageEnd()
4454 
    self._oprot.trans.flush()
4455 
 
4456 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4457 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4458 
    if mtype == TMessageType.EXCEPTION:
4459 
      x = TApplicationException()
4460 
      x.read(self._iprot)
4461 
      self._iprot.readMessageEnd()
4462 
      raise x
4463 
    result = markOrderCancellationRequestConfirmed_result()
4464 
    result.read(self._iprot)
4465 
    self._iprot.readMessageEnd()
4466 
    if result.ex is not None:
4467 
      raise result.ex
4468 
    return
4469 
 
4470 
  def markOrderCancellationRequestDenied(self, orderId):
4471 
    """
4472 
    If we decide to not to cancel order, we will move the order ro previous status.
4473 
 
4474 
    Parameters:
4475 
     - orderId
4476 
    """
4477 
    self.send_markOrderCancellationRequestDenied(orderId)
4478 
    self.recv_markOrderCancellationRequestDenied()
4479 
 
4480 
  def send_markOrderCancellationRequestDenied(self, orderId):
4481 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4482 
    args = markOrderCancellationRequestDenied_args()
4483 
    args.orderId = orderId
4484 
    args.write(self._oprot)
4485 
    self._oprot.writeMessageEnd()
4486 
    self._oprot.trans.flush()
4487 
 
4488 
  def recv_markOrderCancellationRequestDenied(self, ):
4489 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4490 
    if mtype == TMessageType.EXCEPTION:
4491 
      x = TApplicationException()
4492 
      x.read(self._iprot)
4493 
      self._iprot.readMessageEnd()
4494 
      raise x
4495 
    result = markOrderCancellationRequestDenied_result()
4496 
    result.read(self._iprot)
4497 
    self._iprot.readMessageEnd()
4498 
    if result.ex is not None:
4499 
      raise result.ex
4500 
    return
4501 
 
4258 rajveer 4502 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4503 
    """
4258 rajveer 4504 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4505 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4506 
 
4507 
    Parameters:
4258 rajveer 4508 
     - transactionId
4247 rajveer 4509 
    """
4258 rajveer 4510 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4511 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4512 
 
4258 rajveer 4513 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4514 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4515 
    args = markTransactionAsPaymentFlagRemoved_args()
4516 
    args.transactionId = transactionId
4247 rajveer 4517 
    args.write(self._oprot)
4518 
    self._oprot.writeMessageEnd()
4519 
    self._oprot.trans.flush()
4520 
 
4258 rajveer 4521 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4522 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4523 
    if mtype == TMessageType.EXCEPTION:
4524 
      x = TApplicationException()
4525 
      x.read(self._iprot)
4526 
      self._iprot.readMessageEnd()
4527 
      raise x
4258 rajveer 4528 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4529 
    result.read(self._iprot)
4530 
    self._iprot.readMessageEnd()
4531 
    if result.ex is not None:
4532 
      raise result.ex
4533 
    return
4534 
 
4259 anupam.sin 4535 
  def refundTransaction(self, transactionId, refundedBy, reason):
4536 
    """
4537 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4538 
    need to be cancelled
4247 rajveer 4539 
 
4259 anupam.sin 4540 
    Parameters:
4541 
     - transactionId
4542 
     - refundedBy
4543 
     - reason
4544 
    """
4545 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4546 
    self.recv_refundTransaction()
4547 
 
4548 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4549 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4550 
    args = refundTransaction_args()
4551 
    args.transactionId = transactionId
4552 
    args.refundedBy = refundedBy
4553 
    args.reason = reason
4554 
    args.write(self._oprot)
4555 
    self._oprot.writeMessageEnd()
4556 
    self._oprot.trans.flush()
4557 
 
4558 
  def recv_refundTransaction(self, ):
4559 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4560 
    if mtype == TMessageType.EXCEPTION:
4561 
      x = TApplicationException()
4562 
      x.read(self._iprot)
4563 
      self._iprot.readMessageEnd()
4564 
      raise x
4565 
    result = refundTransaction_result()
4566 
    result.read(self._iprot)
4567 
    self._iprot.readMessageEnd()
4568 
    if result.ex is not None:
4569 
      raise result.ex
4570 
    return
4571 
 
4324 mandeep.dh 4572 
  def updateShipmentAddress(self, orderId, addressId):
4573 
    """
4574 
    Updates shipment address of an order. Delivery and shipping date estimates
4575 
    etc. are also updated here.
4576 
 
4577 
    Throws TransactionServiceException in case address change is not
4578 
    possible due to certain reasons such as new pincode in address is
4579 
    not serviceable etc.
4580 
 
4581 
    Parameters:
4582 
     - orderId
4583 
     - addressId
4584 
    """
4585 
    self.send_updateShipmentAddress(orderId, addressId)
4586 
    self.recv_updateShipmentAddress()
4587 
 
4588 
  def send_updateShipmentAddress(self, orderId, addressId):
4589 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4590 
    args = updateShipmentAddress_args()
4591 
    args.orderId = orderId
4592 
    args.addressId = addressId
4593 
    args.write(self._oprot)
4594 
    self._oprot.writeMessageEnd()
4595 
    self._oprot.trans.flush()
4596 
 
4597 
  def recv_updateShipmentAddress(self, ):
4598 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4599 
    if mtype == TMessageType.EXCEPTION:
4600 
      x = TApplicationException()
4601 
      x.read(self._iprot)
4602 
      self._iprot.readMessageEnd()
4603 
      raise x
4604 
    result = updateShipmentAddress_result()
4605 
    result.read(self._iprot)
4606 
    self._iprot.readMessageEnd()
4607 
    if result.ex is not None:
4608 
      raise result.ex
4609 
    return
4610 
 
4285 rajveer 4611 
  def acceptOrdersForItemId(self, itemId, inventory):
4612 
    """
4613 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4614 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4615 
 
4285 rajveer 4616 
    Parameters:
4617 
     - itemId
4618 
     - inventory
4619 
    """
4620 
    self.send_acceptOrdersForItemId(itemId, inventory)
4621 
    return self.recv_acceptOrdersForItemId()
4622 
 
4623 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4624 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4625 
    args = acceptOrdersForItemId_args()
4626 
    args.itemId = itemId
4627 
    args.inventory = inventory
4628 
    args.write(self._oprot)
4629 
    self._oprot.writeMessageEnd()
4630 
    self._oprot.trans.flush()
4631 
 
4632 
  def recv_acceptOrdersForItemId(self, ):
4633 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4634 
    if mtype == TMessageType.EXCEPTION:
4635 
      x = TApplicationException()
4636 
      x.read(self._iprot)
4637 
      self._iprot.readMessageEnd()
4638 
      raise x
4639 
    result = acceptOrdersForItemId_result()
4640 
    result.read(self._iprot)
4641 
    self._iprot.readMessageEnd()
4642 
    if result.success is not None:
4643 
      return result.success
4644 
    if result.ex is not None:
4645 
      raise result.ex
4646 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4647 
 
4369 rajveer 4648 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4649 
    """
4650 
    Parameters:
4651 
     - vendorId
4652 
     - itemId
4653 
     - quantity
4654 
     - estimate
4369 rajveer 4655 
     - isReminder
4303 rajveer 4656 
    """
4369 rajveer 4657 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4658 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4659 
 
4369 rajveer 4660 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4661 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4662 
    args = markOrdersAsPORaised_args()
4663 
    args.vendorId = vendorId
4664 
    args.itemId = itemId
4665 
    args.quantity = quantity
4666 
    args.estimate = estimate
4369 rajveer 4667 
    args.isReminder = isReminder
4303 rajveer 4668 
    args.write(self._oprot)
4669 
    self._oprot.writeMessageEnd()
4670 
    self._oprot.trans.flush()
4671 
 
4672 
  def recv_markOrdersAsPORaised(self, ):
4673 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4674 
    if mtype == TMessageType.EXCEPTION:
4675 
      x = TApplicationException()
4676 
      x.read(self._iprot)
4677 
      self._iprot.readMessageEnd()
4678 
      raise x
4679 
    result = markOrdersAsPORaised_result()
4680 
    result.read(self._iprot)
4681 
    self._iprot.readMessageEnd()
4682 
    if result.ex is not None:
4683 
      raise result.ex
4684 
    return
4685 
 
4369 rajveer 4686 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4687 
    """
4688 
    Parameters:
4689 
     - vendorId
4690 
     - itemId
4691 
     - quantity
4692 
     - estimate
4369 rajveer 4693 
     - isReminder
4303 rajveer 4694 
    """
4369 rajveer 4695 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4696 
    self.recv_markOrdersAsReversalInitiated()
4697 
 
4369 rajveer 4698 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4699 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4700 
    args = markOrdersAsReversalInitiated_args()
4701 
    args.vendorId = vendorId
4702 
    args.itemId = itemId
4703 
    args.quantity = quantity
4704 
    args.estimate = estimate
4369 rajveer 4705 
    args.isReminder = isReminder
4303 rajveer 4706 
    args.write(self._oprot)
4707 
    self._oprot.writeMessageEnd()
4708 
    self._oprot.trans.flush()
4709 
 
4710 
  def recv_markOrdersAsReversalInitiated(self, ):
4711 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4712 
    if mtype == TMessageType.EXCEPTION:
4713 
      x = TApplicationException()
4714 
      x.read(self._iprot)
4715 
      self._iprot.readMessageEnd()
4716 
      raise x
4717 
    result = markOrdersAsReversalInitiated_result()
4718 
    result.read(self._iprot)
4719 
    self._iprot.readMessageEnd()
4720 
    if result.ex is not None:
4721 
      raise result.ex
4722 
    return
4723 
 
4369 rajveer 4724 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4725 
    """
4726 
    Parameters:
4727 
     - vendorId
4728 
     - itemId
4729 
     - quantity
4730 
     - estimate
4369 rajveer 4731 
     - isReminder
4303 rajveer 4732 
    """
4369 rajveer 4733 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4734 
    self.recv_markOrdersAsNotAvailabke()
4735 
 
4369 rajveer 4736 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4737 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4738 
    args = markOrdersAsNotAvailabke_args()
4739 
    args.vendorId = vendorId
4740 
    args.itemId = itemId
4741 
    args.quantity = quantity
4742 
    args.estimate = estimate
4369 rajveer 4743 
    args.isReminder = isReminder
4303 rajveer 4744 
    args.write(self._oprot)
4745 
    self._oprot.writeMessageEnd()
4746 
    self._oprot.trans.flush()
4747 
 
4748 
  def recv_markOrdersAsNotAvailabke(self, ):
4749 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4750 
    if mtype == TMessageType.EXCEPTION:
4751 
      x = TApplicationException()
4752 
      x.read(self._iprot)
4753 
      self._iprot.readMessageEnd()
4754 
      raise x
4755 
    result = markOrdersAsNotAvailabke_result()
4756 
    result.read(self._iprot)
4757 
    self._iprot.readMessageEnd()
4758 
    if result.ex is not None:
4759 
      raise result.ex
4760 
    return
4761 
 
4369 rajveer 4762 
  def markOrdersAsTimeout(self, vendorId):
4763 
    """
4764 
    Parameters:
4765 
     - vendorId
4766 
    """
4767 
    self.send_markOrdersAsTimeout(vendorId)
4768 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4769 
 
4369 rajveer 4770 
  def send_markOrdersAsTimeout(self, vendorId):
4771 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4772 
    args = markOrdersAsTimeout_args()
4773 
    args.vendorId = vendorId
4774 
    args.write(self._oprot)
4775 
    self._oprot.writeMessageEnd()
4776 
    self._oprot.trans.flush()
4777 
 
4778 
  def recv_markOrdersAsTimeout(self, ):
4779 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4780 
    if mtype == TMessageType.EXCEPTION:
4781 
      x = TApplicationException()
4782 
      x.read(self._iprot)
4783 
      self._iprot.readMessageEnd()
4784 
      raise x
4785 
    result = markOrdersAsTimeout_result()
4786 
    result.read(self._iprot)
4787 
    self._iprot.readMessageEnd()
4788 
    if result.success is not None:
4789 
      return result.success
4790 
    if result.ex is not None:
4791 
      raise result.ex
4792 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4793 
 
4662 rajveer 4794 
  def markOrderAsLostInTransit(self, orderId):
4795 
    """
4796 
    Mark order as LOST_IN_TRANSIT
4797 
 
4798 
    Parameters:
4799 
     - orderId
4800 
    """
4801 
    self.send_markOrderAsLostInTransit(orderId)
4802 
    return self.recv_markOrderAsLostInTransit()
4803 
 
4804 
  def send_markOrderAsLostInTransit(self, orderId):
4805 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4806 
    args = markOrderAsLostInTransit_args()
4807 
    args.orderId = orderId
4808 
    args.write(self._oprot)
4809 
    self._oprot.writeMessageEnd()
4810 
    self._oprot.trans.flush()
4811 
 
4812 
  def recv_markOrderAsLostInTransit(self, ):
4813 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4814 
    if mtype == TMessageType.EXCEPTION:
4815 
      x = TApplicationException()
4816 
      x.read(self._iprot)
4817 
      self._iprot.readMessageEnd()
4818 
      raise x
4819 
    result = markOrderAsLostInTransit_result()
4820 
    result.read(self._iprot)
4821 
    self._iprot.readMessageEnd()
4822 
    if result.success is not None:
4823 
      return result.success
4824 
    if result.ex is not None:
4825 
      raise result.ex
4826 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4827 
 
4386 anupam.sin 4828 
  def getOrderForAwb(self, awb):
4829 
    """
4830 
    Returns the order corresponding to an AWB number
4369 rajveer 4831 
 
4386 anupam.sin 4832 
    Parameters:
4833 
     - awb
4834 
    """
4835 
    self.send_getOrderForAwb(awb)
4836 
    return self.recv_getOrderForAwb()
4837 
 
4838 
  def send_getOrderForAwb(self, awb):
4839 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4840 
    args = getOrderForAwb_args()
4841 
    args.awb = awb
4842 
    args.write(self._oprot)
4843 
    self._oprot.writeMessageEnd()
4844 
    self._oprot.trans.flush()
4845 
 
4846 
  def recv_getOrderForAwb(self, ):
4847 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4848 
    if mtype == TMessageType.EXCEPTION:
4849 
      x = TApplicationException()
4850 
      x.read(self._iprot)
4851 
      self._iprot.readMessageEnd()
4852 
      raise x
4853 
    result = getOrderForAwb_result()
4854 
    result.read(self._iprot)
4855 
    self._iprot.readMessageEnd()
4856 
    if result.success is not None:
4857 
      return result.success
4858 
    if result.ex is not None:
4859 
      raise result.ex
4860 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4861 
 
4910 phani.kuma 4862 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4863 
    """
4910 phani.kuma 4864 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4865 
 
4506 phani.kuma 4866 
    Parameters:
4867 
     - logistics_provider_id
4910 phani.kuma 4868 
     - order_status_list
4506 phani.kuma 4869 
    """
4910 phani.kuma 4870 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4871 
    return self.recv_getOrdersForProviderForStatus()
4872 
 
4910 phani.kuma 4873 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4874 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4875 
    args = getOrdersForProviderForStatus_args()
4876 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4877 
    args.order_status_list = order_status_list
4506 phani.kuma 4878 
    args.write(self._oprot)
4879 
    self._oprot.writeMessageEnd()
4880 
    self._oprot.trans.flush()
4881 
 
4882 
  def recv_getOrdersForProviderForStatus(self, ):
4883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4884 
    if mtype == TMessageType.EXCEPTION:
4885 
      x = TApplicationException()
4886 
      x.read(self._iprot)
4887 
      self._iprot.readMessageEnd()
4888 
      raise x
4889 
    result = getOrdersForProviderForStatus_result()
4890 
    result.read(self._iprot)
4891 
    self._iprot.readMessageEnd()
4892 
    if result.success is not None:
4893 
      return result.success
4894 
    if result.ex is not None:
4895 
      raise result.ex
4896 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4897 
 
4600 varun.gupt 4898 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4899 
    """
4900 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4901 
 
4600 varun.gupt 4902 
    Parameters:
4903 
     - vendorId
4904 
     - billingDateFrom
4905 
     - billingDateTo
4906 
    """
4907 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4908 
    return self.recv_getBilledOrdersForVendor()
4909 
 
4910 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4911 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4912 
    args = getBilledOrdersForVendor_args()
4913 
    args.vendorId = vendorId
4914 
    args.billingDateFrom = billingDateFrom
4915 
    args.billingDateTo = billingDateTo
4916 
    args.write(self._oprot)
4917 
    self._oprot.writeMessageEnd()
4918 
    self._oprot.trans.flush()
4919 
 
4920 
  def recv_getBilledOrdersForVendor(self, ):
4921 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4922 
    if mtype == TMessageType.EXCEPTION:
4923 
      x = TApplicationException()
4924 
      x.read(self._iprot)
4925 
      self._iprot.readMessageEnd()
4926 
      raise x
4927 
    result = getBilledOrdersForVendor_result()
4928 
    result.read(self._iprot)
4929 
    self._iprot.readMessageEnd()
4930 
    if result.success is not None:
4931 
      return result.success
4932 
    if result.ex is not None:
4933 
      raise result.ex
4934 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4935 
 
4607 rajveer 4936 
  def getSlippedSippingDateOrders(self, ):
4937 
    self.send_getSlippedSippingDateOrders()
4938 
    return self.recv_getSlippedSippingDateOrders()
4939 
 
4940 
  def send_getSlippedSippingDateOrders(self, ):
4941 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4942 
    args = getSlippedSippingDateOrders_args()
4943 
    args.write(self._oprot)
4944 
    self._oprot.writeMessageEnd()
4945 
    self._oprot.trans.flush()
4946 
 
4947 
  def recv_getSlippedSippingDateOrders(self, ):
4948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4949 
    if mtype == TMessageType.EXCEPTION:
4950 
      x = TApplicationException()
4951 
      x.read(self._iprot)
4952 
      self._iprot.readMessageEnd()
4953 
      raise x
4954 
    result = getSlippedSippingDateOrders_result()
4955 
    result.read(self._iprot)
4956 
    self._iprot.readMessageEnd()
4957 
    if result.success is not None:
4958 
      return result.success
4959 
    if result.ex is not None:
4960 
      raise result.ex
4961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4962 
 
4709 rajveer 4963 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4964 
    """
4965 
    Parameters:
4966 
     - cancelDateFrom
4967 
     - cancelDateTo
4968 
    """
4969 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4970 
    return self.recv_getCancelledOrders()
4971 
 
4972 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4973 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4974 
    args = getCancelledOrders_args()
4975 
    args.cancelDateFrom = cancelDateFrom
4976 
    args.cancelDateTo = cancelDateTo
4977 
    args.write(self._oprot)
4978 
    self._oprot.writeMessageEnd()
4979 
    self._oprot.trans.flush()
4980 
 
4981 
  def recv_getCancelledOrders(self, ):
4982 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4983 
    if mtype == TMessageType.EXCEPTION:
4984 
      x = TApplicationException()
4985 
      x.read(self._iprot)
4986 
      self._iprot.readMessageEnd()
4987 
      raise x
4988 
    result = getCancelledOrders_result()
4989 
    result.read(self._iprot)
4990 
    self._iprot.readMessageEnd()
4991 
    if result.success is not None:
4992 
      return result.success
4993 
    if result.ex is not None:
4994 
      raise result.ex
4995 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4996 
 
4600 varun.gupt 4997 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4998 
    """
4999 
    Parameters:
5000 
     - mapAWBAndAmount
5001 
    """
5002 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
5003 
    self.recv_saveBluedartSettlements()
5004 
 
5005 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
5006 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
5007 
    args = saveBluedartSettlements_args()
5008 
    args.mapAWBAndAmount = mapAWBAndAmount
5009 
    args.write(self._oprot)
5010 
    self._oprot.writeMessageEnd()
5011 
    self._oprot.trans.flush()
5012 
 
5013 
  def recv_saveBluedartSettlements(self, ):
5014 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5015 
    if mtype == TMessageType.EXCEPTION:
5016 
      x = TApplicationException()
5017 
      x.read(self._iprot)
5018 
      self._iprot.readMessageEnd()
5019 
      raise x
5020 
    result = saveBluedartSettlements_result()
5021 
    result.read(self._iprot)
5022 
    self._iprot.readMessageEnd()
5023 
    if result.ex is not None:
5024 
      raise result.ex
5025 
    return
5026 
 
4905 varun.gupt 5027 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5028 
    """
5029 
    Parameters:
5030 
     - settlementDate
5031 
     - paymentGatewayId
4905 varun.gupt 5032 
     - referenceId
4600 varun.gupt 5033 
     - serviceTax
5034 
     - otherCharges
5035 
     - netCollection
5036 
    """
4905 varun.gupt 5037 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5038 
    self.recv_savePaymentSettlements()
5039 
 
4905 varun.gupt 5040 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5041 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5042 
    args = savePaymentSettlements_args()
5043 
    args.settlementDate = settlementDate
5044 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5045 
    args.referenceId = referenceId
4600 varun.gupt 5046 
    args.serviceTax = serviceTax
5047 
    args.otherCharges = otherCharges
5048 
    args.netCollection = netCollection
5049 
    args.write(self._oprot)
5050 
    self._oprot.writeMessageEnd()
5051 
    self._oprot.trans.flush()
5052 
 
5053 
  def recv_savePaymentSettlements(self, ):
5054 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5055 
    if mtype == TMessageType.EXCEPTION:
5056 
      x = TApplicationException()
5057 
      x.read(self._iprot)
5058 
      self._iprot.readMessageEnd()
5059 
      raise x
5060 
    result = savePaymentSettlements_result()
5061 
    result.read(self._iprot)
5062 
    self._iprot.readMessageEnd()
5063 
    if result.ex is not None:
5064 
      raise result.ex
5065 
    return
5066 
 
5067 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5068 
    """
5069 
    Parameters:
5070 
     - settlementId
5071 
     - settlementDate
5072 
     - transactionDateFrom
5073 
     - transactionDateTo
5074 
     - amount
5075 
    """
5076 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5077 
    self.recv_saveEBSSettlementSummary()
5078 
 
5079 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5080 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5081 
    args = saveEBSSettlementSummary_args()
5082 
    args.settlementId = settlementId
5083 
    args.settlementDate = settlementDate
5084 
    args.transactionDateFrom = transactionDateFrom
5085 
    args.transactionDateTo = transactionDateTo
5086 
    args.amount = amount
5087 
    args.write(self._oprot)
5088 
    self._oprot.writeMessageEnd()
5089 
    self._oprot.trans.flush()
5090 
 
5091 
  def recv_saveEBSSettlementSummary(self, ):
5092 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5093 
    if mtype == TMessageType.EXCEPTION:
5094 
      x = TApplicationException()
5095 
      x.read(self._iprot)
5096 
      self._iprot.readMessageEnd()
5097 
      raise x
5098 
    result = saveEBSSettlementSummary_result()
5099 
    result.read(self._iprot)
5100 
    self._iprot.readMessageEnd()
5101 
    if result.ex is not None:
5102 
      raise result.ex
5103 
    return
5104 
 
5386 phani.kuma 5105 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5106 
    """
5107 
    Parameters:
5189 varun.gupt 5108 
     - referenceId
5109 
     - isRefund
4600 varun.gupt 5110 
    """
5386 phani.kuma 5111 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5112 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5113 
 
5386 phani.kuma 5114 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5115 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5116 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5117 
    args.referenceId = referenceId
5118 
    args.isRefund = isRefund
4600 varun.gupt 5119 
    args.write(self._oprot)
5120 
    self._oprot.writeMessageEnd()
5121 
    self._oprot.trans.flush()
5122 
 
5386 phani.kuma 5123 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5124 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5125 
    if mtype == TMessageType.EXCEPTION:
5126 
      x = TApplicationException()
5127 
      x.read(self._iprot)
5128 
      self._iprot.readMessageEnd()
5129 
      raise x
5386 phani.kuma 5130 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5131 
    result.read(self._iprot)
5132 
    self._iprot.readMessageEnd()
5133 
    if result.success is not None:
5134 
      return result.success
5135 
    if result.ex is not None:
5136 
      raise result.ex
5386 phani.kuma 5137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5138 
 
5386 phani.kuma 5139 
  def getSettlementForCod(self, orderId, isRefund):
5140 
    """
5141 
    Parameters:
5142 
     - orderId
5143 
     - isRefund
5144 
    """
5145 
    self.send_getSettlementForCod(orderId, isRefund)
5146 
    return self.recv_getSettlementForCod()
5147 
 
5148 
  def send_getSettlementForCod(self, orderId, isRefund):
5149 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5150 
    args = getSettlementForCod_args()
5151 
    args.orderId = orderId
5152 
    args.isRefund = isRefund
5153 
    args.write(self._oprot)
5154 
    self._oprot.writeMessageEnd()
5155 
    self._oprot.trans.flush()
5156 
 
5157 
  def recv_getSettlementForCod(self, ):
5158 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5159 
    if mtype == TMessageType.EXCEPTION:
5160 
      x = TApplicationException()
5161 
      x.read(self._iprot)
5162 
      self._iprot.readMessageEnd()
5163 
      raise x
5164 
    result = getSettlementForCod_result()
5165 
    result.read(self._iprot)
5166 
    self._iprot.readMessageEnd()
5167 
    if result.success is not None:
5168 
      return result.success
5169 
    if result.ex is not None:
5170 
      raise result.ex
5171 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5172 
 
4600 varun.gupt 5173 
  def getEBSSettlementSummaries(self, ):
5174 
    self.send_getEBSSettlementSummaries()
5175 
    return self.recv_getEBSSettlementSummaries()
5176 
 
5177 
  def send_getEBSSettlementSummaries(self, ):
5178 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5179 
    args = getEBSSettlementSummaries_args()
5180 
    args.write(self._oprot)
5181 
    self._oprot.writeMessageEnd()
5182 
    self._oprot.trans.flush()
5183 
 
5184 
  def recv_getEBSSettlementSummaries(self, ):
5185 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5186 
    if mtype == TMessageType.EXCEPTION:
5187 
      x = TApplicationException()
5188 
      x.read(self._iprot)
5189 
      self._iprot.readMessageEnd()
5190 
      raise x
5191 
    result = getEBSSettlementSummaries_result()
5192 
    result.read(self._iprot)
5193 
    self._iprot.readMessageEnd()
5194 
    if result.success is not None:
5195 
      return result.success
5196 
    if result.ex is not None:
5197 
      raise result.ex
5198 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5199 
 
5200 
  def markEBSSettlementUploaded(self, settlementId):
5201 
    """
5202 
    Parameters:
5203 
     - settlementId
5204 
    """
5205 
    self.send_markEBSSettlementUploaded(settlementId)
5206 
    self.recv_markEBSSettlementUploaded()
5207 
 
5208 
  def send_markEBSSettlementUploaded(self, settlementId):
5209 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5210 
    args = markEBSSettlementUploaded_args()
5211 
    args.settlementId = settlementId
5212 
    args.write(self._oprot)
5213 
    self._oprot.writeMessageEnd()
5214 
    self._oprot.trans.flush()
5215 
 
5216 
  def recv_markEBSSettlementUploaded(self, ):
5217 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5218 
    if mtype == TMessageType.EXCEPTION:
5219 
      x = TApplicationException()
5220 
      x.read(self._iprot)
5221 
      self._iprot.readMessageEnd()
5222 
      raise x
5223 
    result = markEBSSettlementUploaded_result()
5224 
    result.read(self._iprot)
5225 
    self._iprot.readMessageEnd()
5226 
    if result.ex is not None:
5227 
      raise result.ex
5228 
    return
5229 
 
5230 
  def getEBSSettlementDate(self, settlementId):
5231 
    """
5232 
    Parameters:
5233 
     - settlementId
5234 
    """
5235 
    self.send_getEBSSettlementDate(settlementId)
5236 
    return self.recv_getEBSSettlementDate()
5237 
 
5238 
  def send_getEBSSettlementDate(self, settlementId):
5239 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5240 
    args = getEBSSettlementDate_args()
5241 
    args.settlementId = settlementId
5242 
    args.write(self._oprot)
5243 
    self._oprot.writeMessageEnd()
5244 
    self._oprot.trans.flush()
5245 
 
5246 
  def recv_getEBSSettlementDate(self, ):
5247 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5248 
    if mtype == TMessageType.EXCEPTION:
5249 
      x = TApplicationException()
5250 
      x.read(self._iprot)
5251 
      self._iprot.readMessageEnd()
5252 
      raise x
5253 
    result = getEBSSettlementDate_result()
5254 
    result.read(self._iprot)
5255 
    self._iprot.readMessageEnd()
5256 
    if result.success is not None:
5257 
      return result.success
5258 
    if result.ex is not None:
5259 
      raise result.ex
5260 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5261 
 
4715 varun.gupt 5262 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5263 
    """
5264 
    Parameters:
5265 
     - settlementDateFrom
5266 
     - settlementDateTo
5267 
     - isRefund
5268 
    """
5269 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5270 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5271 
 
4715 varun.gupt 5272 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5273 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5274 
    args = getSettlementsByDate_args()
5275 
    args.settlementDateFrom = settlementDateFrom
5276 
    args.settlementDateTo = settlementDateTo
5277 
    args.isRefund = isRefund
5278 
    args.write(self._oprot)
5279 
    self._oprot.writeMessageEnd()
5280 
    self._oprot.trans.flush()
5281 
 
5282 
  def recv_getSettlementsByDate(self, ):
5283 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5284 
    if mtype == TMessageType.EXCEPTION:
5285 
      x = TApplicationException()
5286 
      x.read(self._iprot)
5287 
      self._iprot.readMessageEnd()
5288 
      raise x
5289 
    result = getSettlementsByDate_result()
5290 
    result.read(self._iprot)
5291 
    self._iprot.readMessageEnd()
5292 
    if result.success is not None:
5293 
      return result.success
5294 
    if result.ex is not None:
5295 
      raise result.ex
5296 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5297 
 
5298 
  def getReshippedOrderIds(self, orderIds):
5299 
    """
5300 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5301 
 
5302 
    Parameters:
5303 
     - orderIds
5304 
    """
5305 
    self.send_getReshippedOrderIds(orderIds)
5306 
    return self.recv_getReshippedOrderIds()
5307 
 
5308 
  def send_getReshippedOrderIds(self, orderIds):
5309 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5310 
    args = getReshippedOrderIds_args()
5311 
    args.orderIds = orderIds
5312 
    args.write(self._oprot)
5313 
    self._oprot.writeMessageEnd()
5314 
    self._oprot.trans.flush()
5315 
 
5316 
  def recv_getReshippedOrderIds(self, ):
5317 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5318 
    if mtype == TMessageType.EXCEPTION:
5319 
      x = TApplicationException()
5320 
      x.read(self._iprot)
5321 
      self._iprot.readMessageEnd()
5322 
      raise x
5323 
    result = getReshippedOrderIds_result()
5324 
    result.read(self._iprot)
5325 
    self._iprot.readMessageEnd()
5326 
    if result.success is not None:
5327 
      return result.success
5328 
    if result.ex is not None:
5329 
      raise result.ex
5330 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5331 
 
5481 phani.kuma 5332 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5333 
    """
5334 
    Parameters:
5335 
     - vendorId
5481 phani.kuma 5336 
     - onlyVendorNotPaid
5337 
     - billingDateFrom
5338 
     - billingDateTo
4875 varun.gupt 5339 
    """
5481 phani.kuma 5340 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5341 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5342 
 
5481 phani.kuma 5343 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5344 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5345 
    args = getBilledOrders_args()
4875 varun.gupt 5346 
    args.vendorId = vendorId
5481 phani.kuma 5347 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5348 
    args.billingDateFrom = billingDateFrom
5349 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5350 
    args.write(self._oprot)
5351 
    self._oprot.writeMessageEnd()
5352 
    self._oprot.trans.flush()
5353 
 
5481 phani.kuma 5354 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5356 
    if mtype == TMessageType.EXCEPTION:
5357 
      x = TApplicationException()
5358 
      x.read(self._iprot)
5359 
      self._iprot.readMessageEnd()
5360 
      raise x
5481 phani.kuma 5361 
    result = getBilledOrders_result()
4875 varun.gupt 5362 
    result.read(self._iprot)
5363 
    self._iprot.readMessageEnd()
5364 
    if result.success is not None:
5365 
      return result.success
5366 
    if result.ex is not None:
5367 
      raise result.ex
5481 phani.kuma 5368 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5369 
 
5031 varun.gupt 5370 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5371 
    """
5372 
    Parameters:
5373 
     - startDate
5374 
     - endDate
5375 
    """
5376 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5377 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5378 
 
5031 varun.gupt 5379 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5380 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5381 
    args = getStatusDistributionOfOrders_args()
5382 
    args.startDate = startDate
5383 
    args.endDate = endDate
5384 
    args.write(self._oprot)
5385 
    self._oprot.writeMessageEnd()
5386 
    self._oprot.trans.flush()
5387 
 
5388 
  def recv_getStatusDistributionOfOrders(self, ):
5389 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5390 
    if mtype == TMessageType.EXCEPTION:
5391 
      x = TApplicationException()
5392 
      x.read(self._iprot)
5393 
      self._iprot.readMessageEnd()
5394 
      raise x
5395 
    result = getStatusDistributionOfOrders_result()
5396 
    result.read(self._iprot)
5397 
    self._iprot.readMessageEnd()
5398 
    if result.success is not None:
5399 
      return result.success
5400 
    if result.ex is not None:
5401 
      raise result.ex
5402 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5403 
 
5067 varun.gupt 5404 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5405 
    """
5406 
    Parameters:
5407 
     - status
5408 
     - startDatetime
5409 
     - endDatetime
5410 
    """
5411 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5412 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5413 
 
5067 varun.gupt 5414 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5415 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5416 
    args = getOrderIdsForStatus_args()
5417 
    args.status = status
5418 
    args.startDatetime = startDatetime
5419 
    args.endDatetime = endDatetime
5420 
    args.write(self._oprot)
5421 
    self._oprot.writeMessageEnd()
5422 
    self._oprot.trans.flush()
5423 
 
5424 
  def recv_getOrderIdsForStatus(self, ):
5425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5426 
    if mtype == TMessageType.EXCEPTION:
5427 
      x = TApplicationException()
5428 
      x.read(self._iprot)
5429 
      self._iprot.readMessageEnd()
5430 
      raise x
5431 
    result = getOrderIdsForStatus_result()
5432 
    result.read(self._iprot)
5433 
    self._iprot.readMessageEnd()
5434 
    if result.success is not None:
5435 
      return result.success
5436 
    if result.ex is not None:
5437 
      raise result.ex
5438 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5439 
 
5348 anupam.sin 5440 
  def updateCODAgent(self, agent, orderId):
5441 
    """
5442 
    Updates the agent who handled the COD verification call
5443 
 
5444 
    Parameters:
5445 
     - agent
5446 
     - orderId
5447 
    """
5448 
    self.send_updateCODAgent(agent, orderId)
5449 
    self.recv_updateCODAgent()
5450 
 
5451 
  def send_updateCODAgent(self, agent, orderId):
5452 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5453 
    args = updateCODAgent_args()
5454 
    args.agent = agent
5455 
    args.orderId = orderId
5456 
    args.write(self._oprot)
5457 
    self._oprot.writeMessageEnd()
5458 
    self._oprot.trans.flush()
5459 
 
5460 
  def recv_updateCODAgent(self, ):
5461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5462 
    if mtype == TMessageType.EXCEPTION:
5463 
      x = TApplicationException()
5464 
      x.read(self._iprot)
5465 
      self._iprot.readMessageEnd()
5466 
      raise x
5467 
    result = updateCODAgent_result()
5468 
    result.read(self._iprot)
5469 
    self._iprot.readMessageEnd()
5470 
    if result.ex is not None:
5471 
      raise result.ex
5472 
    return
5473 
 
5099 varun.gupt 5474 
  def updateOrderAsPaidToVendor(self, orderId):
5475 
    """
5476 
    Parameters:
5477 
     - orderId
5478 
    """
5479 
    self.send_updateOrderAsPaidToVendor(orderId)
5480 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5481 
 
5099 varun.gupt 5482 
  def send_updateOrderAsPaidToVendor(self, orderId):
5483 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5484 
    args = updateOrderAsPaidToVendor_args()
5485 
    args.orderId = orderId
5486 
    args.write(self._oprot)
5487 
    self._oprot.writeMessageEnd()
5488 
    self._oprot.trans.flush()
5489 
 
5490 
  def recv_updateOrderAsPaidToVendor(self, ):
5491 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5492 
    if mtype == TMessageType.EXCEPTION:
5493 
      x = TApplicationException()
5494 
      x.read(self._iprot)
5495 
      self._iprot.readMessageEnd()
5496 
      raise x
5497 
    result = updateOrderAsPaidToVendor_result()
5498 
    result.read(self._iprot)
5499 
    self._iprot.readMessageEnd()
5500 
    if result.ex is not None:
5501 
      raise result.ex
5502 
    return
5503 
 
5386 phani.kuma 5504 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5505 
    """
5506 
    Parameters:
5507 
     - orderId
5508 
    """
5509 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5510 
    self.recv_updateOrderOnlyAsPaidToVendor()
5511 
 
5512 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5513 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5514 
    args = updateOrderOnlyAsPaidToVendor_args()
5515 
    args.orderId = orderId
5516 
    args.write(self._oprot)
5517 
    self._oprot.writeMessageEnd()
5518 
    self._oprot.trans.flush()
5519 
 
5520 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5521 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5522 
    if mtype == TMessageType.EXCEPTION:
5523 
      x = TApplicationException()
5524 
      x.read(self._iprot)
5525 
      self._iprot.readMessageEnd()
5526 
      raise x
5527 
    result = updateOrderOnlyAsPaidToVendor_result()
5528 
    result.read(self._iprot)
5529 
    self._iprot.readMessageEnd()
5530 
    if result.ex is not None:
5531 
      raise result.ex
5532 
    return
5533 
 
5208 varun.gupt 5534 
  def getRefundedOrdersMarkedPaid(self, ):
5535 
    self.send_getRefundedOrdersMarkedPaid()
5536 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5537 
 
5208 varun.gupt 5538 
  def send_getRefundedOrdersMarkedPaid(self, ):
5539 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5540 
    args = getRefundedOrdersMarkedPaid_args()
5541 
    args.write(self._oprot)
5542 
    self._oprot.writeMessageEnd()
5543 
    self._oprot.trans.flush()
5544 
 
5545 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5546 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5547 
    if mtype == TMessageType.EXCEPTION:
5548 
      x = TApplicationException()
5549 
      x.read(self._iprot)
5550 
      self._iprot.readMessageEnd()
5551 
      raise x
5552 
    result = getRefundedOrdersMarkedPaid_result()
5553 
    result.read(self._iprot)
5554 
    self._iprot.readMessageEnd()
5555 
    if result.success is not None:
5556 
      return result.success
5557 
    if result.ex is not None:
5558 
      raise result.ex
5559 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5560 
 
5447 anupam.sin 5561 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5562 
    """
5563 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5564 
 
5447 anupam.sin 5565 
 
5566 
    Parameters:
5567 
     - minOrderId
5568 
     - maxOrderId
5569 
    """
5570 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5571 
    return self.recv_getAllVerificationAgents()
5572 
 
5573 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5574 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5575 
    args = getAllVerificationAgents_args()
5576 
    args.minOrderId = minOrderId
5577 
    args.maxOrderId = maxOrderId
5578 
    args.write(self._oprot)
5579 
    self._oprot.writeMessageEnd()
5580 
    self._oprot.trans.flush()
5581 
 
5582 
  def recv_getAllVerificationAgents(self, ):
5583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5584 
    if mtype == TMessageType.EXCEPTION:
5585 
      x = TApplicationException()
5586 
      x.read(self._iprot)
5587 
      self._iprot.readMessageEnd()
5588 
      raise x
5589 
    result = getAllVerificationAgents_result()
5590 
    result.read(self._iprot)
5591 
    self._iprot.readMessageEnd()
5592 
    if result.success is not None:
5593 
      return result.success
5594 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5595 
 
5527 anupam.sin 5596 
  def getAllAttributesForOrderId(self, orderId):
5597 
    """
5598 
    gets all attributes for a given orderId
5447 anupam.sin 5599 
 
5527 anupam.sin 5600 
    Parameters:
5601 
     - orderId
5602 
    """
5603 
    self.send_getAllAttributesForOrderId(orderId)
5604 
    return self.recv_getAllAttributesForOrderId()
5605 
 
5606 
  def send_getAllAttributesForOrderId(self, orderId):
5607 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5608 
    args = getAllAttributesForOrderId_args()
5609 
    args.orderId = orderId
5610 
    args.write(self._oprot)
5611 
    self._oprot.writeMessageEnd()
5612 
    self._oprot.trans.flush()
5613 
 
5614 
  def recv_getAllAttributesForOrderId(self, ):
5615 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5616 
    if mtype == TMessageType.EXCEPTION:
5617 
      x = TApplicationException()
5618 
      x.read(self._iprot)
5619 
      self._iprot.readMessageEnd()
5620 
      raise x
5621 
    result = getAllAttributesForOrderId_result()
5622 
    result.read(self._iprot)
5623 
    self._iprot.readMessageEnd()
5624 
    if result.success is not None:
5625 
      return result.success
5626 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5627 
 
5676 rajveer 5628 
  def setOrderAttributes(self, orderId, attributes):
5629 
    """
5630 
    sets attributes for an order
5631 
 
5632 
    Parameters:
5633 
     - orderId
5634 
     - attributes
5635 
    """
5636 
    self.send_setOrderAttributes(orderId, attributes)
5637 
    self.recv_setOrderAttributes()
5638 
 
5639 
  def send_setOrderAttributes(self, orderId, attributes):
5640 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5641 
    args = setOrderAttributes_args()
5642 
    args.orderId = orderId
5643 
    args.attributes = attributes
5644 
    args.write(self._oprot)
5645 
    self._oprot.writeMessageEnd()
5646 
    self._oprot.trans.flush()
5647 
 
5648 
  def recv_setOrderAttributes(self, ):
5649 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5650 
    if mtype == TMessageType.EXCEPTION:
5651 
      x = TApplicationException()
5652 
      x.read(self._iprot)
5653 
      self._iprot.readMessageEnd()
5654 
      raise x
5655 
    result = setOrderAttributes_result()
5656 
    result.read(self._iprot)
5657 
    self._iprot.readMessageEnd()
5658 
    return
5659 
 
5527 anupam.sin 5660 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5661 
    """
5662 
    sets attributes for all orders in a transaction
5663 
 
5664 
    Parameters:
5665 
     - transactionId
5666 
     - attribute
5667 
    """
5668 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5669 
    self.recv_setOrderAttributeForTransaction()
5670 
 
5671 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5672 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5673 
    args = setOrderAttributeForTransaction_args()
5674 
    args.transactionId = transactionId
5675 
    args.attribute = attribute
5676 
    args.write(self._oprot)
5677 
    self._oprot.writeMessageEnd()
5678 
    self._oprot.trans.flush()
5679 
 
5680 
  def recv_setOrderAttributeForTransaction(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 = setOrderAttributeForTransaction_result()
5688 
    result.read(self._iprot)
5689 
    self._iprot.readMessageEnd()
5690 
    return
5691 
 
5553 rajveer 5692 
  def getReceivePendingOrders(self, storeId):
5693 
    """
5694 
    Parameters:
5695 
     - storeId
5696 
    """
5697 
    self.send_getReceivePendingOrders(storeId)
5698 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5699 
 
5553 rajveer 5700 
  def send_getReceivePendingOrders(self, storeId):
5701 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5702 
    args = getReceivePendingOrders_args()
5703 
    args.storeId = storeId
5704 
    args.write(self._oprot)
5705 
    self._oprot.writeMessageEnd()
5706 
    self._oprot.trans.flush()
5707 
 
5708 
  def recv_getReceivePendingOrders(self, ):
5709 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5710 
    if mtype == TMessageType.EXCEPTION:
5711 
      x = TApplicationException()
5712 
      x.read(self._iprot)
5713 
      self._iprot.readMessageEnd()
5714 
      raise x
5715 
    result = getReceivePendingOrders_result()
5716 
    result.read(self._iprot)
5717 
    self._iprot.readMessageEnd()
5718 
    if result.success is not None:
5719 
      return result.success
5720 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5721 
 
5722 
  def getReceivedAtStoreOrders(self, storeId):
5723 
    """
5724 
    Parameters:
5725 
     - storeId
5726 
    """
5727 
    self.send_getReceivedAtStoreOrders(storeId)
5728 
    return self.recv_getReceivedAtStoreOrders()
5729 
 
5730 
  def send_getReceivedAtStoreOrders(self, storeId):
5731 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5732 
    args = getReceivedAtStoreOrders_args()
5733 
    args.storeId = storeId
5734 
    args.write(self._oprot)
5735 
    self._oprot.writeMessageEnd()
5736 
    self._oprot.trans.flush()
5737 
 
5738 
  def recv_getReceivedAtStoreOrders(self, ):
5739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5740 
    if mtype == TMessageType.EXCEPTION:
5741 
      x = TApplicationException()
5742 
      x.read(self._iprot)
5743 
      self._iprot.readMessageEnd()
5744 
      raise x
5745 
    result = getReceivedAtStoreOrders_result()
5746 
    result.read(self._iprot)
5747 
    self._iprot.readMessageEnd()
5748 
    if result.success is not None:
5749 
      return result.success
5750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5751 
 
5713 rajveer 5752 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5753 
    """
5754 
    Parameters:
5755 
     - storeId
5756 
     - fromDate
5757 
     - toDate
5758 
     - onlyCod
5759 
    """
5760 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5761 
    return self.recv_getOrdersCollectionAtStore()
5762 
 
5763 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5764 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5765 
    args = getOrdersCollectionAtStore_args()
5766 
    args.storeId = storeId
5767 
    args.fromDate = fromDate
5768 
    args.toDate = toDate
5769 
    args.onlyCod = onlyCod
5770 
    args.write(self._oprot)
5771 
    self._oprot.writeMessageEnd()
5772 
    self._oprot.trans.flush()
5773 
 
5774 
  def recv_getOrdersCollectionAtStore(self, ):
5775 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5776 
    if mtype == TMessageType.EXCEPTION:
5777 
      x = TApplicationException()
5778 
      x.read(self._iprot)
5779 
      self._iprot.readMessageEnd()
5780 
      raise x
5781 
    result = getOrdersCollectionAtStore_result()
5782 
    result.read(self._iprot)
5783 
    self._iprot.readMessageEnd()
5784 
    if result.success is not None:
5785 
      return result.success
5786 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5787 
 
5833 rajveer 5788 
  def getOrderAttributeValue(self, orderId, attributeName):
5789 
    """
5790 
    Parameters:
5791 
     - orderId
5792 
     - attributeName
5793 
    """
5794 
    self.send_getOrderAttributeValue(orderId, attributeName)
5795 
    return self.recv_getOrderAttributeValue()
5796 
 
5797 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5798 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5799 
    args = getOrderAttributeValue_args()
5800 
    args.orderId = orderId
5801 
    args.attributeName = attributeName
5802 
    args.write(self._oprot)
5803 
    self._oprot.writeMessageEnd()
5804 
    self._oprot.trans.flush()
5805 
 
5806 
  def recv_getOrderAttributeValue(self, ):
5807 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5808 
    if mtype == TMessageType.EXCEPTION:
5809 
      x = TApplicationException()
5810 
      x.read(self._iprot)
5811 
      self._iprot.readMessageEnd()
5812 
      raise x
5813 
    result = getOrderAttributeValue_result()
5814 
    result.read(self._iprot)
5815 
    self._iprot.readMessageEnd()
5816 
    if result.success is not None:
5817 
      return result.success
5818 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5819 
 
6019 rajveer 5820 
  def changeJacketNumber(self, orderId, jacketNumber):
5821 
    """
5822 
    Parameters:
5823 
     - orderId
5824 
     - jacketNumber
5825 
    """
5826 
    self.send_changeJacketNumber(orderId, jacketNumber)
5827 
    return self.recv_changeJacketNumber()
5828 
 
5829 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5830 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5831 
    args = changeJacketNumber_args()
5832 
    args.orderId = orderId
5833 
    args.jacketNumber = jacketNumber
5834 
    args.write(self._oprot)
5835 
    self._oprot.writeMessageEnd()
5836 
    self._oprot.trans.flush()
5837 
 
5838 
  def recv_changeJacketNumber(self, ):
5839 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5840 
    if mtype == TMessageType.EXCEPTION:
5841 
      x = TApplicationException()
5842 
      x.read(self._iprot)
5843 
      self._iprot.readMessageEnd()
5844 
      raise x
5845 
    result = changeJacketNumber_result()
5846 
    result.read(self._iprot)
5847 
    self._iprot.readMessageEnd()
5848 
    if result.success is not None:
5849 
      return result.success
5850 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5851 
 
5852 
  def markOrderAsRtoInTransit(self, orderId):
5853 
    """
5854 
    Parameters:
5855 
     - orderId
5856 
    """
5857 
    self.send_markOrderAsRtoInTransit(orderId)
5858 
    return self.recv_markOrderAsRtoInTransit()
5859 
 
5860 
  def send_markOrderAsRtoInTransit(self, orderId):
5861 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5862 
    args = markOrderAsRtoInTransit_args()
5863 
    args.orderId = orderId
5864 
    args.write(self._oprot)
5865 
    self._oprot.writeMessageEnd()
5866 
    self._oprot.trans.flush()
5867 
 
5868 
  def recv_markOrderAsRtoInTransit(self, ):
5869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5870 
    if mtype == TMessageType.EXCEPTION:
5871 
      x = TApplicationException()
5872 
      x.read(self._iprot)
5873 
      self._iprot.readMessageEnd()
5874 
      raise x
5875 
    result = markOrderAsRtoInTransit_result()
5876 
    result.read(self._iprot)
5877 
    self._iprot.readMessageEnd()
5878 
    if result.success is not None:
5879 
      return result.success
5880 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5881 
 
5593 mandeep.dh 5882 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5883 
    """
5884 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5885 
    invoked while scanning IN of items.
5553 rajveer 5886 
 
5593 mandeep.dh 5887 
    Parameters:
5888 
     - itemId
5889 
     - quantity
5890 
     - fulfilmentWarehouseId
5891 
     - billingWarehouseId
5892 
    """
5893 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5894 
    self.recv_acceptOrderForItem()
5895 
 
5896 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5897 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5898 
    args = acceptOrderForItem_args()
5899 
    args.itemId = itemId
5900 
    args.quantity = quantity
5901 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5902 
    args.billingWarehouseId = billingWarehouseId
5903 
    args.write(self._oprot)
5904 
    self._oprot.writeMessageEnd()
5905 
    self._oprot.trans.flush()
5906 
 
5907 
  def recv_acceptOrderForItem(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 = acceptOrderForItem_result()
5915 
    result.read(self._iprot)
5916 
    self._iprot.readMessageEnd()
5917 
    return
5918 
 
6000 mandeep.dh 5919 
  def createRechargeOrder(self, rechargeOrder):
5920 
    """
5921 
    Parameters:
5922 
     - rechargeOrder
5923 
    """
5924 
    self.send_createRechargeOrder(rechargeOrder)
5925 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5926 
 
6000 mandeep.dh 5927 
  def send_createRechargeOrder(self, rechargeOrder):
5928 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5929 
    args = createRechargeOrder_args()
5930 
    args.rechargeOrder = rechargeOrder
5931 
    args.write(self._oprot)
5932 
    self._oprot.writeMessageEnd()
5933 
    self._oprot.trans.flush()
5934 
 
5935 
  def recv_createRechargeOrder(self, ):
5936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5937 
    if mtype == TMessageType.EXCEPTION:
5938 
      x = TApplicationException()
5939 
      x.read(self._iprot)
5940 
      self._iprot.readMessageEnd()
5941 
      raise x
5942 
    result = createRechargeOrder_result()
5943 
    result.read(self._iprot)
5944 
    self._iprot.readMessageEnd()
5945 
    if result.success is not None:
5946 
      return result.success
5947 
    if result.ex is not None:
5948 
      raise result.ex
5949 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5950 
 
6031 rajveer 5951 
  def getRechargeOrder(self, rechargeRrderId):
5952 
    """
5953 
    Parameters:
5954 
     - rechargeRrderId
5955 
    """
5956 
    self.send_getRechargeOrder(rechargeRrderId)
5957 
    return self.recv_getRechargeOrder()
5958 
 
5959 
  def send_getRechargeOrder(self, rechargeRrderId):
5960 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5961 
    args = getRechargeOrder_args()
5962 
    args.rechargeRrderId = rechargeRrderId
5963 
    args.write(self._oprot)
5964 
    self._oprot.writeMessageEnd()
5965 
    self._oprot.trans.flush()
5966 
 
5967 
  def recv_getRechargeOrder(self, ):
5968 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5969 
    if mtype == TMessageType.EXCEPTION:
5970 
      x = TApplicationException()
5971 
      x.read(self._iprot)
5972 
      self._iprot.readMessageEnd()
5973 
      raise x
5974 
    result = getRechargeOrder_result()
5975 
    result.read(self._iprot)
5976 
    self._iprot.readMessageEnd()
5977 
    if result.success is not None:
5978 
      return result.success
5979 
    if result.ex is not None:
5980 
      raise result.ex
5981 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
5982 
 
5983 
  def getRechargeOrders(self, userId):
5984 
    """
5985 
    Parameters:
5986 
     - userId
5987 
    """
5988 
    self.send_getRechargeOrders(userId)
5989 
    return self.recv_getRechargeOrders()
5990 
 
5991 
  def send_getRechargeOrders(self, userId):
5992 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
5993 
    args = getRechargeOrders_args()
5994 
    args.userId = userId
5995 
    args.write(self._oprot)
5996 
    self._oprot.writeMessageEnd()
5997 
    self._oprot.trans.flush()
5998 
 
5999 
  def recv_getRechargeOrders(self, ):
6000 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6001 
    if mtype == TMessageType.EXCEPTION:
6002 
      x = TApplicationException()
6003 
      x.read(self._iprot)
6004 
      self._iprot.readMessageEnd()
6005 
      raise x
6006 
    result = getRechargeOrders_result()
6007 
    result.read(self._iprot)
6008 
    self._iprot.readMessageEnd()
6009 
    if result.success is not None:
6010 
      return result.success
6011 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
6012 
 
6000 mandeep.dh 6013 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6014 
    """
6015 
    Parameters:
6016 
     - rechargeOrderId
6017 
     - rechargeOrderStatus
6018 
    """
6019 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 6020 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 6021 
 
6022 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6023 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
6024 
    args = updateRechargeOrderStatus_args()
6025 
    args.rechargeOrderId = rechargeOrderId
6026 
    args.rechargeOrderStatus = rechargeOrderStatus
6027 
    args.write(self._oprot)
6028 
    self._oprot.writeMessageEnd()
6029 
    self._oprot.trans.flush()
6030 
 
6031 
  def recv_updateRechargeOrderStatus(self, ):
6032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6033 
    if mtype == TMessageType.EXCEPTION:
6034 
      x = TApplicationException()
6035 
      x.read(self._iprot)
6036 
      self._iprot.readMessageEnd()
6037 
      raise x
6038 
    result = updateRechargeOrderStatus_result()
6039 
    result.read(self._iprot)
6040 
    self._iprot.readMessageEnd()
6031 rajveer 6041 
    if result.success is not None:
6042 
      return result.success
6000 mandeep.dh 6043 
    if result.ex is not None:
6044 
      raise result.ex
6031 rajveer 6045 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6046 
 
6031 rajveer 6047 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6048 
    """
6049 
    Parameters:
6031 rajveer 6050 
     - rechargeOrderId
6000 mandeep.dh 6051 
    """
6031 rajveer 6052 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6053 
    return self.recv_activateRechargeTxn()
6054 
 
6031 rajveer 6055 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6056 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6057 
    args = activateRechargeTxn_args()
6031 rajveer 6058 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6059 
    args.write(self._oprot)
6060 
    self._oprot.writeMessageEnd()
6061 
    self._oprot.trans.flush()
6062 
 
6063 
  def recv_activateRechargeTxn(self, ):
6064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6065 
    if mtype == TMessageType.EXCEPTION:
6066 
      x = TApplicationException()
6067 
      x.read(self._iprot)
6068 
      self._iprot.readMessageEnd()
6069 
      raise x
6070 
    result = activateRechargeTxn_result()
6071 
    result.read(self._iprot)
6072 
    self._iprot.readMessageEnd()
6073 
    if result.success is not None:
6074 
      return result.success
6075 
    if result.ex is not None:
6076 
      raise result.ex
6077 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6078 
 
6031 rajveer 6079 
  def getUserWallet(self, userId):
6000 mandeep.dh 6080 
    """
6081 
    Parameters:
6031 rajveer 6082 
     - userId
6000 mandeep.dh 6083 
    """
6031 rajveer 6084 
    self.send_getUserWallet(userId)
6085 
    return self.recv_getUserWallet()
6000 mandeep.dh 6086 
 
6031 rajveer 6087 
  def send_getUserWallet(self, userId):
6088 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6089 
    args = getUserWallet_args()
6090 
    args.userId = userId
6000 mandeep.dh 6091 
    args.write(self._oprot)
6092 
    self._oprot.writeMessageEnd()
6093 
    self._oprot.trans.flush()
6094 
 
6031 rajveer 6095 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6096 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6097 
    if mtype == TMessageType.EXCEPTION:
6098 
      x = TApplicationException()
6099 
      x.read(self._iprot)
6100 
      self._iprot.readMessageEnd()
6101 
      raise x
6031 rajveer 6102 
    result = getUserWallet_result()
6000 mandeep.dh 6103 
    result.read(self._iprot)
6104 
    self._iprot.readMessageEnd()
6105 
    if result.success is not None:
6106 
      return result.success
6031 rajveer 6107 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6108 
 
6031 rajveer 6109 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6110 
    """
6111 
    Parameters:
6031 rajveer 6112 
     - userId
6000 mandeep.dh 6113 
    """
6031 rajveer 6114 
    self.send_getUserWalletHistory(userId)
6115 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6116 
 
6031 rajveer 6117 
  def send_getUserWalletHistory(self, userId):
6118 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6119 
    args = getUserWalletHistory_args()
6120 
    args.userId = userId
6000 mandeep.dh 6121 
    args.write(self._oprot)
6122 
    self._oprot.writeMessageEnd()
6123 
    self._oprot.trans.flush()
6124 
 
6031 rajveer 6125 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6126 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6127 
    if mtype == TMessageType.EXCEPTION:
6128 
      x = TApplicationException()
6129 
      x.read(self._iprot)
6130 
      self._iprot.readMessageEnd()
6131 
      raise x
6031 rajveer 6132 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6133 
    result.read(self._iprot)
6134 
    self._iprot.readMessageEnd()
6135 
    if result.success is not None:
6136 
      return result.success
6031 rajveer 6137 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6138 
 
6050 anupam.sin 6139 
  def getRechargeOrdersForTransaction(self, txnId):
6140 
    """
6141 
    Returns a recharge order for a given transactionId
6142 
 
6143 
    Parameters:
6144 
     - txnId
6145 
    """
6146 
    self.send_getRechargeOrdersForTransaction(txnId)
6147 
    return self.recv_getRechargeOrdersForTransaction()
6148 
 
6149 
  def send_getRechargeOrdersForTransaction(self, txnId):
6150 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6151 
    args = getRechargeOrdersForTransaction_args()
6152 
    args.txnId = txnId
6153 
    args.write(self._oprot)
6154 
    self._oprot.writeMessageEnd()
6155 
    self._oprot.trans.flush()
6156 
 
6157 
  def recv_getRechargeOrdersForTransaction(self, ):
6158 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6159 
    if mtype == TMessageType.EXCEPTION:
6160 
      x = TApplicationException()
6161 
      x.read(self._iprot)
6162 
      self._iprot.readMessageEnd()
6163 
      raise x
6164 
    result = getRechargeOrdersForTransaction_result()
6165 
    result.read(self._iprot)
6166 
    self._iprot.readMessageEnd()
6167 
    if result.success is not None:
6168 
      return result.success
6169 
    if result.ex is not None:
6170 
      raise result.ex
6171 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6172 
 
6206 rajveer 6173 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6174 
    """
6175 
    Parameters:
6176 
     - rechargeType
6206 rajveer 6177 
     - onlyActive
6048 rajveer 6178 
    """
6206 rajveer 6179 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6180 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6181 
 
6206 rajveer 6182 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6183 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6184 
    args = getServiceProviders_args()
6185 
    args.rechargeType = rechargeType
6206 rajveer 6186 
    args.onlyActive = onlyActive
6048 rajveer 6187 
    args.write(self._oprot)
6188 
    self._oprot.writeMessageEnd()
6189 
    self._oprot.trans.flush()
6190 
 
6191 
  def recv_getServiceProviders(self, ):
6192 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6193 
    if mtype == TMessageType.EXCEPTION:
6194 
      x = TApplicationException()
6195 
      x.read(self._iprot)
6196 
      self._iprot.readMessageEnd()
6197 
      raise x
6198 
    result = getServiceProviders_result()
6199 
    result.read(self._iprot)
6200 
    self._iprot.readMessageEnd()
6201 
    if result.success is not None:
6202 
      return result.success
6203 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6204 
 
6049 rajveer 6205 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6206 
    """
6207 
    Parameters:
6049 rajveer 6208 
     - rechargeType
6048 rajveer 6209 
     - deviceNumber
6210 
    """
6049 rajveer 6211 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6212 
    return self.recv_getServiceProviderForDevice()
6213 
 
6049 rajveer 6214 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6215 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6216 
    args = getServiceProviderForDevice_args()
6049 rajveer 6217 
    args.rechargeType = rechargeType
6048 rajveer 6218 
    args.deviceNumber = deviceNumber
6219 
    args.write(self._oprot)
6220 
    self._oprot.writeMessageEnd()
6221 
    self._oprot.trans.flush()
6222 
 
6223 
  def recv_getServiceProviderForDevice(self, ):
6224 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6225 
    if mtype == TMessageType.EXCEPTION:
6226 
      x = TApplicationException()
6227 
      x.read(self._iprot)
6228 
      self._iprot.readMessageEnd()
6229 
      raise x
6230 
    result = getServiceProviderForDevice_result()
6231 
    result.read(self._iprot)
6232 
    self._iprot.readMessageEnd()
6233 
    if result.success is not None:
6234 
      return result.success
6235 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6236 
 
6591 anupam.sin 6237 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6238 
    """
6239 
    Parameters:
6240 
     - rechargeType
6241 
     - deviceNumber
6307 anupam.sin 6242 
     - userSelectedProviderId
6591 anupam.sin 6243 
     - clientAddress
6269 rajveer 6244 
    """
6591 anupam.sin 6245 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId, clientAddress)
6269 rajveer 6246 
    return self.recv_validateRecharge()
6247 
 
6591 anupam.sin 6248 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6249 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6250 
    args = validateRecharge_args()
6251 
    args.rechargeType = rechargeType
6252 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6253 
    args.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 6254 
    args.clientAddress = clientAddress
6269 rajveer 6255 
    args.write(self._oprot)
6256 
    self._oprot.writeMessageEnd()
6257 
    self._oprot.trans.flush()
6258 
 
6259 
  def recv_validateRecharge(self, ):
6260 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6261 
    if mtype == TMessageType.EXCEPTION:
6262 
      x = TApplicationException()
6263 
      x.read(self._iprot)
6264 
      self._iprot.readMessageEnd()
6265 
      raise x
6266 
    result = validateRecharge_result()
6267 
    result.read(self._iprot)
6268 
    self._iprot.readMessageEnd()
6269 
    if result.success is not None:
6270 
      return result.success
6271 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6272 
 
6094 rajveer 6273 
  def getRechargeOrdersForDevice(self, deviceNumber):
6274 
    """
6275 
    Parameters:
6276 
     - deviceNumber
6277 
    """
6278 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6279 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6280 
 
6094 rajveer 6281 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6282 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6283 
    args = getRechargeOrdersForDevice_args()
6284 
    args.deviceNumber = deviceNumber
6285 
    args.write(self._oprot)
6286 
    self._oprot.writeMessageEnd()
6287 
    self._oprot.trans.flush()
6288 
 
6289 
  def recv_getRechargeOrdersForDevice(self, ):
6290 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6291 
    if mtype == TMessageType.EXCEPTION:
6292 
      x = TApplicationException()
6293 
      x.read(self._iprot)
6294 
      self._iprot.readMessageEnd()
6295 
      raise x
6296 
    result = getRechargeOrdersForDevice_result()
6297 
    result.read(self._iprot)
6298 
    self._iprot.readMessageEnd()
6299 
    if result.success is not None:
6300 
      return result.success
6301 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6302 
 
6303 
  def addAmountToWallet(self, userId, orderId, amount):
6304 
    """
6305 
    Parameters:
6306 
     - userId
6307 
     - orderId
6308 
     - amount
6309 
    """
6310 
    self.send_addAmountToWallet(userId, orderId, amount)
6311 
    self.recv_addAmountToWallet()
6312 
 
6313 
  def send_addAmountToWallet(self, userId, orderId, amount):
6314 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6315 
    args = addAmountToWallet_args()
6316 
    args.userId = userId
6317 
    args.orderId = orderId
6318 
    args.amount = amount
6319 
    args.write(self._oprot)
6320 
    self._oprot.writeMessageEnd()
6321 
    self._oprot.trans.flush()
6322 
 
6323 
  def recv_addAmountToWallet(self, ):
6324 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6325 
    if mtype == TMessageType.EXCEPTION:
6326 
      x = TApplicationException()
6327 
      x.read(self._iprot)
6328 
      self._iprot.readMessageEnd()
6329 
      raise x
6330 
    result = addAmountToWallet_result()
6331 
    result.read(self._iprot)
6332 
    self._iprot.readMessageEnd()
6333 
    return
6334 
 
6188 rajveer 6335 
  def getRechargeStatistics(self, ):
6336 
    self.send_getRechargeStatistics()
6337 
    return self.recv_getRechargeStatistics()
6338 
 
6339 
  def send_getRechargeStatistics(self, ):
6340 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6341 
    args = getRechargeStatistics_args()
6342 
    args.write(self._oprot)
6343 
    self._oprot.writeMessageEnd()
6344 
    self._oprot.trans.flush()
6345 
 
6346 
  def recv_getRechargeStatistics(self, ):
6347 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6348 
    if mtype == TMessageType.EXCEPTION:
6349 
      x = TApplicationException()
6350 
      x.read(self._iprot)
6351 
      self._iprot.readMessageEnd()
6352 
      raise x
6353 
    result = getRechargeStatistics_result()
6354 
    result.read(self._iprot)
6355 
    self._iprot.readMessageEnd()
6356 
    if result.success is not None:
6357 
      return result.success
6358 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6359 
 
6154 rajveer 6360 
  def getRechargeOrdersForStatus(self, status):
6361 
    """
6362 
    Parameters:
6363 
     - status
6364 
    """
6365 
    self.send_getRechargeOrdersForStatus(status)
6366 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6367 
 
6154 rajveer 6368 
  def send_getRechargeOrdersForStatus(self, status):
6369 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6370 
    args = getRechargeOrdersForStatus_args()
6371 
    args.status = status
6372 
    args.write(self._oprot)
6373 
    self._oprot.writeMessageEnd()
6374 
    self._oprot.trans.flush()
6375 
 
6376 
  def recv_getRechargeOrdersForStatus(self, ):
6377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6378 
    if mtype == TMessageType.EXCEPTION:
6379 
      x = TApplicationException()
6380 
      x.read(self._iprot)
6381 
      self._iprot.readMessageEnd()
6382 
      raise x
6383 
    result = getRechargeOrdersForStatus_result()
6384 
    result.read(self._iprot)
6385 
    self._iprot.readMessageEnd()
6386 
    if result.success is not None:
6387 
      return result.success
6388 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6389 
 
6159 rajveer 6390 
  def getPlansForOperator(self, operatorId):
6391 
    """
6392 
    Parameters:
6393 
     - operatorId
6394 
    """
6395 
    self.send_getPlansForOperator(operatorId)
6396 
    return self.recv_getPlansForOperator()
6154 rajveer 6397 
 
6159 rajveer 6398 
  def send_getPlansForOperator(self, operatorId):
6399 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6400 
    args = getPlansForOperator_args()
6401 
    args.operatorId = operatorId
6402 
    args.write(self._oprot)
6403 
    self._oprot.writeMessageEnd()
6404 
    self._oprot.trans.flush()
6405 
 
6406 
  def recv_getPlansForOperator(self, ):
6407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6408 
    if mtype == TMessageType.EXCEPTION:
6409 
      x = TApplicationException()
6410 
      x.read(self._iprot)
6411 
      self._iprot.readMessageEnd()
6412 
      raise x
6413 
    result = getPlansForOperator_result()
6414 
    result.read(self._iprot)
6415 
    self._iprot.readMessageEnd()
6416 
    if result.success is not None:
6417 
      return result.success
6418 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6419 
 
6307 anupam.sin 6420 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6421 
    """
6422 
    Returns denominations for a given operator and circle
6159 rajveer 6423 
 
6289 anupam.sin 6424 
    Parameters:
6425 
     - operatorId
6307 anupam.sin 6426 
     - circleCode
6289 anupam.sin 6427 
     - denominationType
6428 
    """
6307 anupam.sin 6429 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6430 
    return self.recv_getRechargeDenominations()
6431 
 
6307 anupam.sin 6432 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6433 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6434 
    args = getRechargeDenominations_args()
6435 
    args.operatorId = operatorId
6307 anupam.sin 6436 
    args.circleCode = circleCode
6289 anupam.sin 6437 
    args.denominationType = denominationType
6438 
    args.write(self._oprot)
6439 
    self._oprot.writeMessageEnd()
6440 
    self._oprot.trans.flush()
6441 
 
6442 
  def recv_getRechargeDenominations(self, ):
6443 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6444 
    if mtype == TMessageType.EXCEPTION:
6445 
      x = TApplicationException()
6446 
      x.read(self._iprot)
6447 
      self._iprot.readMessageEnd()
6448 
      raise x
6449 
    result = getRechargeDenominations_result()
6450 
    result.read(self._iprot)
6451 
    self._iprot.readMessageEnd()
6452 
    if result.success is not None:
6453 
      return result.success
6454 
    if result.ex is not None:
6455 
      raise result.ex
6456 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6457 
 
6371 rajveer 6458 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6459 
    """
6460 
    Parameters:
6461 
     - operatorId
6462 
     - circleId
6463 
     - isAvailable
6464 
    """
6465 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6466 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6467 
 
6371 rajveer 6468 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6469 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6470 
    args = updateAvailabilityStatus_args()
6471 
    args.operatorId = operatorId
6472 
    args.circleId = circleId
6473 
    args.isAvailable = isAvailable
6474 
    args.write(self._oprot)
6475 
    self._oprot.writeMessageEnd()
6476 
    self._oprot.trans.flush()
6477 
 
6478 
  def recv_updateAvailabilityStatus(self, ):
6479 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6480 
    if mtype == TMessageType.EXCEPTION:
6481 
      x = TApplicationException()
6482 
      x.read(self._iprot)
6483 
      self._iprot.readMessageEnd()
6484 
      raise x
6485 
    result = updateAvailabilityStatus_result()
6486 
    result.read(self._iprot)
6487 
    self._iprot.readMessageEnd()
6488 
    return
6489 
 
6389 rajveer 6490 
  def getAvailableEmiSchemes(self, ):
6491 
    self.send_getAvailableEmiSchemes()
6492 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6493 
 
6389 rajveer 6494 
  def send_getAvailableEmiSchemes(self, ):
6495 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6496 
    args = getAvailableEmiSchemes_args()
6497 
    args.write(self._oprot)
6498 
    self._oprot.writeMessageEnd()
6499 
    self._oprot.trans.flush()
6500 
 
6501 
  def recv_getAvailableEmiSchemes(self, ):
6502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6503 
    if mtype == TMessageType.EXCEPTION:
6504 
      x = TApplicationException()
6505 
      x.read(self._iprot)
6506 
      self._iprot.readMessageEnd()
6507 
      raise x
6508 
    result = getAvailableEmiSchemes_result()
6509 
    result.read(self._iprot)
6510 
    self._iprot.readMessageEnd()
6511 
    if result.success is not None:
6512 
      return result.success
6513 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6514 
 
6515 
  def getMiscCharges(self, transactionId):
6516 
    """
6517 
    Parameters:
6518 
     - transactionId
6519 
    """
6520 
    self.send_getMiscCharges(transactionId)
6521 
    return self.recv_getMiscCharges()
6522 
 
6523 
  def send_getMiscCharges(self, transactionId):
6524 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6525 
    args = getMiscCharges_args()
6526 
    args.transactionId = transactionId
6527 
    args.write(self._oprot)
6528 
    self._oprot.writeMessageEnd()
6529 
    self._oprot.trans.flush()
6530 
 
6531 
  def recv_getMiscCharges(self, ):
6532 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6533 
    if mtype == TMessageType.EXCEPTION:
6534 
      x = TApplicationException()
6535 
      x.read(self._iprot)
6536 
      self._iprot.readMessageEnd()
6537 
      raise x
6538 
    result = getMiscCharges_result()
6539 
    result.read(self._iprot)
6540 
    self._iprot.readMessageEnd()
6541 
    if result.success is not None:
6542 
      return result.success
6543 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6544 
 
6507 anupam.sin 6545 
  def refundRechargeOrder(self, rechargeOrderId):
6546 
    """
6547 
    Parameters:
6548 
     - rechargeOrderId
6549 
    """
6550 
    self.send_refundRechargeOrder(rechargeOrderId)
6551 
    return self.recv_refundRechargeOrder()
6389 rajveer 6552 
 
6507 anupam.sin 6553 
  def send_refundRechargeOrder(self, rechargeOrderId):
6554 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6555 
    args = refundRechargeOrder_args()
6556 
    args.rechargeOrderId = rechargeOrderId
6557 
    args.write(self._oprot)
6558 
    self._oprot.writeMessageEnd()
6559 
    self._oprot.trans.flush()
6560 
 
6561 
  def recv_refundRechargeOrder(self, ):
6562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6563 
    if mtype == TMessageType.EXCEPTION:
6564 
      x = TApplicationException()
6565 
      x.read(self._iprot)
6566 
      self._iprot.readMessageEnd()
6567 
      raise x
6568 
    result = refundRechargeOrder_result()
6569 
    result.read(self._iprot)
6570 
    self._iprot.readMessageEnd()
6571 
    if result.success is not None:
6572 
      return result.success
6573 
    if result.ex is not None:
6574 
      raise result.ex
6575 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6576 
 
6821 amar.kumar 6577 
  def getPhysicalOrders(self, fromDate, toDate):
6578 
    """
6579 
    Parameters:
6580 
     - fromDate
6581 
     - toDate
6582 
    """
6583 
    self.send_getPhysicalOrders(fromDate, toDate)
6584 
    return self.recv_getPhysicalOrders()
6507 anupam.sin 6585 
 
6821 amar.kumar 6586 
  def send_getPhysicalOrders(self, fromDate, toDate):
6587 
    self._oprot.writeMessageBegin('getPhysicalOrders', TMessageType.CALL, self._seqid)
6588 
    args = getPhysicalOrders_args()
6589 
    args.fromDate = fromDate
6590 
    args.toDate = toDate
6591 
    args.write(self._oprot)
6592 
    self._oprot.writeMessageEnd()
6593 
    self._oprot.trans.flush()
6594 
 
6595 
  def recv_getPhysicalOrders(self, ):
6596 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6597 
    if mtype == TMessageType.EXCEPTION:
6598 
      x = TApplicationException()
6599 
      x.read(self._iprot)
6600 
      self._iprot.readMessageEnd()
6601 
      raise x
6602 
    result = getPhysicalOrders_result()
6603 
    result.read(self._iprot)
6604 
    self._iprot.readMessageEnd()
6605 
    if result.success is not None:
6606 
      return result.success
6607 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPhysicalOrders failed: unknown result");
6608 
 
6906 rajveer 6609 
  def getDocument(self, docType, docSource):
6610 
    """
6611 
    Parameters:
6612 
     - docType
6613 
     - docSource
6614 
    """
6615 
    self.send_getDocument(docType, docSource)
6616 
    return self.recv_getDocument()
6821 amar.kumar 6617 
 
6906 rajveer 6618 
  def send_getDocument(self, docType, docSource):
6619 
    self._oprot.writeMessageBegin('getDocument', TMessageType.CALL, self._seqid)
6620 
    args = getDocument_args()
6621 
    args.docType = docType
6622 
    args.docSource = docSource
6623 
    args.write(self._oprot)
6624 
    self._oprot.writeMessageEnd()
6625 
    self._oprot.trans.flush()
6626 
 
6627 
  def recv_getDocument(self, ):
6628 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6629 
    if mtype == TMessageType.EXCEPTION:
6630 
      x = TApplicationException()
6631 
      x.read(self._iprot)
6632 
      self._iprot.readMessageEnd()
6633 
      raise x
6634 
    result = getDocument_result()
6635 
    result.read(self._iprot)
6636 
    self._iprot.readMessageEnd()
6637 
    if result.success is not None:
6638 
      return result.success
6639 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDocument failed: unknown result");
6640 
 
6985 anupam.sin 6641 
  def changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6642 
    """
6643 
    Parameters:
6644 
     - orderId
6645 
     - line1
6646 
     - line2
6647 
     - city
6648 
     - state
6649 
     - pin
6650 
    """
6651 
    self.send_changeShippingAddress(orderId, line1, line2, city, state, pin)
6652 
    return self.recv_changeShippingAddress()
6906 rajveer 6653 
 
6985 anupam.sin 6654 
  def send_changeShippingAddress(self, orderId, line1, line2, city, state, pin):
6655 
    self._oprot.writeMessageBegin('changeShippingAddress', TMessageType.CALL, self._seqid)
6656 
    args = changeShippingAddress_args()
6657 
    args.orderId = orderId
6658 
    args.line1 = line1
6659 
    args.line2 = line2
6660 
    args.city = city
6661 
    args.state = state
6662 
    args.pin = pin
6663 
    args.write(self._oprot)
6664 
    self._oprot.writeMessageEnd()
6665 
    self._oprot.trans.flush()
6666 
 
6667 
  def recv_changeShippingAddress(self, ):
6668 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6669 
    if mtype == TMessageType.EXCEPTION:
6670 
      x = TApplicationException()
6671 
      x.read(self._iprot)
6672 
      self._iprot.readMessageEnd()
6673 
      raise x
6674 
    result = changeShippingAddress_result()
6675 
    result.read(self._iprot)
6676 
    self._iprot.readMessageEnd()
6677 
    if result.success is not None:
6678 
      return result.success
6679 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeShippingAddress failed: unknown result");
6680 
 
6681 
 
3376 rajveer 6682 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6683 
  def __init__(self, handler):
3376 rajveer 6684 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6685 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6686 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6687 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6688 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6689 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6690 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6691 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6692 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6693 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6694 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6695 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6696 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6697 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6698 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6699 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6700 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6701 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6702 
    self._processMap["createOrder"] = Processor.process_createOrder
6703 
    self._processMap["getOrder"] = Processor.process_getOrder
6704 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6705 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6706 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6707 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6708 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6709 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6710 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6711 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6712 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6713 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6714 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6715 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6716 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6717 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6718 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6719 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6720 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6721 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6722 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6723 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6724 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6725 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6726 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6727 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6728 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6729 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6730 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6731 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6732 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6733 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6734 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6735 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6736 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6737 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6738 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6739 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6740 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6741 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6742 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6743 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6744 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6745 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6746 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6747 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6748 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6749 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6750 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6751 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6752 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6753 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6754 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6755 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6756 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6757 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6758 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6759 
    self._processMap["changeItem"] = Processor.process_changeItem
6760 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6761 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6762 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6763 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6764 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6765 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6766 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6767 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6768 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6769 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6770 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6771 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6772 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6773 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6774 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6775 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6776 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6777 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6778 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6779 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6780 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6781 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6782 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6783 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6784 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6785 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6786 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6787 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6788 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6789 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6790 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6791 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6792 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6793 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6794 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6795 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6796 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6797 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6798 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6799 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6800 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6801 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6802 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6803 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6804 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6805 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6806 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6807 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6808 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6809 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6810 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6811 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6812 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6813 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6814 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6815 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6816 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6817 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6818 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 6819 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 6820 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6821 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 6822 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 6823 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
6824 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 6825 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 6826 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 6827 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 6828 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 6829 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 6830 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
6831 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 6832 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
6821 amar.kumar 6833 
    self._processMap["getPhysicalOrders"] = Processor.process_getPhysicalOrders
6906 rajveer 6834 
    self._processMap["getDocument"] = Processor.process_getDocument
6985 anupam.sin 6835 
    self._processMap["changeShippingAddress"] = Processor.process_changeShippingAddress
94 ashish 6836 
 
6837 
  def process(self, iprot, oprot):
6838 
    (name, type, seqid) = iprot.readMessageBegin()
6839 
    if name not in self._processMap:
6840 
      iprot.skip(TType.STRUCT)
6841 
      iprot.readMessageEnd()
6842 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6843 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6844 
      x.write(oprot)
6845 
      oprot.writeMessageEnd()
6846 
      oprot.trans.flush()
6847 
      return
6848 
    else:
6849 
      self._processMap[name](self, seqid, iprot, oprot)
6850 
    return True
6851 
 
6852 
  def process_createTransaction(self, seqid, iprot, oprot):
6853 
    args = createTransaction_args()
6854 
    args.read(iprot)
6855 
    iprot.readMessageEnd()
6856 
    result = createTransaction_result()
6857 
    try:
132 ashish 6858 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6859 
    except TransactionServiceException, ex:
6860 
      result.ex = ex
6861 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6862 
    result.write(oprot)
6863 
    oprot.writeMessageEnd()
6864 
    oprot.trans.flush()
6865 
 
6866 
  def process_getTransaction(self, seqid, iprot, oprot):
6867 
    args = getTransaction_args()
6868 
    args.read(iprot)
6869 
    iprot.readMessageEnd()
6870 
    result = getTransaction_result()
6871 
    try:
6872 
      result.success = self._handler.getTransaction(args.id)
6873 
    except TransactionServiceException, ex:
6874 
      result.ex = ex
6875 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6876 
    result.write(oprot)
6877 
    oprot.writeMessageEnd()
6878 
    oprot.trans.flush()
6879 
 
6880 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6881 
    args = getTransactionsForCustomer_args()
6882 
    args.read(iprot)
6883 
    iprot.readMessageEnd()
6884 
    result = getTransactionsForCustomer_result()
6885 
    try:
6886 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6887 
    except TransactionServiceException, ex:
6888 
      result.ex = ex
6889 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6890 
    result.write(oprot)
6891 
    oprot.writeMessageEnd()
6892 
    oprot.trans.flush()
6893 
 
132 ashish 6894 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6895 
    args = getTransactionsForShoppingCartId_args()
6896 
    args.read(iprot)
6897 
    iprot.readMessageEnd()
6898 
    result = getTransactionsForShoppingCartId_result()
6899 
    try:
6900 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6901 
    except TransactionServiceException, ex:
6902 
      result.ex = ex
6903 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6904 
    result.write(oprot)
6905 
    oprot.writeMessageEnd()
6906 
    oprot.trans.flush()
6907 
 
94 ashish 6908 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6909 
    args = getTransactionStatus_args()
6910 
    args.read(iprot)
6911 
    iprot.readMessageEnd()
6912 
    result = getTransactionStatus_result()
6913 
    try:
6914 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6915 
    except TransactionServiceException, ex:
6916 
      result.ex = ex
6917 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6918 
    result.write(oprot)
6919 
    oprot.writeMessageEnd()
6920 
    oprot.trans.flush()
6921 
 
6922 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6923 
    args = changeTransactionStatus_args()
6924 
    args.read(iprot)
6925 
    iprot.readMessageEnd()
6926 
    result = changeTransactionStatus_result()
6927 
    try:
5527 anupam.sin 6928 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6929 
    except TransactionServiceException, ex:
6930 
      result.ex = ex
6931 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6932 
    result.write(oprot)
6933 
    oprot.writeMessageEnd()
6934 
    oprot.trans.flush()
6935 
 
1398 varun.gupt 6936 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6937 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6938 
    args.read(iprot)
6939 
    iprot.readMessageEnd()
1398 varun.gupt 6940 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6941 
    try:
1398 varun.gupt 6942 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6943 
    except TransactionServiceException, ex:
6944 
      result.ex = ex
1398 varun.gupt 6945 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6946 
    result.write(oprot)
6947 
    oprot.writeMessageEnd()
6948 
    oprot.trans.flush()
6949 
 
483 rajveer 6950 
  def process_getAllOrders(self, seqid, iprot, oprot):
6951 
    args = getAllOrders_args()
94 ashish 6952 
    args.read(iprot)
6953 
    iprot.readMessageEnd()
483 rajveer 6954 
    result = getAllOrders_result()
94 ashish 6955 
    try:
4801 anupam.sin 6956 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6957 
    except TransactionServiceException, ex:
6958 
      result.ex = ex
483 rajveer 6959 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6960 
    result.write(oprot)
6961 
    oprot.writeMessageEnd()
6962 
    oprot.trans.flush()
6963 
 
4133 chandransh 6964 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
6965 
    args = getOrdersInBatch_args()
6966 
    args.read(iprot)
6967 
    iprot.readMessageEnd()
6968 
    result = getOrdersInBatch_result()
6969 
    try:
6970 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
6971 
    except TransactionServiceException, ex:
6972 
      result.ex = ex
6973 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
6974 
    result.write(oprot)
6975 
    oprot.writeMessageEnd()
6976 
    oprot.trans.flush()
6977 
 
6978 
  def process_getOrderCount(self, seqid, iprot, oprot):
6979 
    args = getOrderCount_args()
6980 
    args.read(iprot)
6981 
    iprot.readMessageEnd()
6982 
    result = getOrderCount_result()
6983 
    try:
6984 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
6985 
    except TransactionServiceException, ex:
6986 
      result.ex = ex
6987 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
6988 
    result.write(oprot)
6989 
    oprot.writeMessageEnd()
6990 
    oprot.trans.flush()
6991 
 
999 varun.gupt 6992 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
6993 
    args = getOrdersByBillingDate_args()
6994 
    args.read(iprot)
6995 
    iprot.readMessageEnd()
6996 
    result = getOrdersByBillingDate_result()
6997 
    try:
6998 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
6999 
    except TransactionServiceException, ex:
7000 
      result.ex = ex
7001 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
7002 
    result.write(oprot)
7003 
    oprot.writeMessageEnd()
7004 
    oprot.trans.flush()
7005 
 
3427 chandransh 7006 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
7007 
    args = getOrdersByShippingDate_args()
7008 
    args.read(iprot)
7009 
    iprot.readMessageEnd()
7010 
    result = getOrdersByShippingDate_result()
7011 
    try:
3451 chandransh 7012 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 7013 
    except TransactionServiceException, ex:
7014 
      result.ex = ex
7015 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
7016 
    result.write(oprot)
7017 
    oprot.writeMessageEnd()
7018 
    oprot.trans.flush()
7019 
 
1382 varun.gupt 7020 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
7021 
    args = getReturnableOrdersForCustomer_args()
7022 
    args.read(iprot)
7023 
    iprot.readMessageEnd()
7024 
    result = getReturnableOrdersForCustomer_result()
7025 
    try:
7026 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
7027 
    except TransactionServiceException, ex:
7028 
      result.ex = ex
7029 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
7030 
    result.write(oprot)
7031 
    oprot.writeMessageEnd()
7032 
    oprot.trans.flush()
7033 
 
7034 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
7035 
    args = getCancellableOrdersForCustomer_args()
7036 
    args.read(iprot)
7037 
    iprot.readMessageEnd()
7038 
    result = getCancellableOrdersForCustomer_result()
7039 
    try:
7040 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
7041 
    except TransactionServiceException, ex:
7042 
      result.ex = ex
7043 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
7044 
    result.write(oprot)
7045 
    oprot.writeMessageEnd()
7046 
    oprot.trans.flush()
7047 
 
483 rajveer 7048 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
7049 
    args = changeOrderStatus_args()
94 ashish 7050 
    args.read(iprot)
7051 
    iprot.readMessageEnd()
483 rajveer 7052 
    result = changeOrderStatus_result()
94 ashish 7053 
    try:
483 rajveer 7054 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 7055 
    except TransactionServiceException, ex:
7056 
      result.ex = ex
483 rajveer 7057 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 7058 
    result.write(oprot)
7059 
    oprot.writeMessageEnd()
7060 
    oprot.trans.flush()
7061 
 
483 rajveer 7062 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
7063 
    args = getOrdersForTransaction_args()
94 ashish 7064 
    args.read(iprot)
7065 
    iprot.readMessageEnd()
483 rajveer 7066 
    result = getOrdersForTransaction_result()
94 ashish 7067 
    try:
1528 ankur.sing 7068 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 7069 
    except TransactionServiceException, ex:
7070 
      result.ex = ex
483 rajveer 7071 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 7072 
    result.write(oprot)
7073 
    oprot.writeMessageEnd()
7074 
    oprot.trans.flush()
7075 
 
483 rajveer 7076 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
7077 
    args = getOrdersForCustomer_args()
94 ashish 7078 
    args.read(iprot)
7079 
    iprot.readMessageEnd()
483 rajveer 7080 
    result = getOrdersForCustomer_result()
94 ashish 7081 
    try:
3014 chandransh 7082 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 7083 
    except TransactionServiceException, ex:
7084 
      result.ex = ex
483 rajveer 7085 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 7086 
    result.write(oprot)
7087 
    oprot.writeMessageEnd()
7088 
    oprot.trans.flush()
7089 
 
483 rajveer 7090 
  def process_createOrder(self, seqid, iprot, oprot):
7091 
    args = createOrder_args()
94 ashish 7092 
    args.read(iprot)
7093 
    iprot.readMessageEnd()
483 rajveer 7094 
    result = createOrder_result()
94 ashish 7095 
    try:
483 rajveer 7096 
      result.success = self._handler.createOrder(args.order)
94 ashish 7097 
    except TransactionServiceException, ex:
7098 
      result.ex = ex
483 rajveer 7099 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 7100 
    result.write(oprot)
7101 
    oprot.writeMessageEnd()
7102 
    oprot.trans.flush()
7103 
 
483 rajveer 7104 
  def process_getOrder(self, seqid, iprot, oprot):
7105 
    args = getOrder_args()
94 ashish 7106 
    args.read(iprot)
7107 
    iprot.readMessageEnd()
483 rajveer 7108 
    result = getOrder_result()
94 ashish 7109 
    try:
483 rajveer 7110 
      result.success = self._handler.getOrder(args.id)
94 ashish 7111 
    except TransactionServiceException, ex:
7112 
      result.ex = ex
483 rajveer 7113 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 7114 
    result.write(oprot)
7115 
    oprot.writeMessageEnd()
7116 
    oprot.trans.flush()
7117 
 
483 rajveer 7118 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
7119 
    args = getLineItemsForOrder_args()
94 ashish 7120 
    args.read(iprot)
7121 
    iprot.readMessageEnd()
483 rajveer 7122 
    result = getLineItemsForOrder_result()
94 ashish 7123 
    try:
483 rajveer 7124 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 7125 
    except TransactionServiceException, ex:
7126 
      result.ex = ex
483 rajveer 7127 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 7128 
    result.write(oprot)
7129 
    oprot.writeMessageEnd()
7130 
    oprot.trans.flush()
7131 
 
4999 phani.kuma 7132 
  def process_getOrderList(self, seqid, iprot, oprot):
7133 
    args = getOrderList_args()
7134 
    args.read(iprot)
7135 
    iprot.readMessageEnd()
7136 
    result = getOrderList_result()
7137 
    result.success = self._handler.getOrderList(args.order_ids)
7138 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
7139 
    result.write(oprot)
7140 
    oprot.writeMessageEnd()
7141 
    oprot.trans.flush()
7142 
 
5386 phani.kuma 7143 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
7144 
    args = getOrderListForVendor_args()
7145 
    args.read(iprot)
7146 
    iprot.readMessageEnd()
7147 
    result = getOrderListForVendor_result()
7148 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
7149 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
7150 
    result.write(oprot)
7151 
    oprot.writeMessageEnd()
7152 
    oprot.trans.flush()
7153 
 
1528 ankur.sing 7154 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
7155 
    args = getOrderForCustomer_args()
7156 
    args.read(iprot)
7157 
    iprot.readMessageEnd()
7158 
    result = getOrderForCustomer_result()
7159 
    try:
7160 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
7161 
    except TransactionServiceException, ex:
7162 
      result.ex = ex
7163 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
7164 
    result.write(oprot)
7165 
    oprot.writeMessageEnd()
7166 
    oprot.trans.flush()
7167 
 
3064 chandransh 7168 
  def process_getAlerts(self, seqid, iprot, oprot):
7169 
    args = getAlerts_args()
7170 
    args.read(iprot)
7171 
    iprot.readMessageEnd()
7172 
    result = getAlerts_result()
4444 rajveer 7173 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 7174 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
7175 
    result.write(oprot)
7176 
    oprot.writeMessageEnd()
7177 
    oprot.trans.flush()
7178 
 
4394 rajveer 7179 
  def process_addAlert(self, seqid, iprot, oprot):
7180 
    args = addAlert_args()
3064 chandransh 7181 
    args.read(iprot)
7182 
    iprot.readMessageEnd()
4394 rajveer 7183 
    result = addAlert_result()
4444 rajveer 7184 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 7185 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 7186 
    result.write(oprot)
7187 
    oprot.writeMessageEnd()
7188 
    oprot.trans.flush()
7189 
 
4444 rajveer 7190 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
7191 
    args = markAlertsAsSeen_args()
7192 
    args.read(iprot)
7193 
    iprot.readMessageEnd()
7194 
    result = markAlertsAsSeen_result()
7195 
    self._handler.markAlertsAsSeen(args.warehouseId)
7196 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
7197 
    result.write(oprot)
7198 
    oprot.writeMessageEnd()
7199 
    oprot.trans.flush()
7200 
 
3064 chandransh 7201 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
7202 
    args = getValidOrderCount_args()
7203 
    args.read(iprot)
7204 
    iprot.readMessageEnd()
7205 
    result = getValidOrderCount_result()
7206 
    result.success = self._handler.getValidOrderCount()
7207 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
7208 
    result.write(oprot)
7209 
    oprot.writeMessageEnd()
7210 
    oprot.trans.flush()
7211 
 
7212 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
7213 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
7214 
    args.read(iprot)
7215 
    iprot.readMessageEnd()
7216 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
7217 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
7218 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
7219 
    result.write(oprot)
7220 
    oprot.writeMessageEnd()
7221 
    oprot.trans.flush()
7222 
 
7223 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
7224 
    args = getValidOrdersAmountRange_args()
7225 
    args.read(iprot)
7226 
    iprot.readMessageEnd()
7227 
    result = getValidOrdersAmountRange_result()
7228 
    result.success = self._handler.getValidOrdersAmountRange()
7229 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
7230 
    result.write(oprot)
7231 
    oprot.writeMessageEnd()
7232 
    oprot.trans.flush()
7233 
 
7234 
  def process_getValidOrders(self, seqid, iprot, oprot):
7235 
    args = getValidOrders_args()
7236 
    args.read(iprot)
7237 
    iprot.readMessageEnd()
7238 
    result = getValidOrders_result()
5874 rajveer 7239 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 7240 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
7241 
    result.write(oprot)
7242 
    oprot.writeMessageEnd()
7243 
    oprot.trans.flush()
7244 
 
1220 chandransh 7245 
  def process_batchOrders(self, seqid, iprot, oprot):
7246 
    args = batchOrders_args()
7247 
    args.read(iprot)
7248 
    iprot.readMessageEnd()
7249 
    result = batchOrders_result()
7250 
    try:
7251 
      result.success = self._handler.batchOrders(args.warehouseId)
7252 
    except TransactionServiceException, ex:
7253 
      result.ex = ex
7254 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
7255 
    result.write(oprot)
7256 
    oprot.writeMessageEnd()
7257 
    oprot.trans.flush()
7258 
 
1208 chandransh 7259 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
7260 
    args = markOrderAsOutOfStock_args()
7261 
    args.read(iprot)
7262 
    iprot.readMessageEnd()
7263 
    result = markOrderAsOutOfStock_result()
7264 
    try:
7265 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
7266 
    except TransactionServiceException, ex:
7267 
      result.ex = ex
7268 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
7269 
    result.write(oprot)
7270 
    oprot.writeMessageEnd()
7271 
    oprot.trans.flush()
7272 
 
3064 chandransh 7273 
  def process_verifyOrder(self, seqid, iprot, oprot):
7274 
    args = verifyOrder_args()
759 chandransh 7275 
    args.read(iprot)
7276 
    iprot.readMessageEnd()
3064 chandransh 7277 
    result = verifyOrder_result()
759 chandransh 7278 
    try:
3064 chandransh 7279 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 7280 
    except TransactionServiceException, ex:
7281 
      result.ex = ex
3064 chandransh 7282 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 7283 
    result.write(oprot)
7284 
    oprot.writeMessageEnd()
7285 
    oprot.trans.flush()
7286 
 
3064 chandransh 7287 
  def process_acceptOrder(self, seqid, iprot, oprot):
7288 
    args = acceptOrder_args()
1113 chandransh 7289 
    args.read(iprot)
7290 
    iprot.readMessageEnd()
3064 chandransh 7291 
    result = acceptOrder_result()
1113 chandransh 7292 
    try:
3064 chandransh 7293 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7294 
    except TransactionServiceException, ex:
7295 
      result.ex = ex
3064 chandransh 7296 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7297 
    result.write(oprot)
7298 
    oprot.writeMessageEnd()
7299 
    oprot.trans.flush()
7300 
 
3064 chandransh 7301 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7302 
    args = addBillingDetails_args()
1135 chandransh 7303 
    args.read(iprot)
7304 
    iprot.readMessageEnd()
3064 chandransh 7305 
    result = addBillingDetails_result()
1135 chandransh 7306 
    try:
5110 mandeep.dh 7307 
      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 7308 
    except TransactionServiceException, ex:
7309 
      result.ex = ex
3064 chandransh 7310 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7311 
    result.write(oprot)
7312 
    oprot.writeMessageEnd()
7313 
    oprot.trans.flush()
7314 
 
4579 rajveer 7315 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7316 
    args = addInvoiceNumber_args()
7317 
    args.read(iprot)
7318 
    iprot.readMessageEnd()
7319 
    result = addInvoiceNumber_result()
7320 
    try:
6756 amar.kumar 7321 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color, args.serialNumber, args.itemNumber)
4579 rajveer 7322 
    except TransactionServiceException, ex:
7323 
      result.ex = ex
7324 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7325 
    result.write(oprot)
7326 
    oprot.writeMessageEnd()
7327 
    oprot.trans.flush()
7328 
 
4410 rajveer 7329 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7330 
    args = markOrdersAsShippedFromWarehouse_args()
7331 
    args.read(iprot)
7332 
    iprot.readMessageEnd()
7333 
    result = markOrdersAsShippedFromWarehouse_result()
7334 
    try:
4789 rajveer 7335 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7336 
    except TransactionServiceException, ex:
7337 
      result.ex = ex
7338 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7339 
    result.write(oprot)
7340 
    oprot.writeMessageEnd()
7341 
    oprot.trans.flush()
7342 
 
5676 rajveer 7343 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7344 
    args = markOrdersAsReturnedFromStore_args()
7345 
    args.read(iprot)
7346 
    iprot.readMessageEnd()
7347 
    result = markOrdersAsReturnedFromStore_result()
7348 
    try:
5713 rajveer 7349 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7350 
    except TransactionServiceException, ex:
7351 
      result.ex = ex
7352 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7353 
    result.write(oprot)
7354 
    oprot.writeMessageEnd()
7355 
    oprot.trans.flush()
7356 
 
3064 chandransh 7357 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7358 
    args = markOrdersAsPickedUp_args()
304 ashish 7359 
    args.read(iprot)
7360 
    iprot.readMessageEnd()
3064 chandransh 7361 
    result = markOrdersAsPickedUp_result()
7362 
    try:
4910 phani.kuma 7363 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7364 
    except TransactionServiceException, ex:
7365 
      result.ex = ex
7366 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7367 
    result.write(oprot)
7368 
    oprot.writeMessageEnd()
7369 
    oprot.trans.flush()
94 ashish 7370 
 
4910 phani.kuma 7371 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7372 
    args = getOrdersNotPickedUp_args()
7373 
    args.read(iprot)
7374 
    iprot.readMessageEnd()
7375 
    result = getOrdersNotPickedUp_result()
7376 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7377 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7378 
    result.write(oprot)
7379 
    oprot.writeMessageEnd()
7380 
    oprot.trans.flush()
7381 
 
3064 chandransh 7382 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7383 
    args = markOrdersAsDelivered_args()
304 ashish 7384 
    args.read(iprot)
7385 
    iprot.readMessageEnd()
3064 chandransh 7386 
    result = markOrdersAsDelivered_result()
7387 
    try:
7388 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7389 
    except TransactionServiceException, ex:
7390 
      result.ex = ex
7391 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7392 
    result.write(oprot)
7393 
    oprot.writeMessageEnd()
7394 
    oprot.trans.flush()
7395 
 
4910 phani.kuma 7396 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7397 
    args = markAsRTOrders_args()
1596 ankur.sing 7398 
    args.read(iprot)
7399 
    iprot.readMessageEnd()
4910 phani.kuma 7400 
    result = markAsRTOrders_result()
3064 chandransh 7401 
    try:
4910 phani.kuma 7402 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7403 
    except TransactionServiceException, ex:
7404 
      result.ex = ex
4910 phani.kuma 7405 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7406 
    result.write(oprot)
7407 
    oprot.writeMessageEnd()
7408 
    oprot.trans.flush()
304 ashish 7409 
 
4910 phani.kuma 7410 
  def process_getRTOrders(self, seqid, iprot, oprot):
7411 
    args = getRTOrders_args()
7412 
    args.read(iprot)
7413 
    iprot.readMessageEnd()
7414 
    result = getRTOrders_result()
7415 
    result.success = self._handler.getRTOrders(args.providerId)
7416 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7417 
    result.write(oprot)
7418 
    oprot.writeMessageEnd()
7419 
    oprot.trans.flush()
7420 
 
3064 chandransh 7421 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7422 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7423 
    args.read(iprot)
7424 
    iprot.readMessageEnd()
3064 chandransh 7425 
    result = updateNonDeliveryReason_result()
7426 
    try:
4910 phani.kuma 7427 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7428 
    except TransactionServiceException, ex:
7429 
      result.ex = ex
7430 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7431 
    result.write(oprot)
7432 
    oprot.writeMessageEnd()
7433 
    oprot.trans.flush()
1596 ankur.sing 7434 
 
4910 phani.kuma 7435 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7436 
    args = getNonDeliveredOrdersbyCourier_args()
7437 
    args.read(iprot)
7438 
    iprot.readMessageEnd()
7439 
    result = getNonDeliveredOrdersbyCourier_result()
7440 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7441 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7442 
    result.write(oprot)
7443 
    oprot.writeMessageEnd()
7444 
    oprot.trans.flush()
7445 
 
7446 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7447 
    args = markOrdersAsLocalConnected_args()
7448 
    args.read(iprot)
7449 
    iprot.readMessageEnd()
7450 
    result = markOrdersAsLocalConnected_result()
7451 
    try:
7452 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7453 
    except TransactionServiceException, ex:
7454 
      result.ex = ex
7455 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7456 
    result.write(oprot)
7457 
    oprot.writeMessageEnd()
7458 
    oprot.trans.flush()
7459 
 
7460 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7461 
    args = getOrdersNotLocalConnected_args()
7462 
    args.read(iprot)
7463 
    iprot.readMessageEnd()
7464 
    result = getOrdersNotLocalConnected_result()
7465 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7466 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7467 
    result.write(oprot)
7468 
    oprot.writeMessageEnd()
7469 
    oprot.trans.flush()
7470 
 
7471 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7472 
    args = markOrdersAsDestinationCityReached_args()
7473 
    args.read(iprot)
7474 
    iprot.readMessageEnd()
7475 
    result = markOrdersAsDestinationCityReached_result()
7476 
    try:
7477 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7478 
    except TransactionServiceException, ex:
7479 
      result.ex = ex
7480 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7481 
    result.write(oprot)
7482 
    oprot.writeMessageEnd()
7483 
    oprot.trans.flush()
7484 
 
7485 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7486 
    args = markOrdersAsFirstDeliveryAttempted_args()
7487 
    args.read(iprot)
7488 
    iprot.readMessageEnd()
7489 
    result = markOrdersAsFirstDeliveryAttempted_result()
7490 
    try:
7491 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7492 
    except TransactionServiceException, ex:
7493 
      result.ex = ex
7494 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7495 
    result.write(oprot)
7496 
    oprot.writeMessageEnd()
7497 
    oprot.trans.flush()
7498 
 
3064 chandransh 7499 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7500 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7501 
    args.read(iprot)
7502 
    iprot.readMessageEnd()
3064 chandransh 7503 
    result = getUndeliveredOrders_result()
7504 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7505 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7506 
    result.write(oprot)
7507 
    oprot.writeMessageEnd()
7508 
    oprot.trans.flush()
7509 
 
4783 phani.kuma 7510 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7511 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7512 
    args.read(iprot)
7513 
    iprot.readMessageEnd()
7514 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7515 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7516 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7517 
    result.write(oprot)
7518 
    oprot.writeMessageEnd()
7519 
    oprot.trans.flush()
7520 
 
2536 chandransh 7521 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7522 
    args = toggleDOAFlag_args()
7523 
    args.read(iprot)
7524 
    iprot.readMessageEnd()
7525 
    result = toggleDOAFlag_result()
7526 
    try:
7527 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7528 
    except TransactionServiceException, ex:
7529 
      result.ex = ex
7530 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7531 
    result.write(oprot)
7532 
    oprot.writeMessageEnd()
7533 
    oprot.trans.flush()
1886 ankur.sing 7534 
 
4712 rajveer 7535 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7536 
    args = markOrderAsDelivered_args()
7537 
    args.read(iprot)
7538 
    iprot.readMessageEnd()
7539 
    result = markOrderAsDelivered_result()
7540 
    try:
7541 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7542 
    except TransactionServiceException, ex:
7543 
      result.ex = ex
7544 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7545 
    result.write(oprot)
7546 
    oprot.writeMessageEnd()
7547 
    oprot.trans.flush()
7548 
 
5553 rajveer 7549 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7550 
    args = markOrderAsReceivedAtStore_args()
7551 
    args.read(iprot)
7552 
    iprot.readMessageEnd()
7553 
    result = markOrderAsReceivedAtStore_result()
7554 
    try:
7555 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7556 
    except TransactionServiceException, ex:
7557 
      result.ex = ex
7558 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7559 
    result.write(oprot)
7560 
    oprot.writeMessageEnd()
7561 
    oprot.trans.flush()
7562 
 
4454 rajveer 7563 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7564 
    args = markOrderDoaRequestReceived_args()
7565 
    args.read(iprot)
7566 
    iprot.readMessageEnd()
7567 
    result = markOrderDoaRequestReceived_result()
7568 
    try:
7569 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7570 
    except TransactionServiceException, ex:
7571 
      result.ex = ex
7572 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7573 
    result.write(oprot)
7574 
    oprot.writeMessageEnd()
7575 
    oprot.trans.flush()
7576 
 
7577 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7578 
    args = markOrderDoaRequestAuthorized_args()
7579 
    args.read(iprot)
7580 
    iprot.readMessageEnd()
7581 
    result = markOrderDoaRequestAuthorized_result()
7582 
    try:
7583 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7584 
    except TransactionServiceException, ex:
7585 
      result.ex = ex
7586 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7587 
    result.write(oprot)
7588 
    oprot.writeMessageEnd()
7589 
    oprot.trans.flush()
7590 
 
4488 rajveer 7591 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7592 
    args = markOrderReturnRequestReceived_args()
7593 
    args.read(iprot)
7594 
    iprot.readMessageEnd()
7595 
    result = markOrderReturnRequestReceived_result()
7596 
    try:
7597 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7598 
    except TransactionServiceException, ex:
7599 
      result.ex = ex
7600 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7601 
    result.write(oprot)
7602 
    oprot.writeMessageEnd()
7603 
    oprot.trans.flush()
7604 
 
7605 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7606 
    args = markOrderReturnRequestAuthorized_args()
7607 
    args.read(iprot)
7608 
    iprot.readMessageEnd()
7609 
    result = markOrderReturnRequestAuthorized_result()
7610 
    try:
7611 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7612 
    except TransactionServiceException, ex:
7613 
      result.ex = ex
7614 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7615 
    result.write(oprot)
7616 
    oprot.writeMessageEnd()
7617 
    oprot.trans.flush()
7618 
 
2536 chandransh 7619 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7620 
    args = requestPickupNumber_args()
7621 
    args.read(iprot)
7622 
    iprot.readMessageEnd()
7623 
    result = requestPickupNumber_result()
7624 
    try:
4579 rajveer 7625 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7626 
    except TransactionServiceException, ex:
7627 
      result.ex = ex
7628 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7629 
    result.write(oprot)
7630 
    oprot.writeMessageEnd()
7631 
    oprot.trans.flush()
7632 
 
7633 
  def process_authorizePickup(self, seqid, iprot, oprot):
7634 
    args = authorizePickup_args()
7635 
    args.read(iprot)
7636 
    iprot.readMessageEnd()
7637 
    result = authorizePickup_result()
7638 
    try:
4602 rajveer 7639 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7640 
    except TransactionServiceException, ex:
7641 
      result.ex = ex
7642 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7643 
    result.write(oprot)
7644 
    oprot.writeMessageEnd()
7645 
    oprot.trans.flush()
7646 
 
2764 chandransh 7647 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7648 
    args = markDoasAsPickedUp_args()
7649 
    args.read(iprot)
7650 
    iprot.readMessageEnd()
7651 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7652 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7653 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7654 
    result.write(oprot)
7655 
    oprot.writeMessageEnd()
7656 
    oprot.trans.flush()
7657 
 
4910 phani.kuma 7658 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7659 
    args = getDoasNotPickedUp_args()
7660 
    args.read(iprot)
7661 
    iprot.readMessageEnd()
7662 
    result = getDoasNotPickedUp_result()
7663 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7664 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7665 
    result.write(oprot)
7666 
    oprot.writeMessageEnd()
7667 
    oprot.trans.flush()
7668 
 
4741 phani.kuma 7669 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7670 
    args = markReturnOrdersAsPickedUp_args()
7671 
    args.read(iprot)
7672 
    iprot.readMessageEnd()
7673 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7674 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7675 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7676 
    result.write(oprot)
7677 
    oprot.writeMessageEnd()
7678 
    oprot.trans.flush()
7679 
 
4910 phani.kuma 7680 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7681 
    args = getReturnOrdersNotPickedUp_args()
7682 
    args.read(iprot)
7683 
    iprot.readMessageEnd()
7684 
    result = getReturnOrdersNotPickedUp_result()
7685 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7686 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7687 
    result.write(oprot)
7688 
    oprot.writeMessageEnd()
7689 
    oprot.trans.flush()
7690 
 
2616 chandransh 7691 
  def process_receiveReturn(self, seqid, iprot, oprot):
7692 
    args = receiveReturn_args()
2591 chandransh 7693 
    args.read(iprot)
7694 
    iprot.readMessageEnd()
2616 chandransh 7695 
    result = receiveReturn_result()
2591 chandransh 7696 
    try:
4479 rajveer 7697 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7698 
    except TransactionServiceException, ex:
7699 
      result.ex = ex
2616 chandransh 7700 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7701 
    result.write(oprot)
7702 
    oprot.writeMessageEnd()
7703 
    oprot.trans.flush()
2536 chandransh 7704 
 
2591 chandransh 7705 
  def process_validateDoa(self, seqid, iprot, oprot):
7706 
    args = validateDoa_args()
7707 
    args.read(iprot)
7708 
    iprot.readMessageEnd()
7709 
    result = validateDoa_result()
7710 
    try:
7711 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7712 
    except TransactionServiceException, ex:
7713 
      result.ex = ex
7714 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7715 
    result.write(oprot)
7716 
    oprot.writeMessageEnd()
7717 
    oprot.trans.flush()
7718 
 
4495 rajveer 7719 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7720 
    args = validateReturnProduct_args()
7721 
    args.read(iprot)
7722 
    iprot.readMessageEnd()
7723 
    result = validateReturnProduct_result()
7724 
    try:
7725 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7726 
    except TransactionServiceException, ex:
7727 
      result.ex = ex
7728 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7729 
    result.write(oprot)
7730 
    oprot.writeMessageEnd()
7731 
    oprot.trans.flush()
7732 
 
2616 chandransh 7733 
  def process_reshipOrder(self, seqid, iprot, oprot):
7734 
    args = reshipOrder_args()
7735 
    args.read(iprot)
7736 
    iprot.readMessageEnd()
7737 
    result = reshipOrder_result()
7738 
    try:
7739 
      result.success = self._handler.reshipOrder(args.orderId)
7740 
    except TransactionServiceException, ex:
7741 
      result.ex = ex
7742 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7743 
    result.write(oprot)
7744 
    oprot.writeMessageEnd()
7745 
    oprot.trans.flush()
2591 chandransh 7746 
 
2616 chandransh 7747 
  def process_refundOrder(self, seqid, iprot, oprot):
7748 
    args = refundOrder_args()
7749 
    args.read(iprot)
7750 
    iprot.readMessageEnd()
7751 
    result = refundOrder_result()
7752 
    try:
3226 chandransh 7753 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7754 
    except TransactionServiceException, ex:
7755 
      result.ex = ex
7756 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7757 
    result.write(oprot)
7758 
    oprot.writeMessageEnd()
7759 
    oprot.trans.flush()
7760 
 
2690 chandransh 7761 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7762 
    args = getReturnOrders_args()
7763 
    args.read(iprot)
7764 
    iprot.readMessageEnd()
7765 
    result = getReturnOrders_result()
7766 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7767 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7768 
    result.write(oprot)
7769 
    oprot.writeMessageEnd()
7770 
    oprot.trans.flush()
2616 chandransh 7771 
 
5481 phani.kuma 7772 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7773 
    args = getAllReturnOrders_args()
7774 
    args.read(iprot)
7775 
    iprot.readMessageEnd()
7776 
    result = getAllReturnOrders_result()
7777 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7778 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7779 
    result.write(oprot)
7780 
    oprot.writeMessageEnd()
7781 
    oprot.trans.flush()
7782 
 
2700 chandransh 7783 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7784 
    args = getReturnOrder_args()
7785 
    args.read(iprot)
7786 
    iprot.readMessageEnd()
7787 
    result = getReturnOrder_result()
7788 
    try:
7789 
      result.success = self._handler.getReturnOrder(args.id)
7790 
    except TransactionServiceException, ex:
7791 
      result.ex = ex
7792 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7793 
    result.write(oprot)
7794 
    oprot.writeMessageEnd()
7795 
    oprot.trans.flush()
7796 
 
2690 chandransh 7797 
  def process_processReturn(self, seqid, iprot, oprot):
7798 
    args = processReturn_args()
7799 
    args.read(iprot)
7800 
    iprot.readMessageEnd()
7801 
    result = processReturn_result()
7802 
    try:
7803 
      self._handler.processReturn(args.returnOrderId)
7804 
    except TransactionServiceException, ex:
7805 
      result.ex = ex
7806 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7807 
    result.write(oprot)
7808 
    oprot.writeMessageEnd()
7809 
    oprot.trans.flush()
7810 
 
3451 chandransh 7811 
  def process_updateWeight(self, seqid, iprot, oprot):
7812 
    args = updateWeight_args()
7813 
    args.read(iprot)
7814 
    iprot.readMessageEnd()
7815 
    result = updateWeight_result()
7816 
    try:
7817 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7818 
    except TransactionServiceException, ex:
7819 
      result.ex = ex
7820 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7821 
    result.write(oprot)
7822 
    oprot.writeMessageEnd()
7823 
    oprot.trans.flush()
2819 chandransh 7824 
 
3469 chandransh 7825 
  def process_changeItem(self, seqid, iprot, oprot):
7826 
    args = changeItem_args()
7827 
    args.read(iprot)
7828 
    iprot.readMessageEnd()
7829 
    result = changeItem_result()
7830 
    try:
7831 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7832 
    except TransactionServiceException, ex:
7833 
      result.ex = ex
7834 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7835 
    result.write(oprot)
7836 
    oprot.writeMessageEnd()
7837 
    oprot.trans.flush()
3451 chandransh 7838 
 
3469 chandransh 7839 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7840 
    args = shiftToWarehouse_args()
7841 
    args.read(iprot)
7842 
    iprot.readMessageEnd()
7843 
    result = shiftToWarehouse_result()
7844 
    try:
7845 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7846 
    except TransactionServiceException, ex:
7847 
      result.ex = ex
7848 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7849 
    result.write(oprot)
7850 
    oprot.writeMessageEnd()
7851 
    oprot.trans.flush()
7852 
 
3553 chandransh 7853 
  def process_addDelayReason(self, seqid, iprot, oprot):
7854 
    args = addDelayReason_args()
7855 
    args.read(iprot)
7856 
    iprot.readMessageEnd()
7857 
    result = addDelayReason_result()
7858 
    try:
4647 rajveer 7859 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7860 
    except TransactionServiceException, ex:
7861 
      result.ex = ex
7862 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7863 
    result.write(oprot)
7864 
    oprot.writeMessageEnd()
7865 
    oprot.trans.flush()
3469 chandransh 7866 
 
3956 chandransh 7867 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7868 
    args = reconcileCodCollection_args()
7869 
    args.read(iprot)
7870 
    iprot.readMessageEnd()
7871 
    result = reconcileCodCollection_result()
7872 
    try:
7873 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7874 
    except TransactionServiceException, ex:
7875 
      result.ex = ex
7876 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7877 
    result.write(oprot)
7878 
    oprot.writeMessageEnd()
7879 
    oprot.trans.flush()
3553 chandransh 7880 
 
4008 mandeep.dh 7881 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7882 
    args = getTransactionsRequiringExtraProcessing_args()
7883 
    args.read(iprot)
7884 
    iprot.readMessageEnd()
7885 
    result = getTransactionsRequiringExtraProcessing_result()
7886 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7887 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7888 
    result.write(oprot)
7889 
    oprot.writeMessageEnd()
7890 
    oprot.trans.flush()
3956 chandransh 7891 
 
4008 mandeep.dh 7892 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7893 
    args = markTransactionAsProcessed_args()
7894 
    args.read(iprot)
7895 
    iprot.readMessageEnd()
7896 
    result = markTransactionAsProcessed_result()
7897 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7898 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7899 
    result.write(oprot)
7900 
    oprot.writeMessageEnd()
7901 
    oprot.trans.flush()
7902 
 
4018 chandransh 7903 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7904 
    args = getItemWiseRiskyOrdersCount_args()
7905 
    args.read(iprot)
7906 
    iprot.readMessageEnd()
7907 
    result = getItemWiseRiskyOrdersCount_result()
7908 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7909 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7910 
    result.write(oprot)
7911 
    oprot.writeMessageEnd()
7912 
    oprot.trans.flush()
4008 mandeep.dh 7913 
 
4295 varun.gupt 7914 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7915 
    args = getOrdersForItemIds_args()
7916 
    args.read(iprot)
7917 
    iprot.readMessageEnd()
7918 
    result = getOrdersForItemIds_result()
7919 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7920 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7921 
    result.write(oprot)
7922 
    oprot.writeMessageEnd()
7923 
    oprot.trans.flush()
7924 
 
4247 rajveer 7925 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7926 
    args = markOrderCancellationRequestReceived_args()
7927 
    args.read(iprot)
7928 
    iprot.readMessageEnd()
7929 
    result = markOrderCancellationRequestReceived_result()
7930 
    try:
7931 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7932 
    except TransactionServiceException, ex:
7933 
      result.ex = ex
7934 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7935 
    result.write(oprot)
7936 
    oprot.writeMessageEnd()
7937 
    oprot.trans.flush()
4018 chandransh 7938 
 
4247 rajveer 7939 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7940 
    args = markOrderCancellationRequestConfirmed_args()
7941 
    args.read(iprot)
7942 
    iprot.readMessageEnd()
7943 
    result = markOrderCancellationRequestConfirmed_result()
7944 
    try:
7945 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7946 
    except TransactionServiceException, ex:
7947 
      result.ex = ex
7948 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7949 
    result.write(oprot)
7950 
    oprot.writeMessageEnd()
7951 
    oprot.trans.flush()
7952 
 
7953 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7954 
    args = markOrderCancellationRequestDenied_args()
7955 
    args.read(iprot)
7956 
    iprot.readMessageEnd()
7957 
    result = markOrderCancellationRequestDenied_result()
7958 
    try:
7959 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7960 
    except TransactionServiceException, ex:
7961 
      result.ex = ex
7962 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
7963 
    result.write(oprot)
7964 
    oprot.writeMessageEnd()
7965 
    oprot.trans.flush()
7966 
 
4258 rajveer 7967 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
7968 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 7969 
    args.read(iprot)
7970 
    iprot.readMessageEnd()
4258 rajveer 7971 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 7972 
    try:
4258 rajveer 7973 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 7974 
    except TransactionServiceException, ex:
7975 
      result.ex = ex
4258 rajveer 7976 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 7977 
    result.write(oprot)
7978 
    oprot.writeMessageEnd()
7979 
    oprot.trans.flush()
7980 
 
4259 anupam.sin 7981 
  def process_refundTransaction(self, seqid, iprot, oprot):
7982 
    args = refundTransaction_args()
7983 
    args.read(iprot)
7984 
    iprot.readMessageEnd()
7985 
    result = refundTransaction_result()
7986 
    try:
7987 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
7988 
    except TransactionServiceException, ex:
7989 
      result.ex = ex
7990 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
7991 
    result.write(oprot)
7992 
    oprot.writeMessageEnd()
7993 
    oprot.trans.flush()
4247 rajveer 7994 
 
4324 mandeep.dh 7995 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
7996 
    args = updateShipmentAddress_args()
7997 
    args.read(iprot)
7998 
    iprot.readMessageEnd()
7999 
    result = updateShipmentAddress_result()
8000 
    try:
8001 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
8002 
    except TransactionServiceException, ex:
8003 
      result.ex = ex
8004 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
8005 
    result.write(oprot)
8006 
    oprot.writeMessageEnd()
8007 
    oprot.trans.flush()
8008 
 
4285 rajveer 8009 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
8010 
    args = acceptOrdersForItemId_args()
8011 
    args.read(iprot)
8012 
    iprot.readMessageEnd()
8013 
    result = acceptOrdersForItemId_result()
8014 
    try:
8015 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
8016 
    except TransactionServiceException, ex:
8017 
      result.ex = ex
8018 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
8019 
    result.write(oprot)
8020 
    oprot.writeMessageEnd()
8021 
    oprot.trans.flush()
4259 anupam.sin 8022 
 
4303 rajveer 8023 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
8024 
    args = markOrdersAsPORaised_args()
8025 
    args.read(iprot)
8026 
    iprot.readMessageEnd()
8027 
    result = markOrdersAsPORaised_result()
8028 
    try:
4369 rajveer 8029 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8030 
    except TransactionServiceException, ex:
8031 
      result.ex = ex
8032 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
8033 
    result.write(oprot)
8034 
    oprot.writeMessageEnd()
8035 
    oprot.trans.flush()
4285 rajveer 8036 
 
4303 rajveer 8037 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
8038 
    args = markOrdersAsReversalInitiated_args()
8039 
    args.read(iprot)
8040 
    iprot.readMessageEnd()
8041 
    result = markOrdersAsReversalInitiated_result()
8042 
    try:
4369 rajveer 8043 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8044 
    except TransactionServiceException, ex:
8045 
      result.ex = ex
8046 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
8047 
    result.write(oprot)
8048 
    oprot.writeMessageEnd()
8049 
    oprot.trans.flush()
8050 
 
8051 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
8052 
    args = markOrdersAsNotAvailabke_args()
8053 
    args.read(iprot)
8054 
    iprot.readMessageEnd()
8055 
    result = markOrdersAsNotAvailabke_result()
8056 
    try:
4369 rajveer 8057 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8058 
    except TransactionServiceException, ex:
8059 
      result.ex = ex
8060 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
8061 
    result.write(oprot)
8062 
    oprot.writeMessageEnd()
8063 
    oprot.trans.flush()
8064 
 
4369 rajveer 8065 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
8066 
    args = markOrdersAsTimeout_args()
8067 
    args.read(iprot)
8068 
    iprot.readMessageEnd()
8069 
    result = markOrdersAsTimeout_result()
8070 
    try:
8071 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
8072 
    except TransactionServiceException, ex:
8073 
      result.ex = ex
8074 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
8075 
    result.write(oprot)
8076 
    oprot.writeMessageEnd()
8077 
    oprot.trans.flush()
4303 rajveer 8078 
 
4662 rajveer 8079 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
8080 
    args = markOrderAsLostInTransit_args()
8081 
    args.read(iprot)
8082 
    iprot.readMessageEnd()
8083 
    result = markOrderAsLostInTransit_result()
8084 
    try:
8085 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
8086 
    except TransactionServiceException, ex:
8087 
      result.ex = ex
8088 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
8089 
    result.write(oprot)
8090 
    oprot.writeMessageEnd()
8091 
    oprot.trans.flush()
8092 
 
4386 anupam.sin 8093 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
8094 
    args = getOrderForAwb_args()
8095 
    args.read(iprot)
8096 
    iprot.readMessageEnd()
8097 
    result = getOrderForAwb_result()
8098 
    try:
8099 
      result.success = self._handler.getOrderForAwb(args.awb)
8100 
    except TransactionServiceException, ex:
8101 
      result.ex = ex
8102 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
8103 
    result.write(oprot)
8104 
    oprot.writeMessageEnd()
8105 
    oprot.trans.flush()
4369 rajveer 8106 
 
4506 phani.kuma 8107 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
8108 
    args = getOrdersForProviderForStatus_args()
8109 
    args.read(iprot)
8110 
    iprot.readMessageEnd()
8111 
    result = getOrdersForProviderForStatus_result()
8112 
    try:
4910 phani.kuma 8113 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 8114 
    except TransactionServiceException, ex:
8115 
      result.ex = ex
8116 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
8117 
    result.write(oprot)
8118 
    oprot.writeMessageEnd()
8119 
    oprot.trans.flush()
4386 anupam.sin 8120 
 
4600 varun.gupt 8121 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
8122 
    args = getBilledOrdersForVendor_args()
8123 
    args.read(iprot)
8124 
    iprot.readMessageEnd()
8125 
    result = getBilledOrdersForVendor_result()
8126 
    try:
8127 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
8128 
    except TransactionServiceException, ex:
8129 
      result.ex = ex
8130 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
8131 
    result.write(oprot)
8132 
    oprot.writeMessageEnd()
8133 
    oprot.trans.flush()
4506 phani.kuma 8134 
 
4607 rajveer 8135 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
8136 
    args = getSlippedSippingDateOrders_args()
8137 
    args.read(iprot)
8138 
    iprot.readMessageEnd()
8139 
    result = getSlippedSippingDateOrders_result()
8140 
    try:
8141 
      result.success = self._handler.getSlippedSippingDateOrders()
8142 
    except TransactionServiceException, ex:
8143 
      result.ex = ex
8144 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
8145 
    result.write(oprot)
8146 
    oprot.writeMessageEnd()
8147 
    oprot.trans.flush()
8148 
 
4709 rajveer 8149 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
8150 
    args = getCancelledOrders_args()
8151 
    args.read(iprot)
8152 
    iprot.readMessageEnd()
8153 
    result = getCancelledOrders_result()
8154 
    try:
8155 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
8156 
    except TransactionServiceException, ex:
8157 
      result.ex = ex
8158 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
8159 
    result.write(oprot)
8160 
    oprot.writeMessageEnd()
8161 
    oprot.trans.flush()
8162 
 
4600 varun.gupt 8163 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
8164 
    args = saveBluedartSettlements_args()
8165 
    args.read(iprot)
8166 
    iprot.readMessageEnd()
8167 
    result = saveBluedartSettlements_result()
8168 
    try:
8169 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
8170 
    except TransactionServiceException, ex:
8171 
      result.ex = ex
8172 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
8173 
    result.write(oprot)
8174 
    oprot.writeMessageEnd()
8175 
    oprot.trans.flush()
8176 
 
8177 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
8178 
    args = savePaymentSettlements_args()
8179 
    args.read(iprot)
8180 
    iprot.readMessageEnd()
8181 
    result = savePaymentSettlements_result()
8182 
    try:
4905 varun.gupt 8183 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 8184 
    except TransactionServiceException, ex:
8185 
      result.ex = ex
8186 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
8187 
    result.write(oprot)
8188 
    oprot.writeMessageEnd()
8189 
    oprot.trans.flush()
8190 
 
8191 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
8192 
    args = saveEBSSettlementSummary_args()
8193 
    args.read(iprot)
8194 
    iprot.readMessageEnd()
8195 
    result = saveEBSSettlementSummary_result()
8196 
    try:
8197 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
8198 
    except TransactionServiceException, ex:
8199 
      result.ex = ex
8200 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
8201 
    result.write(oprot)
8202 
    oprot.writeMessageEnd()
8203 
    oprot.trans.flush()
8204 
 
5386 phani.kuma 8205 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
8206 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 8207 
    args.read(iprot)
8208 
    iprot.readMessageEnd()
5386 phani.kuma 8209 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 8210 
    try:
5386 phani.kuma 8211 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 8212 
    except TransactionServiceException, ex:
8213 
      result.ex = ex
5386 phani.kuma 8214 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 8215 
    result.write(oprot)
8216 
    oprot.writeMessageEnd()
8217 
    oprot.trans.flush()
8218 
 
5386 phani.kuma 8219 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
8220 
    args = getSettlementForCod_args()
8221 
    args.read(iprot)
8222 
    iprot.readMessageEnd()
8223 
    result = getSettlementForCod_result()
8224 
    try:
8225 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
8226 
    except TransactionServiceException, ex:
8227 
      result.ex = ex
8228 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
8229 
    result.write(oprot)
8230 
    oprot.writeMessageEnd()
8231 
    oprot.trans.flush()
8232 
 
4600 varun.gupt 8233 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
8234 
    args = getEBSSettlementSummaries_args()
8235 
    args.read(iprot)
8236 
    iprot.readMessageEnd()
8237 
    result = getEBSSettlementSummaries_result()
8238 
    try:
8239 
      result.success = self._handler.getEBSSettlementSummaries()
8240 
    except TransactionServiceException, ex:
8241 
      result.ex = ex
8242 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
8243 
    result.write(oprot)
8244 
    oprot.writeMessageEnd()
8245 
    oprot.trans.flush()
8246 
 
8247 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
8248 
    args = markEBSSettlementUploaded_args()
8249 
    args.read(iprot)
8250 
    iprot.readMessageEnd()
8251 
    result = markEBSSettlementUploaded_result()
8252 
    try:
8253 
      self._handler.markEBSSettlementUploaded(args.settlementId)
8254 
    except TransactionServiceException, ex:
8255 
      result.ex = ex
8256 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
8257 
    result.write(oprot)
8258 
    oprot.writeMessageEnd()
8259 
    oprot.trans.flush()
8260 
 
8261 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
8262 
    args = getEBSSettlementDate_args()
8263 
    args.read(iprot)
8264 
    iprot.readMessageEnd()
8265 
    result = getEBSSettlementDate_result()
8266 
    try:
8267 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
8268 
    except TransactionServiceException, ex:
8269 
      result.ex = ex
8270 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
8271 
    result.write(oprot)
8272 
    oprot.writeMessageEnd()
8273 
    oprot.trans.flush()
8274 
 
4715 varun.gupt 8275 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
8276 
    args = getSettlementsByDate_args()
8277 
    args.read(iprot)
8278 
    iprot.readMessageEnd()
8279 
    result = getSettlementsByDate_result()
8280 
    try:
8281 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
8282 
    except TransactionServiceException, ex:
8283 
      result.ex = ex
8284 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
8285 
    result.write(oprot)
8286 
    oprot.writeMessageEnd()
8287 
    oprot.trans.flush()
4600 varun.gupt 8288 
 
4715 varun.gupt 8289 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
8290 
    args = getReshippedOrderIds_args()
8291 
    args.read(iprot)
8292 
    iprot.readMessageEnd()
8293 
    result = getReshippedOrderIds_result()
8294 
    try:
8295 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8296 
    except TransactionServiceException, ex:
8297 
      result.ex = ex
8298 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8299 
    result.write(oprot)
8300 
    oprot.writeMessageEnd()
8301 
    oprot.trans.flush()
8302 
 
5481 phani.kuma 8303 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8304 
    args = getBilledOrders_args()
4875 varun.gupt 8305 
    args.read(iprot)
8306 
    iprot.readMessageEnd()
5481 phani.kuma 8307 
    result = getBilledOrders_result()
4875 varun.gupt 8308 
    try:
5481 phani.kuma 8309 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8310 
    except TransactionServiceException, ex:
8311 
      result.ex = ex
5481 phani.kuma 8312 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8313 
    result.write(oprot)
8314 
    oprot.writeMessageEnd()
8315 
    oprot.trans.flush()
4757 mandeep.dh 8316 
 
5031 varun.gupt 8317 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8318 
    args = getStatusDistributionOfOrders_args()
8319 
    args.read(iprot)
8320 
    iprot.readMessageEnd()
8321 
    result = getStatusDistributionOfOrders_result()
8322 
    try:
8323 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8324 
    except TransactionServiceException, ex:
8325 
      result.ex = ex
8326 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8327 
    result.write(oprot)
8328 
    oprot.writeMessageEnd()
8329 
    oprot.trans.flush()
4875 varun.gupt 8330 
 
5067 varun.gupt 8331 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8332 
    args = getOrderIdsForStatus_args()
8333 
    args.read(iprot)
8334 
    iprot.readMessageEnd()
8335 
    result = getOrderIdsForStatus_result()
8336 
    try:
8337 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8338 
    except TransactionServiceException, ex:
8339 
      result.ex = ex
8340 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8341 
    result.write(oprot)
8342 
    oprot.writeMessageEnd()
8343 
    oprot.trans.flush()
5031 varun.gupt 8344 
 
5348 anupam.sin 8345 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8346 
    args = updateCODAgent_args()
8347 
    args.read(iprot)
8348 
    iprot.readMessageEnd()
8349 
    result = updateCODAgent_result()
8350 
    try:
8351 
      self._handler.updateCODAgent(args.agent, args.orderId)
8352 
    except TransactionServiceException, ex:
8353 
      result.ex = ex
8354 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8355 
    result.write(oprot)
8356 
    oprot.writeMessageEnd()
8357 
    oprot.trans.flush()
8358 
 
5099 varun.gupt 8359 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8360 
    args = updateOrderAsPaidToVendor_args()
8361 
    args.read(iprot)
8362 
    iprot.readMessageEnd()
8363 
    result = updateOrderAsPaidToVendor_result()
8364 
    try:
8365 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8366 
    except TransactionServiceException, ex:
8367 
      result.ex = ex
8368 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8369 
    result.write(oprot)
8370 
    oprot.writeMessageEnd()
8371 
    oprot.trans.flush()
5067 varun.gupt 8372 
 
5386 phani.kuma 8373 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8374 
    args = updateOrderOnlyAsPaidToVendor_args()
8375 
    args.read(iprot)
8376 
    iprot.readMessageEnd()
8377 
    result = updateOrderOnlyAsPaidToVendor_result()
8378 
    try:
8379 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8380 
    except TransactionServiceException, ex:
8381 
      result.ex = ex
8382 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8383 
    result.write(oprot)
8384 
    oprot.writeMessageEnd()
8385 
    oprot.trans.flush()
8386 
 
5208 varun.gupt 8387 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8388 
    args = getRefundedOrdersMarkedPaid_args()
8389 
    args.read(iprot)
8390 
    iprot.readMessageEnd()
8391 
    result = getRefundedOrdersMarkedPaid_result()
8392 
    try:
8393 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8394 
    except TransactionServiceException, ex:
8395 
      result.ex = ex
8396 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8397 
    result.write(oprot)
8398 
    oprot.writeMessageEnd()
8399 
    oprot.trans.flush()
5099 varun.gupt 8400 
 
5447 anupam.sin 8401 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8402 
    args = getAllVerificationAgents_args()
8403 
    args.read(iprot)
8404 
    iprot.readMessageEnd()
8405 
    result = getAllVerificationAgents_result()
8406 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8407 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8408 
    result.write(oprot)
8409 
    oprot.writeMessageEnd()
8410 
    oprot.trans.flush()
5208 varun.gupt 8411 
 
5527 anupam.sin 8412 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8413 
    args = getAllAttributesForOrderId_args()
8414 
    args.read(iprot)
8415 
    iprot.readMessageEnd()
8416 
    result = getAllAttributesForOrderId_result()
8417 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8418 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8419 
    result.write(oprot)
8420 
    oprot.writeMessageEnd()
8421 
    oprot.trans.flush()
5447 anupam.sin 8422 
 
5676 rajveer 8423 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8424 
    args = setOrderAttributes_args()
8425 
    args.read(iprot)
8426 
    iprot.readMessageEnd()
8427 
    result = setOrderAttributes_result()
8428 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8429 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8430 
    result.write(oprot)
8431 
    oprot.writeMessageEnd()
8432 
    oprot.trans.flush()
8433 
 
5527 anupam.sin 8434 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8435 
    args = setOrderAttributeForTransaction_args()
8436 
    args.read(iprot)
8437 
    iprot.readMessageEnd()
8438 
    result = setOrderAttributeForTransaction_result()
8439 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8440 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8441 
    result.write(oprot)
8442 
    oprot.writeMessageEnd()
8443 
    oprot.trans.flush()
8444 
 
5553 rajveer 8445 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8446 
    args = getReceivePendingOrders_args()
8447 
    args.read(iprot)
8448 
    iprot.readMessageEnd()
8449 
    result = getReceivePendingOrders_result()
8450 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8451 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8452 
    result.write(oprot)
8453 
    oprot.writeMessageEnd()
8454 
    oprot.trans.flush()
5527 anupam.sin 8455 
 
5553 rajveer 8456 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8457 
    args = getReceivedAtStoreOrders_args()
8458 
    args.read(iprot)
8459 
    iprot.readMessageEnd()
8460 
    result = getReceivedAtStoreOrders_result()
8461 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8462 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8463 
    result.write(oprot)
8464 
    oprot.writeMessageEnd()
8465 
    oprot.trans.flush()
8466 
 
5713 rajveer 8467 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8468 
    args = getOrdersCollectionAtStore_args()
8469 
    args.read(iprot)
8470 
    iprot.readMessageEnd()
8471 
    result = getOrdersCollectionAtStore_result()
8472 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8473 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8474 
    result.write(oprot)
8475 
    oprot.writeMessageEnd()
8476 
    oprot.trans.flush()
8477 
 
5833 rajveer 8478 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8479 
    args = getOrderAttributeValue_args()
8480 
    args.read(iprot)
8481 
    iprot.readMessageEnd()
8482 
    result = getOrderAttributeValue_result()
8483 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8484 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8485 
    result.write(oprot)
8486 
    oprot.writeMessageEnd()
8487 
    oprot.trans.flush()
8488 
 
6019 rajveer 8489 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8490 
    args = changeJacketNumber_args()
8491 
    args.read(iprot)
8492 
    iprot.readMessageEnd()
8493 
    result = changeJacketNumber_result()
8494 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8495 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8496 
    result.write(oprot)
8497 
    oprot.writeMessageEnd()
8498 
    oprot.trans.flush()
8499 
 
8500 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8501 
    args = markOrderAsRtoInTransit_args()
8502 
    args.read(iprot)
8503 
    iprot.readMessageEnd()
8504 
    result = markOrderAsRtoInTransit_result()
8505 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8506 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8507 
    result.write(oprot)
8508 
    oprot.writeMessageEnd()
8509 
    oprot.trans.flush()
8510 
 
5593 mandeep.dh 8511 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8512 
    args = acceptOrderForItem_args()
8513 
    args.read(iprot)
8514 
    iprot.readMessageEnd()
8515 
    result = acceptOrderForItem_result()
8516 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8517 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8518 
    result.write(oprot)
8519 
    oprot.writeMessageEnd()
8520 
    oprot.trans.flush()
5553 rajveer 8521 
 
6000 mandeep.dh 8522 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8523 
    args = createRechargeOrder_args()
8524 
    args.read(iprot)
8525 
    iprot.readMessageEnd()
8526 
    result = createRechargeOrder_result()
8527 
    try:
8528 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8529 
    except TransactionServiceException, ex:
8530 
      result.ex = ex
8531 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8532 
    result.write(oprot)
8533 
    oprot.writeMessageEnd()
8534 
    oprot.trans.flush()
5593 mandeep.dh 8535 
 
6031 rajveer 8536 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8537 
    args = getRechargeOrder_args()
8538 
    args.read(iprot)
8539 
    iprot.readMessageEnd()
8540 
    result = getRechargeOrder_result()
8541 
    try:
8542 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8543 
    except TransactionServiceException, ex:
8544 
      result.ex = ex
8545 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8546 
    result.write(oprot)
8547 
    oprot.writeMessageEnd()
8548 
    oprot.trans.flush()
8549 
 
8550 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8551 
    args = getRechargeOrders_args()
8552 
    args.read(iprot)
8553 
    iprot.readMessageEnd()
8554 
    result = getRechargeOrders_result()
8555 
    result.success = self._handler.getRechargeOrders(args.userId)
8556 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8557 
    result.write(oprot)
8558 
    oprot.writeMessageEnd()
8559 
    oprot.trans.flush()
8560 
 
6000 mandeep.dh 8561 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8562 
    args = updateRechargeOrderStatus_args()
8563 
    args.read(iprot)
8564 
    iprot.readMessageEnd()
8565 
    result = updateRechargeOrderStatus_result()
8566 
    try:
6031 rajveer 8567 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8568 
    except TransactionServiceException, ex:
8569 
      result.ex = ex
8570 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8571 
    result.write(oprot)
8572 
    oprot.writeMessageEnd()
8573 
    oprot.trans.flush()
8574 
 
8575 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8576 
    args = activateRechargeTxn_args()
8577 
    args.read(iprot)
8578 
    iprot.readMessageEnd()
8579 
    result = activateRechargeTxn_result()
8580 
    try:
6031 rajveer 8581 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8582 
    except TransactionServiceException, ex:
8583 
      result.ex = ex
8584 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8585 
    result.write(oprot)
8586 
    oprot.writeMessageEnd()
8587 
    oprot.trans.flush()
8588 
 
6031 rajveer 8589 
  def process_getUserWallet(self, seqid, iprot, oprot):
8590 
    args = getUserWallet_args()
6000 mandeep.dh 8591 
    args.read(iprot)
8592 
    iprot.readMessageEnd()
6031 rajveer 8593 
    result = getUserWallet_result()
8594 
    result.success = self._handler.getUserWallet(args.userId)
8595 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8596 
    result.write(oprot)
8597 
    oprot.writeMessageEnd()
8598 
    oprot.trans.flush()
8599 
 
6031 rajveer 8600 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8601 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8602 
    args.read(iprot)
8603 
    iprot.readMessageEnd()
6031 rajveer 8604 
    result = getUserWalletHistory_result()
8605 
    result.success = self._handler.getUserWalletHistory(args.userId)
8606 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8607 
    result.write(oprot)
8608 
    oprot.writeMessageEnd()
8609 
    oprot.trans.flush()
8610 
 
6050 anupam.sin 8611 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8612 
    args = getRechargeOrdersForTransaction_args()
8613 
    args.read(iprot)
8614 
    iprot.readMessageEnd()
8615 
    result = getRechargeOrdersForTransaction_result()
8616 
    try:
8617 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8618 
    except TransactionServiceException, ex:
8619 
      result.ex = ex
8620 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8621 
    result.write(oprot)
8622 
    oprot.writeMessageEnd()
8623 
    oprot.trans.flush()
8624 
 
6048 rajveer 8625 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8626 
    args = getServiceProviders_args()
8627 
    args.read(iprot)
8628 
    iprot.readMessageEnd()
8629 
    result = getServiceProviders_result()
6206 rajveer 8630 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 8631 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8632 
    result.write(oprot)
8633 
    oprot.writeMessageEnd()
8634 
    oprot.trans.flush()
6000 mandeep.dh 8635 
 
6048 rajveer 8636 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8637 
    args = getServiceProviderForDevice_args()
8638 
    args.read(iprot)
8639 
    iprot.readMessageEnd()
8640 
    result = getServiceProviderForDevice_result()
6049 rajveer 8641 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8642 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8643 
    result.write(oprot)
8644 
    oprot.writeMessageEnd()
8645 
    oprot.trans.flush()
8646 
 
6269 rajveer 8647 
  def process_validateRecharge(self, seqid, iprot, oprot):
8648 
    args = validateRecharge_args()
8649 
    args.read(iprot)
8650 
    iprot.readMessageEnd()
8651 
    result = validateRecharge_result()
6591 anupam.sin 8652 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId, args.clientAddress)
6269 rajveer 8653 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
8654 
    result.write(oprot)
8655 
    oprot.writeMessageEnd()
8656 
    oprot.trans.flush()
8657 
 
6094 rajveer 8658 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8659 
    args = getRechargeOrdersForDevice_args()
8660 
    args.read(iprot)
8661 
    iprot.readMessageEnd()
8662 
    result = getRechargeOrdersForDevice_result()
8663 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8664 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8665 
    result.write(oprot)
8666 
    oprot.writeMessageEnd()
8667 
    oprot.trans.flush()
6048 rajveer 8668 
 
6094 rajveer 8669 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8670 
    args = addAmountToWallet_args()
8671 
    args.read(iprot)
8672 
    iprot.readMessageEnd()
8673 
    result = addAmountToWallet_result()
8674 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8675 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8676 
    result.write(oprot)
8677 
    oprot.writeMessageEnd()
8678 
    oprot.trans.flush()
8679 
 
6188 rajveer 8680 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
8681 
    args = getRechargeStatistics_args()
8682 
    args.read(iprot)
8683 
    iprot.readMessageEnd()
8684 
    result = getRechargeStatistics_result()
8685 
    result.success = self._handler.getRechargeStatistics()
8686 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
8687 
    result.write(oprot)
8688 
    oprot.writeMessageEnd()
8689 
    oprot.trans.flush()
8690 
 
6154 rajveer 8691 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
8692 
    args = getRechargeOrdersForStatus_args()
8693 
    args.read(iprot)
8694 
    iprot.readMessageEnd()
8695 
    result = getRechargeOrdersForStatus_result()
8696 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
8697 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
8698 
    result.write(oprot)
8699 
    oprot.writeMessageEnd()
8700 
    oprot.trans.flush()
6094 rajveer 8701 
 
6159 rajveer 8702 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
8703 
    args = getPlansForOperator_args()
8704 
    args.read(iprot)
8705 
    iprot.readMessageEnd()
8706 
    result = getPlansForOperator_result()
8707 
    result.success = self._handler.getPlansForOperator(args.operatorId)
8708 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
8709 
    result.write(oprot)
8710 
    oprot.writeMessageEnd()
8711 
    oprot.trans.flush()
6154 rajveer 8712 
 
6289 anupam.sin 8713 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
8714 
    args = getRechargeDenominations_args()
8715 
    args.read(iprot)
8716 
    iprot.readMessageEnd()
8717 
    result = getRechargeDenominations_result()
8718 
    try:
6307 anupam.sin 8719 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 8720 
    except TransactionServiceException, ex:
8721 
      result.ex = ex
8722 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
8723 
    result.write(oprot)
8724 
    oprot.writeMessageEnd()
8725 
    oprot.trans.flush()
6159 rajveer 8726 
 
6371 rajveer 8727 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
8728 
    args = updateAvailabilityStatus_args()
8729 
    args.read(iprot)
8730 
    iprot.readMessageEnd()
8731 
    result = updateAvailabilityStatus_result()
8732 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
8733 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
8734 
    result.write(oprot)
8735 
    oprot.writeMessageEnd()
8736 
    oprot.trans.flush()
6289 anupam.sin 8737 
 
6389 rajveer 8738 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
8739 
    args = getAvailableEmiSchemes_args()
8740 
    args.read(iprot)
8741 
    iprot.readMessageEnd()
8742 
    result = getAvailableEmiSchemes_result()
8743 
    result.success = self._handler.getAvailableEmiSchemes()
8744 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
8745 
    result.write(oprot)
8746 
    oprot.writeMessageEnd()
8747 
    oprot.trans.flush()
6371 rajveer 8748 
 
6389 rajveer 8749 
  def process_getMiscCharges(self, seqid, iprot, oprot):
8750 
    args = getMiscCharges_args()
8751 
    args.read(iprot)
8752 
    iprot.readMessageEnd()
8753 
    result = getMiscCharges_result()
8754 
    result.success = self._handler.getMiscCharges(args.transactionId)
8755 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
8756 
    result.write(oprot)
8757 
    oprot.writeMessageEnd()
8758 
    oprot.trans.flush()
8759 
 
6507 anupam.sin 8760 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
8761 
    args = refundRechargeOrder_args()
8762 
    args.read(iprot)
8763 
    iprot.readMessageEnd()
8764 
    result = refundRechargeOrder_result()
8765 
    try:
8766 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
8767 
    except TransactionServiceException, ex:
8768 
      result.ex = ex
8769 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
8770 
    result.write(oprot)
8771 
    oprot.writeMessageEnd()
8772 
    oprot.trans.flush()
6389 rajveer 8773 
 
6821 amar.kumar 8774 
  def process_getPhysicalOrders(self, seqid, iprot, oprot):
8775 
    args = getPhysicalOrders_args()
8776 
    args.read(iprot)
8777 
    iprot.readMessageEnd()
8778 
    result = getPhysicalOrders_result()
8779 
    result.success = self._handler.getPhysicalOrders(args.fromDate, args.toDate)
8780 
    oprot.writeMessageBegin("getPhysicalOrders", TMessageType.REPLY, seqid)
8781 
    result.write(oprot)
8782 
    oprot.writeMessageEnd()
8783 
    oprot.trans.flush()
6507 anupam.sin 8784 
 
6906 rajveer 8785 
  def process_getDocument(self, seqid, iprot, oprot):
8786 
    args = getDocument_args()
8787 
    args.read(iprot)
8788 
    iprot.readMessageEnd()
8789 
    result = getDocument_result()
8790 
    result.success = self._handler.getDocument(args.docType, args.docSource)
8791 
    oprot.writeMessageBegin("getDocument", TMessageType.REPLY, seqid)
8792 
    result.write(oprot)
8793 
    oprot.writeMessageEnd()
8794 
    oprot.trans.flush()
6821 amar.kumar 8795 
 
6985 anupam.sin 8796 
  def process_changeShippingAddress(self, seqid, iprot, oprot):
8797 
    args = changeShippingAddress_args()
8798 
    args.read(iprot)
8799 
    iprot.readMessageEnd()
8800 
    result = changeShippingAddress_result()
8801 
    result.success = self._handler.changeShippingAddress(args.orderId, args.line1, args.line2, args.city, args.state, args.pin)
8802 
    oprot.writeMessageBegin("changeShippingAddress", TMessageType.REPLY, seqid)
8803 
    result.write(oprot)
8804 
    oprot.writeMessageEnd()
8805 
    oprot.trans.flush()
6906 rajveer 8806 
 
6985 anupam.sin 8807 
 
94 ashish 8808 
# HELPER FUNCTIONS AND STRUCTURES
8809 
 
8810 
class createTransaction_args:
8811 
  """
8812 
  Attributes:
8813 
   - transaction
8814 
  """
8815 
 
8816 
  thrift_spec = (
8817 
    None, # 0
8818 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8819 
  )
8820 
 
8821 
  def __init__(self, transaction=None,):
8822 
    self.transaction = transaction
8823 
 
8824 
  def read(self, iprot):
8825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8827 
      return
8828 
    iprot.readStructBegin()
8829 
    while True:
8830 
      (fname, ftype, fid) = iprot.readFieldBegin()
8831 
      if ftype == TType.STOP:
8832 
        break
8833 
      if fid == 1:
8834 
        if ftype == TType.STRUCT:
8835 
          self.transaction = Transaction()
8836 
          self.transaction.read(iprot)
8837 
        else:
8838 
          iprot.skip(ftype)
8839 
      else:
8840 
        iprot.skip(ftype)
8841 
      iprot.readFieldEnd()
8842 
    iprot.readStructEnd()
8843 
 
8844 
  def write(self, oprot):
8845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8847 
      return
8848 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8849 
    if self.transaction is not None:
94 ashish 8850 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
8851 
      self.transaction.write(oprot)
8852 
      oprot.writeFieldEnd()
8853 
    oprot.writeFieldStop()
8854 
    oprot.writeStructEnd()
8855 
 
3431 rajveer 8856 
  def validate(self):
8857 
    return
8858 
 
8859 
 
94 ashish 8860 
  def __repr__(self):
8861 
    L = ['%s=%r' % (key, value)
8862 
      for key, value in self.__dict__.iteritems()]
8863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8864 
 
8865 
  def __eq__(self, other):
8866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8867 
 
8868 
  def __ne__(self, other):
8869 
    return not (self == other)
8870 
 
8871 
class createTransaction_result:
8872 
  """
8873 
  Attributes:
132 ashish 8874 
   - success
94 ashish 8875 
   - ex
8876 
  """
8877 
 
8878 
  thrift_spec = (
132 ashish 8879 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8880 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8881 
  )
8882 
 
132 ashish 8883 
  def __init__(self, success=None, ex=None,):
8884 
    self.success = success
94 ashish 8885 
    self.ex = ex
8886 
 
8887 
  def read(self, iprot):
8888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8890 
      return
8891 
    iprot.readStructBegin()
8892 
    while True:
8893 
      (fname, ftype, fid) = iprot.readFieldBegin()
8894 
      if ftype == TType.STOP:
8895 
        break
132 ashish 8896 
      if fid == 0:
8897 
        if ftype == TType.I64:
8898 
          self.success = iprot.readI64();
8899 
        else:
8900 
          iprot.skip(ftype)
8901 
      elif fid == 1:
94 ashish 8902 
        if ftype == TType.STRUCT:
8903 
          self.ex = TransactionServiceException()
8904 
          self.ex.read(iprot)
8905 
        else:
8906 
          iprot.skip(ftype)
8907 
      else:
8908 
        iprot.skip(ftype)
8909 
      iprot.readFieldEnd()
8910 
    iprot.readStructEnd()
8911 
 
8912 
  def write(self, oprot):
8913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8915 
      return
8916 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 8917 
    if self.success is not None:
132 ashish 8918 
      oprot.writeFieldBegin('success', TType.I64, 0)
8919 
      oprot.writeI64(self.success)
8920 
      oprot.writeFieldEnd()
3431 rajveer 8921 
    if self.ex is not None:
94 ashish 8922 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8923 
      self.ex.write(oprot)
8924 
      oprot.writeFieldEnd()
8925 
    oprot.writeFieldStop()
8926 
    oprot.writeStructEnd()
8927 
 
3431 rajveer 8928 
  def validate(self):
8929 
    return
8930 
 
8931 
 
94 ashish 8932 
  def __repr__(self):
8933 
    L = ['%s=%r' % (key, value)
8934 
      for key, value in self.__dict__.iteritems()]
8935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8936 
 
8937 
  def __eq__(self, other):
8938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8939 
 
8940 
  def __ne__(self, other):
8941 
    return not (self == other)
8942 
 
8943 
class getTransaction_args:
8944 
  """
8945 
  Attributes:
8946 
   - id
8947 
  """
8948 
 
8949 
  thrift_spec = (
8950 
    None, # 0
8951 
    (1, TType.I64, 'id', None, None, ), # 1
8952 
  )
8953 
 
8954 
  def __init__(self, id=None,):
8955 
    self.id = id
8956 
 
8957 
  def read(self, iprot):
8958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8960 
      return
8961 
    iprot.readStructBegin()
8962 
    while True:
8963 
      (fname, ftype, fid) = iprot.readFieldBegin()
8964 
      if ftype == TType.STOP:
8965 
        break
8966 
      if fid == 1:
8967 
        if ftype == TType.I64:
8968 
          self.id = iprot.readI64();
8969 
        else:
8970 
          iprot.skip(ftype)
8971 
      else:
8972 
        iprot.skip(ftype)
8973 
      iprot.readFieldEnd()
8974 
    iprot.readStructEnd()
8975 
 
8976 
  def write(self, oprot):
8977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8979 
      return
8980 
    oprot.writeStructBegin('getTransaction_args')
3431 rajveer 8981 
    if self.id is not None:
94 ashish 8982 
      oprot.writeFieldBegin('id', TType.I64, 1)
8983 
      oprot.writeI64(self.id)
8984 
      oprot.writeFieldEnd()
8985 
    oprot.writeFieldStop()
8986 
    oprot.writeStructEnd()
8987 
 
3431 rajveer 8988 
  def validate(self):
8989 
    return
8990 
 
8991 
 
94 ashish 8992 
  def __repr__(self):
8993 
    L = ['%s=%r' % (key, value)
8994 
      for key, value in self.__dict__.iteritems()]
8995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8996 
 
8997 
  def __eq__(self, other):
8998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8999 
 
9000 
  def __ne__(self, other):
9001 
    return not (self == other)
9002 
 
9003 
class getTransaction_result:
9004 
  """
9005 
  Attributes:
9006 
   - success
9007 
   - ex
9008 
  """
9009 
 
9010 
  thrift_spec = (
9011 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
9012 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9013 
  )
9014 
 
9015 
  def __init__(self, success=None, ex=None,):
9016 
    self.success = success
9017 
    self.ex = ex
9018 
 
9019 
  def read(self, iprot):
9020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9022 
      return
9023 
    iprot.readStructBegin()
9024 
    while True:
9025 
      (fname, ftype, fid) = iprot.readFieldBegin()
9026 
      if ftype == TType.STOP:
9027 
        break
9028 
      if fid == 0:
9029 
        if ftype == TType.STRUCT:
9030 
          self.success = Transaction()
9031 
          self.success.read(iprot)
9032 
        else:
9033 
          iprot.skip(ftype)
9034 
      elif fid == 1:
9035 
        if ftype == TType.STRUCT:
9036 
          self.ex = TransactionServiceException()
9037 
          self.ex.read(iprot)
9038 
        else:
9039 
          iprot.skip(ftype)
9040 
      else:
9041 
        iprot.skip(ftype)
9042 
      iprot.readFieldEnd()
9043 
    iprot.readStructEnd()
9044 
 
9045 
  def write(self, oprot):
9046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9048 
      return
9049 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 9050 
    if self.success is not None:
94 ashish 9051 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9052 
      self.success.write(oprot)
9053 
      oprot.writeFieldEnd()
3431 rajveer 9054 
    if self.ex is not None:
94 ashish 9055 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9056 
      self.ex.write(oprot)
9057 
      oprot.writeFieldEnd()
9058 
    oprot.writeFieldStop()
9059 
    oprot.writeStructEnd()
9060 
 
3431 rajveer 9061 
  def validate(self):
9062 
    return
9063 
 
9064 
 
94 ashish 9065 
  def __repr__(self):
9066 
    L = ['%s=%r' % (key, value)
9067 
      for key, value in self.__dict__.iteritems()]
9068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9069 
 
9070 
  def __eq__(self, other):
9071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9072 
 
9073 
  def __ne__(self, other):
9074 
    return not (self == other)
9075 
 
9076 
class getTransactionsForCustomer_args:
9077 
  """
9078 
  Attributes:
9079 
   - customerId
9080 
   - from_date
9081 
   - to_date
9082 
   - status
9083 
  """
9084 
 
9085 
  thrift_spec = (
9086 
    None, # 0
9087 
    (1, TType.I64, 'customerId', None, None, ), # 1
9088 
    (2, TType.I64, 'from_date', None, None, ), # 2
9089 
    (3, TType.I64, 'to_date', None, None, ), # 3
9090 
    (4, TType.I32, 'status', None, None, ), # 4
9091 
  )
9092 
 
9093 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
9094 
    self.customerId = customerId
9095 
    self.from_date = from_date
9096 
    self.to_date = to_date
9097 
    self.status = status
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.customerId = iprot.readI64();
9111 
        else:
9112 
          iprot.skip(ftype)
9113 
      elif fid == 2:
9114 
        if ftype == TType.I64:
9115 
          self.from_date = iprot.readI64();
9116 
        else:
9117 
          iprot.skip(ftype)
9118 
      elif fid == 3:
9119 
        if ftype == TType.I64:
9120 
          self.to_date = iprot.readI64();
9121 
        else:
9122 
          iprot.skip(ftype)
9123 
      elif fid == 4:
9124 
        if ftype == TType.I32:
9125 
          self.status = iprot.readI32();
9126 
        else:
9127 
          iprot.skip(ftype)
9128 
      else:
9129 
        iprot.skip(ftype)
9130 
      iprot.readFieldEnd()
9131 
    iprot.readStructEnd()
9132 
 
9133 
  def write(self, oprot):
9134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9136 
      return
9137 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 9138 
    if self.customerId is not None:
94 ashish 9139 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9140 
      oprot.writeI64(self.customerId)
9141 
      oprot.writeFieldEnd()
3431 rajveer 9142 
    if self.from_date is not None:
94 ashish 9143 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9144 
      oprot.writeI64(self.from_date)
9145 
      oprot.writeFieldEnd()
3431 rajveer 9146 
    if self.to_date is not None:
94 ashish 9147 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9148 
      oprot.writeI64(self.to_date)
9149 
      oprot.writeFieldEnd()
3431 rajveer 9150 
    if self.status is not None:
94 ashish 9151 
      oprot.writeFieldBegin('status', TType.I32, 4)
9152 
      oprot.writeI32(self.status)
9153 
      oprot.writeFieldEnd()
9154 
    oprot.writeFieldStop()
9155 
    oprot.writeStructEnd()
9156 
 
3431 rajveer 9157 
  def validate(self):
9158 
    return
9159 
 
9160 
 
94 ashish 9161 
  def __repr__(self):
9162 
    L = ['%s=%r' % (key, value)
9163 
      for key, value in self.__dict__.iteritems()]
9164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9165 
 
9166 
  def __eq__(self, other):
9167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9168 
 
9169 
  def __ne__(self, other):
9170 
    return not (self == other)
9171 
 
9172 
class getTransactionsForCustomer_result:
9173 
  """
9174 
  Attributes:
9175 
   - success
9176 
   - ex
9177 
  """
9178 
 
9179 
  thrift_spec = (
9180 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9181 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9182 
  )
9183 
 
9184 
  def __init__(self, success=None, ex=None,):
9185 
    self.success = success
9186 
    self.ex = ex
9187 
 
9188 
  def read(self, iprot):
9189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9191 
      return
9192 
    iprot.readStructBegin()
9193 
    while True:
9194 
      (fname, ftype, fid) = iprot.readFieldBegin()
9195 
      if ftype == TType.STOP:
9196 
        break
9197 
      if fid == 0:
9198 
        if ftype == TType.LIST:
9199 
          self.success = []
6188 rajveer 9200 
          (_etype109, _size106) = iprot.readListBegin()
9201 
          for _i110 in xrange(_size106):
9202 
            _elem111 = Transaction()
9203 
            _elem111.read(iprot)
9204 
            self.success.append(_elem111)
94 ashish 9205 
          iprot.readListEnd()
9206 
        else:
9207 
          iprot.skip(ftype)
9208 
      elif fid == 1:
9209 
        if ftype == TType.STRUCT:
9210 
          self.ex = TransactionServiceException()
9211 
          self.ex.read(iprot)
9212 
        else:
9213 
          iprot.skip(ftype)
9214 
      else:
9215 
        iprot.skip(ftype)
9216 
      iprot.readFieldEnd()
9217 
    iprot.readStructEnd()
9218 
 
9219 
  def write(self, oprot):
9220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9222 
      return
9223 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 9224 
    if self.success is not None:
94 ashish 9225 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9226 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9227 
      for iter112 in self.success:
9228 
        iter112.write(oprot)
94 ashish 9229 
      oprot.writeListEnd()
9230 
      oprot.writeFieldEnd()
3431 rajveer 9231 
    if self.ex is not None:
94 ashish 9232 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9233 
      self.ex.write(oprot)
9234 
      oprot.writeFieldEnd()
9235 
    oprot.writeFieldStop()
9236 
    oprot.writeStructEnd()
9237 
 
3431 rajveer 9238 
  def validate(self):
9239 
    return
9240 
 
9241 
 
94 ashish 9242 
  def __repr__(self):
9243 
    L = ['%s=%r' % (key, value)
9244 
      for key, value in self.__dict__.iteritems()]
9245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9246 
 
9247 
  def __eq__(self, other):
9248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9249 
 
9250 
  def __ne__(self, other):
9251 
    return not (self == other)
9252 
 
132 ashish 9253 
class getTransactionsForShoppingCartId_args:
9254 
  """
9255 
  Attributes:
9256 
   - shoppingCartId
9257 
  """
9258 
 
9259 
  thrift_spec = (
9260 
    None, # 0
9261 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
9262 
  )
9263 
 
9264 
  def __init__(self, shoppingCartId=None,):
9265 
    self.shoppingCartId = shoppingCartId
9266 
 
9267 
  def read(self, iprot):
9268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9270 
      return
9271 
    iprot.readStructBegin()
9272 
    while True:
9273 
      (fname, ftype, fid) = iprot.readFieldBegin()
9274 
      if ftype == TType.STOP:
9275 
        break
9276 
      if fid == 1:
9277 
        if ftype == TType.I64:
9278 
          self.shoppingCartId = iprot.readI64();
9279 
        else:
9280 
          iprot.skip(ftype)
9281 
      else:
9282 
        iprot.skip(ftype)
9283 
      iprot.readFieldEnd()
9284 
    iprot.readStructEnd()
9285 
 
9286 
  def write(self, oprot):
9287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9289 
      return
9290 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 9291 
    if self.shoppingCartId is not None:
132 ashish 9292 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
9293 
      oprot.writeI64(self.shoppingCartId)
9294 
      oprot.writeFieldEnd()
9295 
    oprot.writeFieldStop()
9296 
    oprot.writeStructEnd()
9297 
 
3431 rajveer 9298 
  def validate(self):
9299 
    return
9300 
 
9301 
 
132 ashish 9302 
  def __repr__(self):
9303 
    L = ['%s=%r' % (key, value)
9304 
      for key, value in self.__dict__.iteritems()]
9305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9306 
 
9307 
  def __eq__(self, other):
9308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9309 
 
9310 
  def __ne__(self, other):
9311 
    return not (self == other)
9312 
 
9313 
class getTransactionsForShoppingCartId_result:
9314 
  """
9315 
  Attributes:
9316 
   - success
9317 
   - ex
9318 
  """
9319 
 
9320 
  thrift_spec = (
9321 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9322 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9323 
  )
9324 
 
9325 
  def __init__(self, success=None, ex=None,):
9326 
    self.success = success
9327 
    self.ex = ex
9328 
 
9329 
  def read(self, iprot):
9330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9332 
      return
9333 
    iprot.readStructBegin()
9334 
    while True:
9335 
      (fname, ftype, fid) = iprot.readFieldBegin()
9336 
      if ftype == TType.STOP:
9337 
        break
9338 
      if fid == 0:
9339 
        if ftype == TType.LIST:
9340 
          self.success = []
6188 rajveer 9341 
          (_etype116, _size113) = iprot.readListBegin()
9342 
          for _i117 in xrange(_size113):
9343 
            _elem118 = Transaction()
9344 
            _elem118.read(iprot)
9345 
            self.success.append(_elem118)
132 ashish 9346 
          iprot.readListEnd()
9347 
        else:
9348 
          iprot.skip(ftype)
9349 
      elif fid == 1:
9350 
        if ftype == TType.STRUCT:
9351 
          self.ex = TransactionServiceException()
9352 
          self.ex.read(iprot)
9353 
        else:
9354 
          iprot.skip(ftype)
9355 
      else:
9356 
        iprot.skip(ftype)
9357 
      iprot.readFieldEnd()
9358 
    iprot.readStructEnd()
9359 
 
9360 
  def write(self, oprot):
9361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9363 
      return
9364 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 9365 
    if self.success is not None:
132 ashish 9366 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9367 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9368 
      for iter119 in self.success:
9369 
        iter119.write(oprot)
132 ashish 9370 
      oprot.writeListEnd()
9371 
      oprot.writeFieldEnd()
3431 rajveer 9372 
    if self.ex is not None:
132 ashish 9373 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9374 
      self.ex.write(oprot)
9375 
      oprot.writeFieldEnd()
9376 
    oprot.writeFieldStop()
9377 
    oprot.writeStructEnd()
9378 
 
3431 rajveer 9379 
  def validate(self):
9380 
    return
9381 
 
9382 
 
132 ashish 9383 
  def __repr__(self):
9384 
    L = ['%s=%r' % (key, value)
9385 
      for key, value in self.__dict__.iteritems()]
9386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9387 
 
9388 
  def __eq__(self, other):
9389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9390 
 
9391 
  def __ne__(self, other):
9392 
    return not (self == other)
9393 
 
94 ashish 9394 
class getTransactionStatus_args:
9395 
  """
9396 
  Attributes:
9397 
   - transactionId
9398 
  """
9399 
 
9400 
  thrift_spec = (
9401 
    None, # 0
9402 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9403 
  )
9404 
 
9405 
  def __init__(self, transactionId=None,):
9406 
    self.transactionId = transactionId
9407 
 
9408 
  def read(self, iprot):
9409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9411 
      return
9412 
    iprot.readStructBegin()
9413 
    while True:
9414 
      (fname, ftype, fid) = iprot.readFieldBegin()
9415 
      if ftype == TType.STOP:
9416 
        break
9417 
      if fid == 1:
9418 
        if ftype == TType.I64:
9419 
          self.transactionId = iprot.readI64();
9420 
        else:
9421 
          iprot.skip(ftype)
9422 
      else:
9423 
        iprot.skip(ftype)
9424 
      iprot.readFieldEnd()
9425 
    iprot.readStructEnd()
9426 
 
9427 
  def write(self, oprot):
9428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9430 
      return
9431 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 9432 
    if self.transactionId is not None:
94 ashish 9433 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9434 
      oprot.writeI64(self.transactionId)
9435 
      oprot.writeFieldEnd()
9436 
    oprot.writeFieldStop()
9437 
    oprot.writeStructEnd()
9438 
 
3431 rajveer 9439 
  def validate(self):
9440 
    return
9441 
 
9442 
 
94 ashish 9443 
  def __repr__(self):
9444 
    L = ['%s=%r' % (key, value)
9445 
      for key, value in self.__dict__.iteritems()]
9446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9447 
 
9448 
  def __eq__(self, other):
9449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9450 
 
9451 
  def __ne__(self, other):
9452 
    return not (self == other)
9453 
 
9454 
class getTransactionStatus_result:
9455 
  """
9456 
  Attributes:
9457 
   - success
9458 
   - ex
9459 
  """
9460 
 
9461 
  thrift_spec = (
9462 
    (0, TType.I32, 'success', None, None, ), # 0
9463 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9464 
  )
9465 
 
9466 
  def __init__(self, success=None, ex=None,):
9467 
    self.success = success
9468 
    self.ex = ex
9469 
 
9470 
  def read(self, iprot):
9471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9473 
      return
9474 
    iprot.readStructBegin()
9475 
    while True:
9476 
      (fname, ftype, fid) = iprot.readFieldBegin()
9477 
      if ftype == TType.STOP:
9478 
        break
9479 
      if fid == 0:
9480 
        if ftype == TType.I32:
9481 
          self.success = iprot.readI32();
9482 
        else:
9483 
          iprot.skip(ftype)
9484 
      elif fid == 1:
9485 
        if ftype == TType.STRUCT:
9486 
          self.ex = TransactionServiceException()
9487 
          self.ex.read(iprot)
9488 
        else:
9489 
          iprot.skip(ftype)
9490 
      else:
9491 
        iprot.skip(ftype)
9492 
      iprot.readFieldEnd()
9493 
    iprot.readStructEnd()
9494 
 
9495 
  def write(self, oprot):
9496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9498 
      return
9499 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 9500 
    if self.success is not None:
94 ashish 9501 
      oprot.writeFieldBegin('success', TType.I32, 0)
9502 
      oprot.writeI32(self.success)
9503 
      oprot.writeFieldEnd()
3431 rajveer 9504 
    if self.ex is not None:
94 ashish 9505 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9506 
      self.ex.write(oprot)
9507 
      oprot.writeFieldEnd()
9508 
    oprot.writeFieldStop()
9509 
    oprot.writeStructEnd()
9510 
 
3431 rajveer 9511 
  def validate(self):
9512 
    return
9513 
 
9514 
 
94 ashish 9515 
  def __repr__(self):
9516 
    L = ['%s=%r' % (key, value)
9517 
      for key, value in self.__dict__.iteritems()]
9518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9519 
 
9520 
  def __eq__(self, other):
9521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9522 
 
9523 
  def __ne__(self, other):
9524 
    return not (self == other)
9525 
 
9526 
class changeTransactionStatus_args:
9527 
  """
9528 
  Attributes:
9529 
   - transactionId
9530 
   - status
9531 
   - description
5527 anupam.sin 9532 
   - pickUp
9533 
   - orderType
94 ashish 9534 
  """
9535 
 
9536 
  thrift_spec = (
9537 
    None, # 0
9538 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9539 
    (2, TType.I32, 'status', None, None, ), # 2
9540 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 9541 
    (4, TType.I64, 'pickUp', None, None, ), # 4
9542 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 9543 
  )
9544 
 
5527 anupam.sin 9545 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 9546 
    self.transactionId = transactionId
9547 
    self.status = status
9548 
    self.description = description
5527 anupam.sin 9549 
    self.pickUp = pickUp
9550 
    self.orderType = orderType
94 ashish 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 
      elif fid == 2:
9567 
        if ftype == TType.I32:
9568 
          self.status = iprot.readI32();
9569 
        else:
9570 
          iprot.skip(ftype)
9571 
      elif fid == 3:
9572 
        if ftype == TType.STRING:
9573 
          self.description = iprot.readString();
9574 
        else:
9575 
          iprot.skip(ftype)
5387 rajveer 9576 
      elif fid == 4:
5527 anupam.sin 9577 
        if ftype == TType.I64:
9578 
          self.pickUp = iprot.readI64();
5387 rajveer 9579 
        else:
9580 
          iprot.skip(ftype)
5527 anupam.sin 9581 
      elif fid == 5:
9582 
        if ftype == TType.I32:
9583 
          self.orderType = iprot.readI32();
9584 
        else:
9585 
          iprot.skip(ftype)
94 ashish 9586 
      else:
9587 
        iprot.skip(ftype)
9588 
      iprot.readFieldEnd()
9589 
    iprot.readStructEnd()
9590 
 
9591 
  def write(self, oprot):
9592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9594 
      return
9595 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 9596 
    if self.transactionId is not None:
94 ashish 9597 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9598 
      oprot.writeI64(self.transactionId)
9599 
      oprot.writeFieldEnd()
3431 rajveer 9600 
    if self.status is not None:
94 ashish 9601 
      oprot.writeFieldBegin('status', TType.I32, 2)
9602 
      oprot.writeI32(self.status)
9603 
      oprot.writeFieldEnd()
3431 rajveer 9604 
    if self.description is not None:
94 ashish 9605 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9606 
      oprot.writeString(self.description)
9607 
      oprot.writeFieldEnd()
5527 anupam.sin 9608 
    if self.pickUp is not None:
9609 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
9610 
      oprot.writeI64(self.pickUp)
5387 rajveer 9611 
      oprot.writeFieldEnd()
5527 anupam.sin 9612 
    if self.orderType is not None:
9613 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
9614 
      oprot.writeI32(self.orderType)
9615 
      oprot.writeFieldEnd()
94 ashish 9616 
    oprot.writeFieldStop()
9617 
    oprot.writeStructEnd()
9618 
 
3431 rajveer 9619 
  def validate(self):
9620 
    return
9621 
 
9622 
 
94 ashish 9623 
  def __repr__(self):
9624 
    L = ['%s=%r' % (key, value)
9625 
      for key, value in self.__dict__.iteritems()]
9626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9627 
 
9628 
  def __eq__(self, other):
9629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9630 
 
9631 
  def __ne__(self, other):
9632 
    return not (self == other)
9633 
 
9634 
class changeTransactionStatus_result:
9635 
  """
9636 
  Attributes:
9637 
   - success
9638 
   - ex
9639 
  """
9640 
 
9641 
  thrift_spec = (
9642 
    (0, TType.BOOL, 'success', None, None, ), # 0
9643 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9644 
  )
9645 
 
9646 
  def __init__(self, success=None, ex=None,):
9647 
    self.success = success
9648 
    self.ex = ex
9649 
 
9650 
  def read(self, iprot):
9651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9653 
      return
9654 
    iprot.readStructBegin()
9655 
    while True:
9656 
      (fname, ftype, fid) = iprot.readFieldBegin()
9657 
      if ftype == TType.STOP:
9658 
        break
9659 
      if fid == 0:
9660 
        if ftype == TType.BOOL:
9661 
          self.success = iprot.readBool();
9662 
        else:
9663 
          iprot.skip(ftype)
9664 
      elif fid == 1:
9665 
        if ftype == TType.STRUCT:
9666 
          self.ex = TransactionServiceException()
9667 
          self.ex.read(iprot)
9668 
        else:
9669 
          iprot.skip(ftype)
9670 
      else:
9671 
        iprot.skip(ftype)
9672 
      iprot.readFieldEnd()
9673 
    iprot.readStructEnd()
9674 
 
9675 
  def write(self, oprot):
9676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9678 
      return
9679 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9680 
    if self.success is not None:
94 ashish 9681 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9682 
      oprot.writeBool(self.success)
9683 
      oprot.writeFieldEnd()
3431 rajveer 9684 
    if self.ex is not None:
94 ashish 9685 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9686 
      self.ex.write(oprot)
9687 
      oprot.writeFieldEnd()
9688 
    oprot.writeFieldStop()
9689 
    oprot.writeStructEnd()
9690 
 
3431 rajveer 9691 
  def validate(self):
9692 
    return
9693 
 
9694 
 
94 ashish 9695 
  def __repr__(self):
9696 
    L = ['%s=%r' % (key, value)
9697 
      for key, value in self.__dict__.iteritems()]
9698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9699 
 
9700 
  def __eq__(self, other):
9701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9702 
 
9703 
  def __ne__(self, other):
9704 
    return not (self == other)
9705 
 
1398 varun.gupt 9706 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 9707 
  """
9708 
  Attributes:
9709 
   - transactionId
9710 
  """
9711 
 
9712 
  thrift_spec = (
9713 
    None, # 0
9714 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9715 
  )
9716 
 
9717 
  def __init__(self, transactionId=None,):
9718 
    self.transactionId = transactionId
9719 
 
9720 
  def read(self, iprot):
9721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9723 
      return
9724 
    iprot.readStructBegin()
9725 
    while True:
9726 
      (fname, ftype, fid) = iprot.readFieldBegin()
9727 
      if ftype == TType.STOP:
9728 
        break
9729 
      if fid == 1:
9730 
        if ftype == TType.I64:
9731 
          self.transactionId = iprot.readI64();
9732 
        else:
9733 
          iprot.skip(ftype)
9734 
      else:
9735 
        iprot.skip(ftype)
9736 
      iprot.readFieldEnd()
9737 
    iprot.readStructEnd()
9738 
 
9739 
  def write(self, oprot):
9740 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9741 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9742 
      return
1398 varun.gupt 9743 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 9744 
    if self.transactionId is not None:
1382 varun.gupt 9745 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9746 
      oprot.writeI64(self.transactionId)
9747 
      oprot.writeFieldEnd()
9748 
    oprot.writeFieldStop()
9749 
    oprot.writeStructEnd()
9750 
 
3431 rajveer 9751 
  def validate(self):
9752 
    return
9753 
 
9754 
 
1382 varun.gupt 9755 
  def __repr__(self):
9756 
    L = ['%s=%r' % (key, value)
9757 
      for key, value in self.__dict__.iteritems()]
9758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9759 
 
9760 
  def __eq__(self, other):
9761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9762 
 
9763 
  def __ne__(self, other):
9764 
    return not (self == other)
9765 
 
1398 varun.gupt 9766 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 9767 
  """
9768 
  Attributes:
9769 
   - success
9770 
   - ex
9771 
  """
9772 
 
9773 
  thrift_spec = (
9774 
    (0, TType.BOOL, 'success', None, None, ), # 0
9775 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9776 
  )
9777 
 
9778 
  def __init__(self, success=None, ex=None,):
9779 
    self.success = success
9780 
    self.ex = ex
9781 
 
9782 
  def read(self, iprot):
9783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9785 
      return
9786 
    iprot.readStructBegin()
9787 
    while True:
9788 
      (fname, ftype, fid) = iprot.readFieldBegin()
9789 
      if ftype == TType.STOP:
9790 
        break
9791 
      if fid == 0:
9792 
        if ftype == TType.BOOL:
9793 
          self.success = iprot.readBool();
9794 
        else:
9795 
          iprot.skip(ftype)
9796 
      elif fid == 1:
9797 
        if ftype == TType.STRUCT:
9798 
          self.ex = TransactionServiceException()
9799 
          self.ex.read(iprot)
9800 
        else:
9801 
          iprot.skip(ftype)
9802 
      else:
9803 
        iprot.skip(ftype)
9804 
      iprot.readFieldEnd()
9805 
    iprot.readStructEnd()
9806 
 
9807 
  def write(self, oprot):
9808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9810 
      return
1398 varun.gupt 9811 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9812 
    if self.success is not None:
1382 varun.gupt 9813 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9814 
      oprot.writeBool(self.success)
9815 
      oprot.writeFieldEnd()
3431 rajveer 9816 
    if self.ex is not None:
1382 varun.gupt 9817 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9818 
      self.ex.write(oprot)
9819 
      oprot.writeFieldEnd()
9820 
    oprot.writeFieldStop()
9821 
    oprot.writeStructEnd()
9822 
 
3431 rajveer 9823 
  def validate(self):
9824 
    return
9825 
 
9826 
 
1382 varun.gupt 9827 
  def __repr__(self):
9828 
    L = ['%s=%r' % (key, value)
9829 
      for key, value in self.__dict__.iteritems()]
9830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9831 
 
9832 
  def __eq__(self, other):
9833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9834 
 
9835 
  def __ne__(self, other):
9836 
    return not (self == other)
9837 
 
483 rajveer 9838 
class getAllOrders_args:
94 ashish 9839 
  """
9840 
  Attributes:
4801 anupam.sin 9841 
   - statuses
483 rajveer 9842 
   - from_date
9843 
   - to_date
9844 
   - warehouse_id
94 ashish 9845 
  """
9846 
 
9847 
  thrift_spec = (
9848 
    None, # 0
4801 anupam.sin 9849 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 9850 
    (2, TType.I64, 'from_date', None, None, ), # 2
9851 
    (3, TType.I64, 'to_date', None, None, ), # 3
9852 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 9853 
  )
9854 
 
4801 anupam.sin 9855 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
9856 
    self.statuses = statuses
483 rajveer 9857 
    self.from_date = from_date
9858 
    self.to_date = to_date
9859 
    self.warehouse_id = warehouse_id
94 ashish 9860 
 
9861 
  def read(self, iprot):
9862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9864 
      return
9865 
    iprot.readStructBegin()
9866 
    while True:
9867 
      (fname, ftype, fid) = iprot.readFieldBegin()
9868 
      if ftype == TType.STOP:
9869 
        break
9870 
      if fid == 1:
4801 anupam.sin 9871 
        if ftype == TType.LIST:
9872 
          self.statuses = []
6188 rajveer 9873 
          (_etype123, _size120) = iprot.readListBegin()
9874 
          for _i124 in xrange(_size120):
9875 
            _elem125 = iprot.readI32();
9876 
            self.statuses.append(_elem125)
4801 anupam.sin 9877 
          iprot.readListEnd()
94 ashish 9878 
        else:
9879 
          iprot.skip(ftype)
483 rajveer 9880 
      elif fid == 2:
9881 
        if ftype == TType.I64:
9882 
          self.from_date = iprot.readI64();
94 ashish 9883 
        else:
9884 
          iprot.skip(ftype)
483 rajveer 9885 
      elif fid == 3:
9886 
        if ftype == TType.I64:
9887 
          self.to_date = iprot.readI64();
94 ashish 9888 
        else:
9889 
          iprot.skip(ftype)
483 rajveer 9890 
      elif fid == 4:
94 ashish 9891 
        if ftype == TType.I64:
483 rajveer 9892 
          self.warehouse_id = iprot.readI64();
94 ashish 9893 
        else:
9894 
          iprot.skip(ftype)
9895 
      else:
9896 
        iprot.skip(ftype)
9897 
      iprot.readFieldEnd()
9898 
    iprot.readStructEnd()
9899 
 
9900 
  def write(self, oprot):
9901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9903 
      return
483 rajveer 9904 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 9905 
    if self.statuses is not None:
9906 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9907 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9908 
      for iter126 in self.statuses:
9909 
        oprot.writeI32(iter126)
4801 anupam.sin 9910 
      oprot.writeListEnd()
94 ashish 9911 
      oprot.writeFieldEnd()
3431 rajveer 9912 
    if self.from_date is not None:
483 rajveer 9913 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9914 
      oprot.writeI64(self.from_date)
94 ashish 9915 
      oprot.writeFieldEnd()
3431 rajveer 9916 
    if self.to_date is not None:
483 rajveer 9917 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9918 
      oprot.writeI64(self.to_date)
94 ashish 9919 
      oprot.writeFieldEnd()
3431 rajveer 9920 
    if self.warehouse_id is not None:
483 rajveer 9921 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9922 
      oprot.writeI64(self.warehouse_id)
94 ashish 9923 
      oprot.writeFieldEnd()
9924 
    oprot.writeFieldStop()
9925 
    oprot.writeStructEnd()
9926 
 
3431 rajveer 9927 
  def validate(self):
9928 
    return
9929 
 
9930 
 
94 ashish 9931 
  def __repr__(self):
9932 
    L = ['%s=%r' % (key, value)
9933 
      for key, value in self.__dict__.iteritems()]
9934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9935 
 
9936 
  def __eq__(self, other):
9937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9938 
 
9939 
  def __ne__(self, other):
9940 
    return not (self == other)
9941 
 
483 rajveer 9942 
class getAllOrders_result:
94 ashish 9943 
  """
9944 
  Attributes:
9945 
   - success
9946 
   - ex
9947 
  """
9948 
 
9949 
  thrift_spec = (
483 rajveer 9950 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 9951 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9952 
  )
9953 
 
9954 
  def __init__(self, success=None, ex=None,):
9955 
    self.success = success
9956 
    self.ex = ex
9957 
 
9958 
  def read(self, iprot):
9959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9961 
      return
9962 
    iprot.readStructBegin()
9963 
    while True:
9964 
      (fname, ftype, fid) = iprot.readFieldBegin()
9965 
      if ftype == TType.STOP:
9966 
        break
9967 
      if fid == 0:
483 rajveer 9968 
        if ftype == TType.LIST:
9969 
          self.success = []
6188 rajveer 9970 
          (_etype130, _size127) = iprot.readListBegin()
9971 
          for _i131 in xrange(_size127):
9972 
            _elem132 = Order()
9973 
            _elem132.read(iprot)
9974 
            self.success.append(_elem132)
483 rajveer 9975 
          iprot.readListEnd()
94 ashish 9976 
        else:
9977 
          iprot.skip(ftype)
9978 
      elif fid == 1:
9979 
        if ftype == TType.STRUCT:
9980 
          self.ex = TransactionServiceException()
9981 
          self.ex.read(iprot)
9982 
        else:
9983 
          iprot.skip(ftype)
9984 
      else:
9985 
        iprot.skip(ftype)
9986 
      iprot.readFieldEnd()
9987 
    iprot.readStructEnd()
9988 
 
9989 
  def write(self, oprot):
9990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9992 
      return
483 rajveer 9993 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 9994 
    if self.success is not None:
483 rajveer 9995 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9996 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9997 
      for iter133 in self.success:
9998 
        iter133.write(oprot)
483 rajveer 9999 
      oprot.writeListEnd()
94 ashish 10000 
      oprot.writeFieldEnd()
3431 rajveer 10001 
    if self.ex is not None:
94 ashish 10002 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10003 
      self.ex.write(oprot)
10004 
      oprot.writeFieldEnd()
10005 
    oprot.writeFieldStop()
10006 
    oprot.writeStructEnd()
10007 
 
3431 rajveer 10008 
  def validate(self):
10009 
    return
10010 
 
10011 
 
94 ashish 10012 
  def __repr__(self):
10013 
    L = ['%s=%r' % (key, value)
10014 
      for key, value in self.__dict__.iteritems()]
10015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10016 
 
10017 
  def __eq__(self, other):
10018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10019 
 
10020 
  def __ne__(self, other):
10021 
    return not (self == other)
10022 
 
4133 chandransh 10023 
class getOrdersInBatch_args:
10024 
  """
10025 
  Attributes:
10026 
   - statuses
10027 
   - offset
10028 
   - limit
10029 
   - warehouse_id
10030 
  """
10031 
 
10032 
  thrift_spec = (
10033 
    None, # 0
10034 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10035 
    (2, TType.I64, 'offset', None, None, ), # 2
10036 
    (3, TType.I64, 'limit', None, None, ), # 3
10037 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10038 
  )
10039 
 
10040 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
10041 
    self.statuses = statuses
10042 
    self.offset = offset
10043 
    self.limit = limit
10044 
    self.warehouse_id = warehouse_id
10045 
 
10046 
  def read(self, iprot):
10047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10049 
      return
10050 
    iprot.readStructBegin()
10051 
    while True:
10052 
      (fname, ftype, fid) = iprot.readFieldBegin()
10053 
      if ftype == TType.STOP:
10054 
        break
10055 
      if fid == 1:
10056 
        if ftype == TType.LIST:
10057 
          self.statuses = []
6188 rajveer 10058 
          (_etype137, _size134) = iprot.readListBegin()
10059 
          for _i138 in xrange(_size134):
10060 
            _elem139 = iprot.readI32();
10061 
            self.statuses.append(_elem139)
4133 chandransh 10062 
          iprot.readListEnd()
10063 
        else:
10064 
          iprot.skip(ftype)
10065 
      elif fid == 2:
10066 
        if ftype == TType.I64:
10067 
          self.offset = iprot.readI64();
10068 
        else:
10069 
          iprot.skip(ftype)
10070 
      elif fid == 3:
10071 
        if ftype == TType.I64:
10072 
          self.limit = iprot.readI64();
10073 
        else:
10074 
          iprot.skip(ftype)
10075 
      elif fid == 4:
10076 
        if ftype == TType.I64:
10077 
          self.warehouse_id = iprot.readI64();
10078 
        else:
10079 
          iprot.skip(ftype)
10080 
      else:
10081 
        iprot.skip(ftype)
10082 
      iprot.readFieldEnd()
10083 
    iprot.readStructEnd()
10084 
 
10085 
  def write(self, oprot):
10086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10088 
      return
10089 
    oprot.writeStructBegin('getOrdersInBatch_args')
10090 
    if self.statuses is not None:
10091 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10092 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10093 
      for iter140 in self.statuses:
10094 
        oprot.writeI32(iter140)
4133 chandransh 10095 
      oprot.writeListEnd()
10096 
      oprot.writeFieldEnd()
10097 
    if self.offset is not None:
10098 
      oprot.writeFieldBegin('offset', TType.I64, 2)
10099 
      oprot.writeI64(self.offset)
10100 
      oprot.writeFieldEnd()
10101 
    if self.limit is not None:
10102 
      oprot.writeFieldBegin('limit', TType.I64, 3)
10103 
      oprot.writeI64(self.limit)
10104 
      oprot.writeFieldEnd()
10105 
    if self.warehouse_id is not None:
10106 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10107 
      oprot.writeI64(self.warehouse_id)
10108 
      oprot.writeFieldEnd()
10109 
    oprot.writeFieldStop()
10110 
    oprot.writeStructEnd()
10111 
 
10112 
  def validate(self):
10113 
    return
10114 
 
10115 
 
10116 
  def __repr__(self):
10117 
    L = ['%s=%r' % (key, value)
10118 
      for key, value in self.__dict__.iteritems()]
10119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10120 
 
10121 
  def __eq__(self, other):
10122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10123 
 
10124 
  def __ne__(self, other):
10125 
    return not (self == other)
10126 
 
10127 
class getOrdersInBatch_result:
10128 
  """
10129 
  Attributes:
10130 
   - success
10131 
   - ex
10132 
  """
10133 
 
10134 
  thrift_spec = (
10135 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10136 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10137 
  )
10138 
 
10139 
  def __init__(self, success=None, ex=None,):
10140 
    self.success = success
10141 
    self.ex = ex
10142 
 
10143 
  def read(self, iprot):
10144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10146 
      return
10147 
    iprot.readStructBegin()
10148 
    while True:
10149 
      (fname, ftype, fid) = iprot.readFieldBegin()
10150 
      if ftype == TType.STOP:
10151 
        break
10152 
      if fid == 0:
10153 
        if ftype == TType.LIST:
10154 
          self.success = []
6188 rajveer 10155 
          (_etype144, _size141) = iprot.readListBegin()
10156 
          for _i145 in xrange(_size141):
10157 
            _elem146 = Order()
10158 
            _elem146.read(iprot)
10159 
            self.success.append(_elem146)
4133 chandransh 10160 
          iprot.readListEnd()
10161 
        else:
10162 
          iprot.skip(ftype)
10163 
      elif fid == 1:
10164 
        if ftype == TType.STRUCT:
10165 
          self.ex = TransactionServiceException()
10166 
          self.ex.read(iprot)
10167 
        else:
10168 
          iprot.skip(ftype)
10169 
      else:
10170 
        iprot.skip(ftype)
10171 
      iprot.readFieldEnd()
10172 
    iprot.readStructEnd()
10173 
 
10174 
  def write(self, oprot):
10175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10177 
      return
10178 
    oprot.writeStructBegin('getOrdersInBatch_result')
10179 
    if self.success is not None:
10180 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10181 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10182 
      for iter147 in self.success:
10183 
        iter147.write(oprot)
4133 chandransh 10184 
      oprot.writeListEnd()
10185 
      oprot.writeFieldEnd()
10186 
    if self.ex is not None:
10187 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10188 
      self.ex.write(oprot)
10189 
      oprot.writeFieldEnd()
10190 
    oprot.writeFieldStop()
10191 
    oprot.writeStructEnd()
10192 
 
10193 
  def validate(self):
10194 
    return
10195 
 
10196 
 
10197 
  def __repr__(self):
10198 
    L = ['%s=%r' % (key, value)
10199 
      for key, value in self.__dict__.iteritems()]
10200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10201 
 
10202 
  def __eq__(self, other):
10203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10204 
 
10205 
  def __ne__(self, other):
10206 
    return not (self == other)
10207 
 
10208 
class getOrderCount_args:
10209 
  """
10210 
  Attributes:
10211 
   - statuses
10212 
   - warehouseId
10213 
  """
10214 
 
10215 
  thrift_spec = (
10216 
    None, # 0
10217 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10218 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10219 
  )
10220 
 
10221 
  def __init__(self, statuses=None, warehouseId=None,):
10222 
    self.statuses = statuses
10223 
    self.warehouseId = warehouseId
10224 
 
10225 
  def read(self, iprot):
10226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10228 
      return
10229 
    iprot.readStructBegin()
10230 
    while True:
10231 
      (fname, ftype, fid) = iprot.readFieldBegin()
10232 
      if ftype == TType.STOP:
10233 
        break
10234 
      if fid == 1:
10235 
        if ftype == TType.LIST:
10236 
          self.statuses = []
6188 rajveer 10237 
          (_etype151, _size148) = iprot.readListBegin()
10238 
          for _i152 in xrange(_size148):
10239 
            _elem153 = iprot.readI32();
10240 
            self.statuses.append(_elem153)
4133 chandransh 10241 
          iprot.readListEnd()
10242 
        else:
10243 
          iprot.skip(ftype)
10244 
      elif fid == 2:
10245 
        if ftype == TType.I64:
10246 
          self.warehouseId = iprot.readI64();
10247 
        else:
10248 
          iprot.skip(ftype)
10249 
      else:
10250 
        iprot.skip(ftype)
10251 
      iprot.readFieldEnd()
10252 
    iprot.readStructEnd()
10253 
 
10254 
  def write(self, oprot):
10255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10257 
      return
10258 
    oprot.writeStructBegin('getOrderCount_args')
10259 
    if self.statuses is not None:
10260 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10261 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10262 
      for iter154 in self.statuses:
10263 
        oprot.writeI32(iter154)
4133 chandransh 10264 
      oprot.writeListEnd()
10265 
      oprot.writeFieldEnd()
10266 
    if self.warehouseId is not None:
10267 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10268 
      oprot.writeI64(self.warehouseId)
10269 
      oprot.writeFieldEnd()
10270 
    oprot.writeFieldStop()
10271 
    oprot.writeStructEnd()
10272 
 
10273 
  def validate(self):
10274 
    return
10275 
 
10276 
 
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 getOrderCount_result:
10289 
  """
10290 
  Attributes:
10291 
   - success
10292 
   - ex
10293 
  """
10294 
 
10295 
  thrift_spec = (
10296 
    (0, TType.I32, 'success', None, 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.I32:
10315 
          self.success = iprot.readI32();
10316 
        else:
10317 
          iprot.skip(ftype)
10318 
      elif fid == 1:
10319 
        if ftype == TType.STRUCT:
10320 
          self.ex = TransactionServiceException()
10321 
          self.ex.read(iprot)
10322 
        else:
10323 
          iprot.skip(ftype)
10324 
      else:
10325 
        iprot.skip(ftype)
10326 
      iprot.readFieldEnd()
10327 
    iprot.readStructEnd()
10328 
 
10329 
  def write(self, oprot):
10330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10332 
      return
10333 
    oprot.writeStructBegin('getOrderCount_result')
10334 
    if self.success is not None:
10335 
      oprot.writeFieldBegin('success', TType.I32, 0)
10336 
      oprot.writeI32(self.success)
10337 
      oprot.writeFieldEnd()
10338 
    if self.ex is not None:
10339 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10340 
      self.ex.write(oprot)
10341 
      oprot.writeFieldEnd()
10342 
    oprot.writeFieldStop()
10343 
    oprot.writeStructEnd()
10344 
 
10345 
  def validate(self):
10346 
    return
10347 
 
10348 
 
10349 
  def __repr__(self):
10350 
    L = ['%s=%r' % (key, value)
10351 
      for key, value in self.__dict__.iteritems()]
10352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10353 
 
10354 
  def __eq__(self, other):
10355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10356 
 
10357 
  def __ne__(self, other):
10358 
    return not (self == other)
10359 
 
999 varun.gupt 10360 
class getOrdersByBillingDate_args:
10361 
  """
10362 
  Attributes:
10363 
   - status
10364 
   - start_billing_date
10365 
   - end_billing_date
10366 
   - warehouse_id
10367 
  """
10368 
 
10369 
  thrift_spec = (
10370 
    None, # 0
10371 
    (1, TType.I32, 'status', None, None, ), # 1
10372 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
10373 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
10374 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10375 
  )
10376 
 
10377 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
10378 
    self.status = status
10379 
    self.start_billing_date = start_billing_date
10380 
    self.end_billing_date = end_billing_date
10381 
    self.warehouse_id = warehouse_id
10382 
 
10383 
  def read(self, iprot):
10384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10386 
      return
10387 
    iprot.readStructBegin()
10388 
    while True:
10389 
      (fname, ftype, fid) = iprot.readFieldBegin()
10390 
      if ftype == TType.STOP:
10391 
        break
10392 
      if fid == 1:
10393 
        if ftype == TType.I32:
10394 
          self.status = iprot.readI32();
10395 
        else:
10396 
          iprot.skip(ftype)
10397 
      elif fid == 2:
10398 
        if ftype == TType.I64:
10399 
          self.start_billing_date = iprot.readI64();
10400 
        else:
10401 
          iprot.skip(ftype)
10402 
      elif fid == 3:
10403 
        if ftype == TType.I64:
10404 
          self.end_billing_date = iprot.readI64();
10405 
        else:
10406 
          iprot.skip(ftype)
10407 
      elif fid == 4:
10408 
        if ftype == TType.I64:
10409 
          self.warehouse_id = iprot.readI64();
10410 
        else:
10411 
          iprot.skip(ftype)
10412 
      else:
10413 
        iprot.skip(ftype)
10414 
      iprot.readFieldEnd()
10415 
    iprot.readStructEnd()
10416 
 
10417 
  def write(self, oprot):
10418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10420 
      return
10421 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 10422 
    if self.status is not None:
999 varun.gupt 10423 
      oprot.writeFieldBegin('status', TType.I32, 1)
10424 
      oprot.writeI32(self.status)
10425 
      oprot.writeFieldEnd()
3431 rajveer 10426 
    if self.start_billing_date is not None:
999 varun.gupt 10427 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
10428 
      oprot.writeI64(self.start_billing_date)
10429 
      oprot.writeFieldEnd()
3431 rajveer 10430 
    if self.end_billing_date is not None:
999 varun.gupt 10431 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
10432 
      oprot.writeI64(self.end_billing_date)
10433 
      oprot.writeFieldEnd()
3431 rajveer 10434 
    if self.warehouse_id is not None:
999 varun.gupt 10435 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10436 
      oprot.writeI64(self.warehouse_id)
10437 
      oprot.writeFieldEnd()
10438 
    oprot.writeFieldStop()
10439 
    oprot.writeStructEnd()
10440 
 
3431 rajveer 10441 
  def validate(self):
10442 
    return
10443 
 
10444 
 
999 varun.gupt 10445 
  def __repr__(self):
10446 
    L = ['%s=%r' % (key, value)
10447 
      for key, value in self.__dict__.iteritems()]
10448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10449 
 
10450 
  def __eq__(self, other):
10451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10452 
 
10453 
  def __ne__(self, other):
10454 
    return not (self == other)
10455 
 
10456 
class getOrdersByBillingDate_result:
10457 
  """
10458 
  Attributes:
10459 
   - success
10460 
   - ex
10461 
  """
10462 
 
10463 
  thrift_spec = (
10464 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10465 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10466 
  )
10467 
 
10468 
  def __init__(self, success=None, ex=None,):
10469 
    self.success = success
10470 
    self.ex = ex
10471 
 
10472 
  def read(self, iprot):
10473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10475 
      return
10476 
    iprot.readStructBegin()
10477 
    while True:
10478 
      (fname, ftype, fid) = iprot.readFieldBegin()
10479 
      if ftype == TType.STOP:
10480 
        break
10481 
      if fid == 0:
10482 
        if ftype == TType.LIST:
10483 
          self.success = []
6188 rajveer 10484 
          (_etype158, _size155) = iprot.readListBegin()
10485 
          for _i159 in xrange(_size155):
10486 
            _elem160 = Order()
10487 
            _elem160.read(iprot)
10488 
            self.success.append(_elem160)
999 varun.gupt 10489 
          iprot.readListEnd()
10490 
        else:
10491 
          iprot.skip(ftype)
10492 
      elif fid == 1:
10493 
        if ftype == TType.STRUCT:
10494 
          self.ex = TransactionServiceException()
10495 
          self.ex.read(iprot)
10496 
        else:
10497 
          iprot.skip(ftype)
10498 
      else:
10499 
        iprot.skip(ftype)
10500 
      iprot.readFieldEnd()
10501 
    iprot.readStructEnd()
10502 
 
10503 
  def write(self, oprot):
10504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10506 
      return
10507 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 10508 
    if self.success is not None:
999 varun.gupt 10509 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10510 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10511 
      for iter161 in self.success:
10512 
        iter161.write(oprot)
999 varun.gupt 10513 
      oprot.writeListEnd()
10514 
      oprot.writeFieldEnd()
3431 rajveer 10515 
    if self.ex is not None:
999 varun.gupt 10516 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10517 
      self.ex.write(oprot)
10518 
      oprot.writeFieldEnd()
10519 
    oprot.writeFieldStop()
10520 
    oprot.writeStructEnd()
10521 
 
3431 rajveer 10522 
  def validate(self):
10523 
    return
10524 
 
10525 
 
999 varun.gupt 10526 
  def __repr__(self):
10527 
    L = ['%s=%r' % (key, value)
10528 
      for key, value in self.__dict__.iteritems()]
10529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10530 
 
10531 
  def __eq__(self, other):
10532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10533 
 
10534 
  def __ne__(self, other):
10535 
    return not (self == other)
10536 
 
3427 chandransh 10537 
class getOrdersByShippingDate_args:
10538 
  """
10539 
  Attributes:
10540 
   - fromShippingDate
10541 
   - toShippingDate
10542 
   - providerId
10543 
   - warehouseId
3451 chandransh 10544 
   - cod
3427 chandransh 10545 
  """
10546 
 
10547 
  thrift_spec = (
10548 
    None, # 0
10549 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
10550 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
10551 
    (3, TType.I64, 'providerId', None, None, ), # 3
10552 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 10553 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 10554 
  )
10555 
 
3451 chandransh 10556 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 10557 
    self.fromShippingDate = fromShippingDate
10558 
    self.toShippingDate = toShippingDate
10559 
    self.providerId = providerId
10560 
    self.warehouseId = warehouseId
3451 chandransh 10561 
    self.cod = cod
3427 chandransh 10562 
 
10563 
  def read(self, iprot):
10564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10566 
      return
10567 
    iprot.readStructBegin()
10568 
    while True:
10569 
      (fname, ftype, fid) = iprot.readFieldBegin()
10570 
      if ftype == TType.STOP:
10571 
        break
10572 
      if fid == 1:
10573 
        if ftype == TType.I64:
10574 
          self.fromShippingDate = iprot.readI64();
10575 
        else:
10576 
          iprot.skip(ftype)
10577 
      elif fid == 2:
10578 
        if ftype == TType.I64:
10579 
          self.toShippingDate = iprot.readI64();
10580 
        else:
10581 
          iprot.skip(ftype)
10582 
      elif fid == 3:
10583 
        if ftype == TType.I64:
10584 
          self.providerId = iprot.readI64();
10585 
        else:
10586 
          iprot.skip(ftype)
10587 
      elif fid == 4:
10588 
        if ftype == TType.I64:
10589 
          self.warehouseId = iprot.readI64();
10590 
        else:
10591 
          iprot.skip(ftype)
3451 chandransh 10592 
      elif fid == 5:
10593 
        if ftype == TType.BOOL:
10594 
          self.cod = iprot.readBool();
10595 
        else:
10596 
          iprot.skip(ftype)
3427 chandransh 10597 
      else:
10598 
        iprot.skip(ftype)
10599 
      iprot.readFieldEnd()
10600 
    iprot.readStructEnd()
10601 
 
10602 
  def write(self, oprot):
10603 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10604 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10605 
      return
10606 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 10607 
    if self.fromShippingDate is not None:
3427 chandransh 10608 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
10609 
      oprot.writeI64(self.fromShippingDate)
10610 
      oprot.writeFieldEnd()
3431 rajveer 10611 
    if self.toShippingDate is not None:
3427 chandransh 10612 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
10613 
      oprot.writeI64(self.toShippingDate)
10614 
      oprot.writeFieldEnd()
3431 rajveer 10615 
    if self.providerId is not None:
3427 chandransh 10616 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
10617 
      oprot.writeI64(self.providerId)
10618 
      oprot.writeFieldEnd()
3431 rajveer 10619 
    if self.warehouseId is not None:
3427 chandransh 10620 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
10621 
      oprot.writeI64(self.warehouseId)
10622 
      oprot.writeFieldEnd()
3451 chandransh 10623 
    if self.cod is not None:
10624 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
10625 
      oprot.writeBool(self.cod)
10626 
      oprot.writeFieldEnd()
3427 chandransh 10627 
    oprot.writeFieldStop()
10628 
    oprot.writeStructEnd()
10629 
 
3431 rajveer 10630 
  def validate(self):
10631 
    return
10632 
 
10633 
 
3427 chandransh 10634 
  def __repr__(self):
10635 
    L = ['%s=%r' % (key, value)
10636 
      for key, value in self.__dict__.iteritems()]
10637 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10638 
 
10639 
  def __eq__(self, other):
10640 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10641 
 
10642 
  def __ne__(self, other):
10643 
    return not (self == other)
10644 
 
10645 
class getOrdersByShippingDate_result:
10646 
  """
10647 
  Attributes:
10648 
   - success
10649 
   - ex
10650 
  """
10651 
 
10652 
  thrift_spec = (
10653 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10654 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10655 
  )
10656 
 
10657 
  def __init__(self, success=None, ex=None,):
10658 
    self.success = success
10659 
    self.ex = ex
10660 
 
10661 
  def read(self, iprot):
10662 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10663 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10664 
      return
10665 
    iprot.readStructBegin()
10666 
    while True:
10667 
      (fname, ftype, fid) = iprot.readFieldBegin()
10668 
      if ftype == TType.STOP:
10669 
        break
10670 
      if fid == 0:
10671 
        if ftype == TType.LIST:
10672 
          self.success = []
6188 rajveer 10673 
          (_etype165, _size162) = iprot.readListBegin()
10674 
          for _i166 in xrange(_size162):
10675 
            _elem167 = Order()
10676 
            _elem167.read(iprot)
10677 
            self.success.append(_elem167)
3427 chandransh 10678 
          iprot.readListEnd()
10679 
        else:
10680 
          iprot.skip(ftype)
10681 
      elif fid == 1:
10682 
        if ftype == TType.STRUCT:
10683 
          self.ex = TransactionServiceException()
10684 
          self.ex.read(iprot)
10685 
        else:
10686 
          iprot.skip(ftype)
10687 
      else:
10688 
        iprot.skip(ftype)
10689 
      iprot.readFieldEnd()
10690 
    iprot.readStructEnd()
10691 
 
10692 
  def write(self, oprot):
10693 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10694 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10695 
      return
10696 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10697 
    if self.success is not None:
3427 chandransh 10698 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10699 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10700 
      for iter168 in self.success:
10701 
        iter168.write(oprot)
3427 chandransh 10702 
      oprot.writeListEnd()
10703 
      oprot.writeFieldEnd()
3431 rajveer 10704 
    if self.ex is not None:
3427 chandransh 10705 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10706 
      self.ex.write(oprot)
10707 
      oprot.writeFieldEnd()
10708 
    oprot.writeFieldStop()
10709 
    oprot.writeStructEnd()
10710 
 
3431 rajveer 10711 
  def validate(self):
10712 
    return
10713 
 
10714 
 
3427 chandransh 10715 
  def __repr__(self):
10716 
    L = ['%s=%r' % (key, value)
10717 
      for key, value in self.__dict__.iteritems()]
10718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10719 
 
10720 
  def __eq__(self, other):
10721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10722 
 
10723 
  def __ne__(self, other):
10724 
    return not (self == other)
10725 
 
1382 varun.gupt 10726 
class getReturnableOrdersForCustomer_args:
10727 
  """
10728 
  Attributes:
10729 
   - customer_id
10730 
   - limit
10731 
  """
10732 
 
10733 
  thrift_spec = (
10734 
    None, # 0
10735 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10736 
    (2, TType.I64, 'limit', None, None, ), # 2
10737 
  )
10738 
 
10739 
  def __init__(self, customer_id=None, limit=None,):
10740 
    self.customer_id = customer_id
10741 
    self.limit = limit
10742 
 
10743 
  def read(self, iprot):
10744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10746 
      return
10747 
    iprot.readStructBegin()
10748 
    while True:
10749 
      (fname, ftype, fid) = iprot.readFieldBegin()
10750 
      if ftype == TType.STOP:
10751 
        break
10752 
      if fid == 1:
10753 
        if ftype == TType.I64:
10754 
          self.customer_id = iprot.readI64();
10755 
        else:
10756 
          iprot.skip(ftype)
10757 
      elif fid == 2:
10758 
        if ftype == TType.I64:
10759 
          self.limit = iprot.readI64();
10760 
        else:
10761 
          iprot.skip(ftype)
10762 
      else:
10763 
        iprot.skip(ftype)
10764 
      iprot.readFieldEnd()
10765 
    iprot.readStructEnd()
10766 
 
10767 
  def write(self, oprot):
10768 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10769 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10770 
      return
10771 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 10772 
    if self.customer_id is not None:
1382 varun.gupt 10773 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10774 
      oprot.writeI64(self.customer_id)
10775 
      oprot.writeFieldEnd()
3431 rajveer 10776 
    if self.limit is not None:
1382 varun.gupt 10777 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10778 
      oprot.writeI64(self.limit)
10779 
      oprot.writeFieldEnd()
10780 
    oprot.writeFieldStop()
10781 
    oprot.writeStructEnd()
10782 
 
3431 rajveer 10783 
  def validate(self):
10784 
    return
10785 
 
10786 
 
1382 varun.gupt 10787 
  def __repr__(self):
10788 
    L = ['%s=%r' % (key, value)
10789 
      for key, value in self.__dict__.iteritems()]
10790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10791 
 
10792 
  def __eq__(self, other):
10793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10794 
 
10795 
  def __ne__(self, other):
10796 
    return not (self == other)
10797 
 
10798 
class getReturnableOrdersForCustomer_result:
10799 
  """
10800 
  Attributes:
10801 
   - success
10802 
   - ex
10803 
  """
10804 
 
10805 
  thrift_spec = (
10806 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10807 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10808 
  )
10809 
 
10810 
  def __init__(self, success=None, ex=None,):
10811 
    self.success = success
10812 
    self.ex = ex
10813 
 
10814 
  def read(self, iprot):
10815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10817 
      return
10818 
    iprot.readStructBegin()
10819 
    while True:
10820 
      (fname, ftype, fid) = iprot.readFieldBegin()
10821 
      if ftype == TType.STOP:
10822 
        break
10823 
      if fid == 0:
10824 
        if ftype == TType.LIST:
10825 
          self.success = []
6188 rajveer 10826 
          (_etype172, _size169) = iprot.readListBegin()
10827 
          for _i173 in xrange(_size169):
10828 
            _elem174 = iprot.readI64();
10829 
            self.success.append(_elem174)
1382 varun.gupt 10830 
          iprot.readListEnd()
10831 
        else:
10832 
          iprot.skip(ftype)
10833 
      elif fid == 1:
10834 
        if ftype == TType.STRUCT:
10835 
          self.ex = TransactionServiceException()
10836 
          self.ex.read(iprot)
10837 
        else:
10838 
          iprot.skip(ftype)
10839 
      else:
10840 
        iprot.skip(ftype)
10841 
      iprot.readFieldEnd()
10842 
    iprot.readStructEnd()
10843 
 
10844 
  def write(self, oprot):
10845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10847 
      return
10848 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10849 
    if self.success is not None:
1382 varun.gupt 10850 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10851 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10852 
      for iter175 in self.success:
10853 
        oprot.writeI64(iter175)
1382 varun.gupt 10854 
      oprot.writeListEnd()
10855 
      oprot.writeFieldEnd()
3431 rajveer 10856 
    if self.ex is not None:
1382 varun.gupt 10857 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10858 
      self.ex.write(oprot)
10859 
      oprot.writeFieldEnd()
10860 
    oprot.writeFieldStop()
10861 
    oprot.writeStructEnd()
10862 
 
3431 rajveer 10863 
  def validate(self):
10864 
    return
10865 
 
10866 
 
1382 varun.gupt 10867 
  def __repr__(self):
10868 
    L = ['%s=%r' % (key, value)
10869 
      for key, value in self.__dict__.iteritems()]
10870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10871 
 
10872 
  def __eq__(self, other):
10873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10874 
 
10875 
  def __ne__(self, other):
10876 
    return not (self == other)
10877 
 
10878 
class getCancellableOrdersForCustomer_args:
10879 
  """
10880 
  Attributes:
10881 
   - customer_id
10882 
   - limit
10883 
  """
10884 
 
10885 
  thrift_spec = (
10886 
    None, # 0
10887 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10888 
    (2, TType.I64, 'limit', None, None, ), # 2
10889 
  )
10890 
 
10891 
  def __init__(self, customer_id=None, limit=None,):
10892 
    self.customer_id = customer_id
10893 
    self.limit = limit
10894 
 
10895 
  def read(self, iprot):
10896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10898 
      return
10899 
    iprot.readStructBegin()
10900 
    while True:
10901 
      (fname, ftype, fid) = iprot.readFieldBegin()
10902 
      if ftype == TType.STOP:
10903 
        break
10904 
      if fid == 1:
10905 
        if ftype == TType.I64:
10906 
          self.customer_id = iprot.readI64();
10907 
        else:
10908 
          iprot.skip(ftype)
10909 
      elif fid == 2:
10910 
        if ftype == TType.I64:
10911 
          self.limit = iprot.readI64();
10912 
        else:
10913 
          iprot.skip(ftype)
10914 
      else:
10915 
        iprot.skip(ftype)
10916 
      iprot.readFieldEnd()
10917 
    iprot.readStructEnd()
10918 
 
10919 
  def write(self, oprot):
10920 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10921 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10922 
      return
10923 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 10924 
    if self.customer_id is not None:
1382 varun.gupt 10925 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10926 
      oprot.writeI64(self.customer_id)
10927 
      oprot.writeFieldEnd()
3431 rajveer 10928 
    if self.limit is not None:
1382 varun.gupt 10929 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10930 
      oprot.writeI64(self.limit)
10931 
      oprot.writeFieldEnd()
10932 
    oprot.writeFieldStop()
10933 
    oprot.writeStructEnd()
10934 
 
3431 rajveer 10935 
  def validate(self):
10936 
    return
10937 
 
10938 
 
1382 varun.gupt 10939 
  def __repr__(self):
10940 
    L = ['%s=%r' % (key, value)
10941 
      for key, value in self.__dict__.iteritems()]
10942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10943 
 
10944 
  def __eq__(self, other):
10945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10946 
 
10947 
  def __ne__(self, other):
10948 
    return not (self == other)
10949 
 
10950 
class getCancellableOrdersForCustomer_result:
10951 
  """
10952 
  Attributes:
10953 
   - success
10954 
   - ex
10955 
  """
10956 
 
10957 
  thrift_spec = (
10958 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10959 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10960 
  )
10961 
 
10962 
  def __init__(self, success=None, ex=None,):
10963 
    self.success = success
10964 
    self.ex = ex
10965 
 
10966 
  def read(self, iprot):
10967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10969 
      return
10970 
    iprot.readStructBegin()
10971 
    while True:
10972 
      (fname, ftype, fid) = iprot.readFieldBegin()
10973 
      if ftype == TType.STOP:
10974 
        break
10975 
      if fid == 0:
10976 
        if ftype == TType.LIST:
10977 
          self.success = []
6188 rajveer 10978 
          (_etype179, _size176) = iprot.readListBegin()
10979 
          for _i180 in xrange(_size176):
10980 
            _elem181 = iprot.readI64();
10981 
            self.success.append(_elem181)
1382 varun.gupt 10982 
          iprot.readListEnd()
10983 
        else:
10984 
          iprot.skip(ftype)
10985 
      elif fid == 1:
10986 
        if ftype == TType.STRUCT:
10987 
          self.ex = TransactionServiceException()
10988 
          self.ex.read(iprot)
10989 
        else:
10990 
          iprot.skip(ftype)
10991 
      else:
10992 
        iprot.skip(ftype)
10993 
      iprot.readFieldEnd()
10994 
    iprot.readStructEnd()
10995 
 
10996 
  def write(self, oprot):
10997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10999 
      return
11000 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 11001 
    if self.success is not None:
1382 varun.gupt 11002 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11003 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 11004 
      for iter182 in self.success:
11005 
        oprot.writeI64(iter182)
1382 varun.gupt 11006 
      oprot.writeListEnd()
11007 
      oprot.writeFieldEnd()
3431 rajveer 11008 
    if self.ex is not None:
1382 varun.gupt 11009 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11010 
      self.ex.write(oprot)
11011 
      oprot.writeFieldEnd()
11012 
    oprot.writeFieldStop()
11013 
    oprot.writeStructEnd()
11014 
 
3431 rajveer 11015 
  def validate(self):
11016 
    return
11017 
 
11018 
 
1382 varun.gupt 11019 
  def __repr__(self):
11020 
    L = ['%s=%r' % (key, value)
11021 
      for key, value in self.__dict__.iteritems()]
11022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11023 
 
11024 
  def __eq__(self, other):
11025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11026 
 
11027 
  def __ne__(self, other):
11028 
    return not (self == other)
11029 
 
483 rajveer 11030 
class changeOrderStatus_args:
94 ashish 11031 
  """
11032 
  Attributes:
483 rajveer 11033 
   - orderId
11034 
   - status
11035 
   - description
94 ashish 11036 
  """
11037 
 
11038 
  thrift_spec = (
11039 
    None, # 0
483 rajveer 11040 
    (1, TType.I64, 'orderId', None, None, ), # 1
11041 
    (2, TType.I32, 'status', None, None, ), # 2
11042 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 11043 
  )
11044 
 
483 rajveer 11045 
  def __init__(self, orderId=None, status=None, description=None,):
11046 
    self.orderId = orderId
11047 
    self.status = status
11048 
    self.description = description
94 ashish 11049 
 
11050 
  def read(self, iprot):
11051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11053 
      return
11054 
    iprot.readStructBegin()
11055 
    while True:
11056 
      (fname, ftype, fid) = iprot.readFieldBegin()
11057 
      if ftype == TType.STOP:
11058 
        break
11059 
      if fid == 1:
11060 
        if ftype == TType.I64:
483 rajveer 11061 
          self.orderId = iprot.readI64();
94 ashish 11062 
        else:
11063 
          iprot.skip(ftype)
11064 
      elif fid == 2:
483 rajveer 11065 
        if ftype == TType.I32:
11066 
          self.status = iprot.readI32();
94 ashish 11067 
        else:
11068 
          iprot.skip(ftype)
483 rajveer 11069 
      elif fid == 3:
11070 
        if ftype == TType.STRING:
11071 
          self.description = iprot.readString();
11072 
        else:
11073 
          iprot.skip(ftype)
94 ashish 11074 
      else:
11075 
        iprot.skip(ftype)
11076 
      iprot.readFieldEnd()
11077 
    iprot.readStructEnd()
11078 
 
11079 
  def write(self, oprot):
11080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11082 
      return
483 rajveer 11083 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 11084 
    if self.orderId is not None:
483 rajveer 11085 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11086 
      oprot.writeI64(self.orderId)
94 ashish 11087 
      oprot.writeFieldEnd()
3431 rajveer 11088 
    if self.status is not None:
483 rajveer 11089 
      oprot.writeFieldBegin('status', TType.I32, 2)
11090 
      oprot.writeI32(self.status)
94 ashish 11091 
      oprot.writeFieldEnd()
3431 rajveer 11092 
    if self.description is not None:
483 rajveer 11093 
      oprot.writeFieldBegin('description', TType.STRING, 3)
11094 
      oprot.writeString(self.description)
11095 
      oprot.writeFieldEnd()
94 ashish 11096 
    oprot.writeFieldStop()
11097 
    oprot.writeStructEnd()
11098 
 
3431 rajveer 11099 
  def validate(self):
11100 
    return
11101 
 
11102 
 
94 ashish 11103 
  def __repr__(self):
11104 
    L = ['%s=%r' % (key, value)
11105 
      for key, value in self.__dict__.iteritems()]
11106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11107 
 
11108 
  def __eq__(self, other):
11109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11110 
 
11111 
  def __ne__(self, other):
11112 
    return not (self == other)
11113 
 
483 rajveer 11114 
class changeOrderStatus_result:
94 ashish 11115 
  """
11116 
  Attributes:
11117 
   - success
11118 
   - ex
11119 
  """
11120 
 
11121 
  thrift_spec = (
11122 
    (0, TType.BOOL, 'success', None, None, ), # 0
11123 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11124 
  )
11125 
 
11126 
  def __init__(self, success=None, ex=None,):
11127 
    self.success = success
11128 
    self.ex = ex
11129 
 
11130 
  def read(self, iprot):
11131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11133 
      return
11134 
    iprot.readStructBegin()
11135 
    while True:
11136 
      (fname, ftype, fid) = iprot.readFieldBegin()
11137 
      if ftype == TType.STOP:
11138 
        break
11139 
      if fid == 0:
11140 
        if ftype == TType.BOOL:
11141 
          self.success = iprot.readBool();
11142 
        else:
11143 
          iprot.skip(ftype)
11144 
      elif fid == 1:
11145 
        if ftype == TType.STRUCT:
11146 
          self.ex = TransactionServiceException()
11147 
          self.ex.read(iprot)
11148 
        else:
11149 
          iprot.skip(ftype)
11150 
      else:
11151 
        iprot.skip(ftype)
11152 
      iprot.readFieldEnd()
11153 
    iprot.readStructEnd()
11154 
 
11155 
  def write(self, oprot):
11156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11158 
      return
483 rajveer 11159 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 11160 
    if self.success is not None:
94 ashish 11161 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11162 
      oprot.writeBool(self.success)
11163 
      oprot.writeFieldEnd()
3431 rajveer 11164 
    if self.ex is not None:
94 ashish 11165 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11166 
      self.ex.write(oprot)
11167 
      oprot.writeFieldEnd()
11168 
    oprot.writeFieldStop()
11169 
    oprot.writeStructEnd()
11170 
 
3431 rajveer 11171 
  def validate(self):
11172 
    return
11173 
 
11174 
 
94 ashish 11175 
  def __repr__(self):
11176 
    L = ['%s=%r' % (key, value)
11177 
      for key, value in self.__dict__.iteritems()]
11178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11179 
 
11180 
  def __eq__(self, other):
11181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11182 
 
11183 
  def __ne__(self, other):
11184 
    return not (self == other)
11185 
 
3064 chandransh 11186 
class getOrdersForTransaction_args:
494 rajveer 11187 
  """
11188 
  Attributes:
3064 chandransh 11189 
   - transactionId
11190 
   - customerId
494 rajveer 11191 
  """
11192 
 
11193 
  thrift_spec = (
11194 
    None, # 0
3064 chandransh 11195 
    (1, TType.I64, 'transactionId', None, None, ), # 1
11196 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 11197 
  )
11198 
 
3064 chandransh 11199 
  def __init__(self, transactionId=None, customerId=None,):
11200 
    self.transactionId = transactionId
11201 
    self.customerId = customerId
494 rajveer 11202 
 
11203 
  def read(self, iprot):
11204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11206 
      return
11207 
    iprot.readStructBegin()
11208 
    while True:
11209 
      (fname, ftype, fid) = iprot.readFieldBegin()
11210 
      if ftype == TType.STOP:
11211 
        break
11212 
      if fid == 1:
11213 
        if ftype == TType.I64:
3064 chandransh 11214 
          self.transactionId = iprot.readI64();
494 rajveer 11215 
        else:
11216 
          iprot.skip(ftype)
11217 
      elif fid == 2:
3064 chandransh 11218 
        if ftype == TType.I64:
11219 
          self.customerId = iprot.readI64();
494 rajveer 11220 
        else:
11221 
          iprot.skip(ftype)
11222 
      else:
11223 
        iprot.skip(ftype)
11224 
      iprot.readFieldEnd()
11225 
    iprot.readStructEnd()
11226 
 
11227 
  def write(self, oprot):
11228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11230 
      return
3064 chandransh 11231 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 11232 
    if self.transactionId is not None:
3064 chandransh 11233 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
11234 
      oprot.writeI64(self.transactionId)
494 rajveer 11235 
      oprot.writeFieldEnd()
3431 rajveer 11236 
    if self.customerId is not None:
3064 chandransh 11237 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
11238 
      oprot.writeI64(self.customerId)
494 rajveer 11239 
      oprot.writeFieldEnd()
11240 
    oprot.writeFieldStop()
11241 
    oprot.writeStructEnd()
11242 
 
3431 rajveer 11243 
  def validate(self):
11244 
    return
11245 
 
11246 
 
494 rajveer 11247 
  def __repr__(self):
11248 
    L = ['%s=%r' % (key, value)
11249 
      for key, value in self.__dict__.iteritems()]
11250 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11251 
 
11252 
  def __eq__(self, other):
11253 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11254 
 
11255 
  def __ne__(self, other):
11256 
    return not (self == other)
11257 
 
3064 chandransh 11258 
class getOrdersForTransaction_result:
494 rajveer 11259 
  """
11260 
  Attributes:
11261 
   - success
11262 
   - ex
11263 
  """
11264 
 
11265 
  thrift_spec = (
3064 chandransh 11266 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 11267 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11268 
  )
11269 
 
11270 
  def __init__(self, success=None, ex=None,):
11271 
    self.success = success
11272 
    self.ex = ex
11273 
 
11274 
  def read(self, iprot):
11275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11277 
      return
11278 
    iprot.readStructBegin()
11279 
    while True:
11280 
      (fname, ftype, fid) = iprot.readFieldBegin()
11281 
      if ftype == TType.STOP:
11282 
        break
11283 
      if fid == 0:
3064 chandransh 11284 
        if ftype == TType.LIST:
11285 
          self.success = []
6188 rajveer 11286 
          (_etype186, _size183) = iprot.readListBegin()
11287 
          for _i187 in xrange(_size183):
11288 
            _elem188 = Order()
11289 
            _elem188.read(iprot)
11290 
            self.success.append(_elem188)
3064 chandransh 11291 
          iprot.readListEnd()
494 rajveer 11292 
        else:
11293 
          iprot.skip(ftype)
11294 
      elif fid == 1:
11295 
        if ftype == TType.STRUCT:
11296 
          self.ex = TransactionServiceException()
11297 
          self.ex.read(iprot)
11298 
        else:
11299 
          iprot.skip(ftype)
11300 
      else:
11301 
        iprot.skip(ftype)
11302 
      iprot.readFieldEnd()
11303 
    iprot.readStructEnd()
11304 
 
11305 
  def write(self, oprot):
11306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11308 
      return
3064 chandransh 11309 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 11310 
    if self.success is not None:
3064 chandransh 11311 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11312 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11313 
      for iter189 in self.success:
11314 
        iter189.write(oprot)
3064 chandransh 11315 
      oprot.writeListEnd()
494 rajveer 11316 
      oprot.writeFieldEnd()
3431 rajveer 11317 
    if self.ex is not None:
494 rajveer 11318 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11319 
      self.ex.write(oprot)
11320 
      oprot.writeFieldEnd()
11321 
    oprot.writeFieldStop()
11322 
    oprot.writeStructEnd()
11323 
 
3431 rajveer 11324 
  def validate(self):
11325 
    return
11326 
 
11327 
 
494 rajveer 11328 
  def __repr__(self):
11329 
    L = ['%s=%r' % (key, value)
11330 
      for key, value in self.__dict__.iteritems()]
11331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11332 
 
11333 
  def __eq__(self, other):
11334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11335 
 
11336 
  def __ne__(self, other):
11337 
    return not (self == other)
11338 
 
3064 chandransh 11339 
class getOrdersForCustomer_args:
1149 chandransh 11340 
  """
11341 
  Attributes:
3064 chandransh 11342 
   - customerId
11343 
   - from_date
11344 
   - to_date
11345 
   - statuses
1149 chandransh 11346 
  """
11347 
 
11348 
  thrift_spec = (
11349 
    None, # 0
3064 chandransh 11350 
    (1, TType.I64, 'customerId', None, None, ), # 1
11351 
    (2, TType.I64, 'from_date', None, None, ), # 2
11352 
    (3, TType.I64, 'to_date', None, None, ), # 3
11353 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 11354 
  )
11355 
 
3064 chandransh 11356 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
11357 
    self.customerId = customerId
11358 
    self.from_date = from_date
11359 
    self.to_date = to_date
11360 
    self.statuses = statuses
1149 chandransh 11361 
 
11362 
  def read(self, iprot):
11363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11365 
      return
11366 
    iprot.readStructBegin()
11367 
    while True:
11368 
      (fname, ftype, fid) = iprot.readFieldBegin()
11369 
      if ftype == TType.STOP:
11370 
        break
11371 
      if fid == 1:
11372 
        if ftype == TType.I64:
3064 chandransh 11373 
          self.customerId = iprot.readI64();
1149 chandransh 11374 
        else:
11375 
          iprot.skip(ftype)
11376 
      elif fid == 2:
11377 
        if ftype == TType.I64:
3064 chandransh 11378 
          self.from_date = iprot.readI64();
1149 chandransh 11379 
        else:
11380 
          iprot.skip(ftype)
2783 chandransh 11381 
      elif fid == 3:
11382 
        if ftype == TType.I64:
3064 chandransh 11383 
          self.to_date = iprot.readI64();
2783 chandransh 11384 
        else:
11385 
          iprot.skip(ftype)
11386 
      elif fid == 4:
3064 chandransh 11387 
        if ftype == TType.LIST:
11388 
          self.statuses = []
6188 rajveer 11389 
          (_etype193, _size190) = iprot.readListBegin()
11390 
          for _i194 in xrange(_size190):
11391 
            _elem195 = iprot.readI32();
11392 
            self.statuses.append(_elem195)
3064 chandransh 11393 
          iprot.readListEnd()
2783 chandransh 11394 
        else:
11395 
          iprot.skip(ftype)
1149 chandransh 11396 
      else:
11397 
        iprot.skip(ftype)
11398 
      iprot.readFieldEnd()
11399 
    iprot.readStructEnd()
11400 
 
11401 
  def write(self, oprot):
11402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11404 
      return
3064 chandransh 11405 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 11406 
    if self.customerId is not None:
3064 chandransh 11407 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
11408 
      oprot.writeI64(self.customerId)
1149 chandransh 11409 
      oprot.writeFieldEnd()
3431 rajveer 11410 
    if self.from_date is not None:
3064 chandransh 11411 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
11412 
      oprot.writeI64(self.from_date)
1149 chandransh 11413 
      oprot.writeFieldEnd()
3431 rajveer 11414 
    if self.to_date is not None:
3064 chandransh 11415 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
11416 
      oprot.writeI64(self.to_date)
2783 chandransh 11417 
      oprot.writeFieldEnd()
3431 rajveer 11418 
    if self.statuses is not None:
3064 chandransh 11419 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
11420 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11421 
      for iter196 in self.statuses:
11422 
        oprot.writeI32(iter196)
3064 chandransh 11423 
      oprot.writeListEnd()
2783 chandransh 11424 
      oprot.writeFieldEnd()
1149 chandransh 11425 
    oprot.writeFieldStop()
11426 
    oprot.writeStructEnd()
11427 
 
3431 rajveer 11428 
  def validate(self):
11429 
    return
11430 
 
11431 
 
1149 chandransh 11432 
  def __repr__(self):
11433 
    L = ['%s=%r' % (key, value)
11434 
      for key, value in self.__dict__.iteritems()]
11435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11436 
 
11437 
  def __eq__(self, other):
11438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11439 
 
11440 
  def __ne__(self, other):
11441 
    return not (self == other)
11442 
 
3064 chandransh 11443 
class getOrdersForCustomer_result:
1149 chandransh 11444 
  """
11445 
  Attributes:
11446 
   - success
11447 
   - ex
11448 
  """
11449 
 
11450 
  thrift_spec = (
3064 chandransh 11451 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 11452 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11453 
  )
11454 
 
11455 
  def __init__(self, success=None, ex=None,):
11456 
    self.success = success
11457 
    self.ex = ex
11458 
 
11459 
  def read(self, iprot):
11460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11462 
      return
11463 
    iprot.readStructBegin()
11464 
    while True:
11465 
      (fname, ftype, fid) = iprot.readFieldBegin()
11466 
      if ftype == TType.STOP:
11467 
        break
11468 
      if fid == 0:
3064 chandransh 11469 
        if ftype == TType.LIST:
11470 
          self.success = []
6188 rajveer 11471 
          (_etype200, _size197) = iprot.readListBegin()
11472 
          for _i201 in xrange(_size197):
11473 
            _elem202 = Order()
11474 
            _elem202.read(iprot)
11475 
            self.success.append(_elem202)
3064 chandransh 11476 
          iprot.readListEnd()
1149 chandransh 11477 
        else:
11478 
          iprot.skip(ftype)
11479 
      elif fid == 1:
11480 
        if ftype == TType.STRUCT:
11481 
          self.ex = TransactionServiceException()
11482 
          self.ex.read(iprot)
11483 
        else:
11484 
          iprot.skip(ftype)
11485 
      else:
11486 
        iprot.skip(ftype)
11487 
      iprot.readFieldEnd()
11488 
    iprot.readStructEnd()
11489 
 
11490 
  def write(self, oprot):
11491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11493 
      return
3064 chandransh 11494 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 11495 
    if self.success is not None:
3064 chandransh 11496 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11497 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11498 
      for iter203 in self.success:
11499 
        iter203.write(oprot)
3064 chandransh 11500 
      oprot.writeListEnd()
1149 chandransh 11501 
      oprot.writeFieldEnd()
3431 rajveer 11502 
    if self.ex is not None:
1149 chandransh 11503 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11504 
      self.ex.write(oprot)
11505 
      oprot.writeFieldEnd()
11506 
    oprot.writeFieldStop()
11507 
    oprot.writeStructEnd()
11508 
 
3431 rajveer 11509 
  def validate(self):
11510 
    return
11511 
 
11512 
 
1149 chandransh 11513 
  def __repr__(self):
11514 
    L = ['%s=%r' % (key, value)
11515 
      for key, value in self.__dict__.iteritems()]
11516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11517 
 
11518 
  def __eq__(self, other):
11519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11520 
 
11521 
  def __ne__(self, other):
11522 
    return not (self == other)
11523 
 
3064 chandransh 11524 
class createOrder_args:
921 rajveer 11525 
  """
11526 
  Attributes:
3064 chandransh 11527 
   - order
921 rajveer 11528 
  """
11529 
 
11530 
  thrift_spec = (
11531 
    None, # 0
3064 chandransh 11532 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 11533 
  )
11534 
 
3064 chandransh 11535 
  def __init__(self, order=None,):
11536 
    self.order = order
921 rajveer 11537 
 
11538 
  def read(self, iprot):
11539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11541 
      return
11542 
    iprot.readStructBegin()
11543 
    while True:
11544 
      (fname, ftype, fid) = iprot.readFieldBegin()
11545 
      if ftype == TType.STOP:
11546 
        break
11547 
      if fid == 1:
3064 chandransh 11548 
        if ftype == TType.STRUCT:
11549 
          self.order = Order()
11550 
          self.order.read(iprot)
921 rajveer 11551 
        else:
11552 
          iprot.skip(ftype)
11553 
      else:
11554 
        iprot.skip(ftype)
11555 
      iprot.readFieldEnd()
11556 
    iprot.readStructEnd()
11557 
 
11558 
  def write(self, oprot):
11559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11561 
      return
3064 chandransh 11562 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 11563 
    if self.order is not None:
3064 chandransh 11564 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
11565 
      self.order.write(oprot)
921 rajveer 11566 
      oprot.writeFieldEnd()
11567 
    oprot.writeFieldStop()
11568 
    oprot.writeStructEnd()
11569 
 
3431 rajveer 11570 
  def validate(self):
11571 
    return
11572 
 
11573 
 
921 rajveer 11574 
  def __repr__(self):
11575 
    L = ['%s=%r' % (key, value)
11576 
      for key, value in self.__dict__.iteritems()]
11577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11578 
 
11579 
  def __eq__(self, other):
11580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11581 
 
11582 
  def __ne__(self, other):
11583 
    return not (self == other)
11584 
 
3064 chandransh 11585 
class createOrder_result:
921 rajveer 11586 
  """
11587 
  Attributes:
11588 
   - success
11589 
   - ex
11590 
  """
11591 
 
11592 
  thrift_spec = (
3064 chandransh 11593 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 11594 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11595 
  )
11596 
 
11597 
  def __init__(self, success=None, ex=None,):
11598 
    self.success = success
11599 
    self.ex = ex
11600 
 
11601 
  def read(self, iprot):
11602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11604 
      return
11605 
    iprot.readStructBegin()
11606 
    while True:
11607 
      (fname, ftype, fid) = iprot.readFieldBegin()
11608 
      if ftype == TType.STOP:
11609 
        break
11610 
      if fid == 0:
3064 chandransh 11611 
        if ftype == TType.I64:
11612 
          self.success = iprot.readI64();
921 rajveer 11613 
        else:
11614 
          iprot.skip(ftype)
11615 
      elif fid == 1:
11616 
        if ftype == TType.STRUCT:
11617 
          self.ex = TransactionServiceException()
11618 
          self.ex.read(iprot)
11619 
        else:
11620 
          iprot.skip(ftype)
11621 
      else:
11622 
        iprot.skip(ftype)
11623 
      iprot.readFieldEnd()
11624 
    iprot.readStructEnd()
11625 
 
11626 
  def write(self, oprot):
11627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11629 
      return
3064 chandransh 11630 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 11631 
    if self.success is not None:
3064 chandransh 11632 
      oprot.writeFieldBegin('success', TType.I64, 0)
11633 
      oprot.writeI64(self.success)
921 rajveer 11634 
      oprot.writeFieldEnd()
3431 rajveer 11635 
    if self.ex is not None:
921 rajveer 11636 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11637 
      self.ex.write(oprot)
11638 
      oprot.writeFieldEnd()
11639 
    oprot.writeFieldStop()
11640 
    oprot.writeStructEnd()
11641 
 
3431 rajveer 11642 
  def validate(self):
11643 
    return
11644 
 
11645 
 
921 rajveer 11646 
  def __repr__(self):
11647 
    L = ['%s=%r' % (key, value)
11648 
      for key, value in self.__dict__.iteritems()]
11649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11650 
 
11651 
  def __eq__(self, other):
11652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11653 
 
11654 
  def __ne__(self, other):
11655 
    return not (self == other)
11656 
 
3064 chandransh 11657 
class getOrder_args:
921 rajveer 11658 
  """
11659 
  Attributes:
3064 chandransh 11660 
   - id
921 rajveer 11661 
  """
11662 
 
11663 
  thrift_spec = (
11664 
    None, # 0
3064 chandransh 11665 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11666 
  )
11667 
 
3064 chandransh 11668 
  def __init__(self, id=None,):
11669 
    self.id = id
921 rajveer 11670 
 
11671 
  def read(self, iprot):
11672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11674 
      return
11675 
    iprot.readStructBegin()
11676 
    while True:
11677 
      (fname, ftype, fid) = iprot.readFieldBegin()
11678 
      if ftype == TType.STOP:
11679 
        break
11680 
      if fid == 1:
11681 
        if ftype == TType.I64:
3064 chandransh 11682 
          self.id = iprot.readI64();
921 rajveer 11683 
        else:
11684 
          iprot.skip(ftype)
11685 
      else:
11686 
        iprot.skip(ftype)
11687 
      iprot.readFieldEnd()
11688 
    iprot.readStructEnd()
11689 
 
11690 
  def write(self, oprot):
11691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11693 
      return
3064 chandransh 11694 
    oprot.writeStructBegin('getOrder_args')
3431 rajveer 11695 
    if self.id is not None:
3064 chandransh 11696 
      oprot.writeFieldBegin('id', TType.I64, 1)
11697 
      oprot.writeI64(self.id)
921 rajveer 11698 
      oprot.writeFieldEnd()
11699 
    oprot.writeFieldStop()
11700 
    oprot.writeStructEnd()
11701 
 
3431 rajveer 11702 
  def validate(self):
11703 
    return
11704 
 
11705 
 
921 rajveer 11706 
  def __repr__(self):
11707 
    L = ['%s=%r' % (key, value)
11708 
      for key, value in self.__dict__.iteritems()]
11709 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11710 
 
11711 
  def __eq__(self, other):
11712 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11713 
 
11714 
  def __ne__(self, other):
11715 
    return not (self == other)
11716 
 
3064 chandransh 11717 
class getOrder_result:
921 rajveer 11718 
  """
11719 
  Attributes:
11720 
   - success
11721 
   - ex
11722 
  """
11723 
 
11724 
  thrift_spec = (
3064 chandransh 11725 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 11726 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11727 
  )
11728 
 
11729 
  def __init__(self, success=None, ex=None,):
11730 
    self.success = success
11731 
    self.ex = ex
11732 
 
11733 
  def read(self, iprot):
11734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11736 
      return
11737 
    iprot.readStructBegin()
11738 
    while True:
11739 
      (fname, ftype, fid) = iprot.readFieldBegin()
11740 
      if ftype == TType.STOP:
11741 
        break
11742 
      if fid == 0:
3064 chandransh 11743 
        if ftype == TType.STRUCT:
11744 
          self.success = Order()
11745 
          self.success.read(iprot)
921 rajveer 11746 
        else:
11747 
          iprot.skip(ftype)
11748 
      elif fid == 1:
11749 
        if ftype == TType.STRUCT:
11750 
          self.ex = TransactionServiceException()
11751 
          self.ex.read(iprot)
11752 
        else:
11753 
          iprot.skip(ftype)
11754 
      else:
11755 
        iprot.skip(ftype)
11756 
      iprot.readFieldEnd()
11757 
    iprot.readStructEnd()
11758 
 
11759 
  def write(self, oprot):
11760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11762 
      return
3064 chandransh 11763 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 11764 
    if self.success is not None:
3064 chandransh 11765 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11766 
      self.success.write(oprot)
921 rajveer 11767 
      oprot.writeFieldEnd()
3431 rajveer 11768 
    if self.ex is not None:
921 rajveer 11769 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11770 
      self.ex.write(oprot)
11771 
      oprot.writeFieldEnd()
11772 
    oprot.writeFieldStop()
11773 
    oprot.writeStructEnd()
11774 
 
3431 rajveer 11775 
  def validate(self):
11776 
    return
11777 
 
11778 
 
921 rajveer 11779 
  def __repr__(self):
11780 
    L = ['%s=%r' % (key, value)
11781 
      for key, value in self.__dict__.iteritems()]
11782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11783 
 
11784 
  def __eq__(self, other):
11785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11786 
 
11787 
  def __ne__(self, other):
11788 
    return not (self == other)
11789 
 
3064 chandransh 11790 
class getLineItemsForOrder_args:
94 ashish 11791 
  """
11792 
  Attributes:
3064 chandransh 11793 
   - orderId
94 ashish 11794 
  """
11795 
 
11796 
  thrift_spec = (
11797 
    None, # 0
3064 chandransh 11798 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11799 
  )
11800 
 
3064 chandransh 11801 
  def __init__(self, orderId=None,):
11802 
    self.orderId = orderId
94 ashish 11803 
 
11804 
  def read(self, iprot):
11805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11807 
      return
11808 
    iprot.readStructBegin()
11809 
    while True:
11810 
      (fname, ftype, fid) = iprot.readFieldBegin()
11811 
      if ftype == TType.STOP:
11812 
        break
11813 
      if fid == 1:
11814 
        if ftype == TType.I64:
3064 chandransh 11815 
          self.orderId = iprot.readI64();
94 ashish 11816 
        else:
11817 
          iprot.skip(ftype)
11818 
      else:
11819 
        iprot.skip(ftype)
11820 
      iprot.readFieldEnd()
11821 
    iprot.readStructEnd()
11822 
 
11823 
  def write(self, oprot):
11824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11826 
      return
3064 chandransh 11827 
    oprot.writeStructBegin('getLineItemsForOrder_args')
3431 rajveer 11828 
    if self.orderId is not None:
3064 chandransh 11829 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11830 
      oprot.writeI64(self.orderId)
94 ashish 11831 
      oprot.writeFieldEnd()
11832 
    oprot.writeFieldStop()
11833 
    oprot.writeStructEnd()
11834 
 
3431 rajveer 11835 
  def validate(self):
11836 
    return
11837 
 
11838 
 
94 ashish 11839 
  def __repr__(self):
11840 
    L = ['%s=%r' % (key, value)
11841 
      for key, value in self.__dict__.iteritems()]
11842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11843 
 
11844 
  def __eq__(self, other):
11845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11846 
 
11847 
  def __ne__(self, other):
11848 
    return not (self == other)
11849 
 
3064 chandransh 11850 
class getLineItemsForOrder_result:
94 ashish 11851 
  """
11852 
  Attributes:
11853 
   - success
11854 
   - ex
11855 
  """
11856 
 
11857 
  thrift_spec = (
3064 chandransh 11858 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 11859 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11860 
  )
11861 
 
11862 
  def __init__(self, success=None, ex=None,):
11863 
    self.success = success
11864 
    self.ex = ex
11865 
 
11866 
  def read(self, iprot):
11867 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11868 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11869 
      return
11870 
    iprot.readStructBegin()
11871 
    while True:
11872 
      (fname, ftype, fid) = iprot.readFieldBegin()
11873 
      if ftype == TType.STOP:
11874 
        break
11875 
      if fid == 0:
483 rajveer 11876 
        if ftype == TType.LIST:
11877 
          self.success = []
6188 rajveer 11878 
          (_etype207, _size204) = iprot.readListBegin()
11879 
          for _i208 in xrange(_size204):
11880 
            _elem209 = LineItem()
11881 
            _elem209.read(iprot)
11882 
            self.success.append(_elem209)
483 rajveer 11883 
          iprot.readListEnd()
94 ashish 11884 
        else:
11885 
          iprot.skip(ftype)
11886 
      elif fid == 1:
11887 
        if ftype == TType.STRUCT:
11888 
          self.ex = TransactionServiceException()
11889 
          self.ex.read(iprot)
11890 
        else:
11891 
          iprot.skip(ftype)
11892 
      else:
11893 
        iprot.skip(ftype)
11894 
      iprot.readFieldEnd()
11895 
    iprot.readStructEnd()
11896 
 
11897 
  def write(self, oprot):
11898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11900 
      return
3064 chandransh 11901 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 11902 
    if self.success is not None:
483 rajveer 11903 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11904 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11905 
      for iter210 in self.success:
11906 
        iter210.write(oprot)
483 rajveer 11907 
      oprot.writeListEnd()
94 ashish 11908 
      oprot.writeFieldEnd()
3431 rajveer 11909 
    if self.ex is not None:
94 ashish 11910 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11911 
      self.ex.write(oprot)
11912 
      oprot.writeFieldEnd()
11913 
    oprot.writeFieldStop()
11914 
    oprot.writeStructEnd()
11915 
 
3431 rajveer 11916 
  def validate(self):
11917 
    return
11918 
 
11919 
 
94 ashish 11920 
  def __repr__(self):
11921 
    L = ['%s=%r' % (key, value)
11922 
      for key, value in self.__dict__.iteritems()]
11923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11924 
 
11925 
  def __eq__(self, other):
11926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11927 
 
11928 
  def __ne__(self, other):
11929 
    return not (self == other)
11930 
 
4999 phani.kuma 11931 
class getOrderList_args:
11932 
  """
11933 
  Attributes:
11934 
   - order_ids
11935 
  """
11936 
 
11937 
  thrift_spec = (
11938 
    None, # 0
11939 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11940 
  )
11941 
 
11942 
  def __init__(self, order_ids=None,):
11943 
    self.order_ids = order_ids
11944 
 
11945 
  def read(self, iprot):
11946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11948 
      return
11949 
    iprot.readStructBegin()
11950 
    while True:
11951 
      (fname, ftype, fid) = iprot.readFieldBegin()
11952 
      if ftype == TType.STOP:
11953 
        break
11954 
      if fid == 1:
11955 
        if ftype == TType.LIST:
11956 
          self.order_ids = []
6188 rajveer 11957 
          (_etype214, _size211) = iprot.readListBegin()
11958 
          for _i215 in xrange(_size211):
11959 
            _elem216 = iprot.readI64();
11960 
            self.order_ids.append(_elem216)
4999 phani.kuma 11961 
          iprot.readListEnd()
11962 
        else:
11963 
          iprot.skip(ftype)
11964 
      else:
11965 
        iprot.skip(ftype)
11966 
      iprot.readFieldEnd()
11967 
    iprot.readStructEnd()
11968 
 
11969 
  def write(self, oprot):
11970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11972 
      return
11973 
    oprot.writeStructBegin('getOrderList_args')
11974 
    if self.order_ids is not None:
11975 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11976 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11977 
      for iter217 in self.order_ids:
11978 
        oprot.writeI64(iter217)
4999 phani.kuma 11979 
      oprot.writeListEnd()
11980 
      oprot.writeFieldEnd()
11981 
    oprot.writeFieldStop()
11982 
    oprot.writeStructEnd()
11983 
 
11984 
  def validate(self):
11985 
    return
11986 
 
11987 
 
11988 
  def __repr__(self):
11989 
    L = ['%s=%r' % (key, value)
11990 
      for key, value in self.__dict__.iteritems()]
11991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11992 
 
11993 
  def __eq__(self, other):
11994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11995 
 
11996 
  def __ne__(self, other):
11997 
    return not (self == other)
11998 
 
11999 
class getOrderList_result:
12000 
  """
12001 
  Attributes:
12002 
   - success
12003 
  """
12004 
 
12005 
  thrift_spec = (
12006 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12007 
  )
12008 
 
12009 
  def __init__(self, success=None,):
12010 
    self.success = success
12011 
 
12012 
  def read(self, iprot):
12013 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12014 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12015 
      return
12016 
    iprot.readStructBegin()
12017 
    while True:
12018 
      (fname, ftype, fid) = iprot.readFieldBegin()
12019 
      if ftype == TType.STOP:
12020 
        break
12021 
      if fid == 0:
12022 
        if ftype == TType.LIST:
12023 
          self.success = []
6188 rajveer 12024 
          (_etype221, _size218) = iprot.readListBegin()
12025 
          for _i222 in xrange(_size218):
12026 
            _elem223 = Order()
12027 
            _elem223.read(iprot)
12028 
            self.success.append(_elem223)
4999 phani.kuma 12029 
          iprot.readListEnd()
12030 
        else:
12031 
          iprot.skip(ftype)
12032 
      else:
12033 
        iprot.skip(ftype)
12034 
      iprot.readFieldEnd()
12035 
    iprot.readStructEnd()
12036 
 
12037 
  def write(self, oprot):
12038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12040 
      return
12041 
    oprot.writeStructBegin('getOrderList_result')
12042 
    if self.success is not None:
12043 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12044 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12045 
      for iter224 in self.success:
12046 
        iter224.write(oprot)
4999 phani.kuma 12047 
      oprot.writeListEnd()
12048 
      oprot.writeFieldEnd()
12049 
    oprot.writeFieldStop()
12050 
    oprot.writeStructEnd()
12051 
 
12052 
  def validate(self):
12053 
    return
12054 
 
12055 
 
12056 
  def __repr__(self):
12057 
    L = ['%s=%r' % (key, value)
12058 
      for key, value in self.__dict__.iteritems()]
12059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12060 
 
12061 
  def __eq__(self, other):
12062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12063 
 
12064 
  def __ne__(self, other):
12065 
    return not (self == other)
12066 
 
5386 phani.kuma 12067 
class getOrderListForVendor_args:
12068 
  """
12069 
  Attributes:
12070 
   - order_ids
12071 
   - vendorId
12072 
  """
12073 
 
12074 
  thrift_spec = (
12075 
    None, # 0
12076 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12077 
    (2, TType.I64, 'vendorId', None, None, ), # 2
12078 
  )
12079 
 
12080 
  def __init__(self, order_ids=None, vendorId=None,):
12081 
    self.order_ids = order_ids
12082 
    self.vendorId = vendorId
12083 
 
12084 
  def read(self, iprot):
12085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12087 
      return
12088 
    iprot.readStructBegin()
12089 
    while True:
12090 
      (fname, ftype, fid) = iprot.readFieldBegin()
12091 
      if ftype == TType.STOP:
12092 
        break
12093 
      if fid == 1:
12094 
        if ftype == TType.LIST:
12095 
          self.order_ids = []
6188 rajveer 12096 
          (_etype228, _size225) = iprot.readListBegin()
12097 
          for _i229 in xrange(_size225):
12098 
            _elem230 = iprot.readI64();
12099 
            self.order_ids.append(_elem230)
5386 phani.kuma 12100 
          iprot.readListEnd()
12101 
        else:
12102 
          iprot.skip(ftype)
12103 
      elif fid == 2:
12104 
        if ftype == TType.I64:
12105 
          self.vendorId = iprot.readI64();
12106 
        else:
12107 
          iprot.skip(ftype)
12108 
      else:
12109 
        iprot.skip(ftype)
12110 
      iprot.readFieldEnd()
12111 
    iprot.readStructEnd()
12112 
 
12113 
  def write(self, oprot):
12114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12116 
      return
12117 
    oprot.writeStructBegin('getOrderListForVendor_args')
12118 
    if self.order_ids is not None:
12119 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12120 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12121 
      for iter231 in self.order_ids:
12122 
        oprot.writeI64(iter231)
5386 phani.kuma 12123 
      oprot.writeListEnd()
12124 
      oprot.writeFieldEnd()
12125 
    if self.vendorId is not None:
12126 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
12127 
      oprot.writeI64(self.vendorId)
12128 
      oprot.writeFieldEnd()
12129 
    oprot.writeFieldStop()
12130 
    oprot.writeStructEnd()
12131 
 
12132 
  def validate(self):
12133 
    return
12134 
 
12135 
 
12136 
  def __repr__(self):
12137 
    L = ['%s=%r' % (key, value)
12138 
      for key, value in self.__dict__.iteritems()]
12139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12140 
 
12141 
  def __eq__(self, other):
12142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12143 
 
12144 
  def __ne__(self, other):
12145 
    return not (self == other)
12146 
 
12147 
class getOrderListForVendor_result:
12148 
  """
12149 
  Attributes:
12150 
   - success
12151 
  """
12152 
 
12153 
  thrift_spec = (
12154 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12155 
  )
12156 
 
12157 
  def __init__(self, success=None,):
12158 
    self.success = success
12159 
 
12160 
  def read(self, iprot):
12161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12163 
      return
12164 
    iprot.readStructBegin()
12165 
    while True:
12166 
      (fname, ftype, fid) = iprot.readFieldBegin()
12167 
      if ftype == TType.STOP:
12168 
        break
12169 
      if fid == 0:
12170 
        if ftype == TType.LIST:
12171 
          self.success = []
6188 rajveer 12172 
          (_etype235, _size232) = iprot.readListBegin()
12173 
          for _i236 in xrange(_size232):
12174 
            _elem237 = Order()
12175 
            _elem237.read(iprot)
12176 
            self.success.append(_elem237)
5386 phani.kuma 12177 
          iprot.readListEnd()
12178 
        else:
12179 
          iprot.skip(ftype)
12180 
      else:
12181 
        iprot.skip(ftype)
12182 
      iprot.readFieldEnd()
12183 
    iprot.readStructEnd()
12184 
 
12185 
  def write(self, oprot):
12186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12188 
      return
12189 
    oprot.writeStructBegin('getOrderListForVendor_result')
12190 
    if self.success is not None:
12191 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12192 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12193 
      for iter238 in self.success:
12194 
        iter238.write(oprot)
5386 phani.kuma 12195 
      oprot.writeListEnd()
12196 
      oprot.writeFieldEnd()
12197 
    oprot.writeFieldStop()
12198 
    oprot.writeStructEnd()
12199 
 
12200 
  def validate(self):
12201 
    return
12202 
 
12203 
 
12204 
  def __repr__(self):
12205 
    L = ['%s=%r' % (key, value)
12206 
      for key, value in self.__dict__.iteritems()]
12207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12208 
 
12209 
  def __eq__(self, other):
12210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12211 
 
12212 
  def __ne__(self, other):
12213 
    return not (self == other)
12214 
 
3064 chandransh 12215 
class getOrderForCustomer_args:
94 ashish 12216 
  """
12217 
  Attributes:
3064 chandransh 12218 
   - orderId
483 rajveer 12219 
   - customerId
94 ashish 12220 
  """
12221 
 
12222 
  thrift_spec = (
12223 
    None, # 0
3064 chandransh 12224 
    (1, TType.I64, 'orderId', None, None, ), # 1
12225 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 12226 
  )
12227 
 
3064 chandransh 12228 
  def __init__(self, orderId=None, customerId=None,):
12229 
    self.orderId = orderId
483 rajveer 12230 
    self.customerId = customerId
94 ashish 12231 
 
12232 
  def read(self, iprot):
12233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12235 
      return
12236 
    iprot.readStructBegin()
12237 
    while True:
12238 
      (fname, ftype, fid) = iprot.readFieldBegin()
12239 
      if ftype == TType.STOP:
12240 
        break
12241 
      if fid == 1:
12242 
        if ftype == TType.I64:
3064 chandransh 12243 
          self.orderId = iprot.readI64();
94 ashish 12244 
        else:
12245 
          iprot.skip(ftype)
12246 
      elif fid == 2:
12247 
        if ftype == TType.I64:
3064 chandransh 12248 
          self.customerId = iprot.readI64();
94 ashish 12249 
        else:
12250 
          iprot.skip(ftype)
12251 
      else:
12252 
        iprot.skip(ftype)
12253 
      iprot.readFieldEnd()
12254 
    iprot.readStructEnd()
12255 
 
12256 
  def write(self, oprot):
12257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12259 
      return
3064 chandransh 12260 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 12261 
    if self.orderId is not None:
3064 chandransh 12262 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12263 
      oprot.writeI64(self.orderId)
12264 
      oprot.writeFieldEnd()
3431 rajveer 12265 
    if self.customerId is not None:
3064 chandransh 12266 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 12267 
      oprot.writeI64(self.customerId)
94 ashish 12268 
      oprot.writeFieldEnd()
12269 
    oprot.writeFieldStop()
12270 
    oprot.writeStructEnd()
12271 
 
3431 rajveer 12272 
  def validate(self):
12273 
    return
12274 
 
12275 
 
94 ashish 12276 
  def __repr__(self):
12277 
    L = ['%s=%r' % (key, value)
12278 
      for key, value in self.__dict__.iteritems()]
12279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12280 
 
12281 
  def __eq__(self, other):
12282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12283 
 
12284 
  def __ne__(self, other):
12285 
    return not (self == other)
12286 
 
3064 chandransh 12287 
class getOrderForCustomer_result:
94 ashish 12288 
  """
12289 
  Attributes:
12290 
   - success
12291 
   - ex
12292 
  """
12293 
 
12294 
  thrift_spec = (
3064 chandransh 12295 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 12296 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12297 
  )
12298 
 
12299 
  def __init__(self, success=None, ex=None,):
12300 
    self.success = success
12301 
    self.ex = ex
12302 
 
12303 
  def read(self, iprot):
12304 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12305 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12306 
      return
12307 
    iprot.readStructBegin()
12308 
    while True:
12309 
      (fname, ftype, fid) = iprot.readFieldBegin()
12310 
      if ftype == TType.STOP:
12311 
        break
12312 
      if fid == 0:
3064 chandransh 12313 
        if ftype == TType.STRUCT:
12314 
          self.success = Order()
12315 
          self.success.read(iprot)
94 ashish 12316 
        else:
12317 
          iprot.skip(ftype)
12318 
      elif fid == 1:
12319 
        if ftype == TType.STRUCT:
12320 
          self.ex = TransactionServiceException()
12321 
          self.ex.read(iprot)
12322 
        else:
12323 
          iprot.skip(ftype)
12324 
      else:
12325 
        iprot.skip(ftype)
12326 
      iprot.readFieldEnd()
12327 
    iprot.readStructEnd()
12328 
 
12329 
  def write(self, oprot):
12330 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12331 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12332 
      return
3064 chandransh 12333 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 12334 
    if self.success is not None:
3064 chandransh 12335 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12336 
      self.success.write(oprot)
94 ashish 12337 
      oprot.writeFieldEnd()
3431 rajveer 12338 
    if self.ex is not None:
94 ashish 12339 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12340 
      self.ex.write(oprot)
12341 
      oprot.writeFieldEnd()
12342 
    oprot.writeFieldStop()
12343 
    oprot.writeStructEnd()
12344 
 
3431 rajveer 12345 
  def validate(self):
12346 
    return
12347 
 
12348 
 
94 ashish 12349 
  def __repr__(self):
12350 
    L = ['%s=%r' % (key, value)
12351 
      for key, value in self.__dict__.iteritems()]
12352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12353 
 
12354 
  def __eq__(self, other):
12355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12356 
 
12357 
  def __ne__(self, other):
12358 
    return not (self == other)
12359 
 
3064 chandransh 12360 
class getAlerts_args:
94 ashish 12361 
  """
12362 
  Attributes:
4394 rajveer 12363 
   - type
4444 rajveer 12364 
   - warehouseId
4394 rajveer 12365 
   - status
12366 
   - timestamp
94 ashish 12367 
  """
12368 
 
12369 
  thrift_spec = (
12370 
    None, # 0
4394 rajveer 12371 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12372 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12373 
    (3, TType.I64, 'status', None, None, ), # 3
12374 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 12375 
  )
12376 
 
4444 rajveer 12377 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 12378 
    self.type = type
4444 rajveer 12379 
    self.warehouseId = warehouseId
4394 rajveer 12380 
    self.status = status
12381 
    self.timestamp = timestamp
94 ashish 12382 
 
12383 
  def read(self, iprot):
12384 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12385 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12386 
      return
12387 
    iprot.readStructBegin()
12388 
    while True:
12389 
      (fname, ftype, fid) = iprot.readFieldBegin()
12390 
      if ftype == TType.STOP:
12391 
        break
12392 
      if fid == 1:
3064 chandransh 12393 
        if ftype == TType.I64:
4394 rajveer 12394 
          self.type = iprot.readI64();
94 ashish 12395 
        else:
12396 
          iprot.skip(ftype)
3064 chandransh 12397 
      elif fid == 2:
4394 rajveer 12398 
        if ftype == TType.I64:
4444 rajveer 12399 
          self.warehouseId = iprot.readI64();
3064 chandransh 12400 
        else:
12401 
          iprot.skip(ftype)
4394 rajveer 12402 
      elif fid == 3:
12403 
        if ftype == TType.I64:
4444 rajveer 12404 
          self.status = iprot.readI64();
12405 
        else:
12406 
          iprot.skip(ftype)
12407 
      elif fid == 4:
12408 
        if ftype == TType.I64:
4394 rajveer 12409 
          self.timestamp = iprot.readI64();
12410 
        else:
12411 
          iprot.skip(ftype)
94 ashish 12412 
      else:
12413 
        iprot.skip(ftype)
12414 
      iprot.readFieldEnd()
12415 
    iprot.readStructEnd()
12416 
 
12417 
  def write(self, oprot):
12418 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12419 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12420 
      return
3064 chandransh 12421 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 12422 
    if self.type is not None:
12423 
      oprot.writeFieldBegin('type', TType.I64, 1)
12424 
      oprot.writeI64(self.type)
94 ashish 12425 
      oprot.writeFieldEnd()
4444 rajveer 12426 
    if self.warehouseId is not None:
12427 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12428 
      oprot.writeI64(self.warehouseId)
12429 
      oprot.writeFieldEnd()
4394 rajveer 12430 
    if self.status is not None:
4444 rajveer 12431 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 12432 
      oprot.writeI64(self.status)
3064 chandransh 12433 
      oprot.writeFieldEnd()
4394 rajveer 12434 
    if self.timestamp is not None:
4444 rajveer 12435 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 12436 
      oprot.writeI64(self.timestamp)
12437 
      oprot.writeFieldEnd()
94 ashish 12438 
    oprot.writeFieldStop()
12439 
    oprot.writeStructEnd()
12440 
 
3431 rajveer 12441 
  def validate(self):
12442 
    return
12443 
 
12444 
 
94 ashish 12445 
  def __repr__(self):
12446 
    L = ['%s=%r' % (key, value)
12447 
      for key, value in self.__dict__.iteritems()]
12448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12449 
 
12450 
  def __eq__(self, other):
12451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12452 
 
12453 
  def __ne__(self, other):
12454 
    return not (self == other)
12455 
 
3064 chandransh 12456 
class getAlerts_result:
94 ashish 12457 
  """
12458 
  Attributes:
12459 
   - success
12460 
  """
12461 
 
12462 
  thrift_spec = (
3064 chandransh 12463 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 12464 
  )
12465 
 
3064 chandransh 12466 
  def __init__(self, success=None,):
94 ashish 12467 
    self.success = success
12468 
 
12469 
  def read(self, iprot):
12470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12472 
      return
12473 
    iprot.readStructBegin()
12474 
    while True:
12475 
      (fname, ftype, fid) = iprot.readFieldBegin()
12476 
      if ftype == TType.STOP:
12477 
        break
12478 
      if fid == 0:
3064 chandransh 12479 
        if ftype == TType.LIST:
12480 
          self.success = []
6188 rajveer 12481 
          (_etype242, _size239) = iprot.readListBegin()
12482 
          for _i243 in xrange(_size239):
12483 
            _elem244 = Alert()
12484 
            _elem244.read(iprot)
12485 
            self.success.append(_elem244)
3064 chandransh 12486 
          iprot.readListEnd()
94 ashish 12487 
        else:
12488 
          iprot.skip(ftype)
12489 
      else:
12490 
        iprot.skip(ftype)
12491 
      iprot.readFieldEnd()
12492 
    iprot.readStructEnd()
12493 
 
12494 
  def write(self, oprot):
12495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12497 
      return
3064 chandransh 12498 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 12499 
    if self.success is not None:
3064 chandransh 12500 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12501 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12502 
      for iter245 in self.success:
12503 
        iter245.write(oprot)
3064 chandransh 12504 
      oprot.writeListEnd()
94 ashish 12505 
      oprot.writeFieldEnd()
12506 
    oprot.writeFieldStop()
12507 
    oprot.writeStructEnd()
12508 
 
3431 rajveer 12509 
  def validate(self):
12510 
    return
12511 
 
12512 
 
94 ashish 12513 
  def __repr__(self):
12514 
    L = ['%s=%r' % (key, value)
12515 
      for key, value in self.__dict__.iteritems()]
12516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12517 
 
12518 
  def __eq__(self, other):
12519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12520 
 
12521 
  def __ne__(self, other):
12522 
    return not (self == other)
12523 
 
4394 rajveer 12524 
class addAlert_args:
94 ashish 12525 
  """
12526 
  Attributes:
3064 chandransh 12527 
   - type
4444 rajveer 12528 
   - warehouseId
4394 rajveer 12529 
   - description
94 ashish 12530 
  """
12531 
 
12532 
  thrift_spec = (
12533 
    None, # 0
4394 rajveer 12534 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12535 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12536 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12537 
  )
12538 
 
4444 rajveer 12539 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 12540 
    self.type = type
4444 rajveer 12541 
    self.warehouseId = warehouseId
4394 rajveer 12542 
    self.description = description
94 ashish 12543 
 
12544 
  def read(self, iprot):
12545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12547 
      return
12548 
    iprot.readStructBegin()
12549 
    while True:
12550 
      (fname, ftype, fid) = iprot.readFieldBegin()
12551 
      if ftype == TType.STOP:
12552 
        break
12553 
      if fid == 1:
12554 
        if ftype == TType.I64:
4394 rajveer 12555 
          self.type = iprot.readI64();
94 ashish 12556 
        else:
12557 
          iprot.skip(ftype)
3064 chandransh 12558 
      elif fid == 2:
4444 rajveer 12559 
        if ftype == TType.I64:
12560 
          self.warehouseId = iprot.readI64();
12561 
        else:
12562 
          iprot.skip(ftype)
12563 
      elif fid == 3:
3064 chandransh 12564 
        if ftype == TType.STRING:
4394 rajveer 12565 
          self.description = iprot.readString();
3064 chandransh 12566 
        else:
12567 
          iprot.skip(ftype)
94 ashish 12568 
      else:
12569 
        iprot.skip(ftype)
12570 
      iprot.readFieldEnd()
12571 
    iprot.readStructEnd()
12572 
 
12573 
  def write(self, oprot):
12574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12576 
      return
4394 rajveer 12577 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 12578 
    if self.type is not None:
4394 rajveer 12579 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 12580 
      oprot.writeI64(self.type)
12581 
      oprot.writeFieldEnd()
4444 rajveer 12582 
    if self.warehouseId is not None:
12583 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12584 
      oprot.writeI64(self.warehouseId)
12585 
      oprot.writeFieldEnd()
4394 rajveer 12586 
    if self.description is not None:
4444 rajveer 12587 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 12588 
      oprot.writeString(self.description)
3064 chandransh 12589 
      oprot.writeFieldEnd()
94 ashish 12590 
    oprot.writeFieldStop()
12591 
    oprot.writeStructEnd()
12592 
 
3431 rajveer 12593 
  def validate(self):
12594 
    return
12595 
 
12596 
 
94 ashish 12597 
  def __repr__(self):
12598 
    L = ['%s=%r' % (key, value)
12599 
      for key, value in self.__dict__.iteritems()]
12600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12601 
 
12602 
  def __eq__(self, other):
12603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12604 
 
12605 
  def __ne__(self, other):
12606 
    return not (self == other)
12607 
 
4394 rajveer 12608 
class addAlert_result:
3064 chandransh 12609 
 
12610 
  thrift_spec = (
12611 
  )
12612 
 
12613 
  def read(self, iprot):
12614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12616 
      return
12617 
    iprot.readStructBegin()
12618 
    while True:
12619 
      (fname, ftype, fid) = iprot.readFieldBegin()
12620 
      if ftype == TType.STOP:
12621 
        break
12622 
      else:
12623 
        iprot.skip(ftype)
12624 
      iprot.readFieldEnd()
12625 
    iprot.readStructEnd()
12626 
 
12627 
  def write(self, oprot):
12628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12630 
      return
4394 rajveer 12631 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 12632 
    oprot.writeFieldStop()
12633 
    oprot.writeStructEnd()
12634 
 
3431 rajveer 12635 
  def validate(self):
12636 
    return
12637 
 
12638 
 
3064 chandransh 12639 
  def __repr__(self):
12640 
    L = ['%s=%r' % (key, value)
12641 
      for key, value in self.__dict__.iteritems()]
12642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12643 
 
12644 
  def __eq__(self, other):
12645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12646 
 
12647 
  def __ne__(self, other):
12648 
    return not (self == other)
12649 
 
4444 rajveer 12650 
class markAlertsAsSeen_args:
12651 
  """
12652 
  Attributes:
12653 
   - warehouseId
12654 
  """
12655 
 
12656 
  thrift_spec = (
12657 
    None, # 0
12658 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12659 
  )
12660 
 
12661 
  def __init__(self, warehouseId=None,):
12662 
    self.warehouseId = warehouseId
12663 
 
12664 
  def read(self, iprot):
12665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12667 
      return
12668 
    iprot.readStructBegin()
12669 
    while True:
12670 
      (fname, ftype, fid) = iprot.readFieldBegin()
12671 
      if ftype == TType.STOP:
12672 
        break
12673 
      if fid == 1:
12674 
        if ftype == TType.I64:
12675 
          self.warehouseId = iprot.readI64();
12676 
        else:
12677 
          iprot.skip(ftype)
12678 
      else:
12679 
        iprot.skip(ftype)
12680 
      iprot.readFieldEnd()
12681 
    iprot.readStructEnd()
12682 
 
12683 
  def write(self, oprot):
12684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12686 
      return
12687 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12688 
    if self.warehouseId is not None:
12689 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12690 
      oprot.writeI64(self.warehouseId)
12691 
      oprot.writeFieldEnd()
12692 
    oprot.writeFieldStop()
12693 
    oprot.writeStructEnd()
12694 
 
12695 
  def validate(self):
12696 
    return
12697 
 
12698 
 
12699 
  def __repr__(self):
12700 
    L = ['%s=%r' % (key, value)
12701 
      for key, value in self.__dict__.iteritems()]
12702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12703 
 
12704 
  def __eq__(self, other):
12705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12706 
 
12707 
  def __ne__(self, other):
12708 
    return not (self == other)
12709 
 
12710 
class markAlertsAsSeen_result:
12711 
 
12712 
  thrift_spec = (
12713 
  )
12714 
 
12715 
  def read(self, iprot):
12716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12718 
      return
12719 
    iprot.readStructBegin()
12720 
    while True:
12721 
      (fname, ftype, fid) = iprot.readFieldBegin()
12722 
      if ftype == TType.STOP:
12723 
        break
12724 
      else:
12725 
        iprot.skip(ftype)
12726 
      iprot.readFieldEnd()
12727 
    iprot.readStructEnd()
12728 
 
12729 
  def write(self, oprot):
12730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12732 
      return
12733 
    oprot.writeStructBegin('markAlertsAsSeen_result')
12734 
    oprot.writeFieldStop()
12735 
    oprot.writeStructEnd()
12736 
 
12737 
  def validate(self):
12738 
    return
12739 
 
12740 
 
12741 
  def __repr__(self):
12742 
    L = ['%s=%r' % (key, value)
12743 
      for key, value in self.__dict__.iteritems()]
12744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12745 
 
12746 
  def __eq__(self, other):
12747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12748 
 
12749 
  def __ne__(self, other):
12750 
    return not (self == other)
12751 
 
3064 chandransh 12752 
class getValidOrderCount_args:
12753 
 
12754 
  thrift_spec = (
12755 
  )
12756 
 
12757 
  def read(self, iprot):
12758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12760 
      return
12761 
    iprot.readStructBegin()
12762 
    while True:
12763 
      (fname, ftype, fid) = iprot.readFieldBegin()
12764 
      if ftype == TType.STOP:
12765 
        break
12766 
      else:
12767 
        iprot.skip(ftype)
12768 
      iprot.readFieldEnd()
12769 
    iprot.readStructEnd()
12770 
 
12771 
  def write(self, oprot):
12772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12774 
      return
12775 
    oprot.writeStructBegin('getValidOrderCount_args')
12776 
    oprot.writeFieldStop()
12777 
    oprot.writeStructEnd()
12778 
 
3431 rajveer 12779 
  def validate(self):
12780 
    return
12781 
 
12782 
 
3064 chandransh 12783 
  def __repr__(self):
12784 
    L = ['%s=%r' % (key, value)
12785 
      for key, value in self.__dict__.iteritems()]
12786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12787 
 
12788 
  def __eq__(self, other):
12789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12790 
 
12791 
  def __ne__(self, other):
12792 
    return not (self == other)
12793 
 
12794 
class getValidOrderCount_result:
94 ashish 12795 
  """
12796 
  Attributes:
12797 
   - success
12798 
  """
12799 
 
12800 
  thrift_spec = (
3064 chandransh 12801 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12802 
  )
12803 
 
3064 chandransh 12804 
  def __init__(self, success=None,):
94 ashish 12805 
    self.success = success
12806 
 
12807 
  def read(self, iprot):
12808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12810 
      return
12811 
    iprot.readStructBegin()
12812 
    while True:
12813 
      (fname, ftype, fid) = iprot.readFieldBegin()
12814 
      if ftype == TType.STOP:
12815 
        break
12816 
      if fid == 0:
3064 chandransh 12817 
        if ftype == TType.I64:
12818 
          self.success = iprot.readI64();
94 ashish 12819 
        else:
12820 
          iprot.skip(ftype)
12821 
      else:
12822 
        iprot.skip(ftype)
12823 
      iprot.readFieldEnd()
12824 
    iprot.readStructEnd()
12825 
 
12826 
  def write(self, oprot):
12827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12829 
      return
3064 chandransh 12830 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12831 
    if self.success is not None:
3064 chandransh 12832 
      oprot.writeFieldBegin('success', TType.I64, 0)
12833 
      oprot.writeI64(self.success)
94 ashish 12834 
      oprot.writeFieldEnd()
12835 
    oprot.writeFieldStop()
12836 
    oprot.writeStructEnd()
12837 
 
3431 rajveer 12838 
  def validate(self):
12839 
    return
12840 
 
12841 
 
94 ashish 12842 
  def __repr__(self):
12843 
    L = ['%s=%r' % (key, value)
12844 
      for key, value in self.__dict__.iteritems()]
12845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12846 
 
12847 
  def __eq__(self, other):
12848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12849 
 
12850 
  def __ne__(self, other):
12851 
    return not (self == other)
12852 
 
3064 chandransh 12853 
class getNoOfCustomersWithSuccessfulTransaction_args:
12854 
 
12855 
  thrift_spec = (
12856 
  )
12857 
 
12858 
  def read(self, iprot):
12859 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12860 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12861 
      return
12862 
    iprot.readStructBegin()
12863 
    while True:
12864 
      (fname, ftype, fid) = iprot.readFieldBegin()
12865 
      if ftype == TType.STOP:
12866 
        break
12867 
      else:
12868 
        iprot.skip(ftype)
12869 
      iprot.readFieldEnd()
12870 
    iprot.readStructEnd()
12871 
 
12872 
  def write(self, oprot):
12873 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12874 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12875 
      return
12876 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
12877 
    oprot.writeFieldStop()
12878 
    oprot.writeStructEnd()
12879 
 
3431 rajveer 12880 
  def validate(self):
12881 
    return
12882 
 
12883 
 
3064 chandransh 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 
 
12895 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 12896 
  """
12897 
  Attributes:
3064 chandransh 12898 
   - success
94 ashish 12899 
  """
12900 
 
12901 
  thrift_spec = (
3064 chandransh 12902 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12903 
  )
12904 
 
3064 chandransh 12905 
  def __init__(self, success=None,):
12906 
    self.success = success
94 ashish 12907 
 
12908 
  def read(self, iprot):
12909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12911 
      return
12912 
    iprot.readStructBegin()
12913 
    while True:
12914 
      (fname, ftype, fid) = iprot.readFieldBegin()
12915 
      if ftype == TType.STOP:
12916 
        break
3064 chandransh 12917 
      if fid == 0:
94 ashish 12918 
        if ftype == TType.I64:
3064 chandransh 12919 
          self.success = iprot.readI64();
94 ashish 12920 
        else:
12921 
          iprot.skip(ftype)
12922 
      else:
12923 
        iprot.skip(ftype)
12924 
      iprot.readFieldEnd()
12925 
    iprot.readStructEnd()
12926 
 
12927 
  def write(self, oprot):
12928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12930 
      return
3064 chandransh 12931 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 12932 
    if self.success is not None:
3064 chandransh 12933 
      oprot.writeFieldBegin('success', TType.I64, 0)
12934 
      oprot.writeI64(self.success)
94 ashish 12935 
      oprot.writeFieldEnd()
12936 
    oprot.writeFieldStop()
12937 
    oprot.writeStructEnd()
12938 
 
3431 rajveer 12939 
  def validate(self):
12940 
    return
12941 
 
12942 
 
94 ashish 12943 
  def __repr__(self):
12944 
    L = ['%s=%r' % (key, value)
12945 
      for key, value in self.__dict__.iteritems()]
12946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12947 
 
12948 
  def __eq__(self, other):
12949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12950 
 
12951 
  def __ne__(self, other):
12952 
    return not (self == other)
12953 
 
3064 chandransh 12954 
class getValidOrdersAmountRange_args:
12955 
 
12956 
  thrift_spec = (
12957 
  )
12958 
 
12959 
  def read(self, iprot):
12960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12962 
      return
12963 
    iprot.readStructBegin()
12964 
    while True:
12965 
      (fname, ftype, fid) = iprot.readFieldBegin()
12966 
      if ftype == TType.STOP:
12967 
        break
12968 
      else:
12969 
        iprot.skip(ftype)
12970 
      iprot.readFieldEnd()
12971 
    iprot.readStructEnd()
12972 
 
12973 
  def write(self, oprot):
12974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12976 
      return
12977 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
12978 
    oprot.writeFieldStop()
12979 
    oprot.writeStructEnd()
12980 
 
3431 rajveer 12981 
  def validate(self):
12982 
    return
12983 
 
12984 
 
3064 chandransh 12985 
  def __repr__(self):
12986 
    L = ['%s=%r' % (key, value)
12987 
      for key, value in self.__dict__.iteritems()]
12988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12989 
 
12990 
  def __eq__(self, other):
12991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12992 
 
12993 
  def __ne__(self, other):
12994 
    return not (self == other)
12995 
 
12996 
class getValidOrdersAmountRange_result:
94 ashish 12997 
  """
12998 
  Attributes:
12999 
   - success
13000 
  """
13001 
 
13002 
  thrift_spec = (
3064 chandransh 13003 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 13004 
  )
13005 
 
3064 chandransh 13006 
  def __init__(self, success=None,):
94 ashish 13007 
    self.success = success
13008 
 
13009 
  def read(self, iprot):
13010 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13011 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13012 
      return
13013 
    iprot.readStructBegin()
13014 
    while True:
13015 
      (fname, ftype, fid) = iprot.readFieldBegin()
13016 
      if ftype == TType.STOP:
13017 
        break
13018 
      if fid == 0:
483 rajveer 13019 
        if ftype == TType.LIST:
13020 
          self.success = []
6188 rajveer 13021 
          (_etype249, _size246) = iprot.readListBegin()
13022 
          for _i250 in xrange(_size246):
13023 
            _elem251 = iprot.readDouble();
13024 
            self.success.append(_elem251)
483 rajveer 13025 
          iprot.readListEnd()
94 ashish 13026 
        else:
13027 
          iprot.skip(ftype)
13028 
      else:
13029 
        iprot.skip(ftype)
13030 
      iprot.readFieldEnd()
13031 
    iprot.readStructEnd()
13032 
 
13033 
  def write(self, oprot):
13034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13036 
      return
3064 chandransh 13037 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 13038 
    if self.success is not None:
483 rajveer 13039 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 13040 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 13041 
      for iter252 in self.success:
13042 
        oprot.writeDouble(iter252)
483 rajveer 13043 
      oprot.writeListEnd()
94 ashish 13044 
      oprot.writeFieldEnd()
13045 
    oprot.writeFieldStop()
13046 
    oprot.writeStructEnd()
13047 
 
3431 rajveer 13048 
  def validate(self):
13049 
    return
13050 
 
13051 
 
94 ashish 13052 
  def __repr__(self):
13053 
    L = ['%s=%r' % (key, value)
13054 
      for key, value in self.__dict__.iteritems()]
13055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13056 
 
13057 
  def __eq__(self, other):
13058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13059 
 
13060 
  def __ne__(self, other):
13061 
    return not (self == other)
13062 
 
3064 chandransh 13063 
class getValidOrders_args:
1528 ankur.sing 13064 
  """
13065 
  Attributes:
3064 chandransh 13066 
   - limit
5874 rajveer 13067 
   - onlyStore
1528 ankur.sing 13068 
  """
13069 
 
13070 
  thrift_spec = (
13071 
    None, # 0
3064 chandransh 13072 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 13073 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 13074 
  )
13075 
 
5874 rajveer 13076 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 13077 
    self.limit = limit
5874 rajveer 13078 
    self.onlyStore = onlyStore
1528 ankur.sing 13079 
 
13080 
  def read(self, iprot):
13081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13083 
      return
13084 
    iprot.readStructBegin()
13085 
    while True:
13086 
      (fname, ftype, fid) = iprot.readFieldBegin()
13087 
      if ftype == TType.STOP:
13088 
        break
13089 
      if fid == 1:
13090 
        if ftype == TType.I64:
3064 chandransh 13091 
          self.limit = iprot.readI64();
1528 ankur.sing 13092 
        else:
13093 
          iprot.skip(ftype)
5874 rajveer 13094 
      elif fid == 2:
13095 
        if ftype == TType.BOOL:
13096 
          self.onlyStore = iprot.readBool();
13097 
        else:
13098 
          iprot.skip(ftype)
1528 ankur.sing 13099 
      else:
13100 
        iprot.skip(ftype)
13101 
      iprot.readFieldEnd()
13102 
    iprot.readStructEnd()
13103 
 
13104 
  def write(self, oprot):
13105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13107 
      return
3064 chandransh 13108 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 13109 
    if self.limit is not None:
3064 chandransh 13110 
      oprot.writeFieldBegin('limit', TType.I64, 1)
13111 
      oprot.writeI64(self.limit)
1528 ankur.sing 13112 
      oprot.writeFieldEnd()
5874 rajveer 13113 
    if self.onlyStore is not None:
13114 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
13115 
      oprot.writeBool(self.onlyStore)
13116 
      oprot.writeFieldEnd()
1528 ankur.sing 13117 
    oprot.writeFieldStop()
13118 
    oprot.writeStructEnd()
13119 
 
3431 rajveer 13120 
  def validate(self):
13121 
    return
13122 
 
13123 
 
1528 ankur.sing 13124 
  def __repr__(self):
13125 
    L = ['%s=%r' % (key, value)
13126 
      for key, value in self.__dict__.iteritems()]
13127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13128 
 
13129 
  def __eq__(self, other):
13130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13131 
 
13132 
  def __ne__(self, other):
13133 
    return not (self == other)
13134 
 
3064 chandransh 13135 
class getValidOrders_result:
1528 ankur.sing 13136 
  """
13137 
  Attributes:
13138 
   - success
13139 
  """
13140 
 
13141 
  thrift_spec = (
3064 chandransh 13142 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 13143 
  )
13144 
 
3064 chandransh 13145 
  def __init__(self, success=None,):
1528 ankur.sing 13146 
    self.success = success
13147 
 
13148 
  def read(self, iprot):
13149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13151 
      return
13152 
    iprot.readStructBegin()
13153 
    while True:
13154 
      (fname, ftype, fid) = iprot.readFieldBegin()
13155 
      if ftype == TType.STOP:
13156 
        break
13157 
      if fid == 0:
3064 chandransh 13158 
        if ftype == TType.LIST:
13159 
          self.success = []
6188 rajveer 13160 
          (_etype256, _size253) = iprot.readListBegin()
13161 
          for _i257 in xrange(_size253):
13162 
            _elem258 = Order()
13163 
            _elem258.read(iprot)
13164 
            self.success.append(_elem258)
3064 chandransh 13165 
          iprot.readListEnd()
1528 ankur.sing 13166 
        else:
13167 
          iprot.skip(ftype)
13168 
      else:
13169 
        iprot.skip(ftype)
13170 
      iprot.readFieldEnd()
13171 
    iprot.readStructEnd()
13172 
 
13173 
  def write(self, oprot):
13174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13176 
      return
3064 chandransh 13177 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 13178 
    if self.success is not None:
3064 chandransh 13179 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13180 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13181 
      for iter259 in self.success:
13182 
        iter259.write(oprot)
3064 chandransh 13183 
      oprot.writeListEnd()
1528 ankur.sing 13184 
      oprot.writeFieldEnd()
13185 
    oprot.writeFieldStop()
13186 
    oprot.writeStructEnd()
13187 
 
3431 rajveer 13188 
  def validate(self):
13189 
    return
13190 
 
13191 
 
1528 ankur.sing 13192 
  def __repr__(self):
13193 
    L = ['%s=%r' % (key, value)
13194 
      for key, value in self.__dict__.iteritems()]
13195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13196 
 
13197 
  def __eq__(self, other):
13198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13199 
 
13200 
  def __ne__(self, other):
13201 
    return not (self == other)
13202 
 
1220 chandransh 13203 
class batchOrders_args:
13204 
  """
13205 
  Attributes:
13206 
   - warehouseId
13207 
  """
13208 
 
13209 
  thrift_spec = (
13210 
    None, # 0
13211 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13212 
  )
13213 
 
13214 
  def __init__(self, warehouseId=None,):
13215 
    self.warehouseId = warehouseId
13216 
 
13217 
  def read(self, iprot):
13218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13220 
      return
13221 
    iprot.readStructBegin()
13222 
    while True:
13223 
      (fname, ftype, fid) = iprot.readFieldBegin()
13224 
      if ftype == TType.STOP:
13225 
        break
13226 
      if fid == 1:
13227 
        if ftype == TType.I64:
13228 
          self.warehouseId = iprot.readI64();
13229 
        else:
13230 
          iprot.skip(ftype)
13231 
      else:
13232 
        iprot.skip(ftype)
13233 
      iprot.readFieldEnd()
13234 
    iprot.readStructEnd()
13235 
 
13236 
  def write(self, oprot):
13237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13239 
      return
13240 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 13241 
    if self.warehouseId is not None:
1220 chandransh 13242 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13243 
      oprot.writeI64(self.warehouseId)
13244 
      oprot.writeFieldEnd()
13245 
    oprot.writeFieldStop()
13246 
    oprot.writeStructEnd()
13247 
 
3431 rajveer 13248 
  def validate(self):
13249 
    return
13250 
 
13251 
 
1220 chandransh 13252 
  def __repr__(self):
13253 
    L = ['%s=%r' % (key, value)
13254 
      for key, value in self.__dict__.iteritems()]
13255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13256 
 
13257 
  def __eq__(self, other):
13258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13259 
 
13260 
  def __ne__(self, other):
13261 
    return not (self == other)
13262 
 
13263 
class batchOrders_result:
13264 
  """
13265 
  Attributes:
13266 
   - success
13267 
   - ex
13268 
  """
13269 
 
13270 
  thrift_spec = (
13271 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13272 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13273 
  )
13274 
 
13275 
  def __init__(self, success=None, ex=None,):
13276 
    self.success = success
13277 
    self.ex = ex
13278 
 
13279 
  def read(self, iprot):
13280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13282 
      return
13283 
    iprot.readStructBegin()
13284 
    while True:
13285 
      (fname, ftype, fid) = iprot.readFieldBegin()
13286 
      if ftype == TType.STOP:
13287 
        break
13288 
      if fid == 0:
13289 
        if ftype == TType.LIST:
13290 
          self.success = []
6188 rajveer 13291 
          (_etype263, _size260) = iprot.readListBegin()
13292 
          for _i264 in xrange(_size260):
13293 
            _elem265 = Order()
13294 
            _elem265.read(iprot)
13295 
            self.success.append(_elem265)
1220 chandransh 13296 
          iprot.readListEnd()
13297 
        else:
13298 
          iprot.skip(ftype)
13299 
      elif fid == 1:
13300 
        if ftype == TType.STRUCT:
13301 
          self.ex = TransactionServiceException()
13302 
          self.ex.read(iprot)
13303 
        else:
13304 
          iprot.skip(ftype)
13305 
      else:
13306 
        iprot.skip(ftype)
13307 
      iprot.readFieldEnd()
13308 
    iprot.readStructEnd()
13309 
 
13310 
  def write(self, oprot):
13311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13313 
      return
13314 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 13315 
    if self.success is not None:
1220 chandransh 13316 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13317 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13318 
      for iter266 in self.success:
13319 
        iter266.write(oprot)
1220 chandransh 13320 
      oprot.writeListEnd()
13321 
      oprot.writeFieldEnd()
3431 rajveer 13322 
    if self.ex is not None:
1220 chandransh 13323 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13324 
      self.ex.write(oprot)
13325 
      oprot.writeFieldEnd()
13326 
    oprot.writeFieldStop()
13327 
    oprot.writeStructEnd()
13328 
 
3431 rajveer 13329 
  def validate(self):
13330 
    return
13331 
 
13332 
 
1220 chandransh 13333 
  def __repr__(self):
13334 
    L = ['%s=%r' % (key, value)
13335 
      for key, value in self.__dict__.iteritems()]
13336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13337 
 
13338 
  def __eq__(self, other):
13339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13340 
 
13341 
  def __ne__(self, other):
13342 
    return not (self == other)
13343 
 
1208 chandransh 13344 
class markOrderAsOutOfStock_args:
13345 
  """
13346 
  Attributes:
13347 
   - orderId
13348 
  """
13349 
 
13350 
  thrift_spec = (
13351 
    None, # 0
13352 
    (1, TType.I64, 'orderId', None, None, ), # 1
13353 
  )
13354 
 
13355 
  def __init__(self, orderId=None,):
13356 
    self.orderId = orderId
13357 
 
13358 
  def read(self, iprot):
13359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13361 
      return
13362 
    iprot.readStructBegin()
13363 
    while True:
13364 
      (fname, ftype, fid) = iprot.readFieldBegin()
13365 
      if ftype == TType.STOP:
13366 
        break
13367 
      if fid == 1:
13368 
        if ftype == TType.I64:
13369 
          self.orderId = iprot.readI64();
13370 
        else:
13371 
          iprot.skip(ftype)
13372 
      else:
13373 
        iprot.skip(ftype)
13374 
      iprot.readFieldEnd()
13375 
    iprot.readStructEnd()
13376 
 
13377 
  def write(self, oprot):
13378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13380 
      return
13381 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 13382 
    if self.orderId is not None:
1208 chandransh 13383 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13384 
      oprot.writeI64(self.orderId)
13385 
      oprot.writeFieldEnd()
13386 
    oprot.writeFieldStop()
13387 
    oprot.writeStructEnd()
13388 
 
3431 rajveer 13389 
  def validate(self):
13390 
    return
13391 
 
13392 
 
1208 chandransh 13393 
  def __repr__(self):
13394 
    L = ['%s=%r' % (key, value)
13395 
      for key, value in self.__dict__.iteritems()]
13396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13397 
 
13398 
  def __eq__(self, other):
13399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13400 
 
13401 
  def __ne__(self, other):
13402 
    return not (self == other)
13403 
 
13404 
class markOrderAsOutOfStock_result:
13405 
  """
13406 
  Attributes:
13407 
   - success
13408 
   - ex
13409 
  """
13410 
 
13411 
  thrift_spec = (
13412 
    (0, TType.BOOL, 'success', None, None, ), # 0
13413 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13414 
  )
13415 
 
13416 
  def __init__(self, success=None, ex=None,):
13417 
    self.success = success
13418 
    self.ex = ex
13419 
 
13420 
  def read(self, iprot):
13421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13423 
      return
13424 
    iprot.readStructBegin()
13425 
    while True:
13426 
      (fname, ftype, fid) = iprot.readFieldBegin()
13427 
      if ftype == TType.STOP:
13428 
        break
13429 
      if fid == 0:
13430 
        if ftype == TType.BOOL:
13431 
          self.success = iprot.readBool();
13432 
        else:
13433 
          iprot.skip(ftype)
13434 
      elif fid == 1:
13435 
        if ftype == TType.STRUCT:
13436 
          self.ex = TransactionServiceException()
13437 
          self.ex.read(iprot)
13438 
        else:
13439 
          iprot.skip(ftype)
13440 
      else:
13441 
        iprot.skip(ftype)
13442 
      iprot.readFieldEnd()
13443 
    iprot.readStructEnd()
13444 
 
13445 
  def write(self, oprot):
13446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13448 
      return
13449 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 13450 
    if self.success is not None:
1208 chandransh 13451 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13452 
      oprot.writeBool(self.success)
13453 
      oprot.writeFieldEnd()
3431 rajveer 13454 
    if self.ex is not None:
1208 chandransh 13455 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13456 
      self.ex.write(oprot)
13457 
      oprot.writeFieldEnd()
13458 
    oprot.writeFieldStop()
13459 
    oprot.writeStructEnd()
13460 
 
3431 rajveer 13461 
  def validate(self):
13462 
    return
13463 
 
13464 
 
1208 chandransh 13465 
  def __repr__(self):
13466 
    L = ['%s=%r' % (key, value)
13467 
      for key, value in self.__dict__.iteritems()]
13468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13469 
 
13470 
  def __eq__(self, other):
13471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13472 
 
13473 
  def __ne__(self, other):
13474 
    return not (self == other)
13475 
 
3064 chandransh 13476 
class verifyOrder_args:
759 chandransh 13477 
  """
13478 
  Attributes:
3064 chandransh 13479 
   - orderId
759 chandransh 13480 
  """
13481 
 
13482 
  thrift_spec = (
13483 
    None, # 0
3064 chandransh 13484 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 13485 
  )
13486 
 
3064 chandransh 13487 
  def __init__(self, orderId=None,):
13488 
    self.orderId = orderId
759 chandransh 13489 
 
13490 
  def read(self, iprot):
13491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13493 
      return
13494 
    iprot.readStructBegin()
13495 
    while True:
13496 
      (fname, ftype, fid) = iprot.readFieldBegin()
13497 
      if ftype == TType.STOP:
13498 
        break
13499 
      if fid == 1:
13500 
        if ftype == TType.I64:
3064 chandransh 13501 
          self.orderId = iprot.readI64();
759 chandransh 13502 
        else:
13503 
          iprot.skip(ftype)
13504 
      else:
13505 
        iprot.skip(ftype)
13506 
      iprot.readFieldEnd()
13507 
    iprot.readStructEnd()
13508 
 
13509 
  def write(self, oprot):
13510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13512 
      return
3064 chandransh 13513 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 13514 
    if self.orderId is not None:
3064 chandransh 13515 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13516 
      oprot.writeI64(self.orderId)
759 chandransh 13517 
      oprot.writeFieldEnd()
13518 
    oprot.writeFieldStop()
13519 
    oprot.writeStructEnd()
13520 
 
3431 rajveer 13521 
  def validate(self):
13522 
    return
13523 
 
13524 
 
759 chandransh 13525 
  def __repr__(self):
13526 
    L = ['%s=%r' % (key, value)
13527 
      for key, value in self.__dict__.iteritems()]
13528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13529 
 
13530 
  def __eq__(self, other):
13531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13532 
 
13533 
  def __ne__(self, other):
13534 
    return not (self == other)
13535 
 
3064 chandransh 13536 
class verifyOrder_result:
759 chandransh 13537 
  """
13538 
  Attributes:
13539 
   - success
13540 
   - ex
13541 
  """
13542 
 
13543 
  thrift_spec = (
13544 
    (0, TType.BOOL, 'success', None, None, ), # 0
13545 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13546 
  )
13547 
 
13548 
  def __init__(self, success=None, ex=None,):
13549 
    self.success = success
13550 
    self.ex = ex
13551 
 
13552 
  def read(self, iprot):
13553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13555 
      return
13556 
    iprot.readStructBegin()
13557 
    while True:
13558 
      (fname, ftype, fid) = iprot.readFieldBegin()
13559 
      if ftype == TType.STOP:
13560 
        break
13561 
      if fid == 0:
13562 
        if ftype == TType.BOOL:
13563 
          self.success = iprot.readBool();
13564 
        else:
13565 
          iprot.skip(ftype)
13566 
      elif fid == 1:
13567 
        if ftype == TType.STRUCT:
13568 
          self.ex = TransactionServiceException()
13569 
          self.ex.read(iprot)
13570 
        else:
13571 
          iprot.skip(ftype)
13572 
      else:
13573 
        iprot.skip(ftype)
13574 
      iprot.readFieldEnd()
13575 
    iprot.readStructEnd()
13576 
 
13577 
  def write(self, oprot):
13578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13580 
      return
3064 chandransh 13581 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 13582 
    if self.success is not None:
759 chandransh 13583 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13584 
      oprot.writeBool(self.success)
13585 
      oprot.writeFieldEnd()
3431 rajveer 13586 
    if self.ex is not None:
759 chandransh 13587 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13588 
      self.ex.write(oprot)
13589 
      oprot.writeFieldEnd()
13590 
    oprot.writeFieldStop()
13591 
    oprot.writeStructEnd()
13592 
 
3431 rajveer 13593 
  def validate(self):
13594 
    return
13595 
 
13596 
 
759 chandransh 13597 
  def __repr__(self):
13598 
    L = ['%s=%r' % (key, value)
13599 
      for key, value in self.__dict__.iteritems()]
13600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13601 
 
13602 
  def __eq__(self, other):
13603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13604 
 
13605 
  def __ne__(self, other):
13606 
    return not (self == other)
13607 
 
3064 chandransh 13608 
class acceptOrder_args:
1113 chandransh 13609 
  """
13610 
  Attributes:
3064 chandransh 13611 
   - orderId
1113 chandransh 13612 
  """
13613 
 
13614 
  thrift_spec = (
13615 
    None, # 0
3064 chandransh 13616 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 13617 
  )
13618 
 
3064 chandransh 13619 
  def __init__(self, orderId=None,):
13620 
    self.orderId = orderId
1113 chandransh 13621 
 
13622 
  def read(self, iprot):
13623 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13624 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13625 
      return
13626 
    iprot.readStructBegin()
13627 
    while True:
13628 
      (fname, ftype, fid) = iprot.readFieldBegin()
13629 
      if ftype == TType.STOP:
13630 
        break
13631 
      if fid == 1:
13632 
        if ftype == TType.I64:
3064 chandransh 13633 
          self.orderId = iprot.readI64();
1113 chandransh 13634 
        else:
13635 
          iprot.skip(ftype)
13636 
      else:
13637 
        iprot.skip(ftype)
13638 
      iprot.readFieldEnd()
13639 
    iprot.readStructEnd()
13640 
 
13641 
  def write(self, oprot):
13642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13644 
      return
3064 chandransh 13645 
    oprot.writeStructBegin('acceptOrder_args')
3431 rajveer 13646 
    if self.orderId is not None:
3064 chandransh 13647 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13648 
      oprot.writeI64(self.orderId)
1113 chandransh 13649 
      oprot.writeFieldEnd()
13650 
    oprot.writeFieldStop()
13651 
    oprot.writeStructEnd()
13652 
 
3431 rajveer 13653 
  def validate(self):
13654 
    return
13655 
 
13656 
 
1113 chandransh 13657 
  def __repr__(self):
13658 
    L = ['%s=%r' % (key, value)
13659 
      for key, value in self.__dict__.iteritems()]
13660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13661 
 
13662 
  def __eq__(self, other):
13663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13664 
 
13665 
  def __ne__(self, other):
13666 
    return not (self == other)
13667 
 
3064 chandransh 13668 
class acceptOrder_result:
1113 chandransh 13669 
  """
13670 
  Attributes:
13671 
   - success
13672 
   - ex
13673 
  """
13674 
 
13675 
  thrift_spec = (
3064 chandransh 13676 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13677 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13678 
  )
13679 
 
13680 
  def __init__(self, success=None, ex=None,):
13681 
    self.success = success
13682 
    self.ex = ex
13683 
 
13684 
  def read(self, iprot):
13685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13687 
      return
13688 
    iprot.readStructBegin()
13689 
    while True:
13690 
      (fname, ftype, fid) = iprot.readFieldBegin()
13691 
      if ftype == TType.STOP:
13692 
        break
13693 
      if fid == 0:
3064 chandransh 13694 
        if ftype == TType.BOOL:
13695 
          self.success = iprot.readBool();
1113 chandransh 13696 
        else:
13697 
          iprot.skip(ftype)
13698 
      elif fid == 1:
13699 
        if ftype == TType.STRUCT:
13700 
          self.ex = TransactionServiceException()
13701 
          self.ex.read(iprot)
13702 
        else:
13703 
          iprot.skip(ftype)
13704 
      else:
13705 
        iprot.skip(ftype)
13706 
      iprot.readFieldEnd()
13707 
    iprot.readStructEnd()
13708 
 
13709 
  def write(self, oprot):
13710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13712 
      return
3064 chandransh 13713 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 13714 
    if self.success is not None:
3064 chandransh 13715 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13716 
      oprot.writeBool(self.success)
1113 chandransh 13717 
      oprot.writeFieldEnd()
3431 rajveer 13718 
    if self.ex is not None:
1113 chandransh 13719 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13720 
      self.ex.write(oprot)
13721 
      oprot.writeFieldEnd()
13722 
    oprot.writeFieldStop()
13723 
    oprot.writeStructEnd()
13724 
 
3431 rajveer 13725 
  def validate(self):
13726 
    return
13727 
 
13728 
 
1113 chandransh 13729 
  def __repr__(self):
13730 
    L = ['%s=%r' % (key, value)
13731 
      for key, value in self.__dict__.iteritems()]
13732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13733 
 
13734 
  def __eq__(self, other):
13735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13736 
 
13737 
  def __ne__(self, other):
13738 
    return not (self == other)
13739 
 
3064 chandransh 13740 
class addBillingDetails_args:
1135 chandransh 13741 
  """
13742 
  Attributes:
3064 chandransh 13743 
   - orderId
13744 
   - invoice_number
4658 mandeep.dh 13745 
   - serialNumber
4283 anupam.sin 13746 
   - itemNumber
3064 chandransh 13747 
   - billed_by
4264 rajveer 13748 
   - jacketNumber
4283 anupam.sin 13749 
   - billingType
5110 mandeep.dh 13750 
   - fulfilmentWarehouseId
4763 rajveer 13751 
   - authorize
1135 chandransh 13752 
  """
13753 
 
13754 
  thrift_spec = (
13755 
    None, # 0
3064 chandransh 13756 
    (1, TType.I64, 'orderId', None, None, ), # 1
13757 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 13758 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
13759 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 13760 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
13761 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
13762 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 13763 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 13764 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 13765 
  )
13766 
 
5110 mandeep.dh 13767 
  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 13768 
    self.orderId = orderId
13769 
    self.invoice_number = invoice_number
4658 mandeep.dh 13770 
    self.serialNumber = serialNumber
4283 anupam.sin 13771 
    self.itemNumber = itemNumber
3064 chandransh 13772 
    self.billed_by = billed_by
4264 rajveer 13773 
    self.jacketNumber = jacketNumber
4283 anupam.sin 13774 
    self.billingType = billingType
5110 mandeep.dh 13775 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 13776 
    self.authorize = authorize
1135 chandransh 13777 
 
13778 
  def read(self, iprot):
13779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13781 
      return
13782 
    iprot.readStructBegin()
13783 
    while True:
13784 
      (fname, ftype, fid) = iprot.readFieldBegin()
13785 
      if ftype == TType.STOP:
13786 
        break
13787 
      if fid == 1:
13788 
        if ftype == TType.I64:
3064 chandransh 13789 
          self.orderId = iprot.readI64();
1135 chandransh 13790 
        else:
13791 
          iprot.skip(ftype)
13792 
      elif fid == 2:
3064 chandransh 13793 
        if ftype == TType.STRING:
13794 
          self.invoice_number = iprot.readString();
1135 chandransh 13795 
        else:
13796 
          iprot.skip(ftype)
3064 chandransh 13797 
      elif fid == 3:
5411 rajveer 13798 
        if ftype == TType.LIST:
13799 
          self.serialNumber = []
6188 rajveer 13800 
          (_etype270, _size267) = iprot.readListBegin()
13801 
          for _i271 in xrange(_size267):
13802 
            _elem272 = iprot.readString();
13803 
            self.serialNumber.append(_elem272)
5411 rajveer 13804 
          iprot.readListEnd()
3064 chandransh 13805 
        else:
13806 
          iprot.skip(ftype)
13807 
      elif fid == 4:
5411 rajveer 13808 
        if ftype == TType.LIST:
13809 
          self.itemNumber = []
6188 rajveer 13810 
          (_etype276, _size273) = iprot.readListBegin()
13811 
          for _i277 in xrange(_size273):
13812 
            _elem278 = iprot.readString();
13813 
            self.itemNumber.append(_elem278)
5411 rajveer 13814 
          iprot.readListEnd()
3064 chandransh 13815 
        else:
13816 
          iprot.skip(ftype)
13817 
      elif fid == 5:
13818 
        if ftype == TType.STRING:
4283 anupam.sin 13819 
          self.billed_by = iprot.readString();
3064 chandransh 13820 
        else:
13821 
          iprot.skip(ftype)
13822 
      elif fid == 6:
13823 
        if ftype == TType.I64:
4283 anupam.sin 13824 
          self.jacketNumber = iprot.readI64();
13825 
        else:
13826 
          iprot.skip(ftype)
13827 
      elif fid == 7:
13828 
        if ftype == TType.I64:
3064 chandransh 13829 
          self.billingType = iprot.readI64();
13830 
        else:
13831 
          iprot.skip(ftype)
4283 anupam.sin 13832 
      elif fid == 8:
13833 
        if ftype == TType.I64:
5110 mandeep.dh 13834 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13835 
        else:
13836 
          iprot.skip(ftype)
4763 rajveer 13837 
      elif fid == 9:
13838 
        if ftype == TType.BOOL:
13839 
          self.authorize = iprot.readBool();
13840 
        else:
13841 
          iprot.skip(ftype)
1246 chandransh 13842 
      else:
13843 
        iprot.skip(ftype)
13844 
      iprot.readFieldEnd()
13845 
    iprot.readStructEnd()
13846 
 
13847 
  def write(self, oprot):
13848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13850 
      return
4283 anupam.sin 13851 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 13852 
    if self.orderId is not None:
3064 chandransh 13853 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13854 
      oprot.writeI64(self.orderId)
1246 chandransh 13855 
      oprot.writeFieldEnd()
4283 anupam.sin 13856 
    if self.invoice_number is not None:
13857 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
13858 
      oprot.writeString(self.invoice_number)
1246 chandransh 13859 
      oprot.writeFieldEnd()
4658 mandeep.dh 13860 
    if self.serialNumber is not None:
5411 rajveer 13861 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
13862 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 13863 
      for iter279 in self.serialNumber:
13864 
        oprot.writeString(iter279)
5411 rajveer 13865 
      oprot.writeListEnd()
3064 chandransh 13866 
      oprot.writeFieldEnd()
3431 rajveer 13867 
    if self.itemNumber is not None:
5411 rajveer 13868 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
13869 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 13870 
      for iter280 in self.itemNumber:
13871 
        oprot.writeString(iter280)
5411 rajveer 13872 
      oprot.writeListEnd()
3064 chandransh 13873 
      oprot.writeFieldEnd()
4283 anupam.sin 13874 
    if self.billed_by is not None:
13875 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
13876 
      oprot.writeString(self.billed_by)
3064 chandransh 13877 
      oprot.writeFieldEnd()
4283 anupam.sin 13878 
    if self.jacketNumber is not None:
13879 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
13880 
      oprot.writeI64(self.jacketNumber)
13881 
      oprot.writeFieldEnd()
3431 rajveer 13882 
    if self.billingType is not None:
4283 anupam.sin 13883 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 13884 
      oprot.writeI64(self.billingType)
13885 
      oprot.writeFieldEnd()
5110 mandeep.dh 13886 
    if self.fulfilmentWarehouseId is not None:
13887 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
13888 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 13889 
      oprot.writeFieldEnd()
4763 rajveer 13890 
    if self.authorize is not None:
13891 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
13892 
      oprot.writeBool(self.authorize)
13893 
      oprot.writeFieldEnd()
1246 chandransh 13894 
    oprot.writeFieldStop()
13895 
    oprot.writeStructEnd()
13896 
 
3431 rajveer 13897 
  def validate(self):
13898 
    return
13899 
 
13900 
 
1246 chandransh 13901 
  def __repr__(self):
13902 
    L = ['%s=%r' % (key, value)
13903 
      for key, value in self.__dict__.iteritems()]
13904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13905 
 
13906 
  def __eq__(self, other):
13907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13908 
 
13909 
  def __ne__(self, other):
13910 
    return not (self == other)
13911 
 
4283 anupam.sin 13912 
class addBillingDetails_result:
1246 chandransh 13913 
  """
13914 
  Attributes:
3064 chandransh 13915 
   - success
1246 chandransh 13916 
   - ex
13917 
  """
13918 
 
13919 
  thrift_spec = (
3064 chandransh 13920 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 13921 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13922 
  )
13923 
 
3064 chandransh 13924 
  def __init__(self, success=None, ex=None,):
13925 
    self.success = success
1246 chandransh 13926 
    self.ex = ex
13927 
 
13928 
  def read(self, iprot):
13929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13931 
      return
13932 
    iprot.readStructBegin()
13933 
    while True:
13934 
      (fname, ftype, fid) = iprot.readFieldBegin()
13935 
      if ftype == TType.STOP:
13936 
        break
3064 chandransh 13937 
      if fid == 0:
13938 
        if ftype == TType.BOOL:
13939 
          self.success = iprot.readBool();
13940 
        else:
13941 
          iprot.skip(ftype)
13942 
      elif fid == 1:
1246 chandransh 13943 
        if ftype == TType.STRUCT:
13944 
          self.ex = TransactionServiceException()
13945 
          self.ex.read(iprot)
13946 
        else:
13947 
          iprot.skip(ftype)
13948 
      else:
13949 
        iprot.skip(ftype)
13950 
      iprot.readFieldEnd()
13951 
    iprot.readStructEnd()
13952 
 
13953 
  def write(self, oprot):
13954 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13955 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13956 
      return
4283 anupam.sin 13957 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 13958 
    if self.success is not None:
3064 chandransh 13959 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13960 
      oprot.writeBool(self.success)
13961 
      oprot.writeFieldEnd()
3431 rajveer 13962 
    if self.ex is not None:
1246 chandransh 13963 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13964 
      self.ex.write(oprot)
13965 
      oprot.writeFieldEnd()
13966 
    oprot.writeFieldStop()
13967 
    oprot.writeStructEnd()
13968 
 
3431 rajveer 13969 
  def validate(self):
13970 
    return
13971 
 
13972 
 
1246 chandransh 13973 
  def __repr__(self):
13974 
    L = ['%s=%r' % (key, value)
13975 
      for key, value in self.__dict__.iteritems()]
13976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13977 
 
13978 
  def __eq__(self, other):
13979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13980 
 
13981 
  def __ne__(self, other):
13982 
    return not (self == other)
13983 
 
4579 rajveer 13984 
class addInvoiceNumber_args:
13985 
  """
13986 
  Attributes:
13987 
   - orderId
13988 
   - invoiceNumber
4763 rajveer 13989 
   - color
6756 amar.kumar 13990 
   - serialNumber
13991 
   - itemNumber
4579 rajveer 13992 
  """
13993 
 
13994 
  thrift_spec = (
13995 
    None, # 0
13996 
    (1, TType.I64, 'orderId', None, None, ), # 1
13997 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 13998 
    (3, TType.STRING, 'color', None, None, ), # 3
6756 amar.kumar 13999 
    (4, TType.STRING, 'serialNumber', None, None, ), # 4
14000 
    (5, TType.STRING, 'itemNumber', None, None, ), # 5
4579 rajveer 14001 
  )
14002 
 
6756 amar.kumar 14003 
  def __init__(self, orderId=None, invoiceNumber=None, color=None, serialNumber=None, itemNumber=None,):
4579 rajveer 14004 
    self.orderId = orderId
14005 
    self.invoiceNumber = invoiceNumber
4763 rajveer 14006 
    self.color = color
6756 amar.kumar 14007 
    self.serialNumber = serialNumber
14008 
    self.itemNumber = itemNumber
4579 rajveer 14009 
 
14010 
  def read(self, iprot):
14011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14013 
      return
14014 
    iprot.readStructBegin()
14015 
    while True:
14016 
      (fname, ftype, fid) = iprot.readFieldBegin()
14017 
      if ftype == TType.STOP:
14018 
        break
14019 
      if fid == 1:
14020 
        if ftype == TType.I64:
14021 
          self.orderId = iprot.readI64();
14022 
        else:
14023 
          iprot.skip(ftype)
14024 
      elif fid == 2:
14025 
        if ftype == TType.STRING:
14026 
          self.invoiceNumber = iprot.readString();
14027 
        else:
14028 
          iprot.skip(ftype)
4763 rajveer 14029 
      elif fid == 3:
14030 
        if ftype == TType.STRING:
14031 
          self.color = iprot.readString();
14032 
        else:
14033 
          iprot.skip(ftype)
6756 amar.kumar 14034 
      elif fid == 4:
14035 
        if ftype == TType.STRING:
14036 
          self.serialNumber = iprot.readString();
14037 
        else:
14038 
          iprot.skip(ftype)
14039 
      elif fid == 5:
14040 
        if ftype == TType.STRING:
14041 
          self.itemNumber = iprot.readString();
14042 
        else:
14043 
          iprot.skip(ftype)
4579 rajveer 14044 
      else:
14045 
        iprot.skip(ftype)
14046 
      iprot.readFieldEnd()
14047 
    iprot.readStructEnd()
14048 
 
14049 
  def write(self, oprot):
14050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14052 
      return
14053 
    oprot.writeStructBegin('addInvoiceNumber_args')
14054 
    if self.orderId is not None:
14055 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
14056 
      oprot.writeI64(self.orderId)
14057 
      oprot.writeFieldEnd()
14058 
    if self.invoiceNumber is not None:
14059 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
14060 
      oprot.writeString(self.invoiceNumber)
14061 
      oprot.writeFieldEnd()
4763 rajveer 14062 
    if self.color is not None:
14063 
      oprot.writeFieldBegin('color', TType.STRING, 3)
14064 
      oprot.writeString(self.color)
14065 
      oprot.writeFieldEnd()
6756 amar.kumar 14066 
    if self.serialNumber is not None:
14067 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 4)
14068 
      oprot.writeString(self.serialNumber)
14069 
      oprot.writeFieldEnd()
14070 
    if self.itemNumber is not None:
14071 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 5)
14072 
      oprot.writeString(self.itemNumber)
14073 
      oprot.writeFieldEnd()
4579 rajveer 14074 
    oprot.writeFieldStop()
14075 
    oprot.writeStructEnd()
14076 
 
14077 
  def validate(self):
14078 
    return
14079 
 
14080 
 
14081 
  def __repr__(self):
14082 
    L = ['%s=%r' % (key, value)
14083 
      for key, value in self.__dict__.iteritems()]
14084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14085 
 
14086 
  def __eq__(self, other):
14087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14088 
 
14089 
  def __ne__(self, other):
14090 
    return not (self == other)
14091 
 
14092 
class addInvoiceNumber_result:
14093 
  """
14094 
  Attributes:
14095 
   - ex
14096 
  """
14097 
 
14098 
  thrift_spec = (
14099 
    None, # 0
14100 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14101 
  )
14102 
 
14103 
  def __init__(self, ex=None,):
14104 
    self.ex = ex
14105 
 
14106 
  def read(self, iprot):
14107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14109 
      return
14110 
    iprot.readStructBegin()
14111 
    while True:
14112 
      (fname, ftype, fid) = iprot.readFieldBegin()
14113 
      if ftype == TType.STOP:
14114 
        break
14115 
      if fid == 1:
14116 
        if ftype == TType.STRUCT:
14117 
          self.ex = TransactionServiceException()
14118 
          self.ex.read(iprot)
14119 
        else:
14120 
          iprot.skip(ftype)
14121 
      else:
14122 
        iprot.skip(ftype)
14123 
      iprot.readFieldEnd()
14124 
    iprot.readStructEnd()
14125 
 
14126 
  def write(self, oprot):
14127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14129 
      return
14130 
    oprot.writeStructBegin('addInvoiceNumber_result')
14131 
    if self.ex is not None:
14132 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14133 
      self.ex.write(oprot)
14134 
      oprot.writeFieldEnd()
14135 
    oprot.writeFieldStop()
14136 
    oprot.writeStructEnd()
14137 
 
14138 
  def validate(self):
14139 
    return
14140 
 
14141 
 
14142 
  def __repr__(self):
14143 
    L = ['%s=%r' % (key, value)
14144 
      for key, value in self.__dict__.iteritems()]
14145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14146 
 
14147 
  def __eq__(self, other):
14148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14149 
 
14150 
  def __ne__(self, other):
14151 
    return not (self == other)
14152 
 
4910 phani.kuma 14153 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 14154 
  """
14155 
  Attributes:
3064 chandransh 14156 
   - warehouseId
1408 ankur.sing 14157 
   - providerId
3064 chandransh 14158 
   - cod
4910 phani.kuma 14159 
   - orderIds
1408 ankur.sing 14160 
  """
14161 
 
14162 
  thrift_spec = (
14163 
    None, # 0
3064 chandransh 14164 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14165 
    (2, TType.I64, 'providerId', None, None, ), # 2
14166 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 14167 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 14168 
  )
14169 
 
4910 phani.kuma 14170 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 14171 
    self.warehouseId = warehouseId
1408 ankur.sing 14172 
    self.providerId = providerId
3064 chandransh 14173 
    self.cod = cod
4910 phani.kuma 14174 
    self.orderIds = orderIds
1408 ankur.sing 14175 
 
14176 
  def read(self, iprot):
14177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14179 
      return
14180 
    iprot.readStructBegin()
14181 
    while True:
14182 
      (fname, ftype, fid) = iprot.readFieldBegin()
14183 
      if ftype == TType.STOP:
14184 
        break
14185 
      if fid == 1:
14186 
        if ftype == TType.I64:
3064 chandransh 14187 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 14188 
        else:
14189 
          iprot.skip(ftype)
14190 
      elif fid == 2:
14191 
        if ftype == TType.I64:
3064 chandransh 14192 
          self.providerId = iprot.readI64();
1408 ankur.sing 14193 
        else:
14194 
          iprot.skip(ftype)
3064 chandransh 14195 
      elif fid == 3:
14196 
        if ftype == TType.BOOL:
14197 
          self.cod = iprot.readBool();
14198 
        else:
14199 
          iprot.skip(ftype)
4910 phani.kuma 14200 
      elif fid == 4:
14201 
        if ftype == TType.LIST:
14202 
          self.orderIds = []
6188 rajveer 14203 
          (_etype284, _size281) = iprot.readListBegin()
14204 
          for _i285 in xrange(_size281):
14205 
            _elem286 = iprot.readI64();
14206 
            self.orderIds.append(_elem286)
4910 phani.kuma 14207 
          iprot.readListEnd()
14208 
        else:
14209 
          iprot.skip(ftype)
1408 ankur.sing 14210 
      else:
14211 
        iprot.skip(ftype)
14212 
      iprot.readFieldEnd()
14213 
    iprot.readStructEnd()
14214 
 
14215 
  def write(self, oprot):
14216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14218 
      return
4910 phani.kuma 14219 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 14220 
    if self.warehouseId is not None:
3064 chandransh 14221 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14222 
      oprot.writeI64(self.warehouseId)
14223 
      oprot.writeFieldEnd()
3431 rajveer 14224 
    if self.providerId is not None:
3064 chandransh 14225 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 14226 
      oprot.writeI64(self.providerId)
14227 
      oprot.writeFieldEnd()
3431 rajveer 14228 
    if self.cod is not None:
3064 chandransh 14229 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
14230 
      oprot.writeBool(self.cod)
1408 ankur.sing 14231 
      oprot.writeFieldEnd()
4910 phani.kuma 14232 
    if self.orderIds is not None:
14233 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
14234 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14235 
      for iter287 in self.orderIds:
14236 
        oprot.writeI64(iter287)
4910 phani.kuma 14237 
      oprot.writeListEnd()
14238 
      oprot.writeFieldEnd()
1408 ankur.sing 14239 
    oprot.writeFieldStop()
14240 
    oprot.writeStructEnd()
14241 
 
3431 rajveer 14242 
  def validate(self):
14243 
    return
14244 
 
14245 
 
1408 ankur.sing 14246 
  def __repr__(self):
14247 
    L = ['%s=%r' % (key, value)
14248 
      for key, value in self.__dict__.iteritems()]
14249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14250 
 
14251 
  def __eq__(self, other):
14252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14253 
 
14254 
  def __ne__(self, other):
14255 
    return not (self == other)
14256 
 
4910 phani.kuma 14257 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 14258 
  """
14259 
  Attributes:
14260 
   - success
3064 chandransh 14261 
   - ex
1408 ankur.sing 14262 
  """
14263 
 
14264 
  thrift_spec = (
3064 chandransh 14265 
    (0, TType.BOOL, 'success', None, None, ), # 0
14266 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 14267 
  )
14268 
 
3064 chandransh 14269 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 14270 
    self.success = success
3064 chandransh 14271 
    self.ex = ex
1408 ankur.sing 14272 
 
14273 
  def read(self, iprot):
14274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14276 
      return
14277 
    iprot.readStructBegin()
14278 
    while True:
14279 
      (fname, ftype, fid) = iprot.readFieldBegin()
14280 
      if ftype == TType.STOP:
14281 
        break
14282 
      if fid == 0:
3064 chandransh 14283 
        if ftype == TType.BOOL:
14284 
          self.success = iprot.readBool();
1408 ankur.sing 14285 
        else:
14286 
          iprot.skip(ftype)
3064 chandransh 14287 
      elif fid == 1:
14288 
        if ftype == TType.STRUCT:
14289 
          self.ex = TransactionServiceException()
14290 
          self.ex.read(iprot)
14291 
        else:
14292 
          iprot.skip(ftype)
1408 ankur.sing 14293 
      else:
14294 
        iprot.skip(ftype)
14295 
      iprot.readFieldEnd()
14296 
    iprot.readStructEnd()
14297 
 
14298 
  def write(self, oprot):
14299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14301 
      return
4910 phani.kuma 14302 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 14303 
    if self.success is not None:
3064 chandransh 14304 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14305 
      oprot.writeBool(self.success)
1408 ankur.sing 14306 
      oprot.writeFieldEnd()
3431 rajveer 14307 
    if self.ex is not None:
3064 chandransh 14308 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14309 
      self.ex.write(oprot)
14310 
      oprot.writeFieldEnd()
1408 ankur.sing 14311 
    oprot.writeFieldStop()
14312 
    oprot.writeStructEnd()
14313 
 
3431 rajveer 14314 
  def validate(self):
14315 
    return
14316 
 
14317 
 
1408 ankur.sing 14318 
  def __repr__(self):
14319 
    L = ['%s=%r' % (key, value)
14320 
      for key, value in self.__dict__.iteritems()]
14321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14322 
 
14323 
  def __eq__(self, other):
14324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14325 
 
14326 
  def __ne__(self, other):
14327 
    return not (self == other)
14328 
 
5676 rajveer 14329 
class markOrdersAsReturnedFromStore_args:
14330 
  """
14331 
  Attributes:
14332 
   - providerId
14333 
   - orderIds
5713 rajveer 14334 
   - awbs
5676 rajveer 14335 
  """
14336 
 
14337 
  thrift_spec = (
14338 
    None, # 0
14339 
    (1, TType.I64, 'providerId', None, None, ), # 1
14340 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 14341 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 14342 
  )
14343 
 
5713 rajveer 14344 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 14345 
    self.providerId = providerId
14346 
    self.orderIds = orderIds
5713 rajveer 14347 
    self.awbs = awbs
5676 rajveer 14348 
 
14349 
  def read(self, iprot):
14350 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14351 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14352 
      return
14353 
    iprot.readStructBegin()
14354 
    while True:
14355 
      (fname, ftype, fid) = iprot.readFieldBegin()
14356 
      if ftype == TType.STOP:
14357 
        break
14358 
      if fid == 1:
14359 
        if ftype == TType.I64:
14360 
          self.providerId = iprot.readI64();
14361 
        else:
14362 
          iprot.skip(ftype)
14363 
      elif fid == 2:
14364 
        if ftype == TType.LIST:
14365 
          self.orderIds = []
6188 rajveer 14366 
          (_etype291, _size288) = iprot.readListBegin()
14367 
          for _i292 in xrange(_size288):
14368 
            _elem293 = iprot.readI64();
14369 
            self.orderIds.append(_elem293)
5676 rajveer 14370 
          iprot.readListEnd()
14371 
        else:
14372 
          iprot.skip(ftype)
5713 rajveer 14373 
      elif fid == 3:
14374 
        if ftype == TType.LIST:
14375 
          self.awbs = []
6188 rajveer 14376 
          (_etype297, _size294) = iprot.readListBegin()
14377 
          for _i298 in xrange(_size294):
14378 
            _elem299 = iprot.readString();
14379 
            self.awbs.append(_elem299)
5713 rajveer 14380 
          iprot.readListEnd()
14381 
        else:
14382 
          iprot.skip(ftype)
5676 rajveer 14383 
      else:
14384 
        iprot.skip(ftype)
14385 
      iprot.readFieldEnd()
14386 
    iprot.readStructEnd()
14387 
 
14388 
  def write(self, oprot):
14389 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14390 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14391 
      return
14392 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
14393 
    if self.providerId is not None:
14394 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14395 
      oprot.writeI64(self.providerId)
14396 
      oprot.writeFieldEnd()
14397 
    if self.orderIds is not None:
14398 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
14399 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14400 
      for iter300 in self.orderIds:
14401 
        oprot.writeI64(iter300)
5676 rajveer 14402 
      oprot.writeListEnd()
14403 
      oprot.writeFieldEnd()
5713 rajveer 14404 
    if self.awbs is not None:
14405 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
14406 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 14407 
      for iter301 in self.awbs:
14408 
        oprot.writeString(iter301)
5713 rajveer 14409 
      oprot.writeListEnd()
14410 
      oprot.writeFieldEnd()
5676 rajveer 14411 
    oprot.writeFieldStop()
14412 
    oprot.writeStructEnd()
14413 
 
14414 
  def validate(self):
14415 
    return
14416 
 
14417 
 
14418 
  def __repr__(self):
14419 
    L = ['%s=%r' % (key, value)
14420 
      for key, value in self.__dict__.iteritems()]
14421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14422 
 
14423 
  def __eq__(self, other):
14424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14425 
 
14426 
  def __ne__(self, other):
14427 
    return not (self == other)
14428 
 
14429 
class markOrdersAsReturnedFromStore_result:
14430 
  """
14431 
  Attributes:
14432 
   - success
14433 
   - ex
14434 
  """
14435 
 
14436 
  thrift_spec = (
14437 
    (0, TType.BOOL, 'success', None, None, ), # 0
14438 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14439 
  )
14440 
 
14441 
  def __init__(self, success=None, ex=None,):
14442 
    self.success = success
14443 
    self.ex = ex
14444 
 
14445 
  def read(self, iprot):
14446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14448 
      return
14449 
    iprot.readStructBegin()
14450 
    while True:
14451 
      (fname, ftype, fid) = iprot.readFieldBegin()
14452 
      if ftype == TType.STOP:
14453 
        break
14454 
      if fid == 0:
14455 
        if ftype == TType.BOOL:
14456 
          self.success = iprot.readBool();
14457 
        else:
14458 
          iprot.skip(ftype)
14459 
      elif fid == 1:
14460 
        if ftype == TType.STRUCT:
14461 
          self.ex = TransactionServiceException()
14462 
          self.ex.read(iprot)
14463 
        else:
14464 
          iprot.skip(ftype)
14465 
      else:
14466 
        iprot.skip(ftype)
14467 
      iprot.readFieldEnd()
14468 
    iprot.readStructEnd()
14469 
 
14470 
  def write(self, oprot):
14471 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14472 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14473 
      return
14474 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
14475 
    if self.success is not None:
14476 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14477 
      oprot.writeBool(self.success)
14478 
      oprot.writeFieldEnd()
14479 
    if self.ex is not None:
14480 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14481 
      self.ex.write(oprot)
14482 
      oprot.writeFieldEnd()
14483 
    oprot.writeFieldStop()
14484 
    oprot.writeStructEnd()
14485 
 
14486 
  def validate(self):
14487 
    return
14488 
 
14489 
 
14490 
  def __repr__(self):
14491 
    L = ['%s=%r' % (key, value)
14492 
      for key, value in self.__dict__.iteritems()]
14493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14494 
 
14495 
  def __eq__(self, other):
14496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14497 
 
14498 
  def __ne__(self, other):
14499 
    return not (self == other)
14500 
 
4910 phani.kuma 14501 
class markOrdersAsPickedUp_args:
4410 rajveer 14502 
  """
14503 
  Attributes:
14504 
   - providerId
4910 phani.kuma 14505 
   - pickupDetails
4410 rajveer 14506 
  """
14507 
 
14508 
  thrift_spec = (
14509 
    None, # 0
4910 phani.kuma 14510 
    (1, TType.I64, 'providerId', None, None, ), # 1
14511 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 14512 
  )
14513 
 
4910 phani.kuma 14514 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 14515 
    self.providerId = providerId
4910 phani.kuma 14516 
    self.pickupDetails = pickupDetails
4410 rajveer 14517 
 
14518 
  def read(self, iprot):
14519 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14520 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14521 
      return
14522 
    iprot.readStructBegin()
14523 
    while True:
14524 
      (fname, ftype, fid) = iprot.readFieldBegin()
14525 
      if ftype == TType.STOP:
14526 
        break
14527 
      if fid == 1:
14528 
        if ftype == TType.I64:
4910 phani.kuma 14529 
          self.providerId = iprot.readI64();
4410 rajveer 14530 
        else:
14531 
          iprot.skip(ftype)
14532 
      elif fid == 2:
4910 phani.kuma 14533 
        if ftype == TType.MAP:
14534 
          self.pickupDetails = {}
6188 rajveer 14535 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
14536 
          for _i306 in xrange(_size302):
14537 
            _key307 = iprot.readString();
14538 
            _val308 = iprot.readString();
14539 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 14540 
          iprot.readMapEnd()
4410 rajveer 14541 
        else:
14542 
          iprot.skip(ftype)
14543 
      else:
14544 
        iprot.skip(ftype)
14545 
      iprot.readFieldEnd()
14546 
    iprot.readStructEnd()
14547 
 
14548 
  def write(self, oprot):
14549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14551 
      return
4910 phani.kuma 14552 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 14553 
    if self.providerId is not None:
4910 phani.kuma 14554 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 14555 
      oprot.writeI64(self.providerId)
14556 
      oprot.writeFieldEnd()
4910 phani.kuma 14557 
    if self.pickupDetails is not None:
14558 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14559 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 14560 
      for kiter309,viter310 in self.pickupDetails.items():
14561 
        oprot.writeString(kiter309)
14562 
        oprot.writeString(viter310)
4910 phani.kuma 14563 
      oprot.writeMapEnd()
4410 rajveer 14564 
      oprot.writeFieldEnd()
14565 
    oprot.writeFieldStop()
14566 
    oprot.writeStructEnd()
14567 
 
14568 
  def validate(self):
14569 
    return
14570 
 
14571 
 
14572 
  def __repr__(self):
14573 
    L = ['%s=%r' % (key, value)
14574 
      for key, value in self.__dict__.iteritems()]
14575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14576 
 
14577 
  def __eq__(self, other):
14578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14579 
 
14580 
  def __ne__(self, other):
14581 
    return not (self == other)
14582 
 
4910 phani.kuma 14583 
class markOrdersAsPickedUp_result:
4410 rajveer 14584 
  """
14585 
  Attributes:
14586 
   - ex
14587 
  """
14588 
 
14589 
  thrift_spec = (
4910 phani.kuma 14590 
    None, # 0
4410 rajveer 14591 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14592 
  )
14593 
 
4910 phani.kuma 14594 
  def __init__(self, ex=None,):
4410 rajveer 14595 
    self.ex = ex
14596 
 
14597 
  def read(self, iprot):
14598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14600 
      return
14601 
    iprot.readStructBegin()
14602 
    while True:
14603 
      (fname, ftype, fid) = iprot.readFieldBegin()
14604 
      if ftype == TType.STOP:
14605 
        break
4910 phani.kuma 14606 
      if fid == 1:
4410 rajveer 14607 
        if ftype == TType.STRUCT:
14608 
          self.ex = TransactionServiceException()
14609 
          self.ex.read(iprot)
14610 
        else:
14611 
          iprot.skip(ftype)
14612 
      else:
14613 
        iprot.skip(ftype)
14614 
      iprot.readFieldEnd()
14615 
    iprot.readStructEnd()
14616 
 
14617 
  def write(self, oprot):
14618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14620 
      return
4910 phani.kuma 14621 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 14622 
    if self.ex is not None:
14623 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14624 
      self.ex.write(oprot)
14625 
      oprot.writeFieldEnd()
14626 
    oprot.writeFieldStop()
14627 
    oprot.writeStructEnd()
14628 
 
14629 
  def validate(self):
14630 
    return
14631 
 
14632 
 
14633 
  def __repr__(self):
14634 
    L = ['%s=%r' % (key, value)
14635 
      for key, value in self.__dict__.iteritems()]
14636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14637 
 
14638 
  def __eq__(self, other):
14639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14640 
 
14641 
  def __ne__(self, other):
14642 
    return not (self == other)
14643 
 
4910 phani.kuma 14644 
class getOrdersNotPickedUp_args:
304 ashish 14645 
  """
14646 
  Attributes:
3064 chandransh 14647 
   - providerId
304 ashish 14648 
  """
94 ashish 14649 
 
304 ashish 14650 
  thrift_spec = (
14651 
    None, # 0
3064 chandransh 14652 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 14653 
  )
14654 
 
4910 phani.kuma 14655 
  def __init__(self, providerId=None,):
3064 chandransh 14656 
    self.providerId = providerId
304 ashish 14657 
 
14658 
  def read(self, iprot):
14659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14661 
      return
14662 
    iprot.readStructBegin()
14663 
    while True:
14664 
      (fname, ftype, fid) = iprot.readFieldBegin()
14665 
      if ftype == TType.STOP:
14666 
        break
14667 
      if fid == 1:
14668 
        if ftype == TType.I64:
3064 chandransh 14669 
          self.providerId = iprot.readI64();
304 ashish 14670 
        else:
14671 
          iprot.skip(ftype)
14672 
      else:
14673 
        iprot.skip(ftype)
14674 
      iprot.readFieldEnd()
14675 
    iprot.readStructEnd()
14676 
 
14677 
  def write(self, oprot):
14678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14680 
      return
4910 phani.kuma 14681 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14682 
    if self.providerId is not None:
3064 chandransh 14683 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14684 
      oprot.writeI64(self.providerId)
304 ashish 14685 
      oprot.writeFieldEnd()
14686 
    oprot.writeFieldStop()
14687 
    oprot.writeStructEnd()
14688 
 
3431 rajveer 14689 
  def validate(self):
14690 
    return
14691 
 
14692 
 
304 ashish 14693 
  def __repr__(self):
14694 
    L = ['%s=%r' % (key, value)
14695 
      for key, value in self.__dict__.iteritems()]
14696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14697 
 
14698 
  def __eq__(self, other):
14699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14700 
 
14701 
  def __ne__(self, other):
14702 
    return not (self == other)
14703 
 
4910 phani.kuma 14704 
class getOrdersNotPickedUp_result:
304 ashish 14705 
  """
14706 
  Attributes:
14707 
   - success
14708 
  """
14709 
 
14710 
  thrift_spec = (
3064 chandransh 14711 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 14712 
  )
14713 
 
4910 phani.kuma 14714 
  def __init__(self, success=None,):
304 ashish 14715 
    self.success = success
14716 
 
14717 
  def read(self, iprot):
14718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14720 
      return
14721 
    iprot.readStructBegin()
14722 
    while True:
14723 
      (fname, ftype, fid) = iprot.readFieldBegin()
14724 
      if ftype == TType.STOP:
14725 
        break
14726 
      if fid == 0:
14727 
        if ftype == TType.LIST:
14728 
          self.success = []
6188 rajveer 14729 
          (_etype314, _size311) = iprot.readListBegin()
14730 
          for _i315 in xrange(_size311):
14731 
            _elem316 = Order()
14732 
            _elem316.read(iprot)
14733 
            self.success.append(_elem316)
304 ashish 14734 
          iprot.readListEnd()
14735 
        else:
14736 
          iprot.skip(ftype)
14737 
      else:
14738 
        iprot.skip(ftype)
14739 
      iprot.readFieldEnd()
14740 
    iprot.readStructEnd()
14741 
 
14742 
  def write(self, oprot):
14743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14745 
      return
4910 phani.kuma 14746 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 14747 
    if self.success is not None:
304 ashish 14748 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14749 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14750 
      for iter317 in self.success:
14751 
        iter317.write(oprot)
304 ashish 14752 
      oprot.writeListEnd()
14753 
      oprot.writeFieldEnd()
14754 
    oprot.writeFieldStop()
14755 
    oprot.writeStructEnd()
14756 
 
3431 rajveer 14757 
  def validate(self):
14758 
    return
14759 
 
14760 
 
304 ashish 14761 
  def __repr__(self):
14762 
    L = ['%s=%r' % (key, value)
14763 
      for key, value in self.__dict__.iteritems()]
14764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14765 
 
14766 
  def __eq__(self, other):
14767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14768 
 
14769 
  def __ne__(self, other):
14770 
    return not (self == other)
14771 
 
3064 chandransh 14772 
class markOrdersAsDelivered_args:
304 ashish 14773 
  """
14774 
  Attributes:
3064 chandransh 14775 
   - providerId
14776 
   - deliveredOrders
304 ashish 14777 
  """
14778 
 
14779 
  thrift_spec = (
14780 
    None, # 0
3064 chandransh 14781 
    (1, TType.I64, 'providerId', None, None, ), # 1
14782 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 14783 
  )
14784 
 
3064 chandransh 14785 
  def __init__(self, providerId=None, deliveredOrders=None,):
14786 
    self.providerId = providerId
14787 
    self.deliveredOrders = deliveredOrders
304 ashish 14788 
 
14789 
  def read(self, iprot):
14790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14792 
      return
14793 
    iprot.readStructBegin()
14794 
    while True:
14795 
      (fname, ftype, fid) = iprot.readFieldBegin()
14796 
      if ftype == TType.STOP:
14797 
        break
14798 
      if fid == 1:
14799 
        if ftype == TType.I64:
3064 chandransh 14800 
          self.providerId = iprot.readI64();
304 ashish 14801 
        else:
14802 
          iprot.skip(ftype)
14803 
      elif fid == 2:
3064 chandransh 14804 
        if ftype == TType.MAP:
14805 
          self.deliveredOrders = {}
6188 rajveer 14806 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
14807 
          for _i322 in xrange(_size318):
14808 
            _key323 = iprot.readString();
14809 
            _val324 = iprot.readString();
14810 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 14811 
          iprot.readMapEnd()
304 ashish 14812 
        else:
14813 
          iprot.skip(ftype)
14814 
      else:
14815 
        iprot.skip(ftype)
14816 
      iprot.readFieldEnd()
14817 
    iprot.readStructEnd()
14818 
 
14819 
  def write(self, oprot):
14820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14822 
      return
3064 chandransh 14823 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14824 
    if self.providerId is not None:
3064 chandransh 14825 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14826 
      oprot.writeI64(self.providerId)
304 ashish 14827 
      oprot.writeFieldEnd()
3431 rajveer 14828 
    if self.deliveredOrders is not None:
3064 chandransh 14829 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14830 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 14831 
      for kiter325,viter326 in self.deliveredOrders.items():
14832 
        oprot.writeString(kiter325)
14833 
        oprot.writeString(viter326)
3064 chandransh 14834 
      oprot.writeMapEnd()
304 ashish 14835 
      oprot.writeFieldEnd()
14836 
    oprot.writeFieldStop()
14837 
    oprot.writeStructEnd()
14838 
 
3431 rajveer 14839 
  def validate(self):
14840 
    return
14841 
 
14842 
 
304 ashish 14843 
  def __repr__(self):
14844 
    L = ['%s=%r' % (key, value)
14845 
      for key, value in self.__dict__.iteritems()]
14846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14847 
 
14848 
  def __eq__(self, other):
14849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14850 
 
14851 
  def __ne__(self, other):
14852 
    return not (self == other)
14853 
 
3064 chandransh 14854 
class markOrdersAsDelivered_result:
14855 
  """
14856 
  Attributes:
14857 
   - ex
14858 
  """
304 ashish 14859 
 
14860 
  thrift_spec = (
3064 chandransh 14861 
    None, # 0
14862 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 14863 
  )
14864 
 
3064 chandransh 14865 
  def __init__(self, ex=None,):
14866 
    self.ex = ex
304 ashish 14867 
 
1596 ankur.sing 14868 
  def read(self, iprot):
14869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14871 
      return
14872 
    iprot.readStructBegin()
14873 
    while True:
14874 
      (fname, ftype, fid) = iprot.readFieldBegin()
14875 
      if ftype == TType.STOP:
14876 
        break
3064 chandransh 14877 
      if fid == 1:
14878 
        if ftype == TType.STRUCT:
14879 
          self.ex = TransactionServiceException()
14880 
          self.ex.read(iprot)
14881 
        else:
14882 
          iprot.skip(ftype)
1596 ankur.sing 14883 
      else:
14884 
        iprot.skip(ftype)
14885 
      iprot.readFieldEnd()
14886 
    iprot.readStructEnd()
14887 
 
14888 
  def write(self, oprot):
14889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14891 
      return
3064 chandransh 14892 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 14893 
    if self.ex is not None:
3064 chandransh 14894 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14895 
      self.ex.write(oprot)
14896 
      oprot.writeFieldEnd()
1596 ankur.sing 14897 
    oprot.writeFieldStop()
14898 
    oprot.writeStructEnd()
14899 
 
3431 rajveer 14900 
  def validate(self):
14901 
    return
14902 
 
14903 
 
1596 ankur.sing 14904 
  def __repr__(self):
14905 
    L = ['%s=%r' % (key, value)
14906 
      for key, value in self.__dict__.iteritems()]
14907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14908 
 
14909 
  def __eq__(self, other):
14910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14911 
 
14912 
  def __ne__(self, other):
14913 
    return not (self == other)
14914 
 
4910 phani.kuma 14915 
class markAsRTOrders_args:
1596 ankur.sing 14916 
  """
14917 
  Attributes:
3064 chandransh 14918 
   - providerId
14919 
   - returnedOrders
1596 ankur.sing 14920 
  """
14921 
 
14922 
  thrift_spec = (
3064 chandransh 14923 
    None, # 0
14924 
    (1, TType.I64, 'providerId', None, None, ), # 1
14925 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 14926 
  )
14927 
 
3064 chandransh 14928 
  def __init__(self, providerId=None, returnedOrders=None,):
14929 
    self.providerId = providerId
14930 
    self.returnedOrders = returnedOrders
1596 ankur.sing 14931 
 
14932 
  def read(self, iprot):
14933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14935 
      return
14936 
    iprot.readStructBegin()
14937 
    while True:
14938 
      (fname, ftype, fid) = iprot.readFieldBegin()
14939 
      if ftype == TType.STOP:
14940 
        break
3064 chandransh 14941 
      if fid == 1:
1596 ankur.sing 14942 
        if ftype == TType.I64:
3064 chandransh 14943 
          self.providerId = iprot.readI64();
1596 ankur.sing 14944 
        else:
14945 
          iprot.skip(ftype)
3064 chandransh 14946 
      elif fid == 2:
14947 
        if ftype == TType.MAP:
14948 
          self.returnedOrders = {}
6188 rajveer 14949 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
14950 
          for _i331 in xrange(_size327):
14951 
            _key332 = iprot.readString();
14952 
            _val333 = iprot.readString();
14953 
            self.returnedOrders[_key332] = _val333
3064 chandransh 14954 
          iprot.readMapEnd()
14955 
        else:
14956 
          iprot.skip(ftype)
1596 ankur.sing 14957 
      else:
14958 
        iprot.skip(ftype)
14959 
      iprot.readFieldEnd()
14960 
    iprot.readStructEnd()
14961 
 
14962 
  def write(self, oprot):
14963 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14964 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14965 
      return
4910 phani.kuma 14966 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 14967 
    if self.providerId is not None:
3064 chandransh 14968 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14969 
      oprot.writeI64(self.providerId)
1596 ankur.sing 14970 
      oprot.writeFieldEnd()
3431 rajveer 14971 
    if self.returnedOrders is not None:
3064 chandransh 14972 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
14973 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 14974 
      for kiter334,viter335 in self.returnedOrders.items():
14975 
        oprot.writeString(kiter334)
14976 
        oprot.writeString(viter335)
3064 chandransh 14977 
      oprot.writeMapEnd()
14978 
      oprot.writeFieldEnd()
1596 ankur.sing 14979 
    oprot.writeFieldStop()
14980 
    oprot.writeStructEnd()
14981 
 
3431 rajveer 14982 
  def validate(self):
14983 
    return
14984 
 
14985 
 
1596 ankur.sing 14986 
  def __repr__(self):
14987 
    L = ['%s=%r' % (key, value)
14988 
      for key, value in self.__dict__.iteritems()]
14989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14990 
 
14991 
  def __eq__(self, other):
14992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14993 
 
14994 
  def __ne__(self, other):
14995 
    return not (self == other)
14996 
 
4910 phani.kuma 14997 
class markAsRTOrders_result:
3064 chandransh 14998 
  """
14999 
  Attributes:
15000 
   - ex
15001 
  """
1596 ankur.sing 15002 
 
1627 ankur.sing 15003 
  thrift_spec = (
3064 chandransh 15004 
    None, # 0
15005 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15006 
  )
15007 
 
3064 chandransh 15008 
  def __init__(self, ex=None,):
15009 
    self.ex = ex
15010 
 
1627 ankur.sing 15011 
  def read(self, iprot):
15012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15014 
      return
15015 
    iprot.readStructBegin()
15016 
    while True:
15017 
      (fname, ftype, fid) = iprot.readFieldBegin()
15018 
      if ftype == TType.STOP:
15019 
        break
3064 chandransh 15020 
      if fid == 1:
15021 
        if ftype == TType.STRUCT:
15022 
          self.ex = TransactionServiceException()
15023 
          self.ex.read(iprot)
15024 
        else:
15025 
          iprot.skip(ftype)
1627 ankur.sing 15026 
      else:
15027 
        iprot.skip(ftype)
15028 
      iprot.readFieldEnd()
15029 
    iprot.readStructEnd()
15030 
 
15031 
  def write(self, oprot):
15032 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15033 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15034 
      return
4910 phani.kuma 15035 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 15036 
    if self.ex is not None:
3064 chandransh 15037 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15038 
      self.ex.write(oprot)
15039 
      oprot.writeFieldEnd()
1627 ankur.sing 15040 
    oprot.writeFieldStop()
15041 
    oprot.writeStructEnd()
15042 
 
3431 rajveer 15043 
  def validate(self):
15044 
    return
15045 
 
15046 
 
1627 ankur.sing 15047 
  def __repr__(self):
15048 
    L = ['%s=%r' % (key, value)
15049 
      for key, value in self.__dict__.iteritems()]
15050 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15051 
 
15052 
  def __eq__(self, other):
15053 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15054 
 
15055 
  def __ne__(self, other):
15056 
    return not (self == other)
15057 
 
4910 phani.kuma 15058 
class getRTOrders_args:
15059 
  """
15060 
  Attributes:
15061 
   - providerId
15062 
  """
15063 
 
15064 
  thrift_spec = (
15065 
    None, # 0
15066 
    (1, TType.I64, 'providerId', None, None, ), # 1
15067 
  )
15068 
 
15069 
  def __init__(self, providerId=None,):
15070 
    self.providerId = providerId
15071 
 
15072 
  def read(self, iprot):
15073 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15074 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15075 
      return
15076 
    iprot.readStructBegin()
15077 
    while True:
15078 
      (fname, ftype, fid) = iprot.readFieldBegin()
15079 
      if ftype == TType.STOP:
15080 
        break
15081 
      if fid == 1:
15082 
        if ftype == TType.I64:
15083 
          self.providerId = iprot.readI64();
15084 
        else:
15085 
          iprot.skip(ftype)
15086 
      else:
15087 
        iprot.skip(ftype)
15088 
      iprot.readFieldEnd()
15089 
    iprot.readStructEnd()
15090 
 
15091 
  def write(self, oprot):
15092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15094 
      return
15095 
    oprot.writeStructBegin('getRTOrders_args')
15096 
    if self.providerId is not None:
15097 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15098 
      oprot.writeI64(self.providerId)
15099 
      oprot.writeFieldEnd()
15100 
    oprot.writeFieldStop()
15101 
    oprot.writeStructEnd()
15102 
 
15103 
  def validate(self):
15104 
    return
15105 
 
15106 
 
15107 
  def __repr__(self):
15108 
    L = ['%s=%r' % (key, value)
15109 
      for key, value in self.__dict__.iteritems()]
15110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15111 
 
15112 
  def __eq__(self, other):
15113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15114 
 
15115 
  def __ne__(self, other):
15116 
    return not (self == other)
15117 
 
15118 
class getRTOrders_result:
15119 
  """
15120 
  Attributes:
15121 
   - success
15122 
  """
15123 
 
15124 
  thrift_spec = (
15125 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15126 
  )
15127 
 
15128 
  def __init__(self, success=None,):
15129 
    self.success = success
15130 
 
15131 
  def read(self, iprot):
15132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15134 
      return
15135 
    iprot.readStructBegin()
15136 
    while True:
15137 
      (fname, ftype, fid) = iprot.readFieldBegin()
15138 
      if ftype == TType.STOP:
15139 
        break
15140 
      if fid == 0:
15141 
        if ftype == TType.LIST:
15142 
          self.success = []
6188 rajveer 15143 
          (_etype339, _size336) = iprot.readListBegin()
15144 
          for _i340 in xrange(_size336):
15145 
            _elem341 = Order()
15146 
            _elem341.read(iprot)
15147 
            self.success.append(_elem341)
4910 phani.kuma 15148 
          iprot.readListEnd()
15149 
        else:
15150 
          iprot.skip(ftype)
15151 
      else:
15152 
        iprot.skip(ftype)
15153 
      iprot.readFieldEnd()
15154 
    iprot.readStructEnd()
15155 
 
15156 
  def write(self, oprot):
15157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15159 
      return
15160 
    oprot.writeStructBegin('getRTOrders_result')
15161 
    if self.success is not None:
15162 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15163 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15164 
      for iter342 in self.success:
15165 
        iter342.write(oprot)
4910 phani.kuma 15166 
      oprot.writeListEnd()
15167 
      oprot.writeFieldEnd()
15168 
    oprot.writeFieldStop()
15169 
    oprot.writeStructEnd()
15170 
 
15171 
  def validate(self):
15172 
    return
15173 
 
15174 
 
15175 
  def __repr__(self):
15176 
    L = ['%s=%r' % (key, value)
15177 
      for key, value in self.__dict__.iteritems()]
15178 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15179 
 
15180 
  def __eq__(self, other):
15181 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15182 
 
15183 
  def __ne__(self, other):
15184 
    return not (self == other)
15185 
 
3064 chandransh 15186 
class updateNonDeliveryReason_args:
1627 ankur.sing 15187 
  """
15188 
  Attributes:
3064 chandransh 15189 
   - providerId
15190 
   - undeliveredOrders
1627 ankur.sing 15191 
  """
15192 
 
15193 
  thrift_spec = (
3064 chandransh 15194 
    None, # 0
15195 
    (1, TType.I64, 'providerId', None, None, ), # 1
15196 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 15197 
  )
15198 
 
3064 chandransh 15199 
  def __init__(self, providerId=None, undeliveredOrders=None,):
15200 
    self.providerId = providerId
15201 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 15202 
 
15203 
  def read(self, iprot):
15204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15206 
      return
15207 
    iprot.readStructBegin()
15208 
    while True:
15209 
      (fname, ftype, fid) = iprot.readFieldBegin()
15210 
      if ftype == TType.STOP:
15211 
        break
3064 chandransh 15212 
      if fid == 1:
1627 ankur.sing 15213 
        if ftype == TType.I64:
3064 chandransh 15214 
          self.providerId = iprot.readI64();
1627 ankur.sing 15215 
        else:
15216 
          iprot.skip(ftype)
3064 chandransh 15217 
      elif fid == 2:
15218 
        if ftype == TType.MAP:
15219 
          self.undeliveredOrders = {}
6188 rajveer 15220 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
15221 
          for _i347 in xrange(_size343):
15222 
            _key348 = iprot.readString();
15223 
            _val349 = iprot.readString();
15224 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 15225 
          iprot.readMapEnd()
15226 
        else:
15227 
          iprot.skip(ftype)
1627 ankur.sing 15228 
      else:
15229 
        iprot.skip(ftype)
15230 
      iprot.readFieldEnd()
15231 
    iprot.readStructEnd()
15232 
 
15233 
  def write(self, oprot):
15234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15236 
      return
3064 chandransh 15237 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 15238 
    if self.providerId is not None:
3064 chandransh 15239 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15240 
      oprot.writeI64(self.providerId)
1627 ankur.sing 15241 
      oprot.writeFieldEnd()
3431 rajveer 15242 
    if self.undeliveredOrders is not None:
3064 chandransh 15243 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
15244 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 15245 
      for kiter350,viter351 in self.undeliveredOrders.items():
15246 
        oprot.writeString(kiter350)
15247 
        oprot.writeString(viter351)
3064 chandransh 15248 
      oprot.writeMapEnd()
15249 
      oprot.writeFieldEnd()
1627 ankur.sing 15250 
    oprot.writeFieldStop()
15251 
    oprot.writeStructEnd()
15252 
 
3431 rajveer 15253 
  def validate(self):
15254 
    return
15255 
 
15256 
 
1627 ankur.sing 15257 
  def __repr__(self):
15258 
    L = ['%s=%r' % (key, value)
15259 
      for key, value in self.__dict__.iteritems()]
15260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15261 
 
15262 
  def __eq__(self, other):
15263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15264 
 
15265 
  def __ne__(self, other):
15266 
    return not (self == other)
15267 
 
3064 chandransh 15268 
class updateNonDeliveryReason_result:
1627 ankur.sing 15269 
  """
15270 
  Attributes:
3064 chandransh 15271 
   - ex
1627 ankur.sing 15272 
  """
15273 
 
15274 
  thrift_spec = (
4910 phani.kuma 15275 
    None, # 0
3064 chandransh 15276 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15277 
  )
15278 
 
4910 phani.kuma 15279 
  def __init__(self, ex=None,):
3064 chandransh 15280 
    self.ex = ex
1627 ankur.sing 15281 
 
15282 
  def read(self, iprot):
15283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15285 
      return
15286 
    iprot.readStructBegin()
15287 
    while True:
15288 
      (fname, ftype, fid) = iprot.readFieldBegin()
15289 
      if ftype == TType.STOP:
15290 
        break
4910 phani.kuma 15291 
      if fid == 1:
15292 
        if ftype == TType.STRUCT:
15293 
          self.ex = TransactionServiceException()
15294 
          self.ex.read(iprot)
15295 
        else:
15296 
          iprot.skip(ftype)
15297 
      else:
15298 
        iprot.skip(ftype)
15299 
      iprot.readFieldEnd()
15300 
    iprot.readStructEnd()
15301 
 
15302 
  def write(self, oprot):
15303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15305 
      return
15306 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
15307 
    if self.ex is not None:
15308 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15309 
      self.ex.write(oprot)
15310 
      oprot.writeFieldEnd()
15311 
    oprot.writeFieldStop()
15312 
    oprot.writeStructEnd()
15313 
 
15314 
  def validate(self):
15315 
    return
15316 
 
15317 
 
15318 
  def __repr__(self):
15319 
    L = ['%s=%r' % (key, value)
15320 
      for key, value in self.__dict__.iteritems()]
15321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15322 
 
15323 
  def __eq__(self, other):
15324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15325 
 
15326 
  def __ne__(self, other):
15327 
    return not (self == other)
15328 
 
15329 
class getNonDeliveredOrdersbyCourier_args:
15330 
  """
15331 
  Attributes:
15332 
   - providerId
15333 
  """
15334 
 
15335 
  thrift_spec = (
15336 
    None, # 0
15337 
    (1, TType.I64, 'providerId', None, None, ), # 1
15338 
  )
15339 
 
15340 
  def __init__(self, providerId=None,):
15341 
    self.providerId = providerId
15342 
 
15343 
  def read(self, iprot):
15344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15346 
      return
15347 
    iprot.readStructBegin()
15348 
    while True:
15349 
      (fname, ftype, fid) = iprot.readFieldBegin()
15350 
      if ftype == TType.STOP:
15351 
        break
15352 
      if fid == 1:
15353 
        if ftype == TType.I64:
15354 
          self.providerId = iprot.readI64();
15355 
        else:
15356 
          iprot.skip(ftype)
15357 
      else:
15358 
        iprot.skip(ftype)
15359 
      iprot.readFieldEnd()
15360 
    iprot.readStructEnd()
15361 
 
15362 
  def write(self, oprot):
15363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15365 
      return
15366 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
15367 
    if self.providerId is not None:
15368 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15369 
      oprot.writeI64(self.providerId)
15370 
      oprot.writeFieldEnd()
15371 
    oprot.writeFieldStop()
15372 
    oprot.writeStructEnd()
15373 
 
15374 
  def validate(self):
15375 
    return
15376 
 
15377 
 
15378 
  def __repr__(self):
15379 
    L = ['%s=%r' % (key, value)
15380 
      for key, value in self.__dict__.iteritems()]
15381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15382 
 
15383 
  def __eq__(self, other):
15384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15385 
 
15386 
  def __ne__(self, other):
15387 
    return not (self == other)
15388 
 
15389 
class getNonDeliveredOrdersbyCourier_result:
15390 
  """
15391 
  Attributes:
15392 
   - success
15393 
  """
15394 
 
15395 
  thrift_spec = (
15396 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15397 
  )
15398 
 
15399 
  def __init__(self, success=None,):
15400 
    self.success = success
15401 
 
15402 
  def read(self, iprot):
15403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15405 
      return
15406 
    iprot.readStructBegin()
15407 
    while True:
15408 
      (fname, ftype, fid) = iprot.readFieldBegin()
15409 
      if ftype == TType.STOP:
15410 
        break
4581 phani.kuma 15411 
      if fid == 0:
15412 
        if ftype == TType.LIST:
15413 
          self.success = []
6188 rajveer 15414 
          (_etype355, _size352) = iprot.readListBegin()
15415 
          for _i356 in xrange(_size352):
15416 
            _elem357 = Order()
15417 
            _elem357.read(iprot)
15418 
            self.success.append(_elem357)
4581 phani.kuma 15419 
          iprot.readListEnd()
15420 
        else:
15421 
          iprot.skip(ftype)
4910 phani.kuma 15422 
      else:
15423 
        iprot.skip(ftype)
15424 
      iprot.readFieldEnd()
15425 
    iprot.readStructEnd()
15426 
 
15427 
  def write(self, oprot):
15428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15430 
      return
15431 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
15432 
    if self.success is not None:
15433 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15434 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15435 
      for iter358 in self.success:
15436 
        iter358.write(oprot)
4910 phani.kuma 15437 
      oprot.writeListEnd()
15438 
      oprot.writeFieldEnd()
15439 
    oprot.writeFieldStop()
15440 
    oprot.writeStructEnd()
15441 
 
15442 
  def validate(self):
15443 
    return
15444 
 
15445 
 
15446 
  def __repr__(self):
15447 
    L = ['%s=%r' % (key, value)
15448 
      for key, value in self.__dict__.iteritems()]
15449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15450 
 
15451 
  def __eq__(self, other):
15452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15453 
 
15454 
  def __ne__(self, other):
15455 
    return not (self == other)
15456 
 
15457 
class markOrdersAsLocalConnected_args:
15458 
  """
15459 
  Attributes:
15460 
   - providerId
15461 
   - local_connected_orders
15462 
  """
15463 
 
15464 
  thrift_spec = (
15465 
    None, # 0
15466 
    (1, TType.I64, 'providerId', None, None, ), # 1
15467 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15468 
  )
15469 
 
15470 
  def __init__(self, providerId=None, local_connected_orders=None,):
15471 
    self.providerId = providerId
15472 
    self.local_connected_orders = local_connected_orders
15473 
 
15474 
  def read(self, iprot):
15475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15477 
      return
15478 
    iprot.readStructBegin()
15479 
    while True:
15480 
      (fname, ftype, fid) = iprot.readFieldBegin()
15481 
      if ftype == TType.STOP:
15482 
        break
15483 
      if fid == 1:
15484 
        if ftype == TType.I64:
15485 
          self.providerId = iprot.readI64();
15486 
        else:
15487 
          iprot.skip(ftype)
15488 
      elif fid == 2:
15489 
        if ftype == TType.MAP:
15490 
          self.local_connected_orders = {}
6188 rajveer 15491 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
15492 
          for _i363 in xrange(_size359):
15493 
            _key364 = iprot.readString();
15494 
            _val365 = iprot.readString();
15495 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 15496 
          iprot.readMapEnd()
15497 
        else:
15498 
          iprot.skip(ftype)
15499 
      else:
15500 
        iprot.skip(ftype)
15501 
      iprot.readFieldEnd()
15502 
    iprot.readStructEnd()
15503 
 
15504 
  def write(self, oprot):
15505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15507 
      return
15508 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
15509 
    if self.providerId is not None:
15510 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15511 
      oprot.writeI64(self.providerId)
15512 
      oprot.writeFieldEnd()
15513 
    if self.local_connected_orders is not None:
15514 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
15515 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 15516 
      for kiter366,viter367 in self.local_connected_orders.items():
15517 
        oprot.writeString(kiter366)
15518 
        oprot.writeString(viter367)
4910 phani.kuma 15519 
      oprot.writeMapEnd()
15520 
      oprot.writeFieldEnd()
15521 
    oprot.writeFieldStop()
15522 
    oprot.writeStructEnd()
15523 
 
15524 
  def validate(self):
15525 
    return
15526 
 
15527 
 
15528 
  def __repr__(self):
15529 
    L = ['%s=%r' % (key, value)
15530 
      for key, value in self.__dict__.iteritems()]
15531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15532 
 
15533 
  def __eq__(self, other):
15534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15535 
 
15536 
  def __ne__(self, other):
15537 
    return not (self == other)
15538 
 
15539 
class markOrdersAsLocalConnected_result:
15540 
  """
15541 
  Attributes:
15542 
   - ex
15543 
  """
15544 
 
15545 
  thrift_spec = (
15546 
    None, # 0
15547 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15548 
  )
15549 
 
15550 
  def __init__(self, ex=None,):
15551 
    self.ex = ex
15552 
 
15553 
  def read(self, iprot):
15554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15556 
      return
15557 
    iprot.readStructBegin()
15558 
    while True:
15559 
      (fname, ftype, fid) = iprot.readFieldBegin()
15560 
      if ftype == TType.STOP:
15561 
        break
15562 
      if fid == 1:
3064 chandransh 15563 
        if ftype == TType.STRUCT:
15564 
          self.ex = TransactionServiceException()
15565 
          self.ex.read(iprot)
1627 ankur.sing 15566 
        else:
15567 
          iprot.skip(ftype)
15568 
      else:
15569 
        iprot.skip(ftype)
15570 
      iprot.readFieldEnd()
15571 
    iprot.readStructEnd()
15572 
 
15573 
  def write(self, oprot):
15574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15576 
      return
4910 phani.kuma 15577 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
15578 
    if self.ex is not None:
15579 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15580 
      self.ex.write(oprot)
15581 
      oprot.writeFieldEnd()
15582 
    oprot.writeFieldStop()
15583 
    oprot.writeStructEnd()
15584 
 
15585 
  def validate(self):
15586 
    return
15587 
 
15588 
 
15589 
  def __repr__(self):
15590 
    L = ['%s=%r' % (key, value)
15591 
      for key, value in self.__dict__.iteritems()]
15592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15593 
 
15594 
  def __eq__(self, other):
15595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15596 
 
15597 
  def __ne__(self, other):
15598 
    return not (self == other)
15599 
 
15600 
class getOrdersNotLocalConnected_args:
15601 
  """
15602 
  Attributes:
15603 
   - providerId
15604 
  """
15605 
 
15606 
  thrift_spec = (
15607 
    None, # 0
15608 
    (1, TType.I64, 'providerId', None, None, ), # 1
15609 
  )
15610 
 
15611 
  def __init__(self, providerId=None,):
15612 
    self.providerId = providerId
15613 
 
15614 
  def read(self, iprot):
15615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15617 
      return
15618 
    iprot.readStructBegin()
15619 
    while True:
15620 
      (fname, ftype, fid) = iprot.readFieldBegin()
15621 
      if ftype == TType.STOP:
15622 
        break
15623 
      if fid == 1:
15624 
        if ftype == TType.I64:
15625 
          self.providerId = iprot.readI64();
15626 
        else:
15627 
          iprot.skip(ftype)
15628 
      else:
15629 
        iprot.skip(ftype)
15630 
      iprot.readFieldEnd()
15631 
    iprot.readStructEnd()
15632 
 
15633 
  def write(self, oprot):
15634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15636 
      return
15637 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
15638 
    if self.providerId is not None:
15639 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15640 
      oprot.writeI64(self.providerId)
15641 
      oprot.writeFieldEnd()
15642 
    oprot.writeFieldStop()
15643 
    oprot.writeStructEnd()
15644 
 
15645 
  def validate(self):
15646 
    return
15647 
 
15648 
 
15649 
  def __repr__(self):
15650 
    L = ['%s=%r' % (key, value)
15651 
      for key, value in self.__dict__.iteritems()]
15652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15653 
 
15654 
  def __eq__(self, other):
15655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15656 
 
15657 
  def __ne__(self, other):
15658 
    return not (self == other)
15659 
 
15660 
class getOrdersNotLocalConnected_result:
15661 
  """
15662 
  Attributes:
15663 
   - success
15664 
  """
15665 
 
15666 
  thrift_spec = (
15667 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15668 
  )
15669 
 
15670 
  def __init__(self, success=None,):
15671 
    self.success = success
15672 
 
15673 
  def read(self, iprot):
15674 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15675 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15676 
      return
15677 
    iprot.readStructBegin()
15678 
    while True:
15679 
      (fname, ftype, fid) = iprot.readFieldBegin()
15680 
      if ftype == TType.STOP:
15681 
        break
15682 
      if fid == 0:
15683 
        if ftype == TType.LIST:
15684 
          self.success = []
6188 rajveer 15685 
          (_etype371, _size368) = iprot.readListBegin()
15686 
          for _i372 in xrange(_size368):
15687 
            _elem373 = Order()
15688 
            _elem373.read(iprot)
15689 
            self.success.append(_elem373)
4910 phani.kuma 15690 
          iprot.readListEnd()
15691 
        else:
15692 
          iprot.skip(ftype)
15693 
      else:
15694 
        iprot.skip(ftype)
15695 
      iprot.readFieldEnd()
15696 
    iprot.readStructEnd()
15697 
 
15698 
  def write(self, oprot):
15699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15701 
      return
15702 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 15703 
    if self.success is not None:
15704 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15705 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15706 
      for iter374 in self.success:
15707 
        iter374.write(oprot)
4581 phani.kuma 15708 
      oprot.writeListEnd()
15709 
      oprot.writeFieldEnd()
4910 phani.kuma 15710 
    oprot.writeFieldStop()
15711 
    oprot.writeStructEnd()
15712 
 
15713 
  def validate(self):
15714 
    return
15715 
 
15716 
 
15717 
  def __repr__(self):
15718 
    L = ['%s=%r' % (key, value)
15719 
      for key, value in self.__dict__.iteritems()]
15720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15721 
 
15722 
  def __eq__(self, other):
15723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15724 
 
15725 
  def __ne__(self, other):
15726 
    return not (self == other)
15727 
 
15728 
class markOrdersAsDestinationCityReached_args:
15729 
  """
15730 
  Attributes:
15731 
   - providerId
15732 
   - destination_city_reached_orders
15733 
  """
15734 
 
15735 
  thrift_spec = (
15736 
    None, # 0
15737 
    (1, TType.I64, 'providerId', None, None, ), # 1
15738 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15739 
  )
15740 
 
15741 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
15742 
    self.providerId = providerId
15743 
    self.destination_city_reached_orders = destination_city_reached_orders
15744 
 
15745 
  def read(self, iprot):
15746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15748 
      return
15749 
    iprot.readStructBegin()
15750 
    while True:
15751 
      (fname, ftype, fid) = iprot.readFieldBegin()
15752 
      if ftype == TType.STOP:
15753 
        break
15754 
      if fid == 1:
15755 
        if ftype == TType.I64:
15756 
          self.providerId = iprot.readI64();
15757 
        else:
15758 
          iprot.skip(ftype)
15759 
      elif fid == 2:
15760 
        if ftype == TType.MAP:
15761 
          self.destination_city_reached_orders = {}
6188 rajveer 15762 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
15763 
          for _i379 in xrange(_size375):
15764 
            _key380 = iprot.readString();
15765 
            _val381 = iprot.readString();
15766 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 15767 
          iprot.readMapEnd()
15768 
        else:
15769 
          iprot.skip(ftype)
15770 
      else:
15771 
        iprot.skip(ftype)
15772 
      iprot.readFieldEnd()
15773 
    iprot.readStructEnd()
15774 
 
15775 
  def write(self, oprot):
15776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15778 
      return
15779 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
15780 
    if self.providerId is not None:
15781 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15782 
      oprot.writeI64(self.providerId)
15783 
      oprot.writeFieldEnd()
15784 
    if self.destination_city_reached_orders is not None:
15785 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
15786 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 15787 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
15788 
        oprot.writeString(kiter382)
15789 
        oprot.writeString(viter383)
4910 phani.kuma 15790 
      oprot.writeMapEnd()
15791 
      oprot.writeFieldEnd()
15792 
    oprot.writeFieldStop()
15793 
    oprot.writeStructEnd()
15794 
 
15795 
  def validate(self):
15796 
    return
15797 
 
15798 
 
15799 
  def __repr__(self):
15800 
    L = ['%s=%r' % (key, value)
15801 
      for key, value in self.__dict__.iteritems()]
15802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15803 
 
15804 
  def __eq__(self, other):
15805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15806 
 
15807 
  def __ne__(self, other):
15808 
    return not (self == other)
15809 
 
15810 
class markOrdersAsDestinationCityReached_result:
15811 
  """
15812 
  Attributes:
15813 
   - ex
15814 
  """
15815 
 
15816 
  thrift_spec = (
15817 
    None, # 0
15818 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15819 
  )
15820 
 
15821 
  def __init__(self, ex=None,):
15822 
    self.ex = ex
15823 
 
15824 
  def read(self, iprot):
15825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15827 
      return
15828 
    iprot.readStructBegin()
15829 
    while True:
15830 
      (fname, ftype, fid) = iprot.readFieldBegin()
15831 
      if ftype == TType.STOP:
15832 
        break
15833 
      if fid == 1:
15834 
        if ftype == TType.STRUCT:
15835 
          self.ex = TransactionServiceException()
15836 
          self.ex.read(iprot)
15837 
        else:
15838 
          iprot.skip(ftype)
15839 
      else:
15840 
        iprot.skip(ftype)
15841 
      iprot.readFieldEnd()
15842 
    iprot.readStructEnd()
15843 
 
15844 
  def write(self, oprot):
15845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15847 
      return
15848 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15849 
    if self.ex is not None:
3064 chandransh 15850 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15851 
      self.ex.write(oprot)
1627 ankur.sing 15852 
      oprot.writeFieldEnd()
15853 
    oprot.writeFieldStop()
15854 
    oprot.writeStructEnd()
15855 
 
3431 rajveer 15856 
  def validate(self):
15857 
    return
15858 
 
15859 
 
1627 ankur.sing 15860 
  def __repr__(self):
15861 
    L = ['%s=%r' % (key, value)
15862 
      for key, value in self.__dict__.iteritems()]
15863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15864 
 
15865 
  def __eq__(self, other):
15866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15867 
 
15868 
  def __ne__(self, other):
15869 
    return not (self == other)
15870 
 
4910 phani.kuma 15871 
class markOrdersAsFirstDeliveryAttempted_args:
15872 
  """
15873 
  Attributes:
15874 
   - providerId
15875 
   - first_atdl_orders
15876 
  """
15877 
 
15878 
  thrift_spec = (
15879 
    None, # 0
15880 
    (1, TType.I64, 'providerId', None, None, ), # 1
15881 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15882 
  )
15883 
 
15884 
  def __init__(self, providerId=None, first_atdl_orders=None,):
15885 
    self.providerId = providerId
15886 
    self.first_atdl_orders = first_atdl_orders
15887 
 
15888 
  def read(self, iprot):
15889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15891 
      return
15892 
    iprot.readStructBegin()
15893 
    while True:
15894 
      (fname, ftype, fid) = iprot.readFieldBegin()
15895 
      if ftype == TType.STOP:
15896 
        break
15897 
      if fid == 1:
15898 
        if ftype == TType.I64:
15899 
          self.providerId = iprot.readI64();
15900 
        else:
15901 
          iprot.skip(ftype)
15902 
      elif fid == 2:
15903 
        if ftype == TType.MAP:
15904 
          self.first_atdl_orders = {}
6188 rajveer 15905 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
15906 
          for _i388 in xrange(_size384):
15907 
            _key389 = iprot.readString();
15908 
            _val390 = iprot.readString();
15909 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 15910 
          iprot.readMapEnd()
15911 
        else:
15912 
          iprot.skip(ftype)
15913 
      else:
15914 
        iprot.skip(ftype)
15915 
      iprot.readFieldEnd()
15916 
    iprot.readStructEnd()
15917 
 
15918 
  def write(self, oprot):
15919 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15920 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15921 
      return
15922 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
15923 
    if self.providerId is not None:
15924 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15925 
      oprot.writeI64(self.providerId)
15926 
      oprot.writeFieldEnd()
15927 
    if self.first_atdl_orders is not None:
15928 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
15929 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 15930 
      for kiter391,viter392 in self.first_atdl_orders.items():
15931 
        oprot.writeString(kiter391)
15932 
        oprot.writeString(viter392)
4910 phani.kuma 15933 
      oprot.writeMapEnd()
15934 
      oprot.writeFieldEnd()
15935 
    oprot.writeFieldStop()
15936 
    oprot.writeStructEnd()
15937 
 
15938 
  def validate(self):
15939 
    return
15940 
 
15941 
 
15942 
  def __repr__(self):
15943 
    L = ['%s=%r' % (key, value)
15944 
      for key, value in self.__dict__.iteritems()]
15945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15946 
 
15947 
  def __eq__(self, other):
15948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15949 
 
15950 
  def __ne__(self, other):
15951 
    return not (self == other)
15952 
 
15953 
class markOrdersAsFirstDeliveryAttempted_result:
15954 
  """
15955 
  Attributes:
15956 
   - ex
15957 
  """
15958 
 
15959 
  thrift_spec = (
15960 
    None, # 0
15961 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15962 
  )
15963 
 
15964 
  def __init__(self, ex=None,):
15965 
    self.ex = ex
15966 
 
15967 
  def read(self, iprot):
15968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15970 
      return
15971 
    iprot.readStructBegin()
15972 
    while True:
15973 
      (fname, ftype, fid) = iprot.readFieldBegin()
15974 
      if ftype == TType.STOP:
15975 
        break
15976 
      if fid == 1:
15977 
        if ftype == TType.STRUCT:
15978 
          self.ex = TransactionServiceException()
15979 
          self.ex.read(iprot)
15980 
        else:
15981 
          iprot.skip(ftype)
15982 
      else:
15983 
        iprot.skip(ftype)
15984 
      iprot.readFieldEnd()
15985 
    iprot.readStructEnd()
15986 
 
15987 
  def write(self, oprot):
15988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15990 
      return
15991 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
15992 
    if self.ex is not None:
15993 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15994 
      self.ex.write(oprot)
15995 
      oprot.writeFieldEnd()
15996 
    oprot.writeFieldStop()
15997 
    oprot.writeStructEnd()
15998 
 
15999 
  def validate(self):
16000 
    return
16001 
 
16002 
 
16003 
  def __repr__(self):
16004 
    L = ['%s=%r' % (key, value)
16005 
      for key, value in self.__dict__.iteritems()]
16006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16007 
 
16008 
  def __eq__(self, other):
16009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16010 
 
16011 
  def __ne__(self, other):
16012 
    return not (self == other)
16013 
 
3064 chandransh 16014 
class getUndeliveredOrders_args:
1886 ankur.sing 16015 
  """
16016 
  Attributes:
3064 chandransh 16017 
   - providerId
16018 
   - warehouseId
1886 ankur.sing 16019 
  """
1627 ankur.sing 16020 
 
1886 ankur.sing 16021 
  thrift_spec = (
16022 
    None, # 0
3064 chandransh 16023 
    (1, TType.I64, 'providerId', None, None, ), # 1
16024 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 16025 
  )
16026 
 
3064 chandransh 16027 
  def __init__(self, providerId=None, warehouseId=None,):
16028 
    self.providerId = providerId
16029 
    self.warehouseId = warehouseId
1886 ankur.sing 16030 
 
16031 
  def read(self, iprot):
16032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16034 
      return
16035 
    iprot.readStructBegin()
16036 
    while True:
16037 
      (fname, ftype, fid) = iprot.readFieldBegin()
16038 
      if ftype == TType.STOP:
16039 
        break
16040 
      if fid == 1:
16041 
        if ftype == TType.I64:
3064 chandransh 16042 
          self.providerId = iprot.readI64();
1886 ankur.sing 16043 
        else:
16044 
          iprot.skip(ftype)
3064 chandransh 16045 
      elif fid == 2:
16046 
        if ftype == TType.I64:
16047 
          self.warehouseId = iprot.readI64();
16048 
        else:
16049 
          iprot.skip(ftype)
1886 ankur.sing 16050 
      else:
16051 
        iprot.skip(ftype)
16052 
      iprot.readFieldEnd()
16053 
    iprot.readStructEnd()
16054 
 
16055 
  def write(self, oprot):
16056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16058 
      return
3064 chandransh 16059 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 16060 
    if self.providerId is not None:
3064 chandransh 16061 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
16062 
      oprot.writeI64(self.providerId)
1886 ankur.sing 16063 
      oprot.writeFieldEnd()
3431 rajveer 16064 
    if self.warehouseId is not None:
3064 chandransh 16065 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16066 
      oprot.writeI64(self.warehouseId)
16067 
      oprot.writeFieldEnd()
1886 ankur.sing 16068 
    oprot.writeFieldStop()
16069 
    oprot.writeStructEnd()
16070 
 
3431 rajveer 16071 
  def validate(self):
16072 
    return
16073 
 
16074 
 
1886 ankur.sing 16075 
  def __repr__(self):
16076 
    L = ['%s=%r' % (key, value)
16077 
      for key, value in self.__dict__.iteritems()]
16078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16079 
 
16080 
  def __eq__(self, other):
16081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16082 
 
16083 
  def __ne__(self, other):
16084 
    return not (self == other)
16085 
 
3064 chandransh 16086 
class getUndeliveredOrders_result:
1886 ankur.sing 16087 
  """
16088 
  Attributes:
16089 
   - success
16090 
  """
16091 
 
16092 
  thrift_spec = (
16093 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16094 
  )
16095 
 
16096 
  def __init__(self, success=None,):
16097 
    self.success = success
16098 
 
16099 
  def read(self, iprot):
16100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16102 
      return
16103 
    iprot.readStructBegin()
16104 
    while True:
16105 
      (fname, ftype, fid) = iprot.readFieldBegin()
16106 
      if ftype == TType.STOP:
16107 
        break
16108 
      if fid == 0:
16109 
        if ftype == TType.LIST:
16110 
          self.success = []
6188 rajveer 16111 
          (_etype396, _size393) = iprot.readListBegin()
16112 
          for _i397 in xrange(_size393):
16113 
            _elem398 = Order()
16114 
            _elem398.read(iprot)
16115 
            self.success.append(_elem398)
1886 ankur.sing 16116 
          iprot.readListEnd()
16117 
        else:
16118 
          iprot.skip(ftype)
16119 
      else:
16120 
        iprot.skip(ftype)
16121 
      iprot.readFieldEnd()
16122 
    iprot.readStructEnd()
16123 
 
16124 
  def write(self, oprot):
16125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16127 
      return
3064 chandransh 16128 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 16129 
    if self.success is not None:
1886 ankur.sing 16130 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16131 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16132 
      for iter399 in self.success:
16133 
        iter399.write(oprot)
1886 ankur.sing 16134 
      oprot.writeListEnd()
16135 
      oprot.writeFieldEnd()
16136 
    oprot.writeFieldStop()
16137 
    oprot.writeStructEnd()
16138 
 
3431 rajveer 16139 
  def validate(self):
16140 
    return
16141 
 
16142 
 
1886 ankur.sing 16143 
  def __repr__(self):
16144 
    L = ['%s=%r' % (key, value)
16145 
      for key, value in self.__dict__.iteritems()]
16146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16147 
 
16148 
  def __eq__(self, other):
16149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16150 
 
16151 
  def __ne__(self, other):
16152 
    return not (self == other)
16153 
 
4783 phani.kuma 16154 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
16155 
 
16156 
  thrift_spec = (
16157 
  )
16158 
 
16159 
  def read(self, iprot):
16160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16162 
      return
16163 
    iprot.readStructBegin()
16164 
    while True:
16165 
      (fname, ftype, fid) = iprot.readFieldBegin()
16166 
      if ftype == TType.STOP:
16167 
        break
16168 
      else:
16169 
        iprot.skip(ftype)
16170 
      iprot.readFieldEnd()
16171 
    iprot.readStructEnd()
16172 
 
16173 
  def write(self, oprot):
16174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16176 
      return
16177 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
16178 
    oprot.writeFieldStop()
16179 
    oprot.writeStructEnd()
16180 
 
16181 
  def validate(self):
16182 
    return
16183 
 
16184 
 
16185 
  def __repr__(self):
16186 
    L = ['%s=%r' % (key, value)
16187 
      for key, value in self.__dict__.iteritems()]
16188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16189 
 
16190 
  def __eq__(self, other):
16191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16192 
 
16193 
  def __ne__(self, other):
16194 
    return not (self == other)
16195 
 
16196 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
16197 
  """
16198 
  Attributes:
16199 
   - success
16200 
  """
16201 
 
16202 
  thrift_spec = (
16203 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16204 
  )
16205 
 
16206 
  def __init__(self, success=None,):
16207 
    self.success = success
16208 
 
16209 
  def read(self, iprot):
16210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16212 
      return
16213 
    iprot.readStructBegin()
16214 
    while True:
16215 
      (fname, ftype, fid) = iprot.readFieldBegin()
16216 
      if ftype == TType.STOP:
16217 
        break
16218 
      if fid == 0:
16219 
        if ftype == TType.LIST:
16220 
          self.success = []
6188 rajveer 16221 
          (_etype403, _size400) = iprot.readListBegin()
16222 
          for _i404 in xrange(_size400):
16223 
            _elem405 = Order()
16224 
            _elem405.read(iprot)
16225 
            self.success.append(_elem405)
4783 phani.kuma 16226 
          iprot.readListEnd()
16227 
        else:
16228 
          iprot.skip(ftype)
16229 
      else:
16230 
        iprot.skip(ftype)
16231 
      iprot.readFieldEnd()
16232 
    iprot.readStructEnd()
16233 
 
16234 
  def write(self, oprot):
16235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16237 
      return
16238 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
16239 
    if self.success is not None:
16240 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16241 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16242 
      for iter406 in self.success:
16243 
        iter406.write(oprot)
4783 phani.kuma 16244 
      oprot.writeListEnd()
16245 
      oprot.writeFieldEnd()
16246 
    oprot.writeFieldStop()
16247 
    oprot.writeStructEnd()
16248 
 
16249 
  def validate(self):
16250 
    return
16251 
 
16252 
 
16253 
  def __repr__(self):
16254 
    L = ['%s=%r' % (key, value)
16255 
      for key, value in self.__dict__.iteritems()]
16256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16257 
 
16258 
  def __eq__(self, other):
16259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16260 
 
16261 
  def __ne__(self, other):
16262 
    return not (self == other)
16263 
 
2536 chandransh 16264 
class toggleDOAFlag_args:
16265 
  """
16266 
  Attributes:
16267 
   - orderId
16268 
  """
1886 ankur.sing 16269 
 
2536 chandransh 16270 
  thrift_spec = (
16271 
    None, # 0
16272 
    (1, TType.I64, 'orderId', None, None, ), # 1
16273 
  )
16274 
 
16275 
  def __init__(self, orderId=None,):
16276 
    self.orderId = orderId
16277 
 
16278 
  def read(self, iprot):
16279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16281 
      return
16282 
    iprot.readStructBegin()
16283 
    while True:
16284 
      (fname, ftype, fid) = iprot.readFieldBegin()
16285 
      if ftype == TType.STOP:
16286 
        break
16287 
      if fid == 1:
16288 
        if ftype == TType.I64:
16289 
          self.orderId = iprot.readI64();
16290 
        else:
16291 
          iprot.skip(ftype)
16292 
      else:
16293 
        iprot.skip(ftype)
16294 
      iprot.readFieldEnd()
16295 
    iprot.readStructEnd()
16296 
 
16297 
  def write(self, oprot):
16298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16300 
      return
16301 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 16302 
    if self.orderId is not None:
2536 chandransh 16303 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16304 
      oprot.writeI64(self.orderId)
16305 
      oprot.writeFieldEnd()
16306 
    oprot.writeFieldStop()
16307 
    oprot.writeStructEnd()
16308 
 
3431 rajveer 16309 
  def validate(self):
16310 
    return
16311 
 
16312 
 
2536 chandransh 16313 
  def __repr__(self):
16314 
    L = ['%s=%r' % (key, value)
16315 
      for key, value in self.__dict__.iteritems()]
16316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16317 
 
16318 
  def __eq__(self, other):
16319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16320 
 
16321 
  def __ne__(self, other):
16322 
    return not (self == other)
16323 
 
16324 
class toggleDOAFlag_result:
16325 
  """
16326 
  Attributes:
16327 
   - success
16328 
   - ex
16329 
  """
16330 
 
16331 
  thrift_spec = (
16332 
    (0, TType.BOOL, 'success', None, None, ), # 0
16333 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16334 
  )
16335 
 
16336 
  def __init__(self, success=None, ex=None,):
16337 
    self.success = success
16338 
    self.ex = ex
16339 
 
16340 
  def read(self, iprot):
16341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16343 
      return
16344 
    iprot.readStructBegin()
16345 
    while True:
16346 
      (fname, ftype, fid) = iprot.readFieldBegin()
16347 
      if ftype == TType.STOP:
16348 
        break
16349 
      if fid == 0:
16350 
        if ftype == TType.BOOL:
16351 
          self.success = iprot.readBool();
16352 
        else:
16353 
          iprot.skip(ftype)
16354 
      elif fid == 1:
16355 
        if ftype == TType.STRUCT:
16356 
          self.ex = TransactionServiceException()
16357 
          self.ex.read(iprot)
16358 
        else:
16359 
          iprot.skip(ftype)
16360 
      else:
16361 
        iprot.skip(ftype)
16362 
      iprot.readFieldEnd()
16363 
    iprot.readStructEnd()
16364 
 
16365 
  def write(self, oprot):
16366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16368 
      return
16369 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 16370 
    if self.success is not None:
2536 chandransh 16371 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16372 
      oprot.writeBool(self.success)
16373 
      oprot.writeFieldEnd()
3431 rajveer 16374 
    if self.ex is not None:
2536 chandransh 16375 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16376 
      self.ex.write(oprot)
16377 
      oprot.writeFieldEnd()
16378 
    oprot.writeFieldStop()
16379 
    oprot.writeStructEnd()
16380 
 
3431 rajveer 16381 
  def validate(self):
16382 
    return
16383 
 
16384 
 
2536 chandransh 16385 
  def __repr__(self):
16386 
    L = ['%s=%r' % (key, value)
16387 
      for key, value in self.__dict__.iteritems()]
16388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16389 
 
16390 
  def __eq__(self, other):
16391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16392 
 
16393 
  def __ne__(self, other):
16394 
    return not (self == other)
16395 
 
4712 rajveer 16396 
class markOrderAsDelivered_args:
16397 
  """
16398 
  Attributes:
16399 
   - orderId
16400 
   - deliveryTimestamp
16401 
   - receiver
16402 
  """
16403 
 
16404 
  thrift_spec = None
16405 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
16406 
    self.orderId = orderId
16407 
    self.deliveryTimestamp = deliveryTimestamp
16408 
    self.receiver = receiver
16409 
 
16410 
  def read(self, iprot):
16411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16413 
      return
16414 
    iprot.readStructBegin()
16415 
    while True:
16416 
      (fname, ftype, fid) = iprot.readFieldBegin()
16417 
      if ftype == TType.STOP:
16418 
        break
16419 
      if fid == 1:
16420 
        if ftype == TType.I64:
16421 
          self.orderId = iprot.readI64();
16422 
        else:
16423 
          iprot.skip(ftype)
16424 
      elif fid == 2:
16425 
        if ftype == TType.I64:
16426 
          self.deliveryTimestamp = iprot.readI64();
16427 
        else:
16428 
          iprot.skip(ftype)
16429 
      elif fid == -1:
16430 
        if ftype == TType.STRING:
16431 
          self.receiver = iprot.readString();
16432 
        else:
16433 
          iprot.skip(ftype)
16434 
      else:
16435 
        iprot.skip(ftype)
16436 
      iprot.readFieldEnd()
16437 
    iprot.readStructEnd()
16438 
 
16439 
  def write(self, oprot):
16440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16442 
      return
16443 
    oprot.writeStructBegin('markOrderAsDelivered_args')
16444 
    if self.receiver is not None:
16445 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
16446 
      oprot.writeString(self.receiver)
16447 
      oprot.writeFieldEnd()
16448 
    if self.orderId is not None:
16449 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16450 
      oprot.writeI64(self.orderId)
16451 
      oprot.writeFieldEnd()
16452 
    if self.deliveryTimestamp is not None:
16453 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16454 
      oprot.writeI64(self.deliveryTimestamp)
16455 
      oprot.writeFieldEnd()
16456 
    oprot.writeFieldStop()
16457 
    oprot.writeStructEnd()
16458 
 
16459 
  def validate(self):
16460 
    return
16461 
 
16462 
 
16463 
  def __repr__(self):
16464 
    L = ['%s=%r' % (key, value)
16465 
      for key, value in self.__dict__.iteritems()]
16466 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16467 
 
16468 
  def __eq__(self, other):
16469 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16470 
 
16471 
  def __ne__(self, other):
16472 
    return not (self == other)
16473 
 
16474 
class markOrderAsDelivered_result:
16475 
  """
16476 
  Attributes:
16477 
   - ex
16478 
  """
16479 
 
16480 
  thrift_spec = (
16481 
    None, # 0
16482 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16483 
  )
16484 
 
16485 
  def __init__(self, ex=None,):
16486 
    self.ex = ex
16487 
 
16488 
  def read(self, iprot):
16489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16491 
      return
16492 
    iprot.readStructBegin()
16493 
    while True:
16494 
      (fname, ftype, fid) = iprot.readFieldBegin()
16495 
      if ftype == TType.STOP:
16496 
        break
16497 
      if fid == 1:
16498 
        if ftype == TType.STRUCT:
16499 
          self.ex = TransactionServiceException()
16500 
          self.ex.read(iprot)
16501 
        else:
16502 
          iprot.skip(ftype)
16503 
      else:
16504 
        iprot.skip(ftype)
16505 
      iprot.readFieldEnd()
16506 
    iprot.readStructEnd()
16507 
 
16508 
  def write(self, oprot):
16509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16511 
      return
16512 
    oprot.writeStructBegin('markOrderAsDelivered_result')
16513 
    if self.ex is not None:
16514 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16515 
      self.ex.write(oprot)
16516 
      oprot.writeFieldEnd()
16517 
    oprot.writeFieldStop()
16518 
    oprot.writeStructEnd()
16519 
 
16520 
  def validate(self):
16521 
    return
16522 
 
16523 
 
16524 
  def __repr__(self):
16525 
    L = ['%s=%r' % (key, value)
16526 
      for key, value in self.__dict__.iteritems()]
16527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16528 
 
16529 
  def __eq__(self, other):
16530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16531 
 
16532 
  def __ne__(self, other):
16533 
    return not (self == other)
16534 
 
5553 rajveer 16535 
class markOrderAsReceivedAtStore_args:
16536 
  """
16537 
  Attributes:
16538 
   - orderId
16539 
   - deliveryTimestamp
16540 
  """
16541 
 
16542 
  thrift_spec = (
16543 
    None, # 0
16544 
    (1, TType.I64, 'orderId', None, None, ), # 1
16545 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
16546 
  )
16547 
 
16548 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
16549 
    self.orderId = orderId
16550 
    self.deliveryTimestamp = deliveryTimestamp
16551 
 
16552 
  def read(self, iprot):
16553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16555 
      return
16556 
    iprot.readStructBegin()
16557 
    while True:
16558 
      (fname, ftype, fid) = iprot.readFieldBegin()
16559 
      if ftype == TType.STOP:
16560 
        break
16561 
      if fid == 1:
16562 
        if ftype == TType.I64:
16563 
          self.orderId = iprot.readI64();
16564 
        else:
16565 
          iprot.skip(ftype)
16566 
      elif fid == 2:
16567 
        if ftype == TType.I64:
16568 
          self.deliveryTimestamp = iprot.readI64();
16569 
        else:
16570 
          iprot.skip(ftype)
16571 
      else:
16572 
        iprot.skip(ftype)
16573 
      iprot.readFieldEnd()
16574 
    iprot.readStructEnd()
16575 
 
16576 
  def write(self, oprot):
16577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16579 
      return
16580 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
16581 
    if self.orderId is not None:
16582 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16583 
      oprot.writeI64(self.orderId)
16584 
      oprot.writeFieldEnd()
16585 
    if self.deliveryTimestamp is not None:
16586 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16587 
      oprot.writeI64(self.deliveryTimestamp)
16588 
      oprot.writeFieldEnd()
16589 
    oprot.writeFieldStop()
16590 
    oprot.writeStructEnd()
16591 
 
16592 
  def validate(self):
16593 
    return
16594 
 
16595 
 
16596 
  def __repr__(self):
16597 
    L = ['%s=%r' % (key, value)
16598 
      for key, value in self.__dict__.iteritems()]
16599 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16600 
 
16601 
  def __eq__(self, other):
16602 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16603 
 
16604 
  def __ne__(self, other):
16605 
    return not (self == other)
16606 
 
16607 
class markOrderAsReceivedAtStore_result:
16608 
  """
16609 
  Attributes:
16610 
   - ex
16611 
  """
16612 
 
16613 
  thrift_spec = (
16614 
    None, # 0
16615 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16616 
  )
16617 
 
16618 
  def __init__(self, ex=None,):
16619 
    self.ex = ex
16620 
 
16621 
  def read(self, iprot):
16622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16624 
      return
16625 
    iprot.readStructBegin()
16626 
    while True:
16627 
      (fname, ftype, fid) = iprot.readFieldBegin()
16628 
      if ftype == TType.STOP:
16629 
        break
16630 
      if fid == 1:
16631 
        if ftype == TType.STRUCT:
16632 
          self.ex = TransactionServiceException()
16633 
          self.ex.read(iprot)
16634 
        else:
16635 
          iprot.skip(ftype)
16636 
      else:
16637 
        iprot.skip(ftype)
16638 
      iprot.readFieldEnd()
16639 
    iprot.readStructEnd()
16640 
 
16641 
  def write(self, oprot):
16642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16644 
      return
16645 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
16646 
    if self.ex is not None:
16647 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16648 
      self.ex.write(oprot)
16649 
      oprot.writeFieldEnd()
16650 
    oprot.writeFieldStop()
16651 
    oprot.writeStructEnd()
16652 
 
16653 
  def validate(self):
16654 
    return
16655 
 
16656 
 
16657 
  def __repr__(self):
16658 
    L = ['%s=%r' % (key, value)
16659 
      for key, value in self.__dict__.iteritems()]
16660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16661 
 
16662 
  def __eq__(self, other):
16663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16664 
 
16665 
  def __ne__(self, other):
16666 
    return not (self == other)
16667 
 
4454 rajveer 16668 
class markOrderDoaRequestReceived_args:
16669 
  """
16670 
  Attributes:
16671 
   - orderId
16672 
  """
16673 
 
16674 
  thrift_spec = (
16675 
    None, # 0
16676 
    (1, TType.I64, 'orderId', None, None, ), # 1
16677 
  )
16678 
 
16679 
  def __init__(self, orderId=None,):
16680 
    self.orderId = orderId
16681 
 
16682 
  def read(self, iprot):
16683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16685 
      return
16686 
    iprot.readStructBegin()
16687 
    while True:
16688 
      (fname, ftype, fid) = iprot.readFieldBegin()
16689 
      if ftype == TType.STOP:
16690 
        break
16691 
      if fid == 1:
16692 
        if ftype == TType.I64:
16693 
          self.orderId = iprot.readI64();
16694 
        else:
16695 
          iprot.skip(ftype)
16696 
      else:
16697 
        iprot.skip(ftype)
16698 
      iprot.readFieldEnd()
16699 
    iprot.readStructEnd()
16700 
 
16701 
  def write(self, oprot):
16702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16704 
      return
16705 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
16706 
    if self.orderId is not None:
16707 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16708 
      oprot.writeI64(self.orderId)
16709 
      oprot.writeFieldEnd()
16710 
    oprot.writeFieldStop()
16711 
    oprot.writeStructEnd()
16712 
 
16713 
  def validate(self):
16714 
    return
16715 
 
16716 
 
16717 
  def __repr__(self):
16718 
    L = ['%s=%r' % (key, value)
16719 
      for key, value in self.__dict__.iteritems()]
16720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16721 
 
16722 
  def __eq__(self, other):
16723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16724 
 
16725 
  def __ne__(self, other):
16726 
    return not (self == other)
16727 
 
16728 
class markOrderDoaRequestReceived_result:
16729 
  """
16730 
  Attributes:
16731 
   - success
16732 
   - ex
16733 
  """
16734 
 
16735 
  thrift_spec = (
16736 
    (0, TType.BOOL, 'success', None, None, ), # 0
16737 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16738 
  )
16739 
 
16740 
  def __init__(self, success=None, ex=None,):
16741 
    self.success = success
16742 
    self.ex = ex
16743 
 
16744 
  def read(self, iprot):
16745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16747 
      return
16748 
    iprot.readStructBegin()
16749 
    while True:
16750 
      (fname, ftype, fid) = iprot.readFieldBegin()
16751 
      if ftype == TType.STOP:
16752 
        break
16753 
      if fid == 0:
16754 
        if ftype == TType.BOOL:
16755 
          self.success = iprot.readBool();
16756 
        else:
16757 
          iprot.skip(ftype)
16758 
      elif fid == 1:
16759 
        if ftype == TType.STRUCT:
16760 
          self.ex = TransactionServiceException()
16761 
          self.ex.read(iprot)
16762 
        else:
16763 
          iprot.skip(ftype)
16764 
      else:
16765 
        iprot.skip(ftype)
16766 
      iprot.readFieldEnd()
16767 
    iprot.readStructEnd()
16768 
 
16769 
  def write(self, oprot):
16770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16772 
      return
16773 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
16774 
    if self.success is not None:
16775 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16776 
      oprot.writeBool(self.success)
16777 
      oprot.writeFieldEnd()
16778 
    if self.ex is not None:
16779 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16780 
      self.ex.write(oprot)
16781 
      oprot.writeFieldEnd()
16782 
    oprot.writeFieldStop()
16783 
    oprot.writeStructEnd()
16784 
 
16785 
  def validate(self):
16786 
    return
16787 
 
16788 
 
16789 
  def __repr__(self):
16790 
    L = ['%s=%r' % (key, value)
16791 
      for key, value in self.__dict__.iteritems()]
16792 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16793 
 
16794 
  def __eq__(self, other):
16795 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16796 
 
16797 
  def __ne__(self, other):
16798 
    return not (self == other)
16799 
 
16800 
class markOrderDoaRequestAuthorized_args:
16801 
  """
16802 
  Attributes:
16803 
   - orderId
16804 
   - isAuthorized
16805 
  """
16806 
 
16807 
  thrift_spec = (
16808 
    None, # 0
16809 
    (1, TType.I64, 'orderId', None, None, ), # 1
16810 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16811 
  )
16812 
 
16813 
  def __init__(self, orderId=None, isAuthorized=None,):
16814 
    self.orderId = orderId
16815 
    self.isAuthorized = isAuthorized
16816 
 
16817 
  def read(self, iprot):
16818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16820 
      return
16821 
    iprot.readStructBegin()
16822 
    while True:
16823 
      (fname, ftype, fid) = iprot.readFieldBegin()
16824 
      if ftype == TType.STOP:
16825 
        break
16826 
      if fid == 1:
16827 
        if ftype == TType.I64:
16828 
          self.orderId = iprot.readI64();
16829 
        else:
16830 
          iprot.skip(ftype)
16831 
      elif fid == 2:
16832 
        if ftype == TType.BOOL:
16833 
          self.isAuthorized = iprot.readBool();
16834 
        else:
16835 
          iprot.skip(ftype)
16836 
      else:
16837 
        iprot.skip(ftype)
16838 
      iprot.readFieldEnd()
16839 
    iprot.readStructEnd()
16840 
 
16841 
  def write(self, oprot):
16842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16844 
      return
16845 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16846 
    if self.orderId is not None:
16847 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16848 
      oprot.writeI64(self.orderId)
16849 
      oprot.writeFieldEnd()
16850 
    if self.isAuthorized is not None:
16851 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16852 
      oprot.writeBool(self.isAuthorized)
16853 
      oprot.writeFieldEnd()
16854 
    oprot.writeFieldStop()
16855 
    oprot.writeStructEnd()
16856 
 
16857 
  def validate(self):
16858 
    return
16859 
 
16860 
 
16861 
  def __repr__(self):
16862 
    L = ['%s=%r' % (key, value)
16863 
      for key, value in self.__dict__.iteritems()]
16864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16865 
 
16866 
  def __eq__(self, other):
16867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16868 
 
16869 
  def __ne__(self, other):
16870 
    return not (self == other)
16871 
 
16872 
class markOrderDoaRequestAuthorized_result:
16873 
  """
16874 
  Attributes:
16875 
   - success
16876 
   - ex
16877 
  """
16878 
 
16879 
  thrift_spec = (
16880 
    (0, TType.BOOL, 'success', None, None, ), # 0
16881 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16882 
  )
16883 
 
16884 
  def __init__(self, success=None, ex=None,):
16885 
    self.success = success
16886 
    self.ex = ex
16887 
 
16888 
  def read(self, iprot):
16889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16891 
      return
16892 
    iprot.readStructBegin()
16893 
    while True:
16894 
      (fname, ftype, fid) = iprot.readFieldBegin()
16895 
      if ftype == TType.STOP:
16896 
        break
16897 
      if fid == 0:
16898 
        if ftype == TType.BOOL:
16899 
          self.success = iprot.readBool();
16900 
        else:
16901 
          iprot.skip(ftype)
16902 
      elif fid == 1:
16903 
        if ftype == TType.STRUCT:
16904 
          self.ex = TransactionServiceException()
16905 
          self.ex.read(iprot)
16906 
        else:
16907 
          iprot.skip(ftype)
16908 
      else:
16909 
        iprot.skip(ftype)
16910 
      iprot.readFieldEnd()
16911 
    iprot.readStructEnd()
16912 
 
16913 
  def write(self, oprot):
16914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16916 
      return
16917 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
16918 
    if self.success is not None:
16919 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16920 
      oprot.writeBool(self.success)
16921 
      oprot.writeFieldEnd()
16922 
    if self.ex is not None:
16923 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16924 
      self.ex.write(oprot)
16925 
      oprot.writeFieldEnd()
16926 
    oprot.writeFieldStop()
16927 
    oprot.writeStructEnd()
16928 
 
16929 
  def validate(self):
16930 
    return
16931 
 
16932 
 
16933 
  def __repr__(self):
16934 
    L = ['%s=%r' % (key, value)
16935 
      for key, value in self.__dict__.iteritems()]
16936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16937 
 
16938 
  def __eq__(self, other):
16939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16940 
 
16941 
  def __ne__(self, other):
16942 
    return not (self == other)
16943 
 
4488 rajveer 16944 
class markOrderReturnRequestReceived_args:
16945 
  """
16946 
  Attributes:
16947 
   - orderId
16948 
  """
16949 
 
16950 
  thrift_spec = (
16951 
    None, # 0
16952 
    (1, TType.I64, 'orderId', None, None, ), # 1
16953 
  )
16954 
 
16955 
  def __init__(self, orderId=None,):
16956 
    self.orderId = orderId
16957 
 
16958 
  def read(self, iprot):
16959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16961 
      return
16962 
    iprot.readStructBegin()
16963 
    while True:
16964 
      (fname, ftype, fid) = iprot.readFieldBegin()
16965 
      if ftype == TType.STOP:
16966 
        break
16967 
      if fid == 1:
16968 
        if ftype == TType.I64:
16969 
          self.orderId = iprot.readI64();
16970 
        else:
16971 
          iprot.skip(ftype)
16972 
      else:
16973 
        iprot.skip(ftype)
16974 
      iprot.readFieldEnd()
16975 
    iprot.readStructEnd()
16976 
 
16977 
  def write(self, oprot):
16978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16980 
      return
16981 
    oprot.writeStructBegin('markOrderReturnRequestReceived_args')
16982 
    if self.orderId is not None:
16983 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16984 
      oprot.writeI64(self.orderId)
16985 
      oprot.writeFieldEnd()
16986 
    oprot.writeFieldStop()
16987 
    oprot.writeStructEnd()
16988 
 
16989 
  def validate(self):
16990 
    return
16991 
 
16992 
 
16993 
  def __repr__(self):
16994 
    L = ['%s=%r' % (key, value)
16995 
      for key, value in self.__dict__.iteritems()]
16996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16997 
 
16998 
  def __eq__(self, other):
16999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17000 
 
17001 
  def __ne__(self, other):
17002 
    return not (self == other)
17003 
 
17004 
class markOrderReturnRequestReceived_result:
17005 
  """
17006 
  Attributes:
17007 
   - success
17008 
   - ex
17009 
  """
17010 
 
17011 
  thrift_spec = (
17012 
    (0, TType.BOOL, 'success', None, None, ), # 0
17013 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17014 
  )
17015 
 
17016 
  def __init__(self, success=None, ex=None,):
17017 
    self.success = success
17018 
    self.ex = ex
17019 
 
17020 
  def read(self, iprot):
17021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17023 
      return
17024 
    iprot.readStructBegin()
17025 
    while True:
17026 
      (fname, ftype, fid) = iprot.readFieldBegin()
17027 
      if ftype == TType.STOP:
17028 
        break
17029 
      if fid == 0:
17030 
        if ftype == TType.BOOL:
17031 
          self.success = iprot.readBool();
17032 
        else:
17033 
          iprot.skip(ftype)
17034 
      elif fid == 1:
17035 
        if ftype == TType.STRUCT:
17036 
          self.ex = TransactionServiceException()
17037 
          self.ex.read(iprot)
17038 
        else:
17039 
          iprot.skip(ftype)
17040 
      else:
17041 
        iprot.skip(ftype)
17042 
      iprot.readFieldEnd()
17043 
    iprot.readStructEnd()
17044 
 
17045 
  def write(self, oprot):
17046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17048 
      return
17049 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
17050 
    if self.success is not None:
17051 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17052 
      oprot.writeBool(self.success)
17053 
      oprot.writeFieldEnd()
17054 
    if self.ex is not None:
17055 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17056 
      self.ex.write(oprot)
17057 
      oprot.writeFieldEnd()
17058 
    oprot.writeFieldStop()
17059 
    oprot.writeStructEnd()
17060 
 
17061 
  def validate(self):
17062 
    return
17063 
 
17064 
 
17065 
  def __repr__(self):
17066 
    L = ['%s=%r' % (key, value)
17067 
      for key, value in self.__dict__.iteritems()]
17068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17069 
 
17070 
  def __eq__(self, other):
17071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17072 
 
17073 
  def __ne__(self, other):
17074 
    return not (self == other)
17075 
 
17076 
class markOrderReturnRequestAuthorized_args:
17077 
  """
17078 
  Attributes:
17079 
   - orderId
17080 
   - isAuthorized
17081 
  """
17082 
 
17083 
  thrift_spec = (
17084 
    None, # 0
17085 
    (1, TType.I64, 'orderId', None, None, ), # 1
17086 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17087 
  )
17088 
 
17089 
  def __init__(self, orderId=None, isAuthorized=None,):
17090 
    self.orderId = orderId
17091 
    self.isAuthorized = isAuthorized
17092 
 
17093 
  def read(self, iprot):
17094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17096 
      return
17097 
    iprot.readStructBegin()
17098 
    while True:
17099 
      (fname, ftype, fid) = iprot.readFieldBegin()
17100 
      if ftype == TType.STOP:
17101 
        break
17102 
      if fid == 1:
17103 
        if ftype == TType.I64:
17104 
          self.orderId = iprot.readI64();
17105 
        else:
17106 
          iprot.skip(ftype)
17107 
      elif fid == 2:
17108 
        if ftype == TType.BOOL:
17109 
          self.isAuthorized = iprot.readBool();
17110 
        else:
17111 
          iprot.skip(ftype)
17112 
      else:
17113 
        iprot.skip(ftype)
17114 
      iprot.readFieldEnd()
17115 
    iprot.readStructEnd()
17116 
 
17117 
  def write(self, oprot):
17118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17120 
      return
17121 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
17122 
    if self.orderId is not None:
17123 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17124 
      oprot.writeI64(self.orderId)
17125 
      oprot.writeFieldEnd()
17126 
    if self.isAuthorized is not None:
17127 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17128 
      oprot.writeBool(self.isAuthorized)
17129 
      oprot.writeFieldEnd()
17130 
    oprot.writeFieldStop()
17131 
    oprot.writeStructEnd()
17132 
 
17133 
  def validate(self):
17134 
    return
17135 
 
17136 
 
17137 
  def __repr__(self):
17138 
    L = ['%s=%r' % (key, value)
17139 
      for key, value in self.__dict__.iteritems()]
17140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17141 
 
17142 
  def __eq__(self, other):
17143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17144 
 
17145 
  def __ne__(self, other):
17146 
    return not (self == other)
17147 
 
17148 
class markOrderReturnRequestAuthorized_result:
17149 
  """
17150 
  Attributes:
17151 
   - success
17152 
   - ex
17153 
  """
17154 
 
17155 
  thrift_spec = (
17156 
    (0, TType.BOOL, 'success', None, None, ), # 0
17157 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17158 
  )
17159 
 
17160 
  def __init__(self, success=None, ex=None,):
17161 
    self.success = success
17162 
    self.ex = ex
17163 
 
17164 
  def read(self, iprot):
17165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17167 
      return
17168 
    iprot.readStructBegin()
17169 
    while True:
17170 
      (fname, ftype, fid) = iprot.readFieldBegin()
17171 
      if ftype == TType.STOP:
17172 
        break
17173 
      if fid == 0:
17174 
        if ftype == TType.BOOL:
17175 
          self.success = iprot.readBool();
17176 
        else:
17177 
          iprot.skip(ftype)
17178 
      elif fid == 1:
17179 
        if ftype == TType.STRUCT:
17180 
          self.ex = TransactionServiceException()
17181 
          self.ex.read(iprot)
17182 
        else:
17183 
          iprot.skip(ftype)
17184 
      else:
17185 
        iprot.skip(ftype)
17186 
      iprot.readFieldEnd()
17187 
    iprot.readStructEnd()
17188 
 
17189 
  def write(self, oprot):
17190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17192 
      return
17193 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
17194 
    if self.success is not None:
17195 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17196 
      oprot.writeBool(self.success)
17197 
      oprot.writeFieldEnd()
17198 
    if self.ex is not None:
17199 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17200 
      self.ex.write(oprot)
17201 
      oprot.writeFieldEnd()
17202 
    oprot.writeFieldStop()
17203 
    oprot.writeStructEnd()
17204 
 
17205 
  def validate(self):
17206 
    return
17207 
 
17208 
 
17209 
  def __repr__(self):
17210 
    L = ['%s=%r' % (key, value)
17211 
      for key, value in self.__dict__.iteritems()]
17212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17213 
 
17214 
  def __eq__(self, other):
17215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17216 
 
17217 
  def __ne__(self, other):
17218 
    return not (self == other)
17219 
 
2536 chandransh 17220 
class requestPickupNumber_args:
17221 
  """
17222 
  Attributes:
17223 
   - orderId
4579 rajveer 17224 
   - providerId
2536 chandransh 17225 
  """
17226 
 
17227 
  thrift_spec = (
17228 
    None, # 0
17229 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 17230 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 17231 
  )
17232 
 
4579 rajveer 17233 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 17234 
    self.orderId = orderId
4579 rajveer 17235 
    self.providerId = providerId
2536 chandransh 17236 
 
17237 
  def read(self, iprot):
17238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17240 
      return
17241 
    iprot.readStructBegin()
17242 
    while True:
17243 
      (fname, ftype, fid) = iprot.readFieldBegin()
17244 
      if ftype == TType.STOP:
17245 
        break
17246 
      if fid == 1:
17247 
        if ftype == TType.I64:
17248 
          self.orderId = iprot.readI64();
17249 
        else:
17250 
          iprot.skip(ftype)
4579 rajveer 17251 
      elif fid == 2:
17252 
        if ftype == TType.I64:
17253 
          self.providerId = iprot.readI64();
17254 
        else:
17255 
          iprot.skip(ftype)
2536 chandransh 17256 
      else:
17257 
        iprot.skip(ftype)
17258 
      iprot.readFieldEnd()
17259 
    iprot.readStructEnd()
17260 
 
17261 
  def write(self, oprot):
17262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17264 
      return
17265 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 17266 
    if self.orderId is not None:
2536 chandransh 17267 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17268 
      oprot.writeI64(self.orderId)
17269 
      oprot.writeFieldEnd()
4579 rajveer 17270 
    if self.providerId is not None:
17271 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
17272 
      oprot.writeI64(self.providerId)
17273 
      oprot.writeFieldEnd()
2536 chandransh 17274 
    oprot.writeFieldStop()
17275 
    oprot.writeStructEnd()
17276 
 
3431 rajveer 17277 
  def validate(self):
17278 
    return
17279 
 
17280 
 
2536 chandransh 17281 
  def __repr__(self):
17282 
    L = ['%s=%r' % (key, value)
17283 
      for key, value in self.__dict__.iteritems()]
17284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17285 
 
17286 
  def __eq__(self, other):
17287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17288 
 
17289 
  def __ne__(self, other):
17290 
    return not (self == other)
17291 
 
17292 
class requestPickupNumber_result:
17293 
  """
17294 
  Attributes:
17295 
   - success
17296 
   - ex
17297 
  """
17298 
 
17299 
  thrift_spec = (
17300 
    (0, TType.BOOL, 'success', None, None, ), # 0
17301 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17302 
  )
17303 
 
17304 
  def __init__(self, success=None, ex=None,):
17305 
    self.success = success
17306 
    self.ex = ex
17307 
 
17308 
  def read(self, iprot):
17309 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17310 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17311 
      return
17312 
    iprot.readStructBegin()
17313 
    while True:
17314 
      (fname, ftype, fid) = iprot.readFieldBegin()
17315 
      if ftype == TType.STOP:
17316 
        break
17317 
      if fid == 0:
17318 
        if ftype == TType.BOOL:
17319 
          self.success = iprot.readBool();
17320 
        else:
17321 
          iprot.skip(ftype)
17322 
      elif fid == 1:
17323 
        if ftype == TType.STRUCT:
17324 
          self.ex = TransactionServiceException()
17325 
          self.ex.read(iprot)
17326 
        else:
17327 
          iprot.skip(ftype)
17328 
      else:
17329 
        iprot.skip(ftype)
17330 
      iprot.readFieldEnd()
17331 
    iprot.readStructEnd()
17332 
 
17333 
  def write(self, oprot):
17334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17336 
      return
17337 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 17338 
    if self.success is not None:
2536 chandransh 17339 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17340 
      oprot.writeBool(self.success)
17341 
      oprot.writeFieldEnd()
3431 rajveer 17342 
    if self.ex is not None:
2536 chandransh 17343 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17344 
      self.ex.write(oprot)
17345 
      oprot.writeFieldEnd()
17346 
    oprot.writeFieldStop()
17347 
    oprot.writeStructEnd()
17348 
 
3431 rajveer 17349 
  def validate(self):
17350 
    return
17351 
 
17352 
 
2536 chandransh 17353 
  def __repr__(self):
17354 
    L = ['%s=%r' % (key, value)
17355 
      for key, value in self.__dict__.iteritems()]
17356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17357 
 
17358 
  def __eq__(self, other):
17359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17360 
 
17361 
  def __ne__(self, other):
17362 
    return not (self == other)
17363 
 
17364 
class authorizePickup_args:
17365 
  """
17366 
  Attributes:
17367 
   - orderId
17368 
   - pickupNumber
4602 rajveer 17369 
   - providerId
2536 chandransh 17370 
  """
17371 
 
17372 
  thrift_spec = (
17373 
    None, # 0
17374 
    (1, TType.I64, 'orderId', None, None, ), # 1
17375 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 17376 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 17377 
  )
17378 
 
4602 rajveer 17379 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 17380 
    self.orderId = orderId
17381 
    self.pickupNumber = pickupNumber
4602 rajveer 17382 
    self.providerId = providerId
2536 chandransh 17383 
 
17384 
  def read(self, iprot):
17385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17387 
      return
17388 
    iprot.readStructBegin()
17389 
    while True:
17390 
      (fname, ftype, fid) = iprot.readFieldBegin()
17391 
      if ftype == TType.STOP:
17392 
        break
17393 
      if fid == 1:
17394 
        if ftype == TType.I64:
17395 
          self.orderId = iprot.readI64();
17396 
        else:
17397 
          iprot.skip(ftype)
17398 
      elif fid == 2:
17399 
        if ftype == TType.STRING:
17400 
          self.pickupNumber = iprot.readString();
17401 
        else:
17402 
          iprot.skip(ftype)
4602 rajveer 17403 
      elif fid == 3:
17404 
        if ftype == TType.I64:
17405 
          self.providerId = iprot.readI64();
17406 
        else:
17407 
          iprot.skip(ftype)
2536 chandransh 17408 
      else:
17409 
        iprot.skip(ftype)
17410 
      iprot.readFieldEnd()
17411 
    iprot.readStructEnd()
17412 
 
17413 
  def write(self, oprot):
17414 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17415 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17416 
      return
17417 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 17418 
    if self.orderId is not None:
2536 chandransh 17419 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17420 
      oprot.writeI64(self.orderId)
17421 
      oprot.writeFieldEnd()
3431 rajveer 17422 
    if self.pickupNumber is not None:
2536 chandransh 17423 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
17424 
      oprot.writeString(self.pickupNumber)
17425 
      oprot.writeFieldEnd()
4602 rajveer 17426 
    if self.providerId is not None:
17427 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
17428 
      oprot.writeI64(self.providerId)
17429 
      oprot.writeFieldEnd()
2536 chandransh 17430 
    oprot.writeFieldStop()
17431 
    oprot.writeStructEnd()
17432 
 
3431 rajveer 17433 
  def validate(self):
17434 
    return
17435 
 
17436 
 
2536 chandransh 17437 
  def __repr__(self):
17438 
    L = ['%s=%r' % (key, value)
17439 
      for key, value in self.__dict__.iteritems()]
17440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17441 
 
17442 
  def __eq__(self, other):
17443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17444 
 
17445 
  def __ne__(self, other):
17446 
    return not (self == other)
17447 
 
17448 
class authorizePickup_result:
17449 
  """
17450 
  Attributes:
17451 
   - success
17452 
   - ex
17453 
  """
17454 
 
17455 
  thrift_spec = (
17456 
    (0, TType.BOOL, 'success', None, None, ), # 0
17457 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17458 
  )
17459 
 
17460 
  def __init__(self, success=None, ex=None,):
17461 
    self.success = success
17462 
    self.ex = ex
17463 
 
17464 
  def read(self, iprot):
17465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17467 
      return
17468 
    iprot.readStructBegin()
17469 
    while True:
17470 
      (fname, ftype, fid) = iprot.readFieldBegin()
17471 
      if ftype == TType.STOP:
17472 
        break
17473 
      if fid == 0:
17474 
        if ftype == TType.BOOL:
17475 
          self.success = iprot.readBool();
17476 
        else:
17477 
          iprot.skip(ftype)
17478 
      elif fid == 1:
17479 
        if ftype == TType.STRUCT:
17480 
          self.ex = TransactionServiceException()
17481 
          self.ex.read(iprot)
17482 
        else:
17483 
          iprot.skip(ftype)
17484 
      else:
17485 
        iprot.skip(ftype)
17486 
      iprot.readFieldEnd()
17487 
    iprot.readStructEnd()
17488 
 
17489 
  def write(self, oprot):
17490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17492 
      return
17493 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 17494 
    if self.success is not None:
2536 chandransh 17495 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17496 
      oprot.writeBool(self.success)
17497 
      oprot.writeFieldEnd()
3431 rajveer 17498 
    if self.ex is not None:
2536 chandransh 17499 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17500 
      self.ex.write(oprot)
17501 
      oprot.writeFieldEnd()
17502 
    oprot.writeFieldStop()
17503 
    oprot.writeStructEnd()
17504 
 
3431 rajveer 17505 
  def validate(self):
17506 
    return
17507 
 
17508 
 
2536 chandransh 17509 
  def __repr__(self):
17510 
    L = ['%s=%r' % (key, value)
17511 
      for key, value in self.__dict__.iteritems()]
17512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17513 
 
17514 
  def __eq__(self, other):
17515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17516 
 
17517 
  def __ne__(self, other):
17518 
    return not (self == other)
17519 
 
2764 chandransh 17520 
class markDoasAsPickedUp_args:
17521 
  """
17522 
  Attributes:
17523 
   - providerId
17524 
   - pickupDetails
17525 
  """
17526 
 
17527 
  thrift_spec = (
17528 
    None, # 0
17529 
    (1, TType.I64, 'providerId', None, None, ), # 1
17530 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17531 
  )
17532 
 
17533 
  def __init__(self, providerId=None, pickupDetails=None,):
17534 
    self.providerId = providerId
17535 
    self.pickupDetails = pickupDetails
17536 
 
17537 
  def read(self, iprot):
17538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17540 
      return
17541 
    iprot.readStructBegin()
17542 
    while True:
17543 
      (fname, ftype, fid) = iprot.readFieldBegin()
17544 
      if ftype == TType.STOP:
17545 
        break
17546 
      if fid == 1:
17547 
        if ftype == TType.I64:
17548 
          self.providerId = iprot.readI64();
17549 
        else:
17550 
          iprot.skip(ftype)
17551 
      elif fid == 2:
17552 
        if ftype == TType.MAP:
17553 
          self.pickupDetails = {}
6188 rajveer 17554 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
17555 
          for _i411 in xrange(_size407):
17556 
            _key412 = iprot.readString();
17557 
            _val413 = iprot.readString();
17558 
            self.pickupDetails[_key412] = _val413
2764 chandransh 17559 
          iprot.readMapEnd()
17560 
        else:
17561 
          iprot.skip(ftype)
17562 
      else:
17563 
        iprot.skip(ftype)
17564 
      iprot.readFieldEnd()
17565 
    iprot.readStructEnd()
17566 
 
17567 
  def write(self, oprot):
17568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17570 
      return
17571 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 17572 
    if self.providerId is not None:
2764 chandransh 17573 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17574 
      oprot.writeI64(self.providerId)
17575 
      oprot.writeFieldEnd()
3431 rajveer 17576 
    if self.pickupDetails is not None:
2764 chandransh 17577 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17578 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17579 
      for kiter414,viter415 in self.pickupDetails.items():
17580 
        oprot.writeString(kiter414)
17581 
        oprot.writeString(viter415)
2764 chandransh 17582 
      oprot.writeMapEnd()
17583 
      oprot.writeFieldEnd()
17584 
    oprot.writeFieldStop()
17585 
    oprot.writeStructEnd()
17586 
 
3431 rajveer 17587 
  def validate(self):
17588 
    return
17589 
 
17590 
 
2764 chandransh 17591 
  def __repr__(self):
17592 
    L = ['%s=%r' % (key, value)
17593 
      for key, value in self.__dict__.iteritems()]
17594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17595 
 
17596 
  def __eq__(self, other):
17597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17598 
 
17599 
  def __ne__(self, other):
17600 
    return not (self == other)
17601 
 
17602 
class markDoasAsPickedUp_result:
4910 phani.kuma 17603 
 
17604 
  thrift_spec = (
17605 
  )
17606 
 
17607 
  def read(self, iprot):
17608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17610 
      return
17611 
    iprot.readStructBegin()
17612 
    while True:
17613 
      (fname, ftype, fid) = iprot.readFieldBegin()
17614 
      if ftype == TType.STOP:
17615 
        break
17616 
      else:
17617 
        iprot.skip(ftype)
17618 
      iprot.readFieldEnd()
17619 
    iprot.readStructEnd()
17620 
 
17621 
  def write(self, oprot):
17622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17624 
      return
17625 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
17626 
    oprot.writeFieldStop()
17627 
    oprot.writeStructEnd()
17628 
 
17629 
  def validate(self):
17630 
    return
17631 
 
17632 
 
17633 
  def __repr__(self):
17634 
    L = ['%s=%r' % (key, value)
17635 
      for key, value in self.__dict__.iteritems()]
17636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17637 
 
17638 
  def __eq__(self, other):
17639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17640 
 
17641 
  def __ne__(self, other):
17642 
    return not (self == other)
17643 
 
17644 
class getDoasNotPickedUp_args:
2764 chandransh 17645 
  """
17646 
  Attributes:
4910 phani.kuma 17647 
   - providerId
17648 
  """
17649 
 
17650 
  thrift_spec = (
17651 
    None, # 0
17652 
    (1, TType.I64, 'providerId', None, None, ), # 1
17653 
  )
17654 
 
17655 
  def __init__(self, providerId=None,):
17656 
    self.providerId = providerId
17657 
 
17658 
  def read(self, iprot):
17659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17661 
      return
17662 
    iprot.readStructBegin()
17663 
    while True:
17664 
      (fname, ftype, fid) = iprot.readFieldBegin()
17665 
      if ftype == TType.STOP:
17666 
        break
17667 
      if fid == 1:
17668 
        if ftype == TType.I64:
17669 
          self.providerId = iprot.readI64();
17670 
        else:
17671 
          iprot.skip(ftype)
17672 
      else:
17673 
        iprot.skip(ftype)
17674 
      iprot.readFieldEnd()
17675 
    iprot.readStructEnd()
17676 
 
17677 
  def write(self, oprot):
17678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17680 
      return
17681 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17682 
    if self.providerId is not None:
17683 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17684 
      oprot.writeI64(self.providerId)
17685 
      oprot.writeFieldEnd()
17686 
    oprot.writeFieldStop()
17687 
    oprot.writeStructEnd()
17688 
 
17689 
  def validate(self):
17690 
    return
17691 
 
17692 
 
17693 
  def __repr__(self):
17694 
    L = ['%s=%r' % (key, value)
17695 
      for key, value in self.__dict__.iteritems()]
17696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17697 
 
17698 
  def __eq__(self, other):
17699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17700 
 
17701 
  def __ne__(self, other):
17702 
    return not (self == other)
17703 
 
17704 
class getDoasNotPickedUp_result:
17705 
  """
17706 
  Attributes:
2764 chandransh 17707 
   - success
17708 
  """
17709 
 
17710 
  thrift_spec = (
17711 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17712 
  )
17713 
 
17714 
  def __init__(self, success=None,):
17715 
    self.success = success
17716 
 
17717 
  def read(self, iprot):
17718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17720 
      return
17721 
    iprot.readStructBegin()
17722 
    while True:
17723 
      (fname, ftype, fid) = iprot.readFieldBegin()
17724 
      if ftype == TType.STOP:
17725 
        break
17726 
      if fid == 0:
17727 
        if ftype == TType.LIST:
17728 
          self.success = []
6188 rajveer 17729 
          (_etype419, _size416) = iprot.readListBegin()
17730 
          for _i420 in xrange(_size416):
17731 
            _elem421 = Order()
17732 
            _elem421.read(iprot)
17733 
            self.success.append(_elem421)
2764 chandransh 17734 
          iprot.readListEnd()
17735 
        else:
17736 
          iprot.skip(ftype)
17737 
      else:
17738 
        iprot.skip(ftype)
17739 
      iprot.readFieldEnd()
17740 
    iprot.readStructEnd()
17741 
 
17742 
  def write(self, oprot):
17743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17745 
      return
4910 phani.kuma 17746 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 17747 
    if self.success is not None:
2764 chandransh 17748 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17749 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17750 
      for iter422 in self.success:
17751 
        iter422.write(oprot)
2764 chandransh 17752 
      oprot.writeListEnd()
17753 
      oprot.writeFieldEnd()
17754 
    oprot.writeFieldStop()
17755 
    oprot.writeStructEnd()
17756 
 
3431 rajveer 17757 
  def validate(self):
17758 
    return
17759 
 
17760 
 
2764 chandransh 17761 
  def __repr__(self):
17762 
    L = ['%s=%r' % (key, value)
17763 
      for key, value in self.__dict__.iteritems()]
17764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17765 
 
17766 
  def __eq__(self, other):
17767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17768 
 
17769 
  def __ne__(self, other):
17770 
    return not (self == other)
17771 
 
4741 phani.kuma 17772 
class markReturnOrdersAsPickedUp_args:
17773 
  """
17774 
  Attributes:
17775 
   - providerId
17776 
   - pickupDetails
17777 
  """
17778 
 
17779 
  thrift_spec = (
17780 
    None, # 0
17781 
    (1, TType.I64, 'providerId', None, None, ), # 1
17782 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17783 
  )
17784 
 
17785 
  def __init__(self, providerId=None, pickupDetails=None,):
17786 
    self.providerId = providerId
17787 
    self.pickupDetails = pickupDetails
17788 
 
17789 
  def read(self, iprot):
17790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17792 
      return
17793 
    iprot.readStructBegin()
17794 
    while True:
17795 
      (fname, ftype, fid) = iprot.readFieldBegin()
17796 
      if ftype == TType.STOP:
17797 
        break
17798 
      if fid == 1:
17799 
        if ftype == TType.I64:
17800 
          self.providerId = iprot.readI64();
17801 
        else:
17802 
          iprot.skip(ftype)
17803 
      elif fid == 2:
17804 
        if ftype == TType.MAP:
17805 
          self.pickupDetails = {}
6188 rajveer 17806 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
17807 
          for _i427 in xrange(_size423):
17808 
            _key428 = iprot.readString();
17809 
            _val429 = iprot.readString();
17810 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 17811 
          iprot.readMapEnd()
17812 
        else:
17813 
          iprot.skip(ftype)
17814 
      else:
17815 
        iprot.skip(ftype)
17816 
      iprot.readFieldEnd()
17817 
    iprot.readStructEnd()
17818 
 
17819 
  def write(self, oprot):
17820 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17821 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17822 
      return
17823 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
17824 
    if self.providerId is not None:
17825 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17826 
      oprot.writeI64(self.providerId)
17827 
      oprot.writeFieldEnd()
17828 
    if self.pickupDetails is not None:
17829 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17830 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17831 
      for kiter430,viter431 in self.pickupDetails.items():
17832 
        oprot.writeString(kiter430)
17833 
        oprot.writeString(viter431)
4741 phani.kuma 17834 
      oprot.writeMapEnd()
17835 
      oprot.writeFieldEnd()
17836 
    oprot.writeFieldStop()
17837 
    oprot.writeStructEnd()
17838 
 
17839 
  def validate(self):
17840 
    return
17841 
 
17842 
 
17843 
  def __repr__(self):
17844 
    L = ['%s=%r' % (key, value)
17845 
      for key, value in self.__dict__.iteritems()]
17846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17847 
 
17848 
  def __eq__(self, other):
17849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17850 
 
17851 
  def __ne__(self, other):
17852 
    return not (self == other)
17853 
 
17854 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 17855 
 
17856 
  thrift_spec = (
17857 
  )
17858 
 
17859 
  def read(self, iprot):
17860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17862 
      return
17863 
    iprot.readStructBegin()
17864 
    while True:
17865 
      (fname, ftype, fid) = iprot.readFieldBegin()
17866 
      if ftype == TType.STOP:
17867 
        break
17868 
      else:
17869 
        iprot.skip(ftype)
17870 
      iprot.readFieldEnd()
17871 
    iprot.readStructEnd()
17872 
 
17873 
  def write(self, oprot):
17874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17876 
      return
17877 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
17878 
    oprot.writeFieldStop()
17879 
    oprot.writeStructEnd()
17880 
 
17881 
  def validate(self):
17882 
    return
17883 
 
17884 
 
17885 
  def __repr__(self):
17886 
    L = ['%s=%r' % (key, value)
17887 
      for key, value in self.__dict__.iteritems()]
17888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17889 
 
17890 
  def __eq__(self, other):
17891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17892 
 
17893 
  def __ne__(self, other):
17894 
    return not (self == other)
17895 
 
17896 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 17897 
  """
17898 
  Attributes:
4910 phani.kuma 17899 
   - providerId
17900 
  """
17901 
 
17902 
  thrift_spec = (
17903 
    None, # 0
17904 
    (1, TType.I64, 'providerId', None, None, ), # 1
17905 
  )
17906 
 
17907 
  def __init__(self, providerId=None,):
17908 
    self.providerId = providerId
17909 
 
17910 
  def read(self, iprot):
17911 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17912 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17913 
      return
17914 
    iprot.readStructBegin()
17915 
    while True:
17916 
      (fname, ftype, fid) = iprot.readFieldBegin()
17917 
      if ftype == TType.STOP:
17918 
        break
17919 
      if fid == 1:
17920 
        if ftype == TType.I64:
17921 
          self.providerId = iprot.readI64();
17922 
        else:
17923 
          iprot.skip(ftype)
17924 
      else:
17925 
        iprot.skip(ftype)
17926 
      iprot.readFieldEnd()
17927 
    iprot.readStructEnd()
17928 
 
17929 
  def write(self, oprot):
17930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17932 
      return
17933 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
17934 
    if self.providerId is not None:
17935 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17936 
      oprot.writeI64(self.providerId)
17937 
      oprot.writeFieldEnd()
17938 
    oprot.writeFieldStop()
17939 
    oprot.writeStructEnd()
17940 
 
17941 
  def validate(self):
17942 
    return
17943 
 
17944 
 
17945 
  def __repr__(self):
17946 
    L = ['%s=%r' % (key, value)
17947 
      for key, value in self.__dict__.iteritems()]
17948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17949 
 
17950 
  def __eq__(self, other):
17951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17952 
 
17953 
  def __ne__(self, other):
17954 
    return not (self == other)
17955 
 
17956 
class getReturnOrdersNotPickedUp_result:
17957 
  """
17958 
  Attributes:
4741 phani.kuma 17959 
   - success
17960 
  """
17961 
 
17962 
  thrift_spec = (
17963 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17964 
  )
17965 
 
17966 
  def __init__(self, success=None,):
17967 
    self.success = success
17968 
 
17969 
  def read(self, iprot):
17970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17972 
      return
17973 
    iprot.readStructBegin()
17974 
    while True:
17975 
      (fname, ftype, fid) = iprot.readFieldBegin()
17976 
      if ftype == TType.STOP:
17977 
        break
17978 
      if fid == 0:
17979 
        if ftype == TType.LIST:
17980 
          self.success = []
6188 rajveer 17981 
          (_etype435, _size432) = iprot.readListBegin()
17982 
          for _i436 in xrange(_size432):
17983 
            _elem437 = Order()
17984 
            _elem437.read(iprot)
17985 
            self.success.append(_elem437)
4741 phani.kuma 17986 
          iprot.readListEnd()
17987 
        else:
17988 
          iprot.skip(ftype)
17989 
      else:
17990 
        iprot.skip(ftype)
17991 
      iprot.readFieldEnd()
17992 
    iprot.readStructEnd()
17993 
 
17994 
  def write(self, oprot):
17995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17997 
      return
4910 phani.kuma 17998 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 17999 
    if self.success is not None:
18000 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18001 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18002 
      for iter438 in self.success:
18003 
        iter438.write(oprot)
4741 phani.kuma 18004 
      oprot.writeListEnd()
18005 
      oprot.writeFieldEnd()
18006 
    oprot.writeFieldStop()
18007 
    oprot.writeStructEnd()
18008 
 
18009 
  def validate(self):
18010 
    return
18011 
 
18012 
 
18013 
  def __repr__(self):
18014 
    L = ['%s=%r' % (key, value)
18015 
      for key, value in self.__dict__.iteritems()]
18016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18017 
 
18018 
  def __eq__(self, other):
18019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18020 
 
18021 
  def __ne__(self, other):
18022 
    return not (self == other)
18023 
 
2616 chandransh 18024 
class receiveReturn_args:
2591 chandransh 18025 
  """
18026 
  Attributes:
18027 
   - orderId
4479 rajveer 18028 
   - receiveCondition
2591 chandransh 18029 
  """
2536 chandransh 18030 
 
2591 chandransh 18031 
  thrift_spec = (
18032 
    None, # 0
18033 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 18034 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 18035 
  )
18036 
 
4479 rajveer 18037 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 18038 
    self.orderId = orderId
4479 rajveer 18039 
    self.receiveCondition = receiveCondition
2591 chandransh 18040 
 
18041 
  def read(self, iprot):
18042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18044 
      return
18045 
    iprot.readStructBegin()
18046 
    while True:
18047 
      (fname, ftype, fid) = iprot.readFieldBegin()
18048 
      if ftype == TType.STOP:
18049 
        break
18050 
      if fid == 1:
18051 
        if ftype == TType.I64:
18052 
          self.orderId = iprot.readI64();
18053 
        else:
18054 
          iprot.skip(ftype)
4479 rajveer 18055 
      elif fid == 2:
18056 
        if ftype == TType.I64:
18057 
          self.receiveCondition = iprot.readI64();
18058 
        else:
18059 
          iprot.skip(ftype)
2591 chandransh 18060 
      else:
18061 
        iprot.skip(ftype)
18062 
      iprot.readFieldEnd()
18063 
    iprot.readStructEnd()
18064 
 
18065 
  def write(self, oprot):
18066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18068 
      return
2616 chandransh 18069 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 18070 
    if self.orderId is not None:
2591 chandransh 18071 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18072 
      oprot.writeI64(self.orderId)
18073 
      oprot.writeFieldEnd()
4479 rajveer 18074 
    if self.receiveCondition is not None:
18075 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
18076 
      oprot.writeI64(self.receiveCondition)
18077 
      oprot.writeFieldEnd()
2591 chandransh 18078 
    oprot.writeFieldStop()
18079 
    oprot.writeStructEnd()
18080 
 
3431 rajveer 18081 
  def validate(self):
18082 
    return
18083 
 
18084 
 
2591 chandransh 18085 
  def __repr__(self):
18086 
    L = ['%s=%r' % (key, value)
18087 
      for key, value in self.__dict__.iteritems()]
18088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18089 
 
18090 
  def __eq__(self, other):
18091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18092 
 
18093 
  def __ne__(self, other):
18094 
    return not (self == other)
18095 
 
2616 chandransh 18096 
class receiveReturn_result:
2591 chandransh 18097 
  """
18098 
  Attributes:
18099 
   - success
18100 
   - ex
18101 
  """
18102 
 
18103 
  thrift_spec = (
18104 
    (0, TType.BOOL, 'success', None, None, ), # 0
18105 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18106 
  )
18107 
 
18108 
  def __init__(self, success=None, ex=None,):
18109 
    self.success = success
18110 
    self.ex = ex
18111 
 
18112 
  def read(self, iprot):
18113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18115 
      return
18116 
    iprot.readStructBegin()
18117 
    while True:
18118 
      (fname, ftype, fid) = iprot.readFieldBegin()
18119 
      if ftype == TType.STOP:
18120 
        break
18121 
      if fid == 0:
18122 
        if ftype == TType.BOOL:
18123 
          self.success = iprot.readBool();
18124 
        else:
18125 
          iprot.skip(ftype)
18126 
      elif fid == 1:
18127 
        if ftype == TType.STRUCT:
18128 
          self.ex = TransactionServiceException()
18129 
          self.ex.read(iprot)
18130 
        else:
18131 
          iprot.skip(ftype)
18132 
      else:
18133 
        iprot.skip(ftype)
18134 
      iprot.readFieldEnd()
18135 
    iprot.readStructEnd()
18136 
 
18137 
  def write(self, oprot):
18138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18140 
      return
2616 chandransh 18141 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 18142 
    if self.success is not None:
2591 chandransh 18143 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18144 
      oprot.writeBool(self.success)
18145 
      oprot.writeFieldEnd()
3431 rajveer 18146 
    if self.ex is not None:
2591 chandransh 18147 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18148 
      self.ex.write(oprot)
18149 
      oprot.writeFieldEnd()
18150 
    oprot.writeFieldStop()
18151 
    oprot.writeStructEnd()
18152 
 
3431 rajveer 18153 
  def validate(self):
18154 
    return
18155 
 
18156 
 
2591 chandransh 18157 
  def __repr__(self):
18158 
    L = ['%s=%r' % (key, value)
18159 
      for key, value in self.__dict__.iteritems()]
18160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18161 
 
18162 
  def __eq__(self, other):
18163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18164 
 
18165 
  def __ne__(self, other):
18166 
    return not (self == other)
18167 
 
18168 
class validateDoa_args:
18169 
  """
18170 
  Attributes:
18171 
   - orderId
18172 
   - isValid
18173 
  """
18174 
 
18175 
  thrift_spec = (
18176 
    None, # 0
18177 
    (1, TType.I64, 'orderId', None, None, ), # 1
18178 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
18179 
  )
18180 
 
18181 
  def __init__(self, orderId=None, isValid=None,):
18182 
    self.orderId = orderId
18183 
    self.isValid = isValid
18184 
 
18185 
  def read(self, iprot):
18186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18188 
      return
18189 
    iprot.readStructBegin()
18190 
    while True:
18191 
      (fname, ftype, fid) = iprot.readFieldBegin()
18192 
      if ftype == TType.STOP:
18193 
        break
18194 
      if fid == 1:
18195 
        if ftype == TType.I64:
18196 
          self.orderId = iprot.readI64();
18197 
        else:
18198 
          iprot.skip(ftype)
18199 
      elif fid == 2:
18200 
        if ftype == TType.BOOL:
18201 
          self.isValid = iprot.readBool();
18202 
        else:
18203 
          iprot.skip(ftype)
18204 
      else:
18205 
        iprot.skip(ftype)
18206 
      iprot.readFieldEnd()
18207 
    iprot.readStructEnd()
18208 
 
18209 
  def write(self, oprot):
18210 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18211 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18212 
      return
18213 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 18214 
    if self.orderId is not None:
2591 chandransh 18215 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18216 
      oprot.writeI64(self.orderId)
18217 
      oprot.writeFieldEnd()
3431 rajveer 18218 
    if self.isValid is not None:
2591 chandransh 18219 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
18220 
      oprot.writeBool(self.isValid)
18221 
      oprot.writeFieldEnd()
18222 
    oprot.writeFieldStop()
18223 
    oprot.writeStructEnd()
18224 
 
3431 rajveer 18225 
  def validate(self):
18226 
    return
18227 
 
18228 
 
2591 chandransh 18229 
  def __repr__(self):
18230 
    L = ['%s=%r' % (key, value)
18231 
      for key, value in self.__dict__.iteritems()]
18232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18233 
 
18234 
  def __eq__(self, other):
18235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18236 
 
18237 
  def __ne__(self, other):
18238 
    return not (self == other)
18239 
 
18240 
class validateDoa_result:
18241 
  """
18242 
  Attributes:
18243 
   - success
18244 
   - ex
18245 
  """
18246 
 
18247 
  thrift_spec = (
18248 
    (0, TType.BOOL, 'success', None, None, ), # 0
18249 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18250 
  )
18251 
 
18252 
  def __init__(self, success=None, ex=None,):
18253 
    self.success = success
18254 
    self.ex = ex
18255 
 
18256 
  def read(self, iprot):
18257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18259 
      return
18260 
    iprot.readStructBegin()
18261 
    while True:
18262 
      (fname, ftype, fid) = iprot.readFieldBegin()
18263 
      if ftype == TType.STOP:
18264 
        break
18265 
      if fid == 0:
18266 
        if ftype == TType.BOOL:
18267 
          self.success = iprot.readBool();
18268 
        else:
18269 
          iprot.skip(ftype)
18270 
      elif fid == 1:
18271 
        if ftype == TType.STRUCT:
18272 
          self.ex = TransactionServiceException()
18273 
          self.ex.read(iprot)
18274 
        else:
18275 
          iprot.skip(ftype)
18276 
      else:
18277 
        iprot.skip(ftype)
18278 
      iprot.readFieldEnd()
18279 
    iprot.readStructEnd()
18280 
 
18281 
  def write(self, oprot):
18282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18284 
      return
18285 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 18286 
    if self.success is not None:
2591 chandransh 18287 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18288 
      oprot.writeBool(self.success)
18289 
      oprot.writeFieldEnd()
3431 rajveer 18290 
    if self.ex is not None:
2591 chandransh 18291 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18292 
      self.ex.write(oprot)
18293 
      oprot.writeFieldEnd()
18294 
    oprot.writeFieldStop()
18295 
    oprot.writeStructEnd()
18296 
 
3431 rajveer 18297 
  def validate(self):
18298 
    return
18299 
 
18300 
 
2591 chandransh 18301 
  def __repr__(self):
18302 
    L = ['%s=%r' % (key, value)
18303 
      for key, value in self.__dict__.iteritems()]
18304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18305 
 
18306 
  def __eq__(self, other):
18307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18308 
 
18309 
  def __ne__(self, other):
18310 
    return not (self == other)
18311 
 
4495 rajveer 18312 
class validateReturnProduct_args:
18313 
  """
18314 
  Attributes:
18315 
   - orderId
18316 
   - isUsable
18317 
  """
18318 
 
18319 
  thrift_spec = (
18320 
    None, # 0
18321 
    (1, TType.I64, 'orderId', None, None, ), # 1
18322 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
18323 
  )
18324 
 
18325 
  def __init__(self, orderId=None, isUsable=None,):
18326 
    self.orderId = orderId
18327 
    self.isUsable = isUsable
18328 
 
18329 
  def read(self, iprot):
18330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18332 
      return
18333 
    iprot.readStructBegin()
18334 
    while True:
18335 
      (fname, ftype, fid) = iprot.readFieldBegin()
18336 
      if ftype == TType.STOP:
18337 
        break
18338 
      if fid == 1:
18339 
        if ftype == TType.I64:
18340 
          self.orderId = iprot.readI64();
18341 
        else:
18342 
          iprot.skip(ftype)
18343 
      elif fid == 2:
18344 
        if ftype == TType.BOOL:
18345 
          self.isUsable = iprot.readBool();
18346 
        else:
18347 
          iprot.skip(ftype)
18348 
      else:
18349 
        iprot.skip(ftype)
18350 
      iprot.readFieldEnd()
18351 
    iprot.readStructEnd()
18352 
 
18353 
  def write(self, oprot):
18354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18356 
      return
18357 
    oprot.writeStructBegin('validateReturnProduct_args')
18358 
    if self.orderId is not None:
18359 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18360 
      oprot.writeI64(self.orderId)
18361 
      oprot.writeFieldEnd()
18362 
    if self.isUsable is not None:
18363 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
18364 
      oprot.writeBool(self.isUsable)
18365 
      oprot.writeFieldEnd()
18366 
    oprot.writeFieldStop()
18367 
    oprot.writeStructEnd()
18368 
 
18369 
  def validate(self):
18370 
    return
18371 
 
18372 
 
18373 
  def __repr__(self):
18374 
    L = ['%s=%r' % (key, value)
18375 
      for key, value in self.__dict__.iteritems()]
18376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18377 
 
18378 
  def __eq__(self, other):
18379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18380 
 
18381 
  def __ne__(self, other):
18382 
    return not (self == other)
18383 
 
18384 
class validateReturnProduct_result:
18385 
  """
18386 
  Attributes:
18387 
   - success
18388 
   - ex
18389 
  """
18390 
 
18391 
  thrift_spec = (
18392 
    (0, TType.BOOL, 'success', None, None, ), # 0
18393 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18394 
  )
18395 
 
18396 
  def __init__(self, success=None, ex=None,):
18397 
    self.success = success
18398 
    self.ex = ex
18399 
 
18400 
  def read(self, iprot):
18401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18403 
      return
18404 
    iprot.readStructBegin()
18405 
    while True:
18406 
      (fname, ftype, fid) = iprot.readFieldBegin()
18407 
      if ftype == TType.STOP:
18408 
        break
18409 
      if fid == 0:
18410 
        if ftype == TType.BOOL:
18411 
          self.success = iprot.readBool();
18412 
        else:
18413 
          iprot.skip(ftype)
18414 
      elif fid == 1:
18415 
        if ftype == TType.STRUCT:
18416 
          self.ex = TransactionServiceException()
18417 
          self.ex.read(iprot)
18418 
        else:
18419 
          iprot.skip(ftype)
18420 
      else:
18421 
        iprot.skip(ftype)
18422 
      iprot.readFieldEnd()
18423 
    iprot.readStructEnd()
18424 
 
18425 
  def write(self, oprot):
18426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18428 
      return
18429 
    oprot.writeStructBegin('validateReturnProduct_result')
18430 
    if self.success is not None:
18431 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18432 
      oprot.writeBool(self.success)
18433 
      oprot.writeFieldEnd()
18434 
    if self.ex is not None:
18435 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18436 
      self.ex.write(oprot)
18437 
      oprot.writeFieldEnd()
18438 
    oprot.writeFieldStop()
18439 
    oprot.writeStructEnd()
18440 
 
18441 
  def validate(self):
18442 
    return
18443 
 
18444 
 
18445 
  def __repr__(self):
18446 
    L = ['%s=%r' % (key, value)
18447 
      for key, value in self.__dict__.iteritems()]
18448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18449 
 
18450 
  def __eq__(self, other):
18451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18452 
 
18453 
  def __ne__(self, other):
18454 
    return not (self == other)
18455 
 
2616 chandransh 18456 
class reshipOrder_args:
18457 
  """
18458 
  Attributes:
18459 
   - orderId
18460 
  """
2591 chandransh 18461 
 
2616 chandransh 18462 
  thrift_spec = (
18463 
    None, # 0
18464 
    (1, TType.I64, 'orderId', None, None, ), # 1
18465 
  )
18466 
 
18467 
  def __init__(self, orderId=None,):
18468 
    self.orderId = orderId
18469 
 
18470 
  def read(self, iprot):
18471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18473 
      return
18474 
    iprot.readStructBegin()
18475 
    while True:
18476 
      (fname, ftype, fid) = iprot.readFieldBegin()
18477 
      if ftype == TType.STOP:
18478 
        break
18479 
      if fid == 1:
18480 
        if ftype == TType.I64:
18481 
          self.orderId = iprot.readI64();
18482 
        else:
18483 
          iprot.skip(ftype)
18484 
      else:
18485 
        iprot.skip(ftype)
18486 
      iprot.readFieldEnd()
18487 
    iprot.readStructEnd()
18488 
 
18489 
  def write(self, oprot):
18490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18492 
      return
18493 
    oprot.writeStructBegin('reshipOrder_args')
3431 rajveer 18494 
    if self.orderId is not None:
2616 chandransh 18495 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18496 
      oprot.writeI64(self.orderId)
18497 
      oprot.writeFieldEnd()
18498 
    oprot.writeFieldStop()
18499 
    oprot.writeStructEnd()
18500 
 
3431 rajveer 18501 
  def validate(self):
18502 
    return
18503 
 
18504 
 
2616 chandransh 18505 
  def __repr__(self):
18506 
    L = ['%s=%r' % (key, value)
18507 
      for key, value in self.__dict__.iteritems()]
18508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18509 
 
18510 
  def __eq__(self, other):
18511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18512 
 
18513 
  def __ne__(self, other):
18514 
    return not (self == other)
18515 
 
18516 
class reshipOrder_result:
18517 
  """
18518 
  Attributes:
18519 
   - success
18520 
   - ex
18521 
  """
18522 
 
18523 
  thrift_spec = (
18524 
    (0, TType.I64, 'success', None, None, ), # 0
18525 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18526 
  )
18527 
 
18528 
  def __init__(self, success=None, ex=None,):
18529 
    self.success = success
18530 
    self.ex = ex
18531 
 
18532 
  def read(self, iprot):
18533 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18534 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18535 
      return
18536 
    iprot.readStructBegin()
18537 
    while True:
18538 
      (fname, ftype, fid) = iprot.readFieldBegin()
18539 
      if ftype == TType.STOP:
18540 
        break
18541 
      if fid == 0:
18542 
        if ftype == TType.I64:
18543 
          self.success = iprot.readI64();
18544 
        else:
18545 
          iprot.skip(ftype)
18546 
      elif fid == 1:
18547 
        if ftype == TType.STRUCT:
18548 
          self.ex = TransactionServiceException()
18549 
          self.ex.read(iprot)
18550 
        else:
18551 
          iprot.skip(ftype)
18552 
      else:
18553 
        iprot.skip(ftype)
18554 
      iprot.readFieldEnd()
18555 
    iprot.readStructEnd()
18556 
 
18557 
  def write(self, oprot):
18558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18560 
      return
18561 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 18562 
    if self.success is not None:
2616 chandransh 18563 
      oprot.writeFieldBegin('success', TType.I64, 0)
18564 
      oprot.writeI64(self.success)
18565 
      oprot.writeFieldEnd()
3431 rajveer 18566 
    if self.ex is not None:
2616 chandransh 18567 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18568 
      self.ex.write(oprot)
18569 
      oprot.writeFieldEnd()
18570 
    oprot.writeFieldStop()
18571 
    oprot.writeStructEnd()
18572 
 
3431 rajveer 18573 
  def validate(self):
18574 
    return
18575 
 
18576 
 
2616 chandransh 18577 
  def __repr__(self):
18578 
    L = ['%s=%r' % (key, value)
18579 
      for key, value in self.__dict__.iteritems()]
18580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18581 
 
18582 
  def __eq__(self, other):
18583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18584 
 
18585 
  def __ne__(self, other):
18586 
    return not (self == other)
18587 
 
18588 
class refundOrder_args:
18589 
  """
18590 
  Attributes:
18591 
   - orderId
3226 chandransh 18592 
   - refundedBy
18593 
   - reason
2616 chandransh 18594 
  """
18595 
 
18596 
  thrift_spec = (
18597 
    None, # 0
18598 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 18599 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18600 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 18601 
  )
18602 
 
3226 chandransh 18603 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 18604 
    self.orderId = orderId
3226 chandransh 18605 
    self.refundedBy = refundedBy
18606 
    self.reason = reason
2616 chandransh 18607 
 
18608 
  def read(self, iprot):
18609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18611 
      return
18612 
    iprot.readStructBegin()
18613 
    while True:
18614 
      (fname, ftype, fid) = iprot.readFieldBegin()
18615 
      if ftype == TType.STOP:
18616 
        break
18617 
      if fid == 1:
18618 
        if ftype == TType.I64:
18619 
          self.orderId = iprot.readI64();
18620 
        else:
18621 
          iprot.skip(ftype)
3226 chandransh 18622 
      elif fid == 2:
18623 
        if ftype == TType.STRING:
18624 
          self.refundedBy = iprot.readString();
18625 
        else:
18626 
          iprot.skip(ftype)
18627 
      elif fid == 3:
18628 
        if ftype == TType.STRING:
18629 
          self.reason = iprot.readString();
18630 
        else:
18631 
          iprot.skip(ftype)
2616 chandransh 18632 
      else:
18633 
        iprot.skip(ftype)
18634 
      iprot.readFieldEnd()
18635 
    iprot.readStructEnd()
18636 
 
18637 
  def write(self, oprot):
18638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18640 
      return
18641 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 18642 
    if self.orderId is not None:
2616 chandransh 18643 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18644 
      oprot.writeI64(self.orderId)
18645 
      oprot.writeFieldEnd()
3431 rajveer 18646 
    if self.refundedBy is not None:
3226 chandransh 18647 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18648 
      oprot.writeString(self.refundedBy)
18649 
      oprot.writeFieldEnd()
3431 rajveer 18650 
    if self.reason is not None:
3226 chandransh 18651 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18652 
      oprot.writeString(self.reason)
18653 
      oprot.writeFieldEnd()
2616 chandransh 18654 
    oprot.writeFieldStop()
18655 
    oprot.writeStructEnd()
18656 
 
3431 rajveer 18657 
  def validate(self):
18658 
    return
18659 
 
18660 
 
2616 chandransh 18661 
  def __repr__(self):
18662 
    L = ['%s=%r' % (key, value)
18663 
      for key, value in self.__dict__.iteritems()]
18664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18665 
 
18666 
  def __eq__(self, other):
18667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18668 
 
18669 
  def __ne__(self, other):
18670 
    return not (self == other)
18671 
 
18672 
class refundOrder_result:
18673 
  """
18674 
  Attributes:
18675 
   - success
18676 
   - ex
18677 
  """
18678 
 
18679 
  thrift_spec = (
18680 
    (0, TType.BOOL, 'success', None, None, ), # 0
18681 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18682 
  )
18683 
 
18684 
  def __init__(self, success=None, ex=None,):
18685 
    self.success = success
18686 
    self.ex = ex
18687 
 
18688 
  def read(self, iprot):
18689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18691 
      return
18692 
    iprot.readStructBegin()
18693 
    while True:
18694 
      (fname, ftype, fid) = iprot.readFieldBegin()
18695 
      if ftype == TType.STOP:
18696 
        break
18697 
      if fid == 0:
18698 
        if ftype == TType.BOOL:
18699 
          self.success = iprot.readBool();
18700 
        else:
18701 
          iprot.skip(ftype)
18702 
      elif fid == 1:
18703 
        if ftype == TType.STRUCT:
18704 
          self.ex = TransactionServiceException()
18705 
          self.ex.read(iprot)
18706 
        else:
18707 
          iprot.skip(ftype)
18708 
      else:
18709 
        iprot.skip(ftype)
18710 
      iprot.readFieldEnd()
18711 
    iprot.readStructEnd()
18712 
 
18713 
  def write(self, oprot):
18714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18716 
      return
18717 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 18718 
    if self.success is not None:
2616 chandransh 18719 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18720 
      oprot.writeBool(self.success)
18721 
      oprot.writeFieldEnd()
3431 rajveer 18722 
    if self.ex is not None:
2616 chandransh 18723 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18724 
      self.ex.write(oprot)
18725 
      oprot.writeFieldEnd()
18726 
    oprot.writeFieldStop()
18727 
    oprot.writeStructEnd()
18728 
 
3431 rajveer 18729 
  def validate(self):
18730 
    return
18731 
 
18732 
 
2616 chandransh 18733 
  def __repr__(self):
18734 
    L = ['%s=%r' % (key, value)
18735 
      for key, value in self.__dict__.iteritems()]
18736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18737 
 
18738 
  def __eq__(self, other):
18739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18740 
 
18741 
  def __ne__(self, other):
18742 
    return not (self == other)
18743 
 
2690 chandransh 18744 
class getReturnOrders_args:
18745 
  """
18746 
  Attributes:
18747 
   - warehouseId
18748 
   - fromDate
18749 
   - toDate
18750 
  """
2616 chandransh 18751 
 
2690 chandransh 18752 
  thrift_spec = (
18753 
    None, # 0
18754 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
18755 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18756 
    (3, TType.I64, 'toDate', None, None, ), # 3
18757 
  )
18758 
 
18759 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
18760 
    self.warehouseId = warehouseId
18761 
    self.fromDate = fromDate
18762 
    self.toDate = toDate
18763 
 
18764 
  def read(self, iprot):
18765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18767 
      return
18768 
    iprot.readStructBegin()
18769 
    while True:
18770 
      (fname, ftype, fid) = iprot.readFieldBegin()
18771 
      if ftype == TType.STOP:
18772 
        break
18773 
      if fid == 1:
18774 
        if ftype == TType.I64:
18775 
          self.warehouseId = iprot.readI64();
18776 
        else:
18777 
          iprot.skip(ftype)
18778 
      elif fid == 2:
18779 
        if ftype == TType.I64:
18780 
          self.fromDate = iprot.readI64();
18781 
        else:
18782 
          iprot.skip(ftype)
18783 
      elif fid == 3:
18784 
        if ftype == TType.I64:
18785 
          self.toDate = iprot.readI64();
18786 
        else:
18787 
          iprot.skip(ftype)
18788 
      else:
18789 
        iprot.skip(ftype)
18790 
      iprot.readFieldEnd()
18791 
    iprot.readStructEnd()
18792 
 
18793 
  def write(self, oprot):
18794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18796 
      return
18797 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 18798 
    if self.warehouseId is not None:
2690 chandransh 18799 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
18800 
      oprot.writeI64(self.warehouseId)
18801 
      oprot.writeFieldEnd()
3431 rajveer 18802 
    if self.fromDate is not None:
2690 chandransh 18803 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18804 
      oprot.writeI64(self.fromDate)
18805 
      oprot.writeFieldEnd()
3431 rajveer 18806 
    if self.toDate is not None:
2690 chandransh 18807 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18808 
      oprot.writeI64(self.toDate)
18809 
      oprot.writeFieldEnd()
18810 
    oprot.writeFieldStop()
18811 
    oprot.writeStructEnd()
18812 
 
3431 rajveer 18813 
  def validate(self):
18814 
    return
18815 
 
18816 
 
2690 chandransh 18817 
  def __repr__(self):
18818 
    L = ['%s=%r' % (key, value)
18819 
      for key, value in self.__dict__.iteritems()]
18820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18821 
 
18822 
  def __eq__(self, other):
18823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18824 
 
18825 
  def __ne__(self, other):
18826 
    return not (self == other)
18827 
 
18828 
class getReturnOrders_result:
18829 
  """
18830 
  Attributes:
18831 
   - success
18832 
  """
18833 
 
18834 
  thrift_spec = (
18835 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18836 
  )
18837 
 
18838 
  def __init__(self, success=None,):
18839 
    self.success = success
18840 
 
18841 
  def read(self, iprot):
18842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18844 
      return
18845 
    iprot.readStructBegin()
18846 
    while True:
18847 
      (fname, ftype, fid) = iprot.readFieldBegin()
18848 
      if ftype == TType.STOP:
18849 
        break
18850 
      if fid == 0:
18851 
        if ftype == TType.LIST:
18852 
          self.success = []
6188 rajveer 18853 
          (_etype442, _size439) = iprot.readListBegin()
18854 
          for _i443 in xrange(_size439):
18855 
            _elem444 = ReturnOrder()
18856 
            _elem444.read(iprot)
18857 
            self.success.append(_elem444)
2690 chandransh 18858 
          iprot.readListEnd()
18859 
        else:
18860 
          iprot.skip(ftype)
18861 
      else:
18862 
        iprot.skip(ftype)
18863 
      iprot.readFieldEnd()
18864 
    iprot.readStructEnd()
18865 
 
18866 
  def write(self, oprot):
18867 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18868 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18869 
      return
18870 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 18871 
    if self.success is not None:
2690 chandransh 18872 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18873 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18874 
      for iter445 in self.success:
18875 
        iter445.write(oprot)
2690 chandransh 18876 
      oprot.writeListEnd()
18877 
      oprot.writeFieldEnd()
18878 
    oprot.writeFieldStop()
18879 
    oprot.writeStructEnd()
18880 
 
3431 rajveer 18881 
  def validate(self):
18882 
    return
18883 
 
18884 
 
2690 chandransh 18885 
  def __repr__(self):
18886 
    L = ['%s=%r' % (key, value)
18887 
      for key, value in self.__dict__.iteritems()]
18888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18889 
 
18890 
  def __eq__(self, other):
18891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18892 
 
18893 
  def __ne__(self, other):
18894 
    return not (self == other)
18895 
 
5481 phani.kuma 18896 
class getAllReturnOrders_args:
18897 
  """
18898 
  Attributes:
18899 
   - onlyNotProcessed
18900 
   - fromDate
18901 
   - toDate
18902 
  """
18903 
 
18904 
  thrift_spec = (
18905 
    None, # 0
18906 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
18907 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18908 
    (3, TType.I64, 'toDate', None, None, ), # 3
18909 
  )
18910 
 
18911 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
18912 
    self.onlyNotProcessed = onlyNotProcessed
18913 
    self.fromDate = fromDate
18914 
    self.toDate = toDate
18915 
 
18916 
  def read(self, iprot):
18917 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18918 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18919 
      return
18920 
    iprot.readStructBegin()
18921 
    while True:
18922 
      (fname, ftype, fid) = iprot.readFieldBegin()
18923 
      if ftype == TType.STOP:
18924 
        break
18925 
      if fid == 1:
18926 
        if ftype == TType.BOOL:
18927 
          self.onlyNotProcessed = iprot.readBool();
18928 
        else:
18929 
          iprot.skip(ftype)
18930 
      elif fid == 2:
18931 
        if ftype == TType.I64:
18932 
          self.fromDate = iprot.readI64();
18933 
        else:
18934 
          iprot.skip(ftype)
18935 
      elif fid == 3:
18936 
        if ftype == TType.I64:
18937 
          self.toDate = iprot.readI64();
18938 
        else:
18939 
          iprot.skip(ftype)
18940 
      else:
18941 
        iprot.skip(ftype)
18942 
      iprot.readFieldEnd()
18943 
    iprot.readStructEnd()
18944 
 
18945 
  def write(self, oprot):
18946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18948 
      return
18949 
    oprot.writeStructBegin('getAllReturnOrders_args')
18950 
    if self.onlyNotProcessed is not None:
18951 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
18952 
      oprot.writeBool(self.onlyNotProcessed)
18953 
      oprot.writeFieldEnd()
18954 
    if self.fromDate is not None:
18955 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18956 
      oprot.writeI64(self.fromDate)
18957 
      oprot.writeFieldEnd()
18958 
    if self.toDate is not None:
18959 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18960 
      oprot.writeI64(self.toDate)
18961 
      oprot.writeFieldEnd()
18962 
    oprot.writeFieldStop()
18963 
    oprot.writeStructEnd()
18964 
 
18965 
  def validate(self):
18966 
    return
18967 
 
18968 
 
18969 
  def __repr__(self):
18970 
    L = ['%s=%r' % (key, value)
18971 
      for key, value in self.__dict__.iteritems()]
18972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18973 
 
18974 
  def __eq__(self, other):
18975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18976 
 
18977 
  def __ne__(self, other):
18978 
    return not (self == other)
18979 
 
18980 
class getAllReturnOrders_result:
18981 
  """
18982 
  Attributes:
18983 
   - success
18984 
  """
18985 
 
18986 
  thrift_spec = (
18987 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18988 
  )
18989 
 
18990 
  def __init__(self, success=None,):
18991 
    self.success = success
18992 
 
18993 
  def read(self, iprot):
18994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18996 
      return
18997 
    iprot.readStructBegin()
18998 
    while True:
18999 
      (fname, ftype, fid) = iprot.readFieldBegin()
19000 
      if ftype == TType.STOP:
19001 
        break
19002 
      if fid == 0:
19003 
        if ftype == TType.LIST:
19004 
          self.success = []
6188 rajveer 19005 
          (_etype449, _size446) = iprot.readListBegin()
19006 
          for _i450 in xrange(_size446):
19007 
            _elem451 = ReturnOrder()
19008 
            _elem451.read(iprot)
19009 
            self.success.append(_elem451)
5481 phani.kuma 19010 
          iprot.readListEnd()
19011 
        else:
19012 
          iprot.skip(ftype)
19013 
      else:
19014 
        iprot.skip(ftype)
19015 
      iprot.readFieldEnd()
19016 
    iprot.readStructEnd()
19017 
 
19018 
  def write(self, oprot):
19019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19021 
      return
19022 
    oprot.writeStructBegin('getAllReturnOrders_result')
19023 
    if self.success is not None:
19024 
      oprot.writeFieldBegin('success', TType.LIST, 0)
19025 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 19026 
      for iter452 in self.success:
19027 
        iter452.write(oprot)
5481 phani.kuma 19028 
      oprot.writeListEnd()
19029 
      oprot.writeFieldEnd()
19030 
    oprot.writeFieldStop()
19031 
    oprot.writeStructEnd()
19032 
 
19033 
  def validate(self):
19034 
    return
19035 
 
19036 
 
19037 
  def __repr__(self):
19038 
    L = ['%s=%r' % (key, value)
19039 
      for key, value in self.__dict__.iteritems()]
19040 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19041 
 
19042 
  def __eq__(self, other):
19043 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19044 
 
19045 
  def __ne__(self, other):
19046 
    return not (self == other)
19047 
 
2700 chandransh 19048 
class getReturnOrder_args:
19049 
  """
19050 
  Attributes:
19051 
   - id
19052 
  """
19053 
 
19054 
  thrift_spec = (
19055 
    None, # 0
19056 
    (1, TType.I64, 'id', None, None, ), # 1
19057 
  )
19058 
 
19059 
  def __init__(self, id=None,):
19060 
    self.id = id
19061 
 
19062 
  def read(self, iprot):
19063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19065 
      return
19066 
    iprot.readStructBegin()
19067 
    while True:
19068 
      (fname, ftype, fid) = iprot.readFieldBegin()
19069 
      if ftype == TType.STOP:
19070 
        break
19071 
      if fid == 1:
19072 
        if ftype == TType.I64:
19073 
          self.id = iprot.readI64();
19074 
        else:
19075 
          iprot.skip(ftype)
19076 
      else:
19077 
        iprot.skip(ftype)
19078 
      iprot.readFieldEnd()
19079 
    iprot.readStructEnd()
19080 
 
19081 
  def write(self, oprot):
19082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19084 
      return
19085 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 19086 
    if self.id is not None:
2700 chandransh 19087 
      oprot.writeFieldBegin('id', TType.I64, 1)
19088 
      oprot.writeI64(self.id)
19089 
      oprot.writeFieldEnd()
19090 
    oprot.writeFieldStop()
19091 
    oprot.writeStructEnd()
19092 
 
3431 rajveer 19093 
  def validate(self):
19094 
    return
19095 
 
19096 
 
2700 chandransh 19097 
  def __repr__(self):
19098 
    L = ['%s=%r' % (key, value)
19099 
      for key, value in self.__dict__.iteritems()]
19100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19101 
 
19102 
  def __eq__(self, other):
19103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19104 
 
19105 
  def __ne__(self, other):
19106 
    return not (self == other)
19107 
 
19108 
class getReturnOrder_result:
19109 
  """
19110 
  Attributes:
19111 
   - success
19112 
   - ex
19113 
  """
19114 
 
19115 
  thrift_spec = (
19116 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
19117 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19118 
  )
19119 
 
19120 
  def __init__(self, success=None, ex=None,):
19121 
    self.success = success
19122 
    self.ex = ex
19123 
 
19124 
  def read(self, iprot):
19125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19127 
      return
19128 
    iprot.readStructBegin()
19129 
    while True:
19130 
      (fname, ftype, fid) = iprot.readFieldBegin()
19131 
      if ftype == TType.STOP:
19132 
        break
19133 
      if fid == 0:
19134 
        if ftype == TType.STRUCT:
19135 
          self.success = ReturnOrder()
19136 
          self.success.read(iprot)
19137 
        else:
19138 
          iprot.skip(ftype)
19139 
      elif fid == 1:
19140 
        if ftype == TType.STRUCT:
19141 
          self.ex = TransactionServiceException()
19142 
          self.ex.read(iprot)
19143 
        else:
19144 
          iprot.skip(ftype)
19145 
      else:
19146 
        iprot.skip(ftype)
19147 
      iprot.readFieldEnd()
19148 
    iprot.readStructEnd()
19149 
 
19150 
  def write(self, oprot):
19151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19153 
      return
19154 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 19155 
    if self.success is not None:
2700 chandransh 19156 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19157 
      self.success.write(oprot)
19158 
      oprot.writeFieldEnd()
3431 rajveer 19159 
    if self.ex is not None:
2700 chandransh 19160 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19161 
      self.ex.write(oprot)
19162 
      oprot.writeFieldEnd()
19163 
    oprot.writeFieldStop()
19164 
    oprot.writeStructEnd()
19165 
 
3431 rajveer 19166 
  def validate(self):
19167 
    return
19168 
 
19169 
 
2700 chandransh 19170 
  def __repr__(self):
19171 
    L = ['%s=%r' % (key, value)
19172 
      for key, value in self.__dict__.iteritems()]
19173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19174 
 
19175 
  def __eq__(self, other):
19176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19177 
 
19178 
  def __ne__(self, other):
19179 
    return not (self == other)
19180 
 
2690 chandransh 19181 
class processReturn_args:
19182 
  """
19183 
  Attributes:
19184 
   - returnOrderId
19185 
  """
19186 
 
19187 
  thrift_spec = (
19188 
    None, # 0
19189 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
19190 
  )
19191 
 
19192 
  def __init__(self, returnOrderId=None,):
19193 
    self.returnOrderId = returnOrderId
19194 
 
19195 
  def read(self, iprot):
19196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19198 
      return
19199 
    iprot.readStructBegin()
19200 
    while True:
19201 
      (fname, ftype, fid) = iprot.readFieldBegin()
19202 
      if ftype == TType.STOP:
19203 
        break
19204 
      if fid == 1:
19205 
        if ftype == TType.I64:
19206 
          self.returnOrderId = iprot.readI64();
19207 
        else:
19208 
          iprot.skip(ftype)
19209 
      else:
19210 
        iprot.skip(ftype)
19211 
      iprot.readFieldEnd()
19212 
    iprot.readStructEnd()
19213 
 
19214 
  def write(self, oprot):
19215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19217 
      return
19218 
    oprot.writeStructBegin('processReturn_args')
3431 rajveer 19219 
    if self.returnOrderId is not None:
2690 chandransh 19220 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
19221 
      oprot.writeI64(self.returnOrderId)
19222 
      oprot.writeFieldEnd()
19223 
    oprot.writeFieldStop()
19224 
    oprot.writeStructEnd()
19225 
 
3431 rajveer 19226 
  def validate(self):
19227 
    return
19228 
 
19229 
 
2690 chandransh 19230 
  def __repr__(self):
19231 
    L = ['%s=%r' % (key, value)
19232 
      for key, value in self.__dict__.iteritems()]
19233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19234 
 
19235 
  def __eq__(self, other):
19236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19237 
 
19238 
  def __ne__(self, other):
19239 
    return not (self == other)
19240 
 
19241 
class processReturn_result:
19242 
  """
19243 
  Attributes:
19244 
   - ex
19245 
  """
19246 
 
19247 
  thrift_spec = (
19248 
    None, # 0
19249 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19250 
  )
19251 
 
19252 
  def __init__(self, ex=None,):
19253 
    self.ex = ex
19254 
 
19255 
  def read(self, iprot):
19256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19258 
      return
19259 
    iprot.readStructBegin()
19260 
    while True:
19261 
      (fname, ftype, fid) = iprot.readFieldBegin()
19262 
      if ftype == TType.STOP:
19263 
        break
19264 
      if fid == 1:
19265 
        if ftype == TType.STRUCT:
19266 
          self.ex = TransactionServiceException()
19267 
          self.ex.read(iprot)
19268 
        else:
19269 
          iprot.skip(ftype)
19270 
      else:
19271 
        iprot.skip(ftype)
19272 
      iprot.readFieldEnd()
19273 
    iprot.readStructEnd()
19274 
 
19275 
  def write(self, oprot):
19276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19278 
      return
19279 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 19280 
    if self.ex is not None:
2690 chandransh 19281 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19282 
      self.ex.write(oprot)
19283 
      oprot.writeFieldEnd()
19284 
    oprot.writeFieldStop()
19285 
    oprot.writeStructEnd()
19286 
 
3431 rajveer 19287 
  def validate(self):
19288 
    return
19289 
 
19290 
 
2690 chandransh 19291 
  def __repr__(self):
19292 
    L = ['%s=%r' % (key, value)
19293 
      for key, value in self.__dict__.iteritems()]
19294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19295 
 
19296 
  def __eq__(self, other):
19297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19298 
 
19299 
  def __ne__(self, other):
19300 
    return not (self == other)
19301 
 
3451 chandransh 19302 
class updateWeight_args:
19303 
  """
19304 
  Attributes:
19305 
   - orderId
19306 
   - weight
19307 
  """
19308 
 
19309 
  thrift_spec = (
19310 
    None, # 0
19311 
    (1, TType.I64, 'orderId', None, None, ), # 1
19312 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
19313 
  )
19314 
 
19315 
  def __init__(self, orderId=None, weight=None,):
19316 
    self.orderId = orderId
19317 
    self.weight = weight
19318 
 
19319 
  def read(self, iprot):
19320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19322 
      return
19323 
    iprot.readStructBegin()
19324 
    while True:
19325 
      (fname, ftype, fid) = iprot.readFieldBegin()
19326 
      if ftype == TType.STOP:
19327 
        break
19328 
      if fid == 1:
19329 
        if ftype == TType.I64:
19330 
          self.orderId = iprot.readI64();
19331 
        else:
19332 
          iprot.skip(ftype)
19333 
      elif fid == 2:
19334 
        if ftype == TType.DOUBLE:
19335 
          self.weight = iprot.readDouble();
19336 
        else:
19337 
          iprot.skip(ftype)
19338 
      else:
19339 
        iprot.skip(ftype)
19340 
      iprot.readFieldEnd()
19341 
    iprot.readStructEnd()
19342 
 
19343 
  def write(self, oprot):
19344 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19345 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19346 
      return
19347 
    oprot.writeStructBegin('updateWeight_args')
19348 
    if self.orderId is not None:
19349 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19350 
      oprot.writeI64(self.orderId)
19351 
      oprot.writeFieldEnd()
19352 
    if self.weight is not None:
19353 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
19354 
      oprot.writeDouble(self.weight)
19355 
      oprot.writeFieldEnd()
19356 
    oprot.writeFieldStop()
19357 
    oprot.writeStructEnd()
19358 
 
19359 
  def validate(self):
19360 
    return
19361 
 
19362 
 
19363 
  def __repr__(self):
19364 
    L = ['%s=%r' % (key, value)
19365 
      for key, value in self.__dict__.iteritems()]
19366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19367 
 
19368 
  def __eq__(self, other):
19369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19370 
 
19371 
  def __ne__(self, other):
19372 
    return not (self == other)
19373 
 
19374 
class updateWeight_result:
19375 
  """
19376 
  Attributes:
19377 
   - success
19378 
   - ex
19379 
  """
19380 
 
19381 
  thrift_spec = (
19382 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19383 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19384 
  )
19385 
 
19386 
  def __init__(self, success=None, ex=None,):
19387 
    self.success = success
19388 
    self.ex = ex
19389 
 
19390 
  def read(self, iprot):
19391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19393 
      return
19394 
    iprot.readStructBegin()
19395 
    while True:
19396 
      (fname, ftype, fid) = iprot.readFieldBegin()
19397 
      if ftype == TType.STOP:
19398 
        break
19399 
      if fid == 0:
19400 
        if ftype == TType.STRUCT:
19401 
          self.success = Order()
19402 
          self.success.read(iprot)
19403 
        else:
19404 
          iprot.skip(ftype)
19405 
      elif fid == 1:
19406 
        if ftype == TType.STRUCT:
19407 
          self.ex = TransactionServiceException()
19408 
          self.ex.read(iprot)
19409 
        else:
19410 
          iprot.skip(ftype)
19411 
      else:
19412 
        iprot.skip(ftype)
19413 
      iprot.readFieldEnd()
19414 
    iprot.readStructEnd()
19415 
 
19416 
  def write(self, oprot):
19417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19419 
      return
19420 
    oprot.writeStructBegin('updateWeight_result')
19421 
    if self.success is not None:
19422 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19423 
      self.success.write(oprot)
19424 
      oprot.writeFieldEnd()
19425 
    if self.ex is not None:
19426 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19427 
      self.ex.write(oprot)
19428 
      oprot.writeFieldEnd()
19429 
    oprot.writeFieldStop()
19430 
    oprot.writeStructEnd()
19431 
 
19432 
  def validate(self):
19433 
    return
19434 
 
19435 
 
19436 
  def __repr__(self):
19437 
    L = ['%s=%r' % (key, value)
19438 
      for key, value in self.__dict__.iteritems()]
19439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19440 
 
19441 
  def __eq__(self, other):
19442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19443 
 
19444 
  def __ne__(self, other):
19445 
    return not (self == other)
3469 chandransh 19446 
 
19447 
class changeItem_args:
19448 
  """
19449 
  Attributes:
19450 
   - orderId
19451 
   - itemId
19452 
  """
19453 
 
19454 
  thrift_spec = (
19455 
    None, # 0
19456 
    (1, TType.I64, 'orderId', None, None, ), # 1
19457 
    (2, TType.I64, 'itemId', None, None, ), # 2
19458 
  )
19459 
 
19460 
  def __init__(self, orderId=None, itemId=None,):
19461 
    self.orderId = orderId
19462 
    self.itemId = itemId
19463 
 
19464 
  def read(self, iprot):
19465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19467 
      return
19468 
    iprot.readStructBegin()
19469 
    while True:
19470 
      (fname, ftype, fid) = iprot.readFieldBegin()
19471 
      if ftype == TType.STOP:
19472 
        break
19473 
      if fid == 1:
19474 
        if ftype == TType.I64:
19475 
          self.orderId = iprot.readI64();
19476 
        else:
19477 
          iprot.skip(ftype)
19478 
      elif fid == 2:
19479 
        if ftype == TType.I64:
19480 
          self.itemId = iprot.readI64();
19481 
        else:
19482 
          iprot.skip(ftype)
19483 
      else:
19484 
        iprot.skip(ftype)
19485 
      iprot.readFieldEnd()
19486 
    iprot.readStructEnd()
19487 
 
19488 
  def write(self, oprot):
19489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19491 
      return
19492 
    oprot.writeStructBegin('changeItem_args')
19493 
    if self.orderId is not None:
19494 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19495 
      oprot.writeI64(self.orderId)
19496 
      oprot.writeFieldEnd()
19497 
    if self.itemId is not None:
19498 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19499 
      oprot.writeI64(self.itemId)
19500 
      oprot.writeFieldEnd()
19501 
    oprot.writeFieldStop()
19502 
    oprot.writeStructEnd()
19503 
 
19504 
  def validate(self):
19505 
    return
19506 
 
19507 
 
19508 
  def __repr__(self):
19509 
    L = ['%s=%r' % (key, value)
19510 
      for key, value in self.__dict__.iteritems()]
19511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19512 
 
19513 
  def __eq__(self, other):
19514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19515 
 
19516 
  def __ne__(self, other):
19517 
    return not (self == other)
19518 
 
19519 
class changeItem_result:
19520 
  """
19521 
  Attributes:
19522 
   - success
19523 
   - ex
19524 
  """
19525 
 
19526 
  thrift_spec = (
19527 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19528 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19529 
  )
19530 
 
19531 
  def __init__(self, success=None, ex=None,):
19532 
    self.success = success
19533 
    self.ex = ex
19534 
 
19535 
  def read(self, iprot):
19536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19538 
      return
19539 
    iprot.readStructBegin()
19540 
    while True:
19541 
      (fname, ftype, fid) = iprot.readFieldBegin()
19542 
      if ftype == TType.STOP:
19543 
        break
19544 
      if fid == 0:
19545 
        if ftype == TType.STRUCT:
19546 
          self.success = Order()
19547 
          self.success.read(iprot)
19548 
        else:
19549 
          iprot.skip(ftype)
19550 
      elif fid == 1:
19551 
        if ftype == TType.STRUCT:
19552 
          self.ex = TransactionServiceException()
19553 
          self.ex.read(iprot)
19554 
        else:
19555 
          iprot.skip(ftype)
19556 
      else:
19557 
        iprot.skip(ftype)
19558 
      iprot.readFieldEnd()
19559 
    iprot.readStructEnd()
19560 
 
19561 
  def write(self, oprot):
19562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19564 
      return
19565 
    oprot.writeStructBegin('changeItem_result')
19566 
    if self.success is not None:
19567 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19568 
      self.success.write(oprot)
19569 
      oprot.writeFieldEnd()
19570 
    if self.ex is not None:
19571 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19572 
      self.ex.write(oprot)
19573 
      oprot.writeFieldEnd()
19574 
    oprot.writeFieldStop()
19575 
    oprot.writeStructEnd()
19576 
 
19577 
  def validate(self):
19578 
    return
19579 
 
19580 
 
19581 
  def __repr__(self):
19582 
    L = ['%s=%r' % (key, value)
19583 
      for key, value in self.__dict__.iteritems()]
19584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19585 
 
19586 
  def __eq__(self, other):
19587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19588 
 
19589 
  def __ne__(self, other):
19590 
    return not (self == other)
19591 
 
19592 
class shiftToWarehouse_args:
19593 
  """
19594 
  Attributes:
19595 
   - orderId
19596 
   - warehouseId
19597 
  """
19598 
 
19599 
  thrift_spec = (
19600 
    None, # 0
19601 
    (1, TType.I64, 'orderId', None, None, ), # 1
19602 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
19603 
  )
19604 
 
19605 
  def __init__(self, orderId=None, warehouseId=None,):
19606 
    self.orderId = orderId
19607 
    self.warehouseId = warehouseId
19608 
 
19609 
  def read(self, iprot):
19610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19612 
      return
19613 
    iprot.readStructBegin()
19614 
    while True:
19615 
      (fname, ftype, fid) = iprot.readFieldBegin()
19616 
      if ftype == TType.STOP:
19617 
        break
19618 
      if fid == 1:
19619 
        if ftype == TType.I64:
19620 
          self.orderId = iprot.readI64();
19621 
        else:
19622 
          iprot.skip(ftype)
19623 
      elif fid == 2:
19624 
        if ftype == TType.I64:
19625 
          self.warehouseId = iprot.readI64();
19626 
        else:
19627 
          iprot.skip(ftype)
19628 
      else:
19629 
        iprot.skip(ftype)
19630 
      iprot.readFieldEnd()
19631 
    iprot.readStructEnd()
19632 
 
19633 
  def write(self, oprot):
19634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19636 
      return
19637 
    oprot.writeStructBegin('shiftToWarehouse_args')
19638 
    if self.orderId is not None:
19639 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19640 
      oprot.writeI64(self.orderId)
19641 
      oprot.writeFieldEnd()
19642 
    if self.warehouseId is not None:
19643 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
19644 
      oprot.writeI64(self.warehouseId)
19645 
      oprot.writeFieldEnd()
19646 
    oprot.writeFieldStop()
19647 
    oprot.writeStructEnd()
19648 
 
19649 
  def validate(self):
19650 
    return
19651 
 
19652 
 
19653 
  def __repr__(self):
19654 
    L = ['%s=%r' % (key, value)
19655 
      for key, value in self.__dict__.iteritems()]
19656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19657 
 
19658 
  def __eq__(self, other):
19659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19660 
 
19661 
  def __ne__(self, other):
19662 
    return not (self == other)
19663 
 
19664 
class shiftToWarehouse_result:
19665 
  """
19666 
  Attributes:
19667 
   - success
19668 
   - ex
19669 
  """
19670 
 
19671 
  thrift_spec = (
19672 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19673 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19674 
  )
19675 
 
19676 
  def __init__(self, success=None, ex=None,):
19677 
    self.success = success
19678 
    self.ex = ex
19679 
 
19680 
  def read(self, iprot):
19681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19683 
      return
19684 
    iprot.readStructBegin()
19685 
    while True:
19686 
      (fname, ftype, fid) = iprot.readFieldBegin()
19687 
      if ftype == TType.STOP:
19688 
        break
19689 
      if fid == 0:
19690 
        if ftype == TType.STRUCT:
19691 
          self.success = Order()
19692 
          self.success.read(iprot)
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('shiftToWarehouse_result')
19711 
    if self.success is not None:
19712 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19713 
      self.success.write(oprot)
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)
3553 chandransh 19736 
 
19737 
class addDelayReason_args:
19738 
  """
19739 
  Attributes:
19740 
   - orderId
19741 
   - delayReason
3986 chandransh 19742 
   - furtherDelay
4647 rajveer 19743 
   - delayReasonText
3553 chandransh 19744 
  """
19745 
 
19746 
  thrift_spec = (
19747 
    None, # 0
19748 
    (1, TType.I64, 'orderId', None, None, ), # 1
19749 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 19750 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 19751 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 19752 
  )
19753 
 
4647 rajveer 19754 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 19755 
    self.orderId = orderId
19756 
    self.delayReason = delayReason
3986 chandransh 19757 
    self.furtherDelay = furtherDelay
4647 rajveer 19758 
    self.delayReasonText = delayReasonText
3553 chandransh 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.I64:
19771 
          self.orderId = iprot.readI64();
19772 
        else:
19773 
          iprot.skip(ftype)
19774 
      elif fid == 2:
19775 
        if ftype == TType.I32:
19776 
          self.delayReason = iprot.readI32();
19777 
        else:
19778 
          iprot.skip(ftype)
3986 chandransh 19779 
      elif fid == 3:
19780 
        if ftype == TType.I64:
19781 
          self.furtherDelay = iprot.readI64();
19782 
        else:
19783 
          iprot.skip(ftype)
4647 rajveer 19784 
      elif fid == 4:
19785 
        if ftype == TType.STRING:
19786 
          self.delayReasonText = iprot.readString();
19787 
        else:
19788 
          iprot.skip(ftype)
3553 chandransh 19789 
      else:
19790 
        iprot.skip(ftype)
19791 
      iprot.readFieldEnd()
19792 
    iprot.readStructEnd()
19793 
 
19794 
  def write(self, oprot):
19795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19797 
      return
19798 
    oprot.writeStructBegin('addDelayReason_args')
19799 
    if self.orderId is not None:
19800 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19801 
      oprot.writeI64(self.orderId)
19802 
      oprot.writeFieldEnd()
19803 
    if self.delayReason is not None:
19804 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
19805 
      oprot.writeI32(self.delayReason)
19806 
      oprot.writeFieldEnd()
3986 chandransh 19807 
    if self.furtherDelay is not None:
19808 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
19809 
      oprot.writeI64(self.furtherDelay)
19810 
      oprot.writeFieldEnd()
4647 rajveer 19811 
    if self.delayReasonText is not None:
19812 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
19813 
      oprot.writeString(self.delayReasonText)
19814 
      oprot.writeFieldEnd()
3553 chandransh 19815 
    oprot.writeFieldStop()
19816 
    oprot.writeStructEnd()
19817 
 
19818 
  def validate(self):
19819 
    return
19820 
 
19821 
 
19822 
  def __repr__(self):
19823 
    L = ['%s=%r' % (key, value)
19824 
      for key, value in self.__dict__.iteritems()]
19825 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19826 
 
19827 
  def __eq__(self, other):
19828 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19829 
 
19830 
  def __ne__(self, other):
19831 
    return not (self == other)
19832 
 
19833 
class addDelayReason_result:
19834 
  """
19835 
  Attributes:
19836 
   - success
19837 
   - ex
19838 
  """
19839 
 
19840 
  thrift_spec = (
19841 
    (0, TType.BOOL, 'success', None, None, ), # 0
19842 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19843 
  )
19844 
 
19845 
  def __init__(self, success=None, ex=None,):
19846 
    self.success = success
19847 
    self.ex = ex
19848 
 
19849 
  def read(self, iprot):
19850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19852 
      return
19853 
    iprot.readStructBegin()
19854 
    while True:
19855 
      (fname, ftype, fid) = iprot.readFieldBegin()
19856 
      if ftype == TType.STOP:
19857 
        break
19858 
      if fid == 0:
19859 
        if ftype == TType.BOOL:
19860 
          self.success = iprot.readBool();
19861 
        else:
19862 
          iprot.skip(ftype)
19863 
      elif fid == 1:
19864 
        if ftype == TType.STRUCT:
19865 
          self.ex = TransactionServiceException()
19866 
          self.ex.read(iprot)
19867 
        else:
19868 
          iprot.skip(ftype)
19869 
      else:
19870 
        iprot.skip(ftype)
19871 
      iprot.readFieldEnd()
19872 
    iprot.readStructEnd()
19873 
 
19874 
  def write(self, oprot):
19875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19877 
      return
19878 
    oprot.writeStructBegin('addDelayReason_result')
19879 
    if self.success is not None:
19880 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19881 
      oprot.writeBool(self.success)
19882 
      oprot.writeFieldEnd()
19883 
    if self.ex is not None:
19884 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19885 
      self.ex.write(oprot)
19886 
      oprot.writeFieldEnd()
19887 
    oprot.writeFieldStop()
19888 
    oprot.writeStructEnd()
19889 
 
19890 
  def validate(self):
19891 
    return
19892 
 
19893 
 
19894 
  def __repr__(self):
19895 
    L = ['%s=%r' % (key, value)
19896 
      for key, value in self.__dict__.iteritems()]
19897 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19898 
 
19899 
  def __eq__(self, other):
19900 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19901 
 
19902 
  def __ne__(self, other):
19903 
    return not (self == other)
3956 chandransh 19904 
 
19905 
class reconcileCodCollection_args:
19906 
  """
19907 
  Attributes:
19908 
   - collectedAmountMap
19909 
   - xferBy
19910 
   - xferTxnId
19911 
   - xferDate
19912 
  """
19913 
 
19914 
  thrift_spec = (
19915 
    None, # 0
19916 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
19917 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
19918 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
19919 
    (4, TType.I64, 'xferDate', None, None, ), # 4
19920 
  )
19921 
 
19922 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
19923 
    self.collectedAmountMap = collectedAmountMap
19924 
    self.xferBy = xferBy
19925 
    self.xferTxnId = xferTxnId
19926 
    self.xferDate = xferDate
19927 
 
19928 
  def read(self, iprot):
19929 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19930 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19931 
      return
19932 
    iprot.readStructBegin()
19933 
    while True:
19934 
      (fname, ftype, fid) = iprot.readFieldBegin()
19935 
      if ftype == TType.STOP:
19936 
        break
19937 
      if fid == 1:
19938 
        if ftype == TType.MAP:
19939 
          self.collectedAmountMap = {}
6188 rajveer 19940 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
19941 
          for _i457 in xrange(_size453):
19942 
            _key458 = iprot.readString();
19943 
            _val459 = iprot.readDouble();
19944 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 19945 
          iprot.readMapEnd()
19946 
        else:
19947 
          iprot.skip(ftype)
19948 
      elif fid == 2:
19949 
        if ftype == TType.STRING:
19950 
          self.xferBy = iprot.readString();
19951 
        else:
19952 
          iprot.skip(ftype)
19953 
      elif fid == 3:
19954 
        if ftype == TType.STRING:
19955 
          self.xferTxnId = iprot.readString();
19956 
        else:
19957 
          iprot.skip(ftype)
19958 
      elif fid == 4:
19959 
        if ftype == TType.I64:
19960 
          self.xferDate = iprot.readI64();
19961 
        else:
19962 
          iprot.skip(ftype)
19963 
      else:
19964 
        iprot.skip(ftype)
19965 
      iprot.readFieldEnd()
19966 
    iprot.readStructEnd()
19967 
 
19968 
  def write(self, oprot):
19969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19971 
      return
19972 
    oprot.writeStructBegin('reconcileCodCollection_args')
19973 
    if self.collectedAmountMap is not None:
19974 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
19975 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 19976 
      for kiter460,viter461 in self.collectedAmountMap.items():
19977 
        oprot.writeString(kiter460)
19978 
        oprot.writeDouble(viter461)
3956 chandransh 19979 
      oprot.writeMapEnd()
19980 
      oprot.writeFieldEnd()
19981 
    if self.xferBy is not None:
19982 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
19983 
      oprot.writeString(self.xferBy)
19984 
      oprot.writeFieldEnd()
19985 
    if self.xferTxnId is not None:
19986 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
19987 
      oprot.writeString(self.xferTxnId)
19988 
      oprot.writeFieldEnd()
19989 
    if self.xferDate is not None:
19990 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
19991 
      oprot.writeI64(self.xferDate)
19992 
      oprot.writeFieldEnd()
19993 
    oprot.writeFieldStop()
19994 
    oprot.writeStructEnd()
19995 
 
19996 
  def validate(self):
19997 
    return
19998 
 
19999 
 
20000 
  def __repr__(self):
20001 
    L = ['%s=%r' % (key, value)
20002 
      for key, value in self.__dict__.iteritems()]
20003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20004 
 
20005 
  def __eq__(self, other):
20006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20007 
 
20008 
  def __ne__(self, other):
20009 
    return not (self == other)
20010 
 
20011 
class reconcileCodCollection_result:
20012 
  """
20013 
  Attributes:
20014 
   - success
20015 
   - ex
20016 
  """
20017 
 
20018 
  thrift_spec = (
20019 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
20020 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20021 
  )
20022 
 
20023 
  def __init__(self, success=None, ex=None,):
20024 
    self.success = success
20025 
    self.ex = ex
20026 
 
20027 
  def read(self, iprot):
20028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20030 
      return
20031 
    iprot.readStructBegin()
20032 
    while True:
20033 
      (fname, ftype, fid) = iprot.readFieldBegin()
20034 
      if ftype == TType.STOP:
20035 
        break
20036 
      if fid == 0:
20037 
        if ftype == TType.MAP:
20038 
          self.success = {}
6188 rajveer 20039 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
20040 
          for _i466 in xrange(_size462):
20041 
            _key467 = iprot.readString();
20042 
            _val468 = iprot.readString();
20043 
            self.success[_key467] = _val468
3956 chandransh 20044 
          iprot.readMapEnd()
20045 
        else:
20046 
          iprot.skip(ftype)
20047 
      elif fid == 1:
20048 
        if ftype == TType.STRUCT:
20049 
          self.ex = TransactionServiceException()
20050 
          self.ex.read(iprot)
20051 
        else:
20052 
          iprot.skip(ftype)
20053 
      else:
20054 
        iprot.skip(ftype)
20055 
      iprot.readFieldEnd()
20056 
    iprot.readStructEnd()
20057 
 
20058 
  def write(self, oprot):
20059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20061 
      return
20062 
    oprot.writeStructBegin('reconcileCodCollection_result')
20063 
    if self.success is not None:
20064 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20065 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 20066 
      for kiter469,viter470 in self.success.items():
20067 
        oprot.writeString(kiter469)
20068 
        oprot.writeString(viter470)
3956 chandransh 20069 
      oprot.writeMapEnd()
20070 
      oprot.writeFieldEnd()
20071 
    if self.ex is not None:
20072 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20073 
      self.ex.write(oprot)
20074 
      oprot.writeFieldEnd()
20075 
    oprot.writeFieldStop()
20076 
    oprot.writeStructEnd()
20077 
 
20078 
  def validate(self):
20079 
    return
20080 
 
20081 
 
20082 
  def __repr__(self):
20083 
    L = ['%s=%r' % (key, value)
20084 
      for key, value in self.__dict__.iteritems()]
20085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20086 
 
20087 
  def __eq__(self, other):
20088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20089 
 
20090 
  def __ne__(self, other):
20091 
    return not (self == other)
4008 mandeep.dh 20092 
 
20093 
class getTransactionsRequiringExtraProcessing_args:
20094 
  """
20095 
  Attributes:
20096 
   - category
20097 
  """
20098 
 
20099 
  thrift_spec = (
20100 
    None, # 0
20101 
    (1, TType.I32, 'category', None, None, ), # 1
20102 
  )
20103 
 
20104 
  def __init__(self, category=None,):
20105 
    self.category = category
20106 
 
20107 
  def read(self, iprot):
20108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20110 
      return
20111 
    iprot.readStructBegin()
20112 
    while True:
20113 
      (fname, ftype, fid) = iprot.readFieldBegin()
20114 
      if ftype == TType.STOP:
20115 
        break
20116 
      if fid == 1:
20117 
        if ftype == TType.I32:
20118 
          self.category = iprot.readI32();
20119 
        else:
20120 
          iprot.skip(ftype)
20121 
      else:
20122 
        iprot.skip(ftype)
20123 
      iprot.readFieldEnd()
20124 
    iprot.readStructEnd()
20125 
 
20126 
  def write(self, oprot):
20127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20129 
      return
20130 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
20131 
    if self.category is not None:
20132 
      oprot.writeFieldBegin('category', TType.I32, 1)
20133 
      oprot.writeI32(self.category)
20134 
      oprot.writeFieldEnd()
20135 
    oprot.writeFieldStop()
20136 
    oprot.writeStructEnd()
20137 
 
20138 
  def validate(self):
20139 
    return
20140 
 
20141 
 
20142 
  def __repr__(self):
20143 
    L = ['%s=%r' % (key, value)
20144 
      for key, value in self.__dict__.iteritems()]
20145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20146 
 
20147 
  def __eq__(self, other):
20148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20149 
 
20150 
  def __ne__(self, other):
20151 
    return not (self == other)
20152 
 
20153 
class getTransactionsRequiringExtraProcessing_result:
20154 
  """
20155 
  Attributes:
20156 
   - success
20157 
  """
20158 
 
20159 
  thrift_spec = (
20160 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
20161 
  )
20162 
 
20163 
  def __init__(self, success=None,):
20164 
    self.success = success
20165 
 
20166 
  def read(self, iprot):
20167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20169 
      return
20170 
    iprot.readStructBegin()
20171 
    while True:
20172 
      (fname, ftype, fid) = iprot.readFieldBegin()
20173 
      if ftype == TType.STOP:
20174 
        break
20175 
      if fid == 0:
20176 
        if ftype == TType.LIST:
20177 
          self.success = []
6188 rajveer 20178 
          (_etype474, _size471) = iprot.readListBegin()
20179 
          for _i475 in xrange(_size471):
20180 
            _elem476 = iprot.readI64();
20181 
            self.success.append(_elem476)
4008 mandeep.dh 20182 
          iprot.readListEnd()
20183 
        else:
20184 
          iprot.skip(ftype)
20185 
      else:
20186 
        iprot.skip(ftype)
20187 
      iprot.readFieldEnd()
20188 
    iprot.readStructEnd()
20189 
 
20190 
  def write(self, oprot):
20191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20193 
      return
20194 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
20195 
    if self.success is not None:
20196 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20197 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 20198 
      for iter477 in self.success:
20199 
        oprot.writeI64(iter477)
4008 mandeep.dh 20200 
      oprot.writeListEnd()
20201 
      oprot.writeFieldEnd()
20202 
    oprot.writeFieldStop()
20203 
    oprot.writeStructEnd()
20204 
 
20205 
  def validate(self):
20206 
    return
20207 
 
20208 
 
20209 
  def __repr__(self):
20210 
    L = ['%s=%r' % (key, value)
20211 
      for key, value in self.__dict__.iteritems()]
20212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20213 
 
20214 
  def __eq__(self, other):
20215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20216 
 
20217 
  def __ne__(self, other):
20218 
    return not (self == other)
20219 
 
20220 
class markTransactionAsProcessed_args:
20221 
  """
20222 
  Attributes:
20223 
   - transactionId
20224 
   - category
20225 
  """
20226 
 
20227 
  thrift_spec = (
20228 
    None, # 0
20229 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20230 
    (2, TType.I32, 'category', None, None, ), # 2
20231 
  )
20232 
 
20233 
  def __init__(self, transactionId=None, category=None,):
20234 
    self.transactionId = transactionId
20235 
    self.category = category
20236 
 
20237 
  def read(self, iprot):
20238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20240 
      return
20241 
    iprot.readStructBegin()
20242 
    while True:
20243 
      (fname, ftype, fid) = iprot.readFieldBegin()
20244 
      if ftype == TType.STOP:
20245 
        break
20246 
      if fid == 1:
20247 
        if ftype == TType.I64:
20248 
          self.transactionId = iprot.readI64();
20249 
        else:
20250 
          iprot.skip(ftype)
20251 
      elif fid == 2:
20252 
        if ftype == TType.I32:
20253 
          self.category = iprot.readI32();
20254 
        else:
20255 
          iprot.skip(ftype)
20256 
      else:
20257 
        iprot.skip(ftype)
20258 
      iprot.readFieldEnd()
20259 
    iprot.readStructEnd()
20260 
 
20261 
  def write(self, oprot):
20262 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20263 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20264 
      return
20265 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
20266 
    if self.transactionId is not None:
20267 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20268 
      oprot.writeI64(self.transactionId)
20269 
      oprot.writeFieldEnd()
20270 
    if self.category is not None:
20271 
      oprot.writeFieldBegin('category', TType.I32, 2)
20272 
      oprot.writeI32(self.category)
20273 
      oprot.writeFieldEnd()
20274 
    oprot.writeFieldStop()
20275 
    oprot.writeStructEnd()
20276 
 
20277 
  def validate(self):
20278 
    return
20279 
 
20280 
 
20281 
  def __repr__(self):
20282 
    L = ['%s=%r' % (key, value)
20283 
      for key, value in self.__dict__.iteritems()]
20284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20285 
 
20286 
  def __eq__(self, other):
20287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20288 
 
20289 
  def __ne__(self, other):
20290 
    return not (self == other)
20291 
 
20292 
class markTransactionAsProcessed_result:
20293 
 
20294 
  thrift_spec = (
20295 
  )
20296 
 
20297 
  def read(self, iprot):
20298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20300 
      return
20301 
    iprot.readStructBegin()
20302 
    while True:
20303 
      (fname, ftype, fid) = iprot.readFieldBegin()
20304 
      if ftype == TType.STOP:
20305 
        break
20306 
      else:
20307 
        iprot.skip(ftype)
20308 
      iprot.readFieldEnd()
20309 
    iprot.readStructEnd()
20310 
 
20311 
  def write(self, oprot):
20312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20314 
      return
20315 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
20316 
    oprot.writeFieldStop()
20317 
    oprot.writeStructEnd()
20318 
 
20319 
  def validate(self):
20320 
    return
20321 
 
20322 
 
20323 
  def __repr__(self):
20324 
    L = ['%s=%r' % (key, value)
20325 
      for key, value in self.__dict__.iteritems()]
20326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20327 
 
20328 
  def __eq__(self, other):
20329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20330 
 
20331 
  def __ne__(self, other):
20332 
    return not (self == other)
4018 chandransh 20333 
 
20334 
class getItemWiseRiskyOrdersCount_args:
20335 
 
20336 
  thrift_spec = (
20337 
  )
20338 
 
20339 
  def read(self, iprot):
20340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20342 
      return
20343 
    iprot.readStructBegin()
20344 
    while True:
20345 
      (fname, ftype, fid) = iprot.readFieldBegin()
20346 
      if ftype == TType.STOP:
20347 
        break
20348 
      else:
20349 
        iprot.skip(ftype)
20350 
      iprot.readFieldEnd()
20351 
    iprot.readStructEnd()
20352 
 
20353 
  def write(self, oprot):
20354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20356 
      return
20357 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
20358 
    oprot.writeFieldStop()
20359 
    oprot.writeStructEnd()
20360 
 
20361 
  def validate(self):
20362 
    return
20363 
 
20364 
 
20365 
  def __repr__(self):
20366 
    L = ['%s=%r' % (key, value)
20367 
      for key, value in self.__dict__.iteritems()]
20368 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20369 
 
20370 
  def __eq__(self, other):
20371 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20372 
 
20373 
  def __ne__(self, other):
20374 
    return not (self == other)
20375 
 
20376 
class getItemWiseRiskyOrdersCount_result:
20377 
  """
20378 
  Attributes:
20379 
   - success
20380 
  """
20381 
 
20382 
  thrift_spec = (
20383 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
20384 
  )
20385 
 
20386 
  def __init__(self, success=None,):
20387 
    self.success = success
20388 
 
20389 
  def read(self, iprot):
20390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20392 
      return
20393 
    iprot.readStructBegin()
20394 
    while True:
20395 
      (fname, ftype, fid) = iprot.readFieldBegin()
20396 
      if ftype == TType.STOP:
20397 
        break
20398 
      if fid == 0:
20399 
        if ftype == TType.MAP:
20400 
          self.success = {}
6188 rajveer 20401 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
20402 
          for _i482 in xrange(_size478):
20403 
            _key483 = iprot.readI64();
20404 
            _val484 = iprot.readI64();
20405 
            self.success[_key483] = _val484
4018 chandransh 20406 
          iprot.readMapEnd()
20407 
        else:
20408 
          iprot.skip(ftype)
20409 
      else:
20410 
        iprot.skip(ftype)
20411 
      iprot.readFieldEnd()
20412 
    iprot.readStructEnd()
20413 
 
20414 
  def write(self, oprot):
20415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20417 
      return
20418 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
20419 
    if self.success is not None:
20420 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20421 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 20422 
      for kiter485,viter486 in self.success.items():
20423 
        oprot.writeI64(kiter485)
20424 
        oprot.writeI64(viter486)
4018 chandransh 20425 
      oprot.writeMapEnd()
20426 
      oprot.writeFieldEnd()
20427 
    oprot.writeFieldStop()
20428 
    oprot.writeStructEnd()
20429 
 
20430 
  def validate(self):
20431 
    return
20432 
 
20433 
 
20434 
  def __repr__(self):
20435 
    L = ['%s=%r' % (key, value)
20436 
      for key, value in self.__dict__.iteritems()]
20437 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20438 
 
20439 
  def __eq__(self, other):
20440 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20441 
 
20442 
  def __ne__(self, other):
20443 
    return not (self == other)
4247 rajveer 20444 
 
4295 varun.gupt 20445 
class getOrdersForItemIds_args:
20446 
  """
20447 
  Attributes:
20448 
   - itemIds
20449 
  """
20450 
 
20451 
  thrift_spec = (
20452 
    None, # 0
20453 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20454 
  )
20455 
 
20456 
  def __init__(self, itemIds=None,):
20457 
    self.itemIds = itemIds
20458 
 
20459 
  def read(self, iprot):
20460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20462 
      return
20463 
    iprot.readStructBegin()
20464 
    while True:
20465 
      (fname, ftype, fid) = iprot.readFieldBegin()
20466 
      if ftype == TType.STOP:
20467 
        break
20468 
      if fid == 1:
20469 
        if ftype == TType.LIST:
20470 
          self.itemIds = []
6188 rajveer 20471 
          (_etype490, _size487) = iprot.readListBegin()
20472 
          for _i491 in xrange(_size487):
20473 
            _elem492 = iprot.readI64();
20474 
            self.itemIds.append(_elem492)
4295 varun.gupt 20475 
          iprot.readListEnd()
20476 
        else:
20477 
          iprot.skip(ftype)
20478 
      else:
20479 
        iprot.skip(ftype)
20480 
      iprot.readFieldEnd()
20481 
    iprot.readStructEnd()
20482 
 
20483 
  def write(self, oprot):
20484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20486 
      return
20487 
    oprot.writeStructBegin('getOrdersForItemIds_args')
20488 
    if self.itemIds is not None:
20489 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20490 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 20491 
      for iter493 in self.itemIds:
20492 
        oprot.writeI64(iter493)
4295 varun.gupt 20493 
      oprot.writeListEnd()
20494 
      oprot.writeFieldEnd()
20495 
    oprot.writeFieldStop()
20496 
    oprot.writeStructEnd()
20497 
 
20498 
  def validate(self):
20499 
    return
20500 
 
20501 
 
20502 
  def __repr__(self):
20503 
    L = ['%s=%r' % (key, value)
20504 
      for key, value in self.__dict__.iteritems()]
20505 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20506 
 
20507 
  def __eq__(self, other):
20508 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20509 
 
20510 
  def __ne__(self, other):
20511 
    return not (self == other)
20512 
 
20513 
class getOrdersForItemIds_result:
20514 
  """
20515 
  Attributes:
20516 
   - success
20517 
  """
20518 
 
20519 
  thrift_spec = (
20520 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20521 
  )
20522 
 
20523 
  def __init__(self, success=None,):
20524 
    self.success = success
20525 
 
20526 
  def read(self, iprot):
20527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20529 
      return
20530 
    iprot.readStructBegin()
20531 
    while True:
20532 
      (fname, ftype, fid) = iprot.readFieldBegin()
20533 
      if ftype == TType.STOP:
20534 
        break
20535 
      if fid == 0:
20536 
        if ftype == TType.LIST:
20537 
          self.success = []
6188 rajveer 20538 
          (_etype497, _size494) = iprot.readListBegin()
20539 
          for _i498 in xrange(_size494):
20540 
            _elem499 = Order()
20541 
            _elem499.read(iprot)
20542 
            self.success.append(_elem499)
4295 varun.gupt 20543 
          iprot.readListEnd()
20544 
        else:
20545 
          iprot.skip(ftype)
20546 
      else:
20547 
        iprot.skip(ftype)
20548 
      iprot.readFieldEnd()
20549 
    iprot.readStructEnd()
20550 
 
20551 
  def write(self, oprot):
20552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20554 
      return
20555 
    oprot.writeStructBegin('getOrdersForItemIds_result')
20556 
    if self.success is not None:
20557 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20558 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20559 
      for iter500 in self.success:
20560 
        iter500.write(oprot)
4295 varun.gupt 20561 
      oprot.writeListEnd()
20562 
      oprot.writeFieldEnd()
20563 
    oprot.writeFieldStop()
20564 
    oprot.writeStructEnd()
20565 
 
20566 
  def validate(self):
20567 
    return
20568 
 
20569 
 
20570 
  def __repr__(self):
20571 
    L = ['%s=%r' % (key, value)
20572 
      for key, value in self.__dict__.iteritems()]
20573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20574 
 
20575 
  def __eq__(self, other):
20576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20577 
 
20578 
  def __ne__(self, other):
20579 
    return not (self == other)
20580 
 
4247 rajveer 20581 
class markOrderCancellationRequestReceived_args:
20582 
  """
20583 
  Attributes:
20584 
   - orderId
20585 
  """
20586 
 
20587 
  thrift_spec = (
20588 
    None, # 0
20589 
    (1, TType.I64, 'orderId', None, None, ), # 1
20590 
  )
20591 
 
20592 
  def __init__(self, orderId=None,):
20593 
    self.orderId = orderId
20594 
 
20595 
  def read(self, iprot):
20596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20598 
      return
20599 
    iprot.readStructBegin()
20600 
    while True:
20601 
      (fname, ftype, fid) = iprot.readFieldBegin()
20602 
      if ftype == TType.STOP:
20603 
        break
20604 
      if fid == 1:
20605 
        if ftype == TType.I64:
20606 
          self.orderId = iprot.readI64();
20607 
        else:
20608 
          iprot.skip(ftype)
20609 
      else:
20610 
        iprot.skip(ftype)
20611 
      iprot.readFieldEnd()
20612 
    iprot.readStructEnd()
20613 
 
20614 
  def write(self, oprot):
20615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20617 
      return
20618 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
20619 
    if self.orderId is not None:
20620 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20621 
      oprot.writeI64(self.orderId)
20622 
      oprot.writeFieldEnd()
20623 
    oprot.writeFieldStop()
20624 
    oprot.writeStructEnd()
20625 
 
20626 
  def validate(self):
20627 
    return
20628 
 
20629 
 
20630 
  def __repr__(self):
20631 
    L = ['%s=%r' % (key, value)
20632 
      for key, value in self.__dict__.iteritems()]
20633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20634 
 
20635 
  def __eq__(self, other):
20636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20637 
 
20638 
  def __ne__(self, other):
20639 
    return not (self == other)
20640 
 
20641 
class markOrderCancellationRequestReceived_result:
20642 
  """
20643 
  Attributes:
20644 
   - ex
20645 
  """
20646 
 
20647 
  thrift_spec = (
20648 
    None, # 0
20649 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20650 
  )
20651 
 
20652 
  def __init__(self, ex=None,):
20653 
    self.ex = ex
20654 
 
20655 
  def read(self, iprot):
20656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20658 
      return
20659 
    iprot.readStructBegin()
20660 
    while True:
20661 
      (fname, ftype, fid) = iprot.readFieldBegin()
20662 
      if ftype == TType.STOP:
20663 
        break
20664 
      if fid == 1:
20665 
        if ftype == TType.STRUCT:
20666 
          self.ex = TransactionServiceException()
20667 
          self.ex.read(iprot)
20668 
        else:
20669 
          iprot.skip(ftype)
20670 
      else:
20671 
        iprot.skip(ftype)
20672 
      iprot.readFieldEnd()
20673 
    iprot.readStructEnd()
20674 
 
20675 
  def write(self, oprot):
20676 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20677 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20678 
      return
20679 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20680 
    if self.ex is not None:
20681 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20682 
      self.ex.write(oprot)
20683 
      oprot.writeFieldEnd()
20684 
    oprot.writeFieldStop()
20685 
    oprot.writeStructEnd()
20686 
 
20687 
  def validate(self):
20688 
    return
20689 
 
20690 
 
20691 
  def __repr__(self):
20692 
    L = ['%s=%r' % (key, value)
20693 
      for key, value in self.__dict__.iteritems()]
20694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20695 
 
20696 
  def __eq__(self, other):
20697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20698 
 
20699 
  def __ne__(self, other):
20700 
    return not (self == other)
20701 
 
20702 
class markOrderCancellationRequestConfirmed_args:
20703 
  """
20704 
  Attributes:
20705 
   - orderId
20706 
  """
20707 
 
20708 
  thrift_spec = (
20709 
    None, # 0
20710 
    (1, TType.I64, 'orderId', None, None, ), # 1
20711 
  )
20712 
 
20713 
  def __init__(self, orderId=None,):
20714 
    self.orderId = orderId
20715 
 
20716 
  def read(self, iprot):
20717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20719 
      return
20720 
    iprot.readStructBegin()
20721 
    while True:
20722 
      (fname, ftype, fid) = iprot.readFieldBegin()
20723 
      if ftype == TType.STOP:
20724 
        break
20725 
      if fid == 1:
20726 
        if ftype == TType.I64:
20727 
          self.orderId = iprot.readI64();
20728 
        else:
20729 
          iprot.skip(ftype)
20730 
      else:
20731 
        iprot.skip(ftype)
20732 
      iprot.readFieldEnd()
20733 
    iprot.readStructEnd()
20734 
 
20735 
  def write(self, oprot):
20736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20738 
      return
20739 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
20740 
    if self.orderId is not None:
20741 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20742 
      oprot.writeI64(self.orderId)
20743 
      oprot.writeFieldEnd()
20744 
    oprot.writeFieldStop()
20745 
    oprot.writeStructEnd()
20746 
 
20747 
  def validate(self):
20748 
    return
20749 
 
20750 
 
20751 
  def __repr__(self):
20752 
    L = ['%s=%r' % (key, value)
20753 
      for key, value in self.__dict__.iteritems()]
20754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20755 
 
20756 
  def __eq__(self, other):
20757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20758 
 
20759 
  def __ne__(self, other):
20760 
    return not (self == other)
20761 
 
20762 
class markOrderCancellationRequestConfirmed_result:
20763 
  """
20764 
  Attributes:
20765 
   - ex
20766 
  """
20767 
 
20768 
  thrift_spec = (
20769 
    None, # 0
20770 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20771 
  )
20772 
 
20773 
  def __init__(self, ex=None,):
20774 
    self.ex = ex
20775 
 
20776 
  def read(self, iprot):
20777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20779 
      return
20780 
    iprot.readStructBegin()
20781 
    while True:
20782 
      (fname, ftype, fid) = iprot.readFieldBegin()
20783 
      if ftype == TType.STOP:
20784 
        break
20785 
      if fid == 1:
20786 
        if ftype == TType.STRUCT:
20787 
          self.ex = TransactionServiceException()
20788 
          self.ex.read(iprot)
20789 
        else:
20790 
          iprot.skip(ftype)
20791 
      else:
20792 
        iprot.skip(ftype)
20793 
      iprot.readFieldEnd()
20794 
    iprot.readStructEnd()
20795 
 
20796 
  def write(self, oprot):
20797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20799 
      return
20800 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
20801 
    if self.ex is not None:
20802 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20803 
      self.ex.write(oprot)
20804 
      oprot.writeFieldEnd()
20805 
    oprot.writeFieldStop()
20806 
    oprot.writeStructEnd()
20807 
 
20808 
  def validate(self):
20809 
    return
20810 
 
20811 
 
20812 
  def __repr__(self):
20813 
    L = ['%s=%r' % (key, value)
20814 
      for key, value in self.__dict__.iteritems()]
20815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20816 
 
20817 
  def __eq__(self, other):
20818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20819 
 
20820 
  def __ne__(self, other):
20821 
    return not (self == other)
20822 
 
20823 
class markOrderCancellationRequestDenied_args:
20824 
  """
20825 
  Attributes:
20826 
   - orderId
20827 
  """
20828 
 
20829 
  thrift_spec = (
20830 
    None, # 0
20831 
    (1, TType.I64, 'orderId', None, None, ), # 1
20832 
  )
20833 
 
20834 
  def __init__(self, orderId=None,):
20835 
    self.orderId = orderId
20836 
 
20837 
  def read(self, iprot):
20838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20840 
      return
20841 
    iprot.readStructBegin()
20842 
    while True:
20843 
      (fname, ftype, fid) = iprot.readFieldBegin()
20844 
      if ftype == TType.STOP:
20845 
        break
20846 
      if fid == 1:
20847 
        if ftype == TType.I64:
20848 
          self.orderId = iprot.readI64();
20849 
        else:
20850 
          iprot.skip(ftype)
20851 
      else:
20852 
        iprot.skip(ftype)
20853 
      iprot.readFieldEnd()
20854 
    iprot.readStructEnd()
20855 
 
20856 
  def write(self, oprot):
20857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20859 
      return
20860 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
20861 
    if self.orderId is not None:
20862 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20863 
      oprot.writeI64(self.orderId)
20864 
      oprot.writeFieldEnd()
20865 
    oprot.writeFieldStop()
20866 
    oprot.writeStructEnd()
20867 
 
20868 
  def validate(self):
20869 
    return
20870 
 
20871 
 
20872 
  def __repr__(self):
20873 
    L = ['%s=%r' % (key, value)
20874 
      for key, value in self.__dict__.iteritems()]
20875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20876 
 
20877 
  def __eq__(self, other):
20878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20879 
 
20880 
  def __ne__(self, other):
20881 
    return not (self == other)
20882 
 
20883 
class markOrderCancellationRequestDenied_result:
20884 
  """
20885 
  Attributes:
20886 
   - ex
20887 
  """
20888 
 
20889 
  thrift_spec = (
20890 
    None, # 0
20891 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20892 
  )
20893 
 
20894 
  def __init__(self, ex=None,):
20895 
    self.ex = ex
20896 
 
20897 
  def read(self, iprot):
20898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20900 
      return
20901 
    iprot.readStructBegin()
20902 
    while True:
20903 
      (fname, ftype, fid) = iprot.readFieldBegin()
20904 
      if ftype == TType.STOP:
20905 
        break
20906 
      if fid == 1:
20907 
        if ftype == TType.STRUCT:
20908 
          self.ex = TransactionServiceException()
20909 
          self.ex.read(iprot)
20910 
        else:
20911 
          iprot.skip(ftype)
20912 
      else:
20913 
        iprot.skip(ftype)
20914 
      iprot.readFieldEnd()
20915 
    iprot.readStructEnd()
20916 
 
20917 
  def write(self, oprot):
20918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20920 
      return
20921 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
20922 
    if self.ex is not None:
20923 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20924 
      self.ex.write(oprot)
20925 
      oprot.writeFieldEnd()
20926 
    oprot.writeFieldStop()
20927 
    oprot.writeStructEnd()
20928 
 
20929 
  def validate(self):
20930 
    return
20931 
 
20932 
 
20933 
  def __repr__(self):
20934 
    L = ['%s=%r' % (key, value)
20935 
      for key, value in self.__dict__.iteritems()]
20936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20937 
 
20938 
  def __eq__(self, other):
20939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20940 
 
20941 
  def __ne__(self, other):
20942 
    return not (self == other)
20943 
 
4258 rajveer 20944 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 20945 
  """
20946 
  Attributes:
4258 rajveer 20947 
   - transactionId
4247 rajveer 20948 
  """
20949 
 
20950 
  thrift_spec = (
20951 
    None, # 0
4258 rajveer 20952 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 20953 
  )
20954 
 
4258 rajveer 20955 
  def __init__(self, transactionId=None,):
20956 
    self.transactionId = transactionId
4247 rajveer 20957 
 
20958 
  def read(self, iprot):
20959 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20960 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20961 
      return
20962 
    iprot.readStructBegin()
20963 
    while True:
20964 
      (fname, ftype, fid) = iprot.readFieldBegin()
20965 
      if ftype == TType.STOP:
20966 
        break
20967 
      if fid == 1:
20968 
        if ftype == TType.I64:
4258 rajveer 20969 
          self.transactionId = iprot.readI64();
4247 rajveer 20970 
        else:
20971 
          iprot.skip(ftype)
20972 
      else:
20973 
        iprot.skip(ftype)
20974 
      iprot.readFieldEnd()
20975 
    iprot.readStructEnd()
20976 
 
20977 
  def write(self, oprot):
20978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20980 
      return
4258 rajveer 20981 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
20982 
    if self.transactionId is not None:
20983 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20984 
      oprot.writeI64(self.transactionId)
4247 rajveer 20985 
      oprot.writeFieldEnd()
20986 
    oprot.writeFieldStop()
20987 
    oprot.writeStructEnd()
20988 
 
20989 
  def validate(self):
20990 
    return
20991 
 
20992 
 
20993 
  def __repr__(self):
20994 
    L = ['%s=%r' % (key, value)
20995 
      for key, value in self.__dict__.iteritems()]
20996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20997 
 
20998 
  def __eq__(self, other):
20999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21000 
 
21001 
  def __ne__(self, other):
21002 
    return not (self == other)
21003 
 
4258 rajveer 21004 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 21005 
  """
21006 
  Attributes:
21007 
   - ex
21008 
  """
21009 
 
21010 
  thrift_spec = (
21011 
    None, # 0
21012 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21013 
  )
21014 
 
21015 
  def __init__(self, ex=None,):
21016 
    self.ex = ex
21017 
 
21018 
  def read(self, iprot):
21019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21021 
      return
21022 
    iprot.readStructBegin()
21023 
    while True:
21024 
      (fname, ftype, fid) = iprot.readFieldBegin()
21025 
      if ftype == TType.STOP:
21026 
        break
21027 
      if fid == 1:
21028 
        if ftype == TType.STRUCT:
21029 
          self.ex = TransactionServiceException()
21030 
          self.ex.read(iprot)
21031 
        else:
21032 
          iprot.skip(ftype)
21033 
      else:
21034 
        iprot.skip(ftype)
21035 
      iprot.readFieldEnd()
21036 
    iprot.readStructEnd()
21037 
 
21038 
  def write(self, oprot):
21039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21041 
      return
4258 rajveer 21042 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 21043 
    if self.ex is not None:
21044 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21045 
      self.ex.write(oprot)
21046 
      oprot.writeFieldEnd()
21047 
    oprot.writeFieldStop()
21048 
    oprot.writeStructEnd()
21049 
 
21050 
  def validate(self):
21051 
    return
21052 
 
21053 
 
21054 
  def __repr__(self):
21055 
    L = ['%s=%r' % (key, value)
21056 
      for key, value in self.__dict__.iteritems()]
21057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21058 
 
21059 
  def __eq__(self, other):
21060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21061 
 
21062 
  def __ne__(self, other):
21063 
    return not (self == other)
4259 anupam.sin 21064 
 
21065 
class refundTransaction_args:
21066 
  """
21067 
  Attributes:
21068 
   - transactionId
21069 
   - refundedBy
21070 
   - reason
21071 
  """
21072 
 
21073 
  thrift_spec = (
21074 
    None, # 0
21075 
    (1, TType.I64, 'transactionId', None, None, ), # 1
21076 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
21077 
    (3, TType.STRING, 'reason', None, None, ), # 3
21078 
  )
21079 
 
21080 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
21081 
    self.transactionId = transactionId
21082 
    self.refundedBy = refundedBy
21083 
    self.reason = reason
21084 
 
21085 
  def read(self, iprot):
21086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21088 
      return
21089 
    iprot.readStructBegin()
21090 
    while True:
21091 
      (fname, ftype, fid) = iprot.readFieldBegin()
21092 
      if ftype == TType.STOP:
21093 
        break
21094 
      if fid == 1:
21095 
        if ftype == TType.I64:
21096 
          self.transactionId = iprot.readI64();
21097 
        else:
21098 
          iprot.skip(ftype)
21099 
      elif fid == 2:
21100 
        if ftype == TType.STRING:
21101 
          self.refundedBy = iprot.readString();
21102 
        else:
21103 
          iprot.skip(ftype)
21104 
      elif fid == 3:
21105 
        if ftype == TType.STRING:
21106 
          self.reason = iprot.readString();
21107 
        else:
21108 
          iprot.skip(ftype)
21109 
      else:
21110 
        iprot.skip(ftype)
21111 
      iprot.readFieldEnd()
21112 
    iprot.readStructEnd()
21113 
 
21114 
  def write(self, oprot):
21115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21117 
      return
21118 
    oprot.writeStructBegin('refundTransaction_args')
21119 
    if self.transactionId is not None:
21120 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21121 
      oprot.writeI64(self.transactionId)
21122 
      oprot.writeFieldEnd()
21123 
    if self.refundedBy is not None:
21124 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
21125 
      oprot.writeString(self.refundedBy)
21126 
      oprot.writeFieldEnd()
21127 
    if self.reason is not None:
21128 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
21129 
      oprot.writeString(self.reason)
21130 
      oprot.writeFieldEnd()
21131 
    oprot.writeFieldStop()
21132 
    oprot.writeStructEnd()
21133 
 
21134 
  def validate(self):
21135 
    return
21136 
 
21137 
 
21138 
  def __repr__(self):
21139 
    L = ['%s=%r' % (key, value)
21140 
      for key, value in self.__dict__.iteritems()]
21141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21142 
 
21143 
  def __eq__(self, other):
21144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21145 
 
21146 
  def __ne__(self, other):
21147 
    return not (self == other)
21148 
 
21149 
class refundTransaction_result:
21150 
  """
21151 
  Attributes:
21152 
   - ex
21153 
  """
21154 
 
21155 
  thrift_spec = (
21156 
    None, # 0
21157 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21158 
  )
21159 
 
21160 
  def __init__(self, ex=None,):
21161 
    self.ex = ex
21162 
 
21163 
  def read(self, iprot):
21164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21166 
      return
21167 
    iprot.readStructBegin()
21168 
    while True:
21169 
      (fname, ftype, fid) = iprot.readFieldBegin()
21170 
      if ftype == TType.STOP:
21171 
        break
21172 
      if fid == 1:
21173 
        if ftype == TType.STRUCT:
21174 
          self.ex = TransactionServiceException()
21175 
          self.ex.read(iprot)
21176 
        else:
21177 
          iprot.skip(ftype)
21178 
      else:
21179 
        iprot.skip(ftype)
21180 
      iprot.readFieldEnd()
21181 
    iprot.readStructEnd()
21182 
 
21183 
  def write(self, oprot):
21184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21186 
      return
21187 
    oprot.writeStructBegin('refundTransaction_result')
21188 
    if self.ex is not None:
21189 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21190 
      self.ex.write(oprot)
21191 
      oprot.writeFieldEnd()
21192 
    oprot.writeFieldStop()
21193 
    oprot.writeStructEnd()
21194 
 
21195 
  def validate(self):
21196 
    return
21197 
 
21198 
 
21199 
  def __repr__(self):
21200 
    L = ['%s=%r' % (key, value)
21201 
      for key, value in self.__dict__.iteritems()]
21202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21203 
 
21204 
  def __eq__(self, other):
21205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21206 
 
21207 
  def __ne__(self, other):
21208 
    return not (self == other)
4285 rajveer 21209 
 
4324 mandeep.dh 21210 
class updateShipmentAddress_args:
21211 
  """
21212 
  Attributes:
21213 
   - orderId
21214 
   - addressId
21215 
  """
21216 
 
21217 
  thrift_spec = (
21218 
    None, # 0
21219 
    (1, TType.I64, 'orderId', None, None, ), # 1
21220 
    (2, TType.I64, 'addressId', None, None, ), # 2
21221 
  )
21222 
 
21223 
  def __init__(self, orderId=None, addressId=None,):
21224 
    self.orderId = orderId
21225 
    self.addressId = addressId
21226 
 
21227 
  def read(self, iprot):
21228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21230 
      return
21231 
    iprot.readStructBegin()
21232 
    while True:
21233 
      (fname, ftype, fid) = iprot.readFieldBegin()
21234 
      if ftype == TType.STOP:
21235 
        break
21236 
      if fid == 1:
21237 
        if ftype == TType.I64:
21238 
          self.orderId = iprot.readI64();
21239 
        else:
21240 
          iprot.skip(ftype)
21241 
      elif fid == 2:
21242 
        if ftype == TType.I64:
21243 
          self.addressId = iprot.readI64();
21244 
        else:
21245 
          iprot.skip(ftype)
21246 
      else:
21247 
        iprot.skip(ftype)
21248 
      iprot.readFieldEnd()
21249 
    iprot.readStructEnd()
21250 
 
21251 
  def write(self, oprot):
21252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21254 
      return
21255 
    oprot.writeStructBegin('updateShipmentAddress_args')
21256 
    if self.orderId is not None:
21257 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21258 
      oprot.writeI64(self.orderId)
21259 
      oprot.writeFieldEnd()
21260 
    if self.addressId is not None:
21261 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
21262 
      oprot.writeI64(self.addressId)
21263 
      oprot.writeFieldEnd()
21264 
    oprot.writeFieldStop()
21265 
    oprot.writeStructEnd()
21266 
 
21267 
  def validate(self):
21268 
    return
21269 
 
21270 
 
21271 
  def __repr__(self):
21272 
    L = ['%s=%r' % (key, value)
21273 
      for key, value in self.__dict__.iteritems()]
21274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21275 
 
21276 
  def __eq__(self, other):
21277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21278 
 
21279 
  def __ne__(self, other):
21280 
    return not (self == other)
21281 
 
21282 
class updateShipmentAddress_result:
21283 
  """
21284 
  Attributes:
21285 
   - ex
21286 
  """
21287 
 
21288 
  thrift_spec = (
21289 
    None, # 0
21290 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21291 
  )
21292 
 
21293 
  def __init__(self, ex=None,):
21294 
    self.ex = ex
21295 
 
21296 
  def read(self, iprot):
21297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21299 
      return
21300 
    iprot.readStructBegin()
21301 
    while True:
21302 
      (fname, ftype, fid) = iprot.readFieldBegin()
21303 
      if ftype == TType.STOP:
21304 
        break
21305 
      if fid == 1:
21306 
        if ftype == TType.STRUCT:
21307 
          self.ex = TransactionServiceException()
21308 
          self.ex.read(iprot)
21309 
        else:
21310 
          iprot.skip(ftype)
21311 
      else:
21312 
        iprot.skip(ftype)
21313 
      iprot.readFieldEnd()
21314 
    iprot.readStructEnd()
21315 
 
21316 
  def write(self, oprot):
21317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21319 
      return
21320 
    oprot.writeStructBegin('updateShipmentAddress_result')
21321 
    if self.ex is not None:
21322 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21323 
      self.ex.write(oprot)
21324 
      oprot.writeFieldEnd()
21325 
    oprot.writeFieldStop()
21326 
    oprot.writeStructEnd()
21327 
 
21328 
  def validate(self):
21329 
    return
21330 
 
21331 
 
21332 
  def __repr__(self):
21333 
    L = ['%s=%r' % (key, value)
21334 
      for key, value in self.__dict__.iteritems()]
21335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21336 
 
21337 
  def __eq__(self, other):
21338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21339 
 
21340 
  def __ne__(self, other):
21341 
    return not (self == other)
21342 
 
4285 rajveer 21343 
class acceptOrdersForItemId_args:
21344 
  """
21345 
  Attributes:
21346 
   - itemId
21347 
   - inventory
21348 
  """
21349 
 
21350 
  thrift_spec = (
21351 
    None, # 0
21352 
    (1, TType.I64, 'itemId', None, None, ), # 1
21353 
    (2, TType.I64, 'inventory', None, None, ), # 2
21354 
  )
21355 
 
21356 
  def __init__(self, itemId=None, inventory=None,):
21357 
    self.itemId = itemId
21358 
    self.inventory = inventory
21359 
 
21360 
  def read(self, iprot):
21361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21363 
      return
21364 
    iprot.readStructBegin()
21365 
    while True:
21366 
      (fname, ftype, fid) = iprot.readFieldBegin()
21367 
      if ftype == TType.STOP:
21368 
        break
21369 
      if fid == 1:
21370 
        if ftype == TType.I64:
21371 
          self.itemId = iprot.readI64();
21372 
        else:
21373 
          iprot.skip(ftype)
21374 
      elif fid == 2:
21375 
        if ftype == TType.I64:
21376 
          self.inventory = iprot.readI64();
21377 
        else:
21378 
          iprot.skip(ftype)
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('acceptOrdersForItemId_args')
21389 
    if self.itemId is not None:
21390 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21391 
      oprot.writeI64(self.itemId)
21392 
      oprot.writeFieldEnd()
21393 
    if self.inventory is not None:
21394 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
21395 
      oprot.writeI64(self.inventory)
21396 
      oprot.writeFieldEnd()
21397 
    oprot.writeFieldStop()
21398 
    oprot.writeStructEnd()
21399 
 
21400 
  def validate(self):
21401 
    return
21402 
 
21403 
 
21404 
  def __repr__(self):
21405 
    L = ['%s=%r' % (key, value)
21406 
      for key, value in self.__dict__.iteritems()]
21407 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21408 
 
21409 
  def __eq__(self, other):
21410 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21411 
 
21412 
  def __ne__(self, other):
21413 
    return not (self == other)
21414 
 
21415 
class acceptOrdersForItemId_result:
21416 
  """
21417 
  Attributes:
21418 
   - success
21419 
   - ex
21420 
  """
21421 
 
21422 
  thrift_spec = (
21423 
    (0, TType.BOOL, 'success', None, None, ), # 0
21424 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21425 
  )
21426 
 
21427 
  def __init__(self, success=None, ex=None,):
21428 
    self.success = success
21429 
    self.ex = ex
21430 
 
21431 
  def read(self, iprot):
21432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21434 
      return
21435 
    iprot.readStructBegin()
21436 
    while True:
21437 
      (fname, ftype, fid) = iprot.readFieldBegin()
21438 
      if ftype == TType.STOP:
21439 
        break
21440 
      if fid == 0:
21441 
        if ftype == TType.BOOL:
21442 
          self.success = iprot.readBool();
21443 
        else:
21444 
          iprot.skip(ftype)
21445 
      elif fid == 1:
21446 
        if ftype == TType.STRUCT:
21447 
          self.ex = TransactionServiceException()
21448 
          self.ex.read(iprot)
21449 
        else:
21450 
          iprot.skip(ftype)
21451 
      else:
21452 
        iprot.skip(ftype)
21453 
      iprot.readFieldEnd()
21454 
    iprot.readStructEnd()
21455 
 
21456 
  def write(self, oprot):
21457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21459 
      return
21460 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
21461 
    if self.success is not None:
21462 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21463 
      oprot.writeBool(self.success)
21464 
      oprot.writeFieldEnd()
21465 
    if self.ex is not None:
21466 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21467 
      self.ex.write(oprot)
21468 
      oprot.writeFieldEnd()
21469 
    oprot.writeFieldStop()
21470 
    oprot.writeStructEnd()
21471 
 
21472 
  def validate(self):
21473 
    return
21474 
 
21475 
 
21476 
  def __repr__(self):
21477 
    L = ['%s=%r' % (key, value)
21478 
      for key, value in self.__dict__.iteritems()]
21479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21480 
 
21481 
  def __eq__(self, other):
21482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21483 
 
21484 
  def __ne__(self, other):
21485 
    return not (self == other)
4303 rajveer 21486 
 
21487 
class markOrdersAsPORaised_args:
21488 
  """
21489 
  Attributes:
21490 
   - vendorId
21491 
   - itemId
21492 
   - quantity
21493 
   - estimate
4369 rajveer 21494 
   - isReminder
4303 rajveer 21495 
  """
21496 
 
21497 
  thrift_spec = (
21498 
    None, # 0
21499 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21500 
    (2, TType.I64, 'itemId', None, None, ), # 2
21501 
    (3, TType.I64, 'quantity', None, None, ), # 3
21502 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21503 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21504 
  )
21505 
 
4369 rajveer 21506 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21507 
    self.vendorId = vendorId
21508 
    self.itemId = itemId
21509 
    self.quantity = quantity
21510 
    self.estimate = estimate
4369 rajveer 21511 
    self.isReminder = isReminder
4303 rajveer 21512 
 
21513 
  def read(self, iprot):
21514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21516 
      return
21517 
    iprot.readStructBegin()
21518 
    while True:
21519 
      (fname, ftype, fid) = iprot.readFieldBegin()
21520 
      if ftype == TType.STOP:
21521 
        break
21522 
      if fid == 1:
21523 
        if ftype == TType.I64:
21524 
          self.vendorId = iprot.readI64();
21525 
        else:
21526 
          iprot.skip(ftype)
21527 
      elif fid == 2:
21528 
        if ftype == TType.I64:
21529 
          self.itemId = iprot.readI64();
21530 
        else:
21531 
          iprot.skip(ftype)
21532 
      elif fid == 3:
21533 
        if ftype == TType.I64:
21534 
          self.quantity = iprot.readI64();
21535 
        else:
21536 
          iprot.skip(ftype)
21537 
      elif fid == 4:
21538 
        if ftype == TType.I64:
21539 
          self.estimate = iprot.readI64();
21540 
        else:
21541 
          iprot.skip(ftype)
4369 rajveer 21542 
      elif fid == 5:
21543 
        if ftype == TType.BOOL:
21544 
          self.isReminder = iprot.readBool();
21545 
        else:
21546 
          iprot.skip(ftype)
4303 rajveer 21547 
      else:
21548 
        iprot.skip(ftype)
21549 
      iprot.readFieldEnd()
21550 
    iprot.readStructEnd()
21551 
 
21552 
  def write(self, oprot):
21553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21555 
      return
21556 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
21557 
    if self.vendorId is not None:
21558 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21559 
      oprot.writeI64(self.vendorId)
21560 
      oprot.writeFieldEnd()
21561 
    if self.itemId is not None:
21562 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21563 
      oprot.writeI64(self.itemId)
21564 
      oprot.writeFieldEnd()
21565 
    if self.quantity is not None:
21566 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21567 
      oprot.writeI64(self.quantity)
21568 
      oprot.writeFieldEnd()
21569 
    if self.estimate is not None:
21570 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21571 
      oprot.writeI64(self.estimate)
21572 
      oprot.writeFieldEnd()
4369 rajveer 21573 
    if self.isReminder is not None:
21574 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21575 
      oprot.writeBool(self.isReminder)
21576 
      oprot.writeFieldEnd()
4303 rajveer 21577 
    oprot.writeFieldStop()
21578 
    oprot.writeStructEnd()
21579 
 
21580 
  def validate(self):
21581 
    return
21582 
 
21583 
 
21584 
  def __repr__(self):
21585 
    L = ['%s=%r' % (key, value)
21586 
      for key, value in self.__dict__.iteritems()]
21587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21588 
 
21589 
  def __eq__(self, other):
21590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21591 
 
21592 
  def __ne__(self, other):
21593 
    return not (self == other)
21594 
 
21595 
class markOrdersAsPORaised_result:
21596 
  """
21597 
  Attributes:
21598 
   - ex
21599 
  """
21600 
 
21601 
  thrift_spec = (
21602 
    None, # 0
21603 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21604 
  )
21605 
 
21606 
  def __init__(self, ex=None,):
21607 
    self.ex = ex
21608 
 
21609 
  def read(self, iprot):
21610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21612 
      return
21613 
    iprot.readStructBegin()
21614 
    while True:
21615 
      (fname, ftype, fid) = iprot.readFieldBegin()
21616 
      if ftype == TType.STOP:
21617 
        break
21618 
      if fid == 1:
21619 
        if ftype == TType.STRUCT:
21620 
          self.ex = TransactionServiceException()
21621 
          self.ex.read(iprot)
21622 
        else:
21623 
          iprot.skip(ftype)
21624 
      else:
21625 
        iprot.skip(ftype)
21626 
      iprot.readFieldEnd()
21627 
    iprot.readStructEnd()
21628 
 
21629 
  def write(self, oprot):
21630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21632 
      return
21633 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
21634 
    if self.ex is not None:
21635 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21636 
      self.ex.write(oprot)
21637 
      oprot.writeFieldEnd()
21638 
    oprot.writeFieldStop()
21639 
    oprot.writeStructEnd()
21640 
 
21641 
  def validate(self):
21642 
    return
21643 
 
21644 
 
21645 
  def __repr__(self):
21646 
    L = ['%s=%r' % (key, value)
21647 
      for key, value in self.__dict__.iteritems()]
21648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21649 
 
21650 
  def __eq__(self, other):
21651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21652 
 
21653 
  def __ne__(self, other):
21654 
    return not (self == other)
21655 
 
21656 
class markOrdersAsReversalInitiated_args:
21657 
  """
21658 
  Attributes:
21659 
   - vendorId
21660 
   - itemId
21661 
   - quantity
21662 
   - estimate
4369 rajveer 21663 
   - isReminder
4303 rajveer 21664 
  """
21665 
 
21666 
  thrift_spec = (
21667 
    None, # 0
21668 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21669 
    (2, TType.I64, 'itemId', None, None, ), # 2
21670 
    (3, TType.I64, 'quantity', None, None, ), # 3
21671 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21672 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21673 
  )
21674 
 
4369 rajveer 21675 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21676 
    self.vendorId = vendorId
21677 
    self.itemId = itemId
21678 
    self.quantity = quantity
21679 
    self.estimate = estimate
4369 rajveer 21680 
    self.isReminder = isReminder
4303 rajveer 21681 
 
21682 
  def read(self, iprot):
21683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21685 
      return
21686 
    iprot.readStructBegin()
21687 
    while True:
21688 
      (fname, ftype, fid) = iprot.readFieldBegin()
21689 
      if ftype == TType.STOP:
21690 
        break
21691 
      if fid == 1:
21692 
        if ftype == TType.I64:
21693 
          self.vendorId = iprot.readI64();
21694 
        else:
21695 
          iprot.skip(ftype)
21696 
      elif fid == 2:
21697 
        if ftype == TType.I64:
21698 
          self.itemId = iprot.readI64();
21699 
        else:
21700 
          iprot.skip(ftype)
21701 
      elif fid == 3:
21702 
        if ftype == TType.I64:
21703 
          self.quantity = iprot.readI64();
21704 
        else:
21705 
          iprot.skip(ftype)
21706 
      elif fid == 4:
21707 
        if ftype == TType.I64:
21708 
          self.estimate = iprot.readI64();
21709 
        else:
21710 
          iprot.skip(ftype)
4369 rajveer 21711 
      elif fid == 5:
21712 
        if ftype == TType.BOOL:
21713 
          self.isReminder = iprot.readBool();
21714 
        else:
21715 
          iprot.skip(ftype)
4303 rajveer 21716 
      else:
21717 
        iprot.skip(ftype)
21718 
      iprot.readFieldEnd()
21719 
    iprot.readStructEnd()
21720 
 
21721 
  def write(self, oprot):
21722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21724 
      return
21725 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
21726 
    if self.vendorId is not None:
21727 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21728 
      oprot.writeI64(self.vendorId)
21729 
      oprot.writeFieldEnd()
21730 
    if self.itemId is not None:
21731 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21732 
      oprot.writeI64(self.itemId)
21733 
      oprot.writeFieldEnd()
21734 
    if self.quantity is not None:
21735 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21736 
      oprot.writeI64(self.quantity)
21737 
      oprot.writeFieldEnd()
21738 
    if self.estimate is not None:
21739 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21740 
      oprot.writeI64(self.estimate)
21741 
      oprot.writeFieldEnd()
4369 rajveer 21742 
    if self.isReminder is not None:
21743 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21744 
      oprot.writeBool(self.isReminder)
21745 
      oprot.writeFieldEnd()
4303 rajveer 21746 
    oprot.writeFieldStop()
21747 
    oprot.writeStructEnd()
21748 
 
21749 
  def validate(self):
21750 
    return
21751 
 
21752 
 
21753 
  def __repr__(self):
21754 
    L = ['%s=%r' % (key, value)
21755 
      for key, value in self.__dict__.iteritems()]
21756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21757 
 
21758 
  def __eq__(self, other):
21759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21760 
 
21761 
  def __ne__(self, other):
21762 
    return not (self == other)
21763 
 
21764 
class markOrdersAsReversalInitiated_result:
21765 
  """
21766 
  Attributes:
21767 
   - ex
21768 
  """
21769 
 
21770 
  thrift_spec = (
21771 
    None, # 0
21772 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21773 
  )
21774 
 
21775 
  def __init__(self, ex=None,):
21776 
    self.ex = ex
21777 
 
21778 
  def read(self, iprot):
21779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21781 
      return
21782 
    iprot.readStructBegin()
21783 
    while True:
21784 
      (fname, ftype, fid) = iprot.readFieldBegin()
21785 
      if ftype == TType.STOP:
21786 
        break
21787 
      if fid == 1:
21788 
        if ftype == TType.STRUCT:
21789 
          self.ex = TransactionServiceException()
21790 
          self.ex.read(iprot)
21791 
        else:
21792 
          iprot.skip(ftype)
21793 
      else:
21794 
        iprot.skip(ftype)
21795 
      iprot.readFieldEnd()
21796 
    iprot.readStructEnd()
21797 
 
21798 
  def write(self, oprot):
21799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21801 
      return
21802 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
21803 
    if self.ex is not None:
21804 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21805 
      self.ex.write(oprot)
21806 
      oprot.writeFieldEnd()
21807 
    oprot.writeFieldStop()
21808 
    oprot.writeStructEnd()
21809 
 
21810 
  def validate(self):
21811 
    return
21812 
 
21813 
 
21814 
  def __repr__(self):
21815 
    L = ['%s=%r' % (key, value)
21816 
      for key, value in self.__dict__.iteritems()]
21817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21818 
 
21819 
  def __eq__(self, other):
21820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21821 
 
21822 
  def __ne__(self, other):
21823 
    return not (self == other)
21824 
 
21825 
class markOrdersAsNotAvailabke_args:
21826 
  """
21827 
  Attributes:
21828 
   - vendorId
21829 
   - itemId
21830 
   - quantity
21831 
   - estimate
4369 rajveer 21832 
   - isReminder
4303 rajveer 21833 
  """
21834 
 
21835 
  thrift_spec = (
21836 
    None, # 0
21837 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21838 
    (2, TType.I64, 'itemId', None, None, ), # 2
21839 
    (3, TType.I64, 'quantity', None, None, ), # 3
21840 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21841 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21842 
  )
21843 
 
4369 rajveer 21844 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21845 
    self.vendorId = vendorId
21846 
    self.itemId = itemId
21847 
    self.quantity = quantity
21848 
    self.estimate = estimate
4369 rajveer 21849 
    self.isReminder = isReminder
4303 rajveer 21850 
 
21851 
  def read(self, iprot):
21852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21854 
      return
21855 
    iprot.readStructBegin()
21856 
    while True:
21857 
      (fname, ftype, fid) = iprot.readFieldBegin()
21858 
      if ftype == TType.STOP:
21859 
        break
21860 
      if fid == 1:
21861 
        if ftype == TType.I64:
21862 
          self.vendorId = iprot.readI64();
21863 
        else:
21864 
          iprot.skip(ftype)
21865 
      elif fid == 2:
21866 
        if ftype == TType.I64:
21867 
          self.itemId = iprot.readI64();
21868 
        else:
21869 
          iprot.skip(ftype)
21870 
      elif fid == 3:
21871 
        if ftype == TType.I64:
21872 
          self.quantity = iprot.readI64();
21873 
        else:
21874 
          iprot.skip(ftype)
21875 
      elif fid == 4:
21876 
        if ftype == TType.I64:
21877 
          self.estimate = iprot.readI64();
21878 
        else:
21879 
          iprot.skip(ftype)
4369 rajveer 21880 
      elif fid == 5:
21881 
        if ftype == TType.BOOL:
21882 
          self.isReminder = iprot.readBool();
21883 
        else:
21884 
          iprot.skip(ftype)
4303 rajveer 21885 
      else:
21886 
        iprot.skip(ftype)
21887 
      iprot.readFieldEnd()
21888 
    iprot.readStructEnd()
21889 
 
21890 
  def write(self, oprot):
21891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21893 
      return
21894 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
21895 
    if self.vendorId is not None:
21896 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21897 
      oprot.writeI64(self.vendorId)
21898 
      oprot.writeFieldEnd()
21899 
    if self.itemId is not None:
21900 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21901 
      oprot.writeI64(self.itemId)
21902 
      oprot.writeFieldEnd()
21903 
    if self.quantity is not None:
21904 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21905 
      oprot.writeI64(self.quantity)
21906 
      oprot.writeFieldEnd()
21907 
    if self.estimate is not None:
21908 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21909 
      oprot.writeI64(self.estimate)
21910 
      oprot.writeFieldEnd()
4369 rajveer 21911 
    if self.isReminder is not None:
21912 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21913 
      oprot.writeBool(self.isReminder)
21914 
      oprot.writeFieldEnd()
4303 rajveer 21915 
    oprot.writeFieldStop()
21916 
    oprot.writeStructEnd()
21917 
 
21918 
  def validate(self):
21919 
    return
21920 
 
21921 
 
21922 
  def __repr__(self):
21923 
    L = ['%s=%r' % (key, value)
21924 
      for key, value in self.__dict__.iteritems()]
21925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21926 
 
21927 
  def __eq__(self, other):
21928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21929 
 
21930 
  def __ne__(self, other):
21931 
    return not (self == other)
21932 
 
21933 
class markOrdersAsNotAvailabke_result:
21934 
  """
21935 
  Attributes:
21936 
   - ex
21937 
  """
21938 
 
21939 
  thrift_spec = (
21940 
    None, # 0
21941 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21942 
  )
21943 
 
21944 
  def __init__(self, ex=None,):
21945 
    self.ex = ex
21946 
 
21947 
  def read(self, iprot):
21948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21950 
      return
21951 
    iprot.readStructBegin()
21952 
    while True:
21953 
      (fname, ftype, fid) = iprot.readFieldBegin()
21954 
      if ftype == TType.STOP:
21955 
        break
21956 
      if fid == 1:
21957 
        if ftype == TType.STRUCT:
21958 
          self.ex = TransactionServiceException()
21959 
          self.ex.read(iprot)
21960 
        else:
21961 
          iprot.skip(ftype)
21962 
      else:
21963 
        iprot.skip(ftype)
21964 
      iprot.readFieldEnd()
21965 
    iprot.readStructEnd()
21966 
 
21967 
  def write(self, oprot):
21968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21970 
      return
21971 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
21972 
    if self.ex is not None:
21973 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21974 
      self.ex.write(oprot)
21975 
      oprot.writeFieldEnd()
21976 
    oprot.writeFieldStop()
21977 
    oprot.writeStructEnd()
21978 
 
21979 
  def validate(self):
21980 
    return
21981 
 
21982 
 
21983 
  def __repr__(self):
21984 
    L = ['%s=%r' % (key, value)
21985 
      for key, value in self.__dict__.iteritems()]
21986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21987 
 
21988 
  def __eq__(self, other):
21989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21990 
 
21991 
  def __ne__(self, other):
21992 
    return not (self == other)
4369 rajveer 21993 
 
21994 
class markOrdersAsTimeout_args:
21995 
  """
21996 
  Attributes:
21997 
   - vendorId
21998 
  """
21999 
 
22000 
  thrift_spec = (
22001 
    None, # 0
22002 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22003 
  )
22004 
 
22005 
  def __init__(self, vendorId=None,):
22006 
    self.vendorId = vendorId
22007 
 
22008 
  def read(self, iprot):
22009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22011 
      return
22012 
    iprot.readStructBegin()
22013 
    while True:
22014 
      (fname, ftype, fid) = iprot.readFieldBegin()
22015 
      if ftype == TType.STOP:
22016 
        break
22017 
      if fid == 1:
22018 
        if ftype == TType.I64:
22019 
          self.vendorId = iprot.readI64();
22020 
        else:
22021 
          iprot.skip(ftype)
22022 
      else:
22023 
        iprot.skip(ftype)
22024 
      iprot.readFieldEnd()
22025 
    iprot.readStructEnd()
22026 
 
22027 
  def write(self, oprot):
22028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22030 
      return
22031 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
22032 
    if self.vendorId is not None:
22033 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22034 
      oprot.writeI64(self.vendorId)
22035 
      oprot.writeFieldEnd()
22036 
    oprot.writeFieldStop()
22037 
    oprot.writeStructEnd()
22038 
 
22039 
  def validate(self):
22040 
    return
22041 
 
22042 
 
22043 
  def __repr__(self):
22044 
    L = ['%s=%r' % (key, value)
22045 
      for key, value in self.__dict__.iteritems()]
22046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22047 
 
22048 
  def __eq__(self, other):
22049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22050 
 
22051 
  def __ne__(self, other):
22052 
    return not (self == other)
22053 
 
22054 
class markOrdersAsTimeout_result:
22055 
  """
22056 
  Attributes:
22057 
   - success
22058 
   - ex
22059 
  """
22060 
 
22061 
  thrift_spec = (
22062 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
22063 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22064 
  )
22065 
 
22066 
  def __init__(self, success=None, ex=None,):
22067 
    self.success = success
22068 
    self.ex = ex
22069 
 
22070 
  def read(self, iprot):
22071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22073 
      return
22074 
    iprot.readStructBegin()
22075 
    while True:
22076 
      (fname, ftype, fid) = iprot.readFieldBegin()
22077 
      if ftype == TType.STOP:
22078 
        break
22079 
      if fid == 0:
22080 
        if ftype == TType.MAP:
22081 
          self.success = {}
6188 rajveer 22082 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
22083 
          for _i505 in xrange(_size501):
22084 
            _key506 = iprot.readI32();
22085 
            _val507 = TimeoutSummary()
22086 
            _val507.read(iprot)
22087 
            self.success[_key506] = _val507
4369 rajveer 22088 
          iprot.readMapEnd()
22089 
        else:
22090 
          iprot.skip(ftype)
22091 
      elif fid == 1:
22092 
        if ftype == TType.STRUCT:
22093 
          self.ex = TransactionServiceException()
22094 
          self.ex.read(iprot)
22095 
        else:
22096 
          iprot.skip(ftype)
22097 
      else:
22098 
        iprot.skip(ftype)
22099 
      iprot.readFieldEnd()
22100 
    iprot.readStructEnd()
22101 
 
22102 
  def write(self, oprot):
22103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22105 
      return
22106 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
22107 
    if self.success is not None:
22108 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22109 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 22110 
      for kiter508,viter509 in self.success.items():
22111 
        oprot.writeI32(kiter508)
22112 
        viter509.write(oprot)
4369 rajveer 22113 
      oprot.writeMapEnd()
22114 
      oprot.writeFieldEnd()
22115 
    if self.ex is not None:
22116 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22117 
      self.ex.write(oprot)
22118 
      oprot.writeFieldEnd()
22119 
    oprot.writeFieldStop()
22120 
    oprot.writeStructEnd()
22121 
 
22122 
  def validate(self):
22123 
    return
22124 
 
22125 
 
22126 
  def __repr__(self):
22127 
    L = ['%s=%r' % (key, value)
22128 
      for key, value in self.__dict__.iteritems()]
22129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22130 
 
22131 
  def __eq__(self, other):
22132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22133 
 
22134 
  def __ne__(self, other):
22135 
    return not (self == other)
4386 anupam.sin 22136 
 
4662 rajveer 22137 
class markOrderAsLostInTransit_args:
22138 
  """
22139 
  Attributes:
22140 
   - orderId
22141 
  """
22142 
 
22143 
  thrift_spec = (
22144 
    None, # 0
22145 
    (1, TType.I64, 'orderId', None, None, ), # 1
22146 
  )
22147 
 
22148 
  def __init__(self, orderId=None,):
22149 
    self.orderId = orderId
22150 
 
22151 
  def read(self, iprot):
22152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22154 
      return
22155 
    iprot.readStructBegin()
22156 
    while True:
22157 
      (fname, ftype, fid) = iprot.readFieldBegin()
22158 
      if ftype == TType.STOP:
22159 
        break
22160 
      if fid == 1:
22161 
        if ftype == TType.I64:
22162 
          self.orderId = iprot.readI64();
22163 
        else:
22164 
          iprot.skip(ftype)
22165 
      else:
22166 
        iprot.skip(ftype)
22167 
      iprot.readFieldEnd()
22168 
    iprot.readStructEnd()
22169 
 
22170 
  def write(self, oprot):
22171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22173 
      return
22174 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
22175 
    if self.orderId is not None:
22176 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22177 
      oprot.writeI64(self.orderId)
22178 
      oprot.writeFieldEnd()
22179 
    oprot.writeFieldStop()
22180 
    oprot.writeStructEnd()
22181 
 
22182 
  def validate(self):
22183 
    return
22184 
 
22185 
 
22186 
  def __repr__(self):
22187 
    L = ['%s=%r' % (key, value)
22188 
      for key, value in self.__dict__.iteritems()]
22189 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22190 
 
22191 
  def __eq__(self, other):
22192 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22193 
 
22194 
  def __ne__(self, other):
22195 
    return not (self == other)
22196 
 
22197 
class markOrderAsLostInTransit_result:
22198 
  """
22199 
  Attributes:
22200 
   - success
22201 
   - ex
22202 
  """
22203 
 
22204 
  thrift_spec = (
22205 
    (0, TType.BOOL, 'success', None, None, ), # 0
22206 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22207 
  )
22208 
 
22209 
  def __init__(self, success=None, ex=None,):
22210 
    self.success = success
22211 
    self.ex = ex
22212 
 
22213 
  def read(self, iprot):
22214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22216 
      return
22217 
    iprot.readStructBegin()
22218 
    while True:
22219 
      (fname, ftype, fid) = iprot.readFieldBegin()
22220 
      if ftype == TType.STOP:
22221 
        break
22222 
      if fid == 0:
22223 
        if ftype == TType.BOOL:
22224 
          self.success = iprot.readBool();
22225 
        else:
22226 
          iprot.skip(ftype)
22227 
      elif fid == 1:
22228 
        if ftype == TType.STRUCT:
22229 
          self.ex = TransactionServiceException()
22230 
          self.ex.read(iprot)
22231 
        else:
22232 
          iprot.skip(ftype)
22233 
      else:
22234 
        iprot.skip(ftype)
22235 
      iprot.readFieldEnd()
22236 
    iprot.readStructEnd()
22237 
 
22238 
  def write(self, oprot):
22239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22241 
      return
22242 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
22243 
    if self.success is not None:
22244 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22245 
      oprot.writeBool(self.success)
22246 
      oprot.writeFieldEnd()
22247 
    if self.ex is not None:
22248 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22249 
      self.ex.write(oprot)
22250 
      oprot.writeFieldEnd()
22251 
    oprot.writeFieldStop()
22252 
    oprot.writeStructEnd()
22253 
 
22254 
  def validate(self):
22255 
    return
22256 
 
22257 
 
22258 
  def __repr__(self):
22259 
    L = ['%s=%r' % (key, value)
22260 
      for key, value in self.__dict__.iteritems()]
22261 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22262 
 
22263 
  def __eq__(self, other):
22264 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22265 
 
22266 
  def __ne__(self, other):
22267 
    return not (self == other)
22268 
 
4386 anupam.sin 22269 
class getOrderForAwb_args:
22270 
  """
22271 
  Attributes:
22272 
   - awb
22273 
  """
22274 
 
22275 
  thrift_spec = (
22276 
    None, # 0
22277 
    (1, TType.STRING, 'awb', None, None, ), # 1
22278 
  )
22279 
 
22280 
  def __init__(self, awb=None,):
22281 
    self.awb = awb
22282 
 
22283 
  def read(self, iprot):
22284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22286 
      return
22287 
    iprot.readStructBegin()
22288 
    while True:
22289 
      (fname, ftype, fid) = iprot.readFieldBegin()
22290 
      if ftype == TType.STOP:
22291 
        break
22292 
      if fid == 1:
22293 
        if ftype == TType.STRING:
22294 
          self.awb = iprot.readString();
22295 
        else:
22296 
          iprot.skip(ftype)
22297 
      else:
22298 
        iprot.skip(ftype)
22299 
      iprot.readFieldEnd()
22300 
    iprot.readStructEnd()
22301 
 
22302 
  def write(self, oprot):
22303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22305 
      return
22306 
    oprot.writeStructBegin('getOrderForAwb_args')
22307 
    if self.awb is not None:
22308 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
22309 
      oprot.writeString(self.awb)
22310 
      oprot.writeFieldEnd()
22311 
    oprot.writeFieldStop()
22312 
    oprot.writeStructEnd()
22313 
 
22314 
  def validate(self):
22315 
    return
22316 
 
22317 
 
22318 
  def __repr__(self):
22319 
    L = ['%s=%r' % (key, value)
22320 
      for key, value in self.__dict__.iteritems()]
22321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22322 
 
22323 
  def __eq__(self, other):
22324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22325 
 
22326 
  def __ne__(self, other):
22327 
    return not (self == other)
22328 
 
22329 
class getOrderForAwb_result:
22330 
  """
22331 
  Attributes:
22332 
   - success
22333 
   - ex
22334 
  """
22335 
 
22336 
  thrift_spec = (
22337 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
22338 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22339 
  )
22340 
 
22341 
  def __init__(self, success=None, ex=None,):
22342 
    self.success = success
22343 
    self.ex = ex
22344 
 
22345 
  def read(self, iprot):
22346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22348 
      return
22349 
    iprot.readStructBegin()
22350 
    while True:
22351 
      (fname, ftype, fid) = iprot.readFieldBegin()
22352 
      if ftype == TType.STOP:
22353 
        break
22354 
      if fid == 0:
22355 
        if ftype == TType.STRUCT:
22356 
          self.success = Order()
22357 
          self.success.read(iprot)
22358 
        else:
22359 
          iprot.skip(ftype)
22360 
      elif fid == 1:
22361 
        if ftype == TType.STRUCT:
22362 
          self.ex = TransactionServiceException()
22363 
          self.ex.read(iprot)
22364 
        else:
22365 
          iprot.skip(ftype)
22366 
      else:
22367 
        iprot.skip(ftype)
22368 
      iprot.readFieldEnd()
22369 
    iprot.readStructEnd()
22370 
 
22371 
  def write(self, oprot):
22372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22374 
      return
22375 
    oprot.writeStructBegin('getOrderForAwb_result')
22376 
    if self.success is not None:
22377 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22378 
      self.success.write(oprot)
22379 
      oprot.writeFieldEnd()
22380 
    if self.ex is not None:
22381 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22382 
      self.ex.write(oprot)
22383 
      oprot.writeFieldEnd()
22384 
    oprot.writeFieldStop()
22385 
    oprot.writeStructEnd()
22386 
 
22387 
  def validate(self):
22388 
    return
22389 
 
22390 
 
22391 
  def __repr__(self):
22392 
    L = ['%s=%r' % (key, value)
22393 
      for key, value in self.__dict__.iteritems()]
22394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22395 
 
22396 
  def __eq__(self, other):
22397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22398 
 
22399 
  def __ne__(self, other):
22400 
    return not (self == other)
4506 phani.kuma 22401 
 
22402 
class getOrdersForProviderForStatus_args:
22403 
  """
22404 
  Attributes:
22405 
   - logistics_provider_id
4910 phani.kuma 22406 
   - order_status_list
4506 phani.kuma 22407 
  """
22408 
 
22409 
  thrift_spec = (
22410 
    None, # 0
22411 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 22412 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 22413 
  )
22414 
 
4910 phani.kuma 22415 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 22416 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 22417 
    self.order_status_list = order_status_list
4506 phani.kuma 22418 
 
22419 
  def read(self, iprot):
22420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22422 
      return
22423 
    iprot.readStructBegin()
22424 
    while True:
22425 
      (fname, ftype, fid) = iprot.readFieldBegin()
22426 
      if ftype == TType.STOP:
22427 
        break
22428 
      if fid == 1:
22429 
        if ftype == TType.I64:
22430 
          self.logistics_provider_id = iprot.readI64();
22431 
        else:
22432 
          iprot.skip(ftype)
22433 
      elif fid == 2:
4910 phani.kuma 22434 
        if ftype == TType.LIST:
22435 
          self.order_status_list = []
6188 rajveer 22436 
          (_etype513, _size510) = iprot.readListBegin()
22437 
          for _i514 in xrange(_size510):
22438 
            _elem515 = iprot.readI32();
22439 
            self.order_status_list.append(_elem515)
4910 phani.kuma 22440 
          iprot.readListEnd()
4506 phani.kuma 22441 
        else:
22442 
          iprot.skip(ftype)
22443 
      else:
22444 
        iprot.skip(ftype)
22445 
      iprot.readFieldEnd()
22446 
    iprot.readStructEnd()
22447 
 
22448 
  def write(self, oprot):
22449 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22450 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22451 
      return
22452 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
22453 
    if self.logistics_provider_id is not None:
22454 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
22455 
      oprot.writeI64(self.logistics_provider_id)
22456 
      oprot.writeFieldEnd()
4910 phani.kuma 22457 
    if self.order_status_list is not None:
22458 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
22459 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 22460 
      for iter516 in self.order_status_list:
22461 
        oprot.writeI32(iter516)
4910 phani.kuma 22462 
      oprot.writeListEnd()
4506 phani.kuma 22463 
      oprot.writeFieldEnd()
22464 
    oprot.writeFieldStop()
22465 
    oprot.writeStructEnd()
22466 
 
22467 
  def validate(self):
22468 
    return
22469 
 
22470 
 
22471 
  def __repr__(self):
22472 
    L = ['%s=%r' % (key, value)
22473 
      for key, value in self.__dict__.iteritems()]
22474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22475 
 
22476 
  def __eq__(self, other):
22477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22478 
 
22479 
  def __ne__(self, other):
22480 
    return not (self == other)
22481 
 
22482 
class getOrdersForProviderForStatus_result:
22483 
  """
22484 
  Attributes:
22485 
   - success
22486 
   - ex
22487 
  """
22488 
 
22489 
  thrift_spec = (
22490 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22491 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22492 
  )
22493 
 
22494 
  def __init__(self, success=None, ex=None,):
22495 
    self.success = success
22496 
    self.ex = ex
22497 
 
22498 
  def read(self, iprot):
22499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22501 
      return
22502 
    iprot.readStructBegin()
22503 
    while True:
22504 
      (fname, ftype, fid) = iprot.readFieldBegin()
22505 
      if ftype == TType.STOP:
22506 
        break
22507 
      if fid == 0:
22508 
        if ftype == TType.LIST:
22509 
          self.success = []
6188 rajveer 22510 
          (_etype520, _size517) = iprot.readListBegin()
22511 
          for _i521 in xrange(_size517):
22512 
            _elem522 = Order()
22513 
            _elem522.read(iprot)
22514 
            self.success.append(_elem522)
4506 phani.kuma 22515 
          iprot.readListEnd()
22516 
        else:
22517 
          iprot.skip(ftype)
22518 
      elif fid == 1:
22519 
        if ftype == TType.STRUCT:
22520 
          self.ex = TransactionServiceException()
22521 
          self.ex.read(iprot)
22522 
        else:
22523 
          iprot.skip(ftype)
22524 
      else:
22525 
        iprot.skip(ftype)
22526 
      iprot.readFieldEnd()
22527 
    iprot.readStructEnd()
22528 
 
22529 
  def write(self, oprot):
22530 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22531 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22532 
      return
22533 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
22534 
    if self.success is not None:
22535 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22536 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22537 
      for iter523 in self.success:
22538 
        iter523.write(oprot)
4506 phani.kuma 22539 
      oprot.writeListEnd()
22540 
      oprot.writeFieldEnd()
22541 
    if self.ex is not None:
22542 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22543 
      self.ex.write(oprot)
22544 
      oprot.writeFieldEnd()
22545 
    oprot.writeFieldStop()
22546 
    oprot.writeStructEnd()
22547 
 
22548 
  def validate(self):
22549 
    return
22550 
 
22551 
 
22552 
  def __repr__(self):
22553 
    L = ['%s=%r' % (key, value)
22554 
      for key, value in self.__dict__.iteritems()]
22555 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22556 
 
22557 
  def __eq__(self, other):
22558 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22559 
 
22560 
  def __ne__(self, other):
22561 
    return not (self == other)
4600 varun.gupt 22562 
 
22563 
class getBilledOrdersForVendor_args:
22564 
  """
22565 
  Attributes:
22566 
   - vendorId
22567 
   - billingDateFrom
22568 
   - billingDateTo
22569 
  """
22570 
 
22571 
  thrift_spec = (
22572 
    None, # 0
22573 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22574 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
22575 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
22576 
  )
22577 
 
22578 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
22579 
    self.vendorId = vendorId
22580 
    self.billingDateFrom = billingDateFrom
22581 
    self.billingDateTo = billingDateTo
22582 
 
22583 
  def read(self, iprot):
22584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22586 
      return
22587 
    iprot.readStructBegin()
22588 
    while True:
22589 
      (fname, ftype, fid) = iprot.readFieldBegin()
22590 
      if ftype == TType.STOP:
22591 
        break
22592 
      if fid == 1:
22593 
        if ftype == TType.I64:
22594 
          self.vendorId = iprot.readI64();
22595 
        else:
22596 
          iprot.skip(ftype)
22597 
      elif fid == 2:
22598 
        if ftype == TType.I64:
22599 
          self.billingDateFrom = iprot.readI64();
22600 
        else:
22601 
          iprot.skip(ftype)
22602 
      elif fid == 3:
22603 
        if ftype == TType.I64:
22604 
          self.billingDateTo = iprot.readI64();
22605 
        else:
22606 
          iprot.skip(ftype)
22607 
      else:
22608 
        iprot.skip(ftype)
22609 
      iprot.readFieldEnd()
22610 
    iprot.readStructEnd()
22611 
 
22612 
  def write(self, oprot):
22613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22615 
      return
22616 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
22617 
    if self.vendorId is not None:
22618 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22619 
      oprot.writeI64(self.vendorId)
22620 
      oprot.writeFieldEnd()
22621 
    if self.billingDateFrom is not None:
22622 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
22623 
      oprot.writeI64(self.billingDateFrom)
22624 
      oprot.writeFieldEnd()
22625 
    if self.billingDateTo is not None:
22626 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
22627 
      oprot.writeI64(self.billingDateTo)
22628 
      oprot.writeFieldEnd()
22629 
    oprot.writeFieldStop()
22630 
    oprot.writeStructEnd()
22631 
 
22632 
  def validate(self):
22633 
    return
22634 
 
22635 
 
22636 
  def __repr__(self):
22637 
    L = ['%s=%r' % (key, value)
22638 
      for key, value in self.__dict__.iteritems()]
22639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22640 
 
22641 
  def __eq__(self, other):
22642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22643 
 
22644 
  def __ne__(self, other):
22645 
    return not (self == other)
22646 
 
22647 
class getBilledOrdersForVendor_result:
22648 
  """
22649 
  Attributes:
22650 
   - success
22651 
   - ex
22652 
  """
22653 
 
22654 
  thrift_spec = (
22655 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22656 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22657 
  )
22658 
 
22659 
  def __init__(self, success=None, ex=None,):
22660 
    self.success = success
22661 
    self.ex = ex
22662 
 
22663 
  def read(self, iprot):
22664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22666 
      return
22667 
    iprot.readStructBegin()
22668 
    while True:
22669 
      (fname, ftype, fid) = iprot.readFieldBegin()
22670 
      if ftype == TType.STOP:
22671 
        break
22672 
      if fid == 0:
22673 
        if ftype == TType.LIST:
22674 
          self.success = []
6188 rajveer 22675 
          (_etype527, _size524) = iprot.readListBegin()
22676 
          for _i528 in xrange(_size524):
22677 
            _elem529 = Order()
22678 
            _elem529.read(iprot)
22679 
            self.success.append(_elem529)
4600 varun.gupt 22680 
          iprot.readListEnd()
22681 
        else:
22682 
          iprot.skip(ftype)
22683 
      elif fid == 1:
22684 
        if ftype == TType.STRUCT:
22685 
          self.ex = TransactionServiceException()
22686 
          self.ex.read(iprot)
22687 
        else:
22688 
          iprot.skip(ftype)
22689 
      else:
22690 
        iprot.skip(ftype)
22691 
      iprot.readFieldEnd()
22692 
    iprot.readStructEnd()
22693 
 
22694 
  def write(self, oprot):
22695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22697 
      return
22698 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
22699 
    if self.success is not None:
22700 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22701 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22702 
      for iter530 in self.success:
22703 
        iter530.write(oprot)
4600 varun.gupt 22704 
      oprot.writeListEnd()
22705 
      oprot.writeFieldEnd()
22706 
    if self.ex is not None:
22707 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22708 
      self.ex.write(oprot)
22709 
      oprot.writeFieldEnd()
22710 
    oprot.writeFieldStop()
22711 
    oprot.writeStructEnd()
22712 
 
22713 
  def validate(self):
22714 
    return
22715 
 
22716 
 
22717 
  def __repr__(self):
22718 
    L = ['%s=%r' % (key, value)
22719 
      for key, value in self.__dict__.iteritems()]
22720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22721 
 
22722 
  def __eq__(self, other):
22723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22724 
 
22725 
  def __ne__(self, other):
22726 
    return not (self == other)
22727 
 
4607 rajveer 22728 
class getSlippedSippingDateOrders_args:
22729 
 
22730 
  thrift_spec = (
22731 
  )
22732 
 
22733 
  def read(self, iprot):
22734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22736 
      return
22737 
    iprot.readStructBegin()
22738 
    while True:
22739 
      (fname, ftype, fid) = iprot.readFieldBegin()
22740 
      if ftype == TType.STOP:
22741 
        break
22742 
      else:
22743 
        iprot.skip(ftype)
22744 
      iprot.readFieldEnd()
22745 
    iprot.readStructEnd()
22746 
 
22747 
  def write(self, oprot):
22748 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22749 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22750 
      return
22751 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
22752 
    oprot.writeFieldStop()
22753 
    oprot.writeStructEnd()
22754 
 
22755 
  def validate(self):
22756 
    return
22757 
 
22758 
 
22759 
  def __repr__(self):
22760 
    L = ['%s=%r' % (key, value)
22761 
      for key, value in self.__dict__.iteritems()]
22762 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22763 
 
22764 
  def __eq__(self, other):
22765 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22766 
 
22767 
  def __ne__(self, other):
22768 
    return not (self == other)
22769 
 
22770 
class getSlippedSippingDateOrders_result:
22771 
  """
22772 
  Attributes:
22773 
   - success
22774 
   - ex
22775 
  """
22776 
 
22777 
  thrift_spec = (
22778 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22779 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22780 
  )
22781 
 
22782 
  def __init__(self, success=None, ex=None,):
22783 
    self.success = success
22784 
    self.ex = ex
22785 
 
22786 
  def read(self, iprot):
22787 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22788 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22789 
      return
22790 
    iprot.readStructBegin()
22791 
    while True:
22792 
      (fname, ftype, fid) = iprot.readFieldBegin()
22793 
      if ftype == TType.STOP:
22794 
        break
22795 
      if fid == 0:
22796 
        if ftype == TType.LIST:
22797 
          self.success = []
6188 rajveer 22798 
          (_etype534, _size531) = iprot.readListBegin()
22799 
          for _i535 in xrange(_size531):
22800 
            _elem536 = Order()
22801 
            _elem536.read(iprot)
22802 
            self.success.append(_elem536)
4607 rajveer 22803 
          iprot.readListEnd()
22804 
        else:
22805 
          iprot.skip(ftype)
22806 
      elif fid == 1:
22807 
        if ftype == TType.STRUCT:
22808 
          self.ex = TransactionServiceException()
22809 
          self.ex.read(iprot)
22810 
        else:
22811 
          iprot.skip(ftype)
22812 
      else:
22813 
        iprot.skip(ftype)
22814 
      iprot.readFieldEnd()
22815 
    iprot.readStructEnd()
22816 
 
22817 
  def write(self, oprot):
22818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22820 
      return
22821 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22822 
    if self.success is not None:
22823 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22824 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22825 
      for iter537 in self.success:
22826 
        iter537.write(oprot)
4607 rajveer 22827 
      oprot.writeListEnd()
22828 
      oprot.writeFieldEnd()
22829 
    if self.ex is not None:
22830 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22831 
      self.ex.write(oprot)
22832 
      oprot.writeFieldEnd()
22833 
    oprot.writeFieldStop()
22834 
    oprot.writeStructEnd()
22835 
 
22836 
  def validate(self):
22837 
    return
22838 
 
22839 
 
22840 
  def __repr__(self):
22841 
    L = ['%s=%r' % (key, value)
22842 
      for key, value in self.__dict__.iteritems()]
22843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22844 
 
22845 
  def __eq__(self, other):
22846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22847 
 
22848 
  def __ne__(self, other):
22849 
    return not (self == other)
22850 
 
4709 rajveer 22851 
class getCancelledOrders_args:
22852 
  """
22853 
  Attributes:
22854 
   - cancelDateFrom
22855 
   - cancelDateTo
22856 
  """
22857 
 
22858 
  thrift_spec = (
22859 
    None, # 0
22860 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
22861 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
22862 
  )
22863 
 
22864 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
22865 
    self.cancelDateFrom = cancelDateFrom
22866 
    self.cancelDateTo = cancelDateTo
22867 
 
22868 
  def read(self, iprot):
22869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22871 
      return
22872 
    iprot.readStructBegin()
22873 
    while True:
22874 
      (fname, ftype, fid) = iprot.readFieldBegin()
22875 
      if ftype == TType.STOP:
22876 
        break
22877 
      if fid == 1:
22878 
        if ftype == TType.I64:
22879 
          self.cancelDateFrom = iprot.readI64();
22880 
        else:
22881 
          iprot.skip(ftype)
22882 
      elif fid == 2:
22883 
        if ftype == TType.I64:
22884 
          self.cancelDateTo = iprot.readI64();
22885 
        else:
22886 
          iprot.skip(ftype)
22887 
      else:
22888 
        iprot.skip(ftype)
22889 
      iprot.readFieldEnd()
22890 
    iprot.readStructEnd()
22891 
 
22892 
  def write(self, oprot):
22893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22895 
      return
22896 
    oprot.writeStructBegin('getCancelledOrders_args')
22897 
    if self.cancelDateFrom is not None:
22898 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
22899 
      oprot.writeI64(self.cancelDateFrom)
22900 
      oprot.writeFieldEnd()
22901 
    if self.cancelDateTo is not None:
22902 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
22903 
      oprot.writeI64(self.cancelDateTo)
22904 
      oprot.writeFieldEnd()
22905 
    oprot.writeFieldStop()
22906 
    oprot.writeStructEnd()
22907 
 
22908 
  def validate(self):
22909 
    return
22910 
 
22911 
 
22912 
  def __repr__(self):
22913 
    L = ['%s=%r' % (key, value)
22914 
      for key, value in self.__dict__.iteritems()]
22915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22916 
 
22917 
  def __eq__(self, other):
22918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22919 
 
22920 
  def __ne__(self, other):
22921 
    return not (self == other)
22922 
 
22923 
class getCancelledOrders_result:
22924 
  """
22925 
  Attributes:
22926 
   - success
22927 
   - ex
22928 
  """
22929 
 
22930 
  thrift_spec = (
22931 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22932 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22933 
  )
22934 
 
22935 
  def __init__(self, success=None, ex=None,):
22936 
    self.success = success
22937 
    self.ex = ex
22938 
 
22939 
  def read(self, iprot):
22940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22942 
      return
22943 
    iprot.readStructBegin()
22944 
    while True:
22945 
      (fname, ftype, fid) = iprot.readFieldBegin()
22946 
      if ftype == TType.STOP:
22947 
        break
22948 
      if fid == 0:
22949 
        if ftype == TType.LIST:
22950 
          self.success = []
6188 rajveer 22951 
          (_etype541, _size538) = iprot.readListBegin()
22952 
          for _i542 in xrange(_size538):
22953 
            _elem543 = Order()
22954 
            _elem543.read(iprot)
22955 
            self.success.append(_elem543)
4709 rajveer 22956 
          iprot.readListEnd()
22957 
        else:
22958 
          iprot.skip(ftype)
22959 
      elif fid == 1:
22960 
        if ftype == TType.STRUCT:
22961 
          self.ex = TransactionServiceException()
22962 
          self.ex.read(iprot)
22963 
        else:
22964 
          iprot.skip(ftype)
22965 
      else:
22966 
        iprot.skip(ftype)
22967 
      iprot.readFieldEnd()
22968 
    iprot.readStructEnd()
22969 
 
22970 
  def write(self, oprot):
22971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22973 
      return
22974 
    oprot.writeStructBegin('getCancelledOrders_result')
22975 
    if self.success is not None:
22976 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22977 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22978 
      for iter544 in self.success:
22979 
        iter544.write(oprot)
4709 rajveer 22980 
      oprot.writeListEnd()
22981 
      oprot.writeFieldEnd()
22982 
    if self.ex is not None:
22983 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22984 
      self.ex.write(oprot)
22985 
      oprot.writeFieldEnd()
22986 
    oprot.writeFieldStop()
22987 
    oprot.writeStructEnd()
22988 
 
22989 
  def validate(self):
22990 
    return
22991 
 
22992 
 
22993 
  def __repr__(self):
22994 
    L = ['%s=%r' % (key, value)
22995 
      for key, value in self.__dict__.iteritems()]
22996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22997 
 
22998 
  def __eq__(self, other):
22999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23000 
 
23001 
  def __ne__(self, other):
23002 
    return not (self == other)
23003 
 
4600 varun.gupt 23004 
class saveBluedartSettlements_args:
23005 
  """
23006 
  Attributes:
23007 
   - mapAWBAndAmount
23008 
  """
23009 
 
23010 
  thrift_spec = (
23011 
    None, # 0
23012 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
23013 
  )
23014 
 
23015 
  def __init__(self, mapAWBAndAmount=None,):
23016 
    self.mapAWBAndAmount = mapAWBAndAmount
23017 
 
23018 
  def read(self, iprot):
23019 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23020 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23021 
      return
23022 
    iprot.readStructBegin()
23023 
    while True:
23024 
      (fname, ftype, fid) = iprot.readFieldBegin()
23025 
      if ftype == TType.STOP:
23026 
        break
23027 
      if fid == 1:
23028 
        if ftype == TType.MAP:
23029 
          self.mapAWBAndAmount = {}
6188 rajveer 23030 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
23031 
          for _i549 in xrange(_size545):
23032 
            _key550 = iprot.readI64();
23033 
            _val551 = iprot.readDouble();
23034 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 23035 
          iprot.readMapEnd()
23036 
        else:
23037 
          iprot.skip(ftype)
23038 
      else:
23039 
        iprot.skip(ftype)
23040 
      iprot.readFieldEnd()
23041 
    iprot.readStructEnd()
23042 
 
23043 
  def write(self, oprot):
23044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23046 
      return
23047 
    oprot.writeStructBegin('saveBluedartSettlements_args')
23048 
    if self.mapAWBAndAmount is not None:
23049 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
23050 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 23051 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
23052 
        oprot.writeI64(kiter552)
23053 
        oprot.writeDouble(viter553)
4600 varun.gupt 23054 
      oprot.writeMapEnd()
23055 
      oprot.writeFieldEnd()
23056 
    oprot.writeFieldStop()
23057 
    oprot.writeStructEnd()
23058 
 
23059 
  def validate(self):
23060 
    return
23061 
 
23062 
 
23063 
  def __repr__(self):
23064 
    L = ['%s=%r' % (key, value)
23065 
      for key, value in self.__dict__.iteritems()]
23066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23067 
 
23068 
  def __eq__(self, other):
23069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23070 
 
23071 
  def __ne__(self, other):
23072 
    return not (self == other)
23073 
 
23074 
class saveBluedartSettlements_result:
23075 
  """
23076 
  Attributes:
23077 
   - ex
23078 
  """
23079 
 
23080 
  thrift_spec = (
23081 
    None, # 0
23082 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23083 
  )
23084 
 
23085 
  def __init__(self, ex=None,):
23086 
    self.ex = ex
23087 
 
23088 
  def read(self, iprot):
23089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23091 
      return
23092 
    iprot.readStructBegin()
23093 
    while True:
23094 
      (fname, ftype, fid) = iprot.readFieldBegin()
23095 
      if ftype == TType.STOP:
23096 
        break
23097 
      if fid == 1:
23098 
        if ftype == TType.STRUCT:
23099 
          self.ex = TransactionServiceException()
23100 
          self.ex.read(iprot)
23101 
        else:
23102 
          iprot.skip(ftype)
23103 
      else:
23104 
        iprot.skip(ftype)
23105 
      iprot.readFieldEnd()
23106 
    iprot.readStructEnd()
23107 
 
23108 
  def write(self, oprot):
23109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23111 
      return
23112 
    oprot.writeStructBegin('saveBluedartSettlements_result')
23113 
    if self.ex is not None:
23114 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23115 
      self.ex.write(oprot)
23116 
      oprot.writeFieldEnd()
23117 
    oprot.writeFieldStop()
23118 
    oprot.writeStructEnd()
23119 
 
23120 
  def validate(self):
23121 
    return
23122 
 
23123 
 
23124 
  def __repr__(self):
23125 
    L = ['%s=%r' % (key, value)
23126 
      for key, value in self.__dict__.iteritems()]
23127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23128 
 
23129 
  def __eq__(self, other):
23130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23131 
 
23132 
  def __ne__(self, other):
23133 
    return not (self == other)
23134 
 
23135 
class savePaymentSettlements_args:
23136 
  """
23137 
  Attributes:
23138 
   - settlementDate
23139 
   - paymentGatewayId
4905 varun.gupt 23140 
   - referenceId
4600 varun.gupt 23141 
   - serviceTax
23142 
   - otherCharges
23143 
   - netCollection
23144 
  """
23145 
 
23146 
  thrift_spec = (
23147 
    None, # 0
23148 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
23149 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 23150 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 23151 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
23152 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
23153 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
23154 
  )
23155 
 
4905 varun.gupt 23156 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 23157 
    self.settlementDate = settlementDate
23158 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 23159 
    self.referenceId = referenceId
4600 varun.gupt 23160 
    self.serviceTax = serviceTax
23161 
    self.otherCharges = otherCharges
23162 
    self.netCollection = netCollection
23163 
 
23164 
  def read(self, iprot):
23165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23167 
      return
23168 
    iprot.readStructBegin()
23169 
    while True:
23170 
      (fname, ftype, fid) = iprot.readFieldBegin()
23171 
      if ftype == TType.STOP:
23172 
        break
23173 
      if fid == 1:
23174 
        if ftype == TType.I64:
23175 
          self.settlementDate = iprot.readI64();
23176 
        else:
23177 
          iprot.skip(ftype)
23178 
      elif fid == 2:
23179 
        if ftype == TType.I64:
23180 
          self.paymentGatewayId = iprot.readI64();
23181 
        else:
23182 
          iprot.skip(ftype)
23183 
      elif fid == 3:
23184 
        if ftype == TType.I64:
4905 varun.gupt 23185 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23186 
        else:
23187 
          iprot.skip(ftype)
23188 
      elif fid == 4:
23189 
        if ftype == TType.DOUBLE:
23190 
          self.serviceTax = iprot.readDouble();
23191 
        else:
23192 
          iprot.skip(ftype)
23193 
      elif fid == 5:
23194 
        if ftype == TType.DOUBLE:
23195 
          self.otherCharges = iprot.readDouble();
23196 
        else:
23197 
          iprot.skip(ftype)
23198 
      elif fid == 6:
23199 
        if ftype == TType.DOUBLE:
23200 
          self.netCollection = iprot.readDouble();
23201 
        else:
23202 
          iprot.skip(ftype)
23203 
      else:
23204 
        iprot.skip(ftype)
23205 
      iprot.readFieldEnd()
23206 
    iprot.readStructEnd()
23207 
 
23208 
  def write(self, oprot):
23209 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23210 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23211 
      return
23212 
    oprot.writeStructBegin('savePaymentSettlements_args')
23213 
    if self.settlementDate is not None:
23214 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
23215 
      oprot.writeI64(self.settlementDate)
23216 
      oprot.writeFieldEnd()
23217 
    if self.paymentGatewayId is not None:
23218 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
23219 
      oprot.writeI64(self.paymentGatewayId)
23220 
      oprot.writeFieldEnd()
4905 varun.gupt 23221 
    if self.referenceId is not None:
23222 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
23223 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23224 
      oprot.writeFieldEnd()
23225 
    if self.serviceTax is not None:
23226 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
23227 
      oprot.writeDouble(self.serviceTax)
23228 
      oprot.writeFieldEnd()
23229 
    if self.otherCharges is not None:
23230 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
23231 
      oprot.writeDouble(self.otherCharges)
23232 
      oprot.writeFieldEnd()
23233 
    if self.netCollection is not None:
23234 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
23235 
      oprot.writeDouble(self.netCollection)
23236 
      oprot.writeFieldEnd()
23237 
    oprot.writeFieldStop()
23238 
    oprot.writeStructEnd()
23239 
 
23240 
  def validate(self):
23241 
    return
23242 
 
23243 
 
23244 
  def __repr__(self):
23245 
    L = ['%s=%r' % (key, value)
23246 
      for key, value in self.__dict__.iteritems()]
23247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23248 
 
23249 
  def __eq__(self, other):
23250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23251 
 
23252 
  def __ne__(self, other):
23253 
    return not (self == other)
23254 
 
23255 
class savePaymentSettlements_result:
23256 
  """
23257 
  Attributes:
23258 
   - ex
23259 
  """
23260 
 
23261 
  thrift_spec = (
23262 
    None, # 0
23263 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23264 
  )
23265 
 
23266 
  def __init__(self, ex=None,):
23267 
    self.ex = ex
23268 
 
23269 
  def read(self, iprot):
23270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23272 
      return
23273 
    iprot.readStructBegin()
23274 
    while True:
23275 
      (fname, ftype, fid) = iprot.readFieldBegin()
23276 
      if ftype == TType.STOP:
23277 
        break
23278 
      if fid == 1:
23279 
        if ftype == TType.STRUCT:
23280 
          self.ex = TransactionServiceException()
23281 
          self.ex.read(iprot)
23282 
        else:
23283 
          iprot.skip(ftype)
23284 
      else:
23285 
        iprot.skip(ftype)
23286 
      iprot.readFieldEnd()
23287 
    iprot.readStructEnd()
23288 
 
23289 
  def write(self, oprot):
23290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23292 
      return
23293 
    oprot.writeStructBegin('savePaymentSettlements_result')
23294 
    if self.ex is not None:
23295 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23296 
      self.ex.write(oprot)
23297 
      oprot.writeFieldEnd()
23298 
    oprot.writeFieldStop()
23299 
    oprot.writeStructEnd()
23300 
 
23301 
  def validate(self):
23302 
    return
23303 
 
23304 
 
23305 
  def __repr__(self):
23306 
    L = ['%s=%r' % (key, value)
23307 
      for key, value in self.__dict__.iteritems()]
23308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23309 
 
23310 
  def __eq__(self, other):
23311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23312 
 
23313 
  def __ne__(self, other):
23314 
    return not (self == other)
23315 
 
23316 
class saveEBSSettlementSummary_args:
23317 
  """
23318 
  Attributes:
23319 
   - settlementId
23320 
   - settlementDate
23321 
   - transactionDateFrom
23322 
   - transactionDateTo
23323 
   - amount
23324 
  """
23325 
 
23326 
  thrift_spec = (
23327 
    None, # 0
23328 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23329 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
23330 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
23331 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
23332 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
23333 
  )
23334 
 
23335 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
23336 
    self.settlementId = settlementId
23337 
    self.settlementDate = settlementDate
23338 
    self.transactionDateFrom = transactionDateFrom
23339 
    self.transactionDateTo = transactionDateTo
23340 
    self.amount = amount
23341 
 
23342 
  def read(self, iprot):
23343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23345 
      return
23346 
    iprot.readStructBegin()
23347 
    while True:
23348 
      (fname, ftype, fid) = iprot.readFieldBegin()
23349 
      if ftype == TType.STOP:
23350 
        break
23351 
      if fid == 1:
23352 
        if ftype == TType.I64:
23353 
          self.settlementId = iprot.readI64();
23354 
        else:
23355 
          iprot.skip(ftype)
23356 
      elif fid == 2:
23357 
        if ftype == TType.I64:
23358 
          self.settlementDate = iprot.readI64();
23359 
        else:
23360 
          iprot.skip(ftype)
23361 
      elif fid == 3:
23362 
        if ftype == TType.I64:
23363 
          self.transactionDateFrom = iprot.readI64();
23364 
        else:
23365 
          iprot.skip(ftype)
23366 
      elif fid == 4:
23367 
        if ftype == TType.I64:
23368 
          self.transactionDateTo = iprot.readI64();
23369 
        else:
23370 
          iprot.skip(ftype)
23371 
      elif fid == 5:
23372 
        if ftype == TType.DOUBLE:
23373 
          self.amount = iprot.readDouble();
23374 
        else:
23375 
          iprot.skip(ftype)
23376 
      else:
23377 
        iprot.skip(ftype)
23378 
      iprot.readFieldEnd()
23379 
    iprot.readStructEnd()
23380 
 
23381 
  def write(self, oprot):
23382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23384 
      return
23385 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
23386 
    if self.settlementId is not None:
23387 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23388 
      oprot.writeI64(self.settlementId)
23389 
      oprot.writeFieldEnd()
23390 
    if self.settlementDate is not None:
23391 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
23392 
      oprot.writeI64(self.settlementDate)
23393 
      oprot.writeFieldEnd()
23394 
    if self.transactionDateFrom is not None:
23395 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
23396 
      oprot.writeI64(self.transactionDateFrom)
23397 
      oprot.writeFieldEnd()
23398 
    if self.transactionDateTo is not None:
23399 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
23400 
      oprot.writeI64(self.transactionDateTo)
23401 
      oprot.writeFieldEnd()
23402 
    if self.amount is not None:
23403 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
23404 
      oprot.writeDouble(self.amount)
23405 
      oprot.writeFieldEnd()
23406 
    oprot.writeFieldStop()
23407 
    oprot.writeStructEnd()
23408 
 
23409 
  def validate(self):
23410 
    return
23411 
 
23412 
 
23413 
  def __repr__(self):
23414 
    L = ['%s=%r' % (key, value)
23415 
      for key, value in self.__dict__.iteritems()]
23416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23417 
 
23418 
  def __eq__(self, other):
23419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23420 
 
23421 
  def __ne__(self, other):
23422 
    return not (self == other)
23423 
 
23424 
class saveEBSSettlementSummary_result:
23425 
  """
23426 
  Attributes:
23427 
   - ex
23428 
  """
23429 
 
23430 
  thrift_spec = (
23431 
    None, # 0
23432 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23433 
  )
23434 
 
23435 
  def __init__(self, ex=None,):
23436 
    self.ex = ex
23437 
 
23438 
  def read(self, iprot):
23439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23441 
      return
23442 
    iprot.readStructBegin()
23443 
    while True:
23444 
      (fname, ftype, fid) = iprot.readFieldBegin()
23445 
      if ftype == TType.STOP:
23446 
        break
23447 
      if fid == 1:
23448 
        if ftype == TType.STRUCT:
23449 
          self.ex = TransactionServiceException()
23450 
          self.ex.read(iprot)
23451 
        else:
23452 
          iprot.skip(ftype)
23453 
      else:
23454 
        iprot.skip(ftype)
23455 
      iprot.readFieldEnd()
23456 
    iprot.readStructEnd()
23457 
 
23458 
  def write(self, oprot):
23459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23461 
      return
23462 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
23463 
    if self.ex is not None:
23464 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23465 
      self.ex.write(oprot)
23466 
      oprot.writeFieldEnd()
23467 
    oprot.writeFieldStop()
23468 
    oprot.writeStructEnd()
23469 
 
23470 
  def validate(self):
23471 
    return
23472 
 
23473 
 
23474 
  def __repr__(self):
23475 
    L = ['%s=%r' % (key, value)
23476 
      for key, value in self.__dict__.iteritems()]
23477 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23478 
 
23479 
  def __eq__(self, other):
23480 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23481 
 
23482 
  def __ne__(self, other):
23483 
    return not (self == other)
23484 
 
5386 phani.kuma 23485 
class getSettlementForPrepaid_args:
4600 varun.gupt 23486 
  """
23487 
  Attributes:
5189 varun.gupt 23488 
   - referenceId
23489 
   - isRefund
4600 varun.gupt 23490 
  """
23491 
 
23492 
  thrift_spec = (
23493 
    None, # 0
5189 varun.gupt 23494 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 23495 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 23496 
  )
23497 
 
5386 phani.kuma 23498 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 23499 
    self.referenceId = referenceId
23500 
    self.isRefund = isRefund
4600 varun.gupt 23501 
 
23502 
  def read(self, iprot):
23503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23505 
      return
23506 
    iprot.readStructBegin()
23507 
    while True:
23508 
      (fname, ftype, fid) = iprot.readFieldBegin()
23509 
      if ftype == TType.STOP:
23510 
        break
23511 
      if fid == 1:
23512 
        if ftype == TType.I64:
5189 varun.gupt 23513 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23514 
        else:
23515 
          iprot.skip(ftype)
5189 varun.gupt 23516 
      elif fid == 2:
23517 
        if ftype == TType.BOOL:
23518 
          self.isRefund = iprot.readBool();
23519 
        else:
23520 
          iprot.skip(ftype)
4600 varun.gupt 23521 
      else:
23522 
        iprot.skip(ftype)
23523 
      iprot.readFieldEnd()
23524 
    iprot.readStructEnd()
23525 
 
23526 
  def write(self, oprot):
23527 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23528 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23529 
      return
5386 phani.kuma 23530 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 23531 
    if self.referenceId is not None:
23532 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
23533 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23534 
      oprot.writeFieldEnd()
5386 phani.kuma 23535 
    if self.isRefund is not None:
23536 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
23537 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 23538 
      oprot.writeFieldEnd()
5386 phani.kuma 23539 
    oprot.writeFieldStop()
23540 
    oprot.writeStructEnd()
23541 
 
23542 
  def validate(self):
23543 
    return
23544 
 
23545 
 
23546 
  def __repr__(self):
23547 
    L = ['%s=%r' % (key, value)
23548 
      for key, value in self.__dict__.iteritems()]
23549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23550 
 
23551 
  def __eq__(self, other):
23552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23553 
 
23554 
  def __ne__(self, other):
23555 
    return not (self == other)
23556 
 
23557 
class getSettlementForPrepaid_result:
23558 
  """
23559 
  Attributes:
23560 
   - success
23561 
   - ex
23562 
  """
23563 
 
23564 
  thrift_spec = (
23565 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23566 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23567 
  )
23568 
 
23569 
  def __init__(self, success=None, ex=None,):
23570 
    self.success = success
23571 
    self.ex = ex
23572 
 
23573 
  def read(self, iprot):
23574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23576 
      return
23577 
    iprot.readStructBegin()
23578 
    while True:
23579 
      (fname, ftype, fid) = iprot.readFieldBegin()
23580 
      if ftype == TType.STOP:
23581 
        break
23582 
      if fid == 0:
23583 
        if ftype == TType.STRUCT:
23584 
          self.success = PaymentSettlement()
23585 
          self.success.read(iprot)
23586 
        else:
23587 
          iprot.skip(ftype)
23588 
      elif fid == 1:
23589 
        if ftype == TType.STRUCT:
23590 
          self.ex = TransactionServiceException()
23591 
          self.ex.read(iprot)
23592 
        else:
23593 
          iprot.skip(ftype)
23594 
      else:
23595 
        iprot.skip(ftype)
23596 
      iprot.readFieldEnd()
23597 
    iprot.readStructEnd()
23598 
 
23599 
  def write(self, oprot):
23600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23602 
      return
23603 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
23604 
    if self.success is not None:
23605 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23606 
      self.success.write(oprot)
23607 
      oprot.writeFieldEnd()
23608 
    if self.ex is not None:
23609 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23610 
      self.ex.write(oprot)
23611 
      oprot.writeFieldEnd()
23612 
    oprot.writeFieldStop()
23613 
    oprot.writeStructEnd()
23614 
 
23615 
  def validate(self):
23616 
    return
23617 
 
23618 
 
23619 
  def __repr__(self):
23620 
    L = ['%s=%r' % (key, value)
23621 
      for key, value in self.__dict__.iteritems()]
23622 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23623 
 
23624 
  def __eq__(self, other):
23625 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23626 
 
23627 
  def __ne__(self, other):
23628 
    return not (self == other)
23629 
 
23630 
class getSettlementForCod_args:
23631 
  """
23632 
  Attributes:
23633 
   - orderId
23634 
   - isRefund
23635 
  """
23636 
 
23637 
  thrift_spec = (
23638 
    None, # 0
23639 
    (1, TType.I64, 'orderId', None, None, ), # 1
23640 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
23641 
  )
23642 
 
23643 
  def __init__(self, orderId=None, isRefund=None,):
23644 
    self.orderId = orderId
23645 
    self.isRefund = isRefund
23646 
 
23647 
  def read(self, iprot):
23648 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23649 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23650 
      return
23651 
    iprot.readStructBegin()
23652 
    while True:
23653 
      (fname, ftype, fid) = iprot.readFieldBegin()
23654 
      if ftype == TType.STOP:
23655 
        break
23656 
      if fid == 1:
23657 
        if ftype == TType.I64:
23658 
          self.orderId = iprot.readI64();
23659 
        else:
23660 
          iprot.skip(ftype)
23661 
      elif fid == 2:
23662 
        if ftype == TType.BOOL:
23663 
          self.isRefund = iprot.readBool();
23664 
        else:
23665 
          iprot.skip(ftype)
23666 
      else:
23667 
        iprot.skip(ftype)
23668 
      iprot.readFieldEnd()
23669 
    iprot.readStructEnd()
23670 
 
23671 
  def write(self, oprot):
23672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23674 
      return
23675 
    oprot.writeStructBegin('getSettlementForCod_args')
23676 
    if self.orderId is not None:
23677 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23678 
      oprot.writeI64(self.orderId)
23679 
      oprot.writeFieldEnd()
5189 varun.gupt 23680 
    if self.isRefund is not None:
5386 phani.kuma 23681 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23682 
      oprot.writeBool(self.isRefund)
23683 
      oprot.writeFieldEnd()
4600 varun.gupt 23684 
    oprot.writeFieldStop()
23685 
    oprot.writeStructEnd()
23686 
 
23687 
  def validate(self):
23688 
    return
23689 
 
23690 
 
23691 
  def __repr__(self):
23692 
    L = ['%s=%r' % (key, value)
23693 
      for key, value in self.__dict__.iteritems()]
23694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23695 
 
23696 
  def __eq__(self, other):
23697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23698 
 
23699 
  def __ne__(self, other):
23700 
    return not (self == other)
23701 
 
5386 phani.kuma 23702 
class getSettlementForCod_result:
4600 varun.gupt 23703 
  """
23704 
  Attributes:
23705 
   - success
23706 
   - ex
23707 
  """
23708 
 
23709 
  thrift_spec = (
23710 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23711 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23712 
  )
23713 
 
23714 
  def __init__(self, success=None, ex=None,):
23715 
    self.success = success
23716 
    self.ex = ex
23717 
 
23718 
  def read(self, iprot):
23719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23721 
      return
23722 
    iprot.readStructBegin()
23723 
    while True:
23724 
      (fname, ftype, fid) = iprot.readFieldBegin()
23725 
      if ftype == TType.STOP:
23726 
        break
23727 
      if fid == 0:
23728 
        if ftype == TType.STRUCT:
23729 
          self.success = PaymentSettlement()
23730 
          self.success.read(iprot)
23731 
        else:
23732 
          iprot.skip(ftype)
23733 
      elif fid == 1:
23734 
        if ftype == TType.STRUCT:
23735 
          self.ex = TransactionServiceException()
23736 
          self.ex.read(iprot)
23737 
        else:
23738 
          iprot.skip(ftype)
23739 
      else:
23740 
        iprot.skip(ftype)
23741 
      iprot.readFieldEnd()
23742 
    iprot.readStructEnd()
23743 
 
23744 
  def write(self, oprot):
23745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23747 
      return
5386 phani.kuma 23748 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 23749 
    if self.success is not None:
23750 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23751 
      self.success.write(oprot)
23752 
      oprot.writeFieldEnd()
23753 
    if self.ex is not None:
23754 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23755 
      self.ex.write(oprot)
23756 
      oprot.writeFieldEnd()
23757 
    oprot.writeFieldStop()
23758 
    oprot.writeStructEnd()
23759 
 
23760 
  def validate(self):
23761 
    return
23762 
 
23763 
 
23764 
  def __repr__(self):
23765 
    L = ['%s=%r' % (key, value)
23766 
      for key, value in self.__dict__.iteritems()]
23767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23768 
 
23769 
  def __eq__(self, other):
23770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23771 
 
23772 
  def __ne__(self, other):
23773 
    return not (self == other)
23774 
 
23775 
class getEBSSettlementSummaries_args:
23776 
 
23777 
  thrift_spec = (
23778 
  )
23779 
 
23780 
  def read(self, iprot):
23781 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23782 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23783 
      return
23784 
    iprot.readStructBegin()
23785 
    while True:
23786 
      (fname, ftype, fid) = iprot.readFieldBegin()
23787 
      if ftype == TType.STOP:
23788 
        break
23789 
      else:
23790 
        iprot.skip(ftype)
23791 
      iprot.readFieldEnd()
23792 
    iprot.readStructEnd()
23793 
 
23794 
  def write(self, oprot):
23795 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23796 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23797 
      return
23798 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
23799 
    oprot.writeFieldStop()
23800 
    oprot.writeStructEnd()
23801 
 
23802 
  def validate(self):
23803 
    return
23804 
 
23805 
 
23806 
  def __repr__(self):
23807 
    L = ['%s=%r' % (key, value)
23808 
      for key, value in self.__dict__.iteritems()]
23809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23810 
 
23811 
  def __eq__(self, other):
23812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23813 
 
23814 
  def __ne__(self, other):
23815 
    return not (self == other)
23816 
 
23817 
class getEBSSettlementSummaries_result:
23818 
  """
23819 
  Attributes:
23820 
   - success
23821 
   - ex
23822 
  """
23823 
 
23824 
  thrift_spec = (
23825 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23826 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23827 
  )
23828 
 
23829 
  def __init__(self, success=None, ex=None,):
23830 
    self.success = success
23831 
    self.ex = ex
23832 
 
23833 
  def read(self, iprot):
23834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23836 
      return
23837 
    iprot.readStructBegin()
23838 
    while True:
23839 
      (fname, ftype, fid) = iprot.readFieldBegin()
23840 
      if ftype == TType.STOP:
23841 
        break
23842 
      if fid == 0:
23843 
        if ftype == TType.MAP:
23844 
          self.success = {}
6188 rajveer 23845 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
23846 
          for _i558 in xrange(_size554):
23847 
            _key559 = iprot.readI64();
23848 
            _val560 = iprot.readString();
23849 
            self.success[_key559] = _val560
4600 varun.gupt 23850 
          iprot.readMapEnd()
23851 
        else:
23852 
          iprot.skip(ftype)
23853 
      elif fid == 1:
23854 
        if ftype == TType.STRUCT:
23855 
          self.ex = TransactionServiceException()
23856 
          self.ex.read(iprot)
23857 
        else:
23858 
          iprot.skip(ftype)
23859 
      else:
23860 
        iprot.skip(ftype)
23861 
      iprot.readFieldEnd()
23862 
    iprot.readStructEnd()
23863 
 
23864 
  def write(self, oprot):
23865 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23866 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23867 
      return
23868 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
23869 
    if self.success is not None:
23870 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23871 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 23872 
      for kiter561,viter562 in self.success.items():
23873 
        oprot.writeI64(kiter561)
23874 
        oprot.writeString(viter562)
4600 varun.gupt 23875 
      oprot.writeMapEnd()
23876 
      oprot.writeFieldEnd()
23877 
    if self.ex is not None:
23878 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23879 
      self.ex.write(oprot)
23880 
      oprot.writeFieldEnd()
23881 
    oprot.writeFieldStop()
23882 
    oprot.writeStructEnd()
23883 
 
23884 
  def validate(self):
23885 
    return
23886 
 
23887 
 
23888 
  def __repr__(self):
23889 
    L = ['%s=%r' % (key, value)
23890 
      for key, value in self.__dict__.iteritems()]
23891 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23892 
 
23893 
  def __eq__(self, other):
23894 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23895 
 
23896 
  def __ne__(self, other):
23897 
    return not (self == other)
23898 
 
23899 
class markEBSSettlementUploaded_args:
23900 
  """
23901 
  Attributes:
23902 
   - settlementId
23903 
  """
23904 
 
23905 
  thrift_spec = (
23906 
    None, # 0
23907 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23908 
  )
23909 
 
23910 
  def __init__(self, settlementId=None,):
23911 
    self.settlementId = settlementId
23912 
 
23913 
  def read(self, iprot):
23914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23916 
      return
23917 
    iprot.readStructBegin()
23918 
    while True:
23919 
      (fname, ftype, fid) = iprot.readFieldBegin()
23920 
      if ftype == TType.STOP:
23921 
        break
23922 
      if fid == 1:
23923 
        if ftype == TType.I64:
23924 
          self.settlementId = iprot.readI64();
23925 
        else:
23926 
          iprot.skip(ftype)
23927 
      else:
23928 
        iprot.skip(ftype)
23929 
      iprot.readFieldEnd()
23930 
    iprot.readStructEnd()
23931 
 
23932 
  def write(self, oprot):
23933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23935 
      return
23936 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
23937 
    if self.settlementId is not None:
23938 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23939 
      oprot.writeI64(self.settlementId)
23940 
      oprot.writeFieldEnd()
23941 
    oprot.writeFieldStop()
23942 
    oprot.writeStructEnd()
23943 
 
23944 
  def validate(self):
23945 
    return
23946 
 
23947 
 
23948 
  def __repr__(self):
23949 
    L = ['%s=%r' % (key, value)
23950 
      for key, value in self.__dict__.iteritems()]
23951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23952 
 
23953 
  def __eq__(self, other):
23954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23955 
 
23956 
  def __ne__(self, other):
23957 
    return not (self == other)
23958 
 
23959 
class markEBSSettlementUploaded_result:
23960 
  """
23961 
  Attributes:
23962 
   - ex
23963 
  """
23964 
 
23965 
  thrift_spec = (
23966 
    None, # 0
23967 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23968 
  )
23969 
 
23970 
  def __init__(self, ex=None,):
23971 
    self.ex = ex
23972 
 
23973 
  def read(self, iprot):
23974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23976 
      return
23977 
    iprot.readStructBegin()
23978 
    while True:
23979 
      (fname, ftype, fid) = iprot.readFieldBegin()
23980 
      if ftype == TType.STOP:
23981 
        break
23982 
      if fid == 1:
23983 
        if ftype == TType.STRUCT:
23984 
          self.ex = TransactionServiceException()
23985 
          self.ex.read(iprot)
23986 
        else:
23987 
          iprot.skip(ftype)
23988 
      else:
23989 
        iprot.skip(ftype)
23990 
      iprot.readFieldEnd()
23991 
    iprot.readStructEnd()
23992 
 
23993 
  def write(self, oprot):
23994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23996 
      return
23997 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
23998 
    if self.ex is not None:
23999 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24000 
      self.ex.write(oprot)
24001 
      oprot.writeFieldEnd()
24002 
    oprot.writeFieldStop()
24003 
    oprot.writeStructEnd()
24004 
 
24005 
  def validate(self):
24006 
    return
24007 
 
24008 
 
24009 
  def __repr__(self):
24010 
    L = ['%s=%r' % (key, value)
24011 
      for key, value in self.__dict__.iteritems()]
24012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24013 
 
24014 
  def __eq__(self, other):
24015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24016 
 
24017 
  def __ne__(self, other):
24018 
    return not (self == other)
24019 
 
24020 
class getEBSSettlementDate_args:
24021 
  """
24022 
  Attributes:
24023 
   - settlementId
24024 
  """
24025 
 
24026 
  thrift_spec = (
24027 
    None, # 0
24028 
    (1, TType.I64, 'settlementId', None, None, ), # 1
24029 
  )
24030 
 
24031 
  def __init__(self, settlementId=None,):
24032 
    self.settlementId = settlementId
24033 
 
24034 
  def read(self, iprot):
24035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24037 
      return
24038 
    iprot.readStructBegin()
24039 
    while True:
24040 
      (fname, ftype, fid) = iprot.readFieldBegin()
24041 
      if ftype == TType.STOP:
24042 
        break
24043 
      if fid == 1:
24044 
        if ftype == TType.I64:
24045 
          self.settlementId = iprot.readI64();
24046 
        else:
24047 
          iprot.skip(ftype)
24048 
      else:
24049 
        iprot.skip(ftype)
24050 
      iprot.readFieldEnd()
24051 
    iprot.readStructEnd()
24052 
 
24053 
  def write(self, oprot):
24054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24056 
      return
24057 
    oprot.writeStructBegin('getEBSSettlementDate_args')
24058 
    if self.settlementId is not None:
24059 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
24060 
      oprot.writeI64(self.settlementId)
24061 
      oprot.writeFieldEnd()
24062 
    oprot.writeFieldStop()
24063 
    oprot.writeStructEnd()
24064 
 
24065 
  def validate(self):
24066 
    return
24067 
 
24068 
 
24069 
  def __repr__(self):
24070 
    L = ['%s=%r' % (key, value)
24071 
      for key, value in self.__dict__.iteritems()]
24072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24073 
 
24074 
  def __eq__(self, other):
24075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24076 
 
24077 
  def __ne__(self, other):
24078 
    return not (self == other)
24079 
 
24080 
class getEBSSettlementDate_result:
24081 
  """
24082 
  Attributes:
24083 
   - success
24084 
   - ex
24085 
  """
24086 
 
24087 
  thrift_spec = (
24088 
    (0, TType.I64, 'success', None, None, ), # 0
24089 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24090 
  )
24091 
 
24092 
  def __init__(self, success=None, ex=None,):
24093 
    self.success = success
24094 
    self.ex = ex
24095 
 
24096 
  def read(self, iprot):
24097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24099 
      return
24100 
    iprot.readStructBegin()
24101 
    while True:
24102 
      (fname, ftype, fid) = iprot.readFieldBegin()
24103 
      if ftype == TType.STOP:
24104 
        break
24105 
      if fid == 0:
24106 
        if ftype == TType.I64:
24107 
          self.success = iprot.readI64();
24108 
        else:
24109 
          iprot.skip(ftype)
24110 
      elif fid == 1:
24111 
        if ftype == TType.STRUCT:
24112 
          self.ex = TransactionServiceException()
24113 
          self.ex.read(iprot)
24114 
        else:
24115 
          iprot.skip(ftype)
24116 
      else:
24117 
        iprot.skip(ftype)
24118 
      iprot.readFieldEnd()
24119 
    iprot.readStructEnd()
24120 
 
24121 
  def write(self, oprot):
24122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24124 
      return
24125 
    oprot.writeStructBegin('getEBSSettlementDate_result')
24126 
    if self.success is not None:
24127 
      oprot.writeFieldBegin('success', TType.I64, 0)
24128 
      oprot.writeI64(self.success)
24129 
      oprot.writeFieldEnd()
24130 
    if self.ex is not None:
24131 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24132 
      self.ex.write(oprot)
24133 
      oprot.writeFieldEnd()
24134 
    oprot.writeFieldStop()
24135 
    oprot.writeStructEnd()
24136 
 
24137 
  def validate(self):
24138 
    return
24139 
 
24140 
 
24141 
  def __repr__(self):
24142 
    L = ['%s=%r' % (key, value)
24143 
      for key, value in self.__dict__.iteritems()]
24144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24145 
 
24146 
  def __eq__(self, other):
24147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24148 
 
24149 
  def __ne__(self, other):
24150 
    return not (self == other)
4715 varun.gupt 24151 
 
24152 
class getSettlementsByDate_args:
24153 
  """
24154 
  Attributes:
24155 
   - settlementDateFrom
24156 
   - settlementDateTo
24157 
   - isRefund
24158 
  """
24159 
 
24160 
  thrift_spec = (
24161 
    None, # 0
24162 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
24163 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
24164 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
24165 
  )
24166 
 
24167 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
24168 
    self.settlementDateFrom = settlementDateFrom
24169 
    self.settlementDateTo = settlementDateTo
24170 
    self.isRefund = isRefund
24171 
 
24172 
  def read(self, iprot):
24173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24175 
      return
24176 
    iprot.readStructBegin()
24177 
    while True:
24178 
      (fname, ftype, fid) = iprot.readFieldBegin()
24179 
      if ftype == TType.STOP:
24180 
        break
24181 
      if fid == 1:
24182 
        if ftype == TType.I64:
24183 
          self.settlementDateFrom = iprot.readI64();
24184 
        else:
24185 
          iprot.skip(ftype)
24186 
      elif fid == 2:
24187 
        if ftype == TType.I64:
24188 
          self.settlementDateTo = iprot.readI64();
24189 
        else:
24190 
          iprot.skip(ftype)
24191 
      elif fid == 3:
24192 
        if ftype == TType.BOOL:
24193 
          self.isRefund = iprot.readBool();
24194 
        else:
24195 
          iprot.skip(ftype)
24196 
      else:
24197 
        iprot.skip(ftype)
24198 
      iprot.readFieldEnd()
24199 
    iprot.readStructEnd()
24200 
 
24201 
  def write(self, oprot):
24202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24204 
      return
24205 
    oprot.writeStructBegin('getSettlementsByDate_args')
24206 
    if self.settlementDateFrom is not None:
24207 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
24208 
      oprot.writeI64(self.settlementDateFrom)
24209 
      oprot.writeFieldEnd()
24210 
    if self.settlementDateTo is not None:
24211 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
24212 
      oprot.writeI64(self.settlementDateTo)
24213 
      oprot.writeFieldEnd()
24214 
    if self.isRefund is not None:
24215 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
24216 
      oprot.writeBool(self.isRefund)
24217 
      oprot.writeFieldEnd()
24218 
    oprot.writeFieldStop()
24219 
    oprot.writeStructEnd()
24220 
 
24221 
  def validate(self):
24222 
    return
24223 
 
24224 
 
24225 
  def __repr__(self):
24226 
    L = ['%s=%r' % (key, value)
24227 
      for key, value in self.__dict__.iteritems()]
24228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24229 
 
24230 
  def __eq__(self, other):
24231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24232 
 
24233 
  def __ne__(self, other):
24234 
    return not (self == other)
24235 
 
24236 
class getSettlementsByDate_result:
24237 
  """
24238 
  Attributes:
24239 
   - success
24240 
   - ex
24241 
  """
24242 
 
24243 
  thrift_spec = (
24244 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
24245 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24246 
  )
24247 
 
24248 
  def __init__(self, success=None, ex=None,):
24249 
    self.success = success
24250 
    self.ex = ex
24251 
 
24252 
  def read(self, iprot):
24253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24255 
      return
24256 
    iprot.readStructBegin()
24257 
    while True:
24258 
      (fname, ftype, fid) = iprot.readFieldBegin()
24259 
      if ftype == TType.STOP:
24260 
        break
24261 
      if fid == 0:
24262 
        if ftype == TType.LIST:
24263 
          self.success = []
6188 rajveer 24264 
          (_etype566, _size563) = iprot.readListBegin()
24265 
          for _i567 in xrange(_size563):
24266 
            _elem568 = PaymentSettlement()
24267 
            _elem568.read(iprot)
24268 
            self.success.append(_elem568)
4715 varun.gupt 24269 
          iprot.readListEnd()
24270 
        else:
24271 
          iprot.skip(ftype)
24272 
      elif fid == 1:
24273 
        if ftype == TType.STRUCT:
24274 
          self.ex = TransactionServiceException()
24275 
          self.ex.read(iprot)
24276 
        else:
24277 
          iprot.skip(ftype)
24278 
      else:
24279 
        iprot.skip(ftype)
24280 
      iprot.readFieldEnd()
24281 
    iprot.readStructEnd()
24282 
 
24283 
  def write(self, oprot):
24284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24286 
      return
24287 
    oprot.writeStructBegin('getSettlementsByDate_result')
24288 
    if self.success is not None:
24289 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24290 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24291 
      for iter569 in self.success:
24292 
        iter569.write(oprot)
4715 varun.gupt 24293 
      oprot.writeListEnd()
24294 
      oprot.writeFieldEnd()
24295 
    if self.ex is not None:
24296 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24297 
      self.ex.write(oprot)
24298 
      oprot.writeFieldEnd()
24299 
    oprot.writeFieldStop()
24300 
    oprot.writeStructEnd()
24301 
 
24302 
  def validate(self):
24303 
    return
24304 
 
24305 
 
24306 
  def __repr__(self):
24307 
    L = ['%s=%r' % (key, value)
24308 
      for key, value in self.__dict__.iteritems()]
24309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24310 
 
24311 
  def __eq__(self, other):
24312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24313 
 
24314 
  def __ne__(self, other):
24315 
    return not (self == other)
24316 
 
24317 
class getReshippedOrderIds_args:
24318 
  """
24319 
  Attributes:
24320 
   - orderIds
24321 
  """
24322 
 
24323 
  thrift_spec = (
24324 
    None, # 0
24325 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
24326 
  )
24327 
 
24328 
  def __init__(self, orderIds=None,):
24329 
    self.orderIds = orderIds
24330 
 
24331 
  def read(self, iprot):
24332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24334 
      return
24335 
    iprot.readStructBegin()
24336 
    while True:
24337 
      (fname, ftype, fid) = iprot.readFieldBegin()
24338 
      if ftype == TType.STOP:
24339 
        break
24340 
      if fid == 1:
24341 
        if ftype == TType.LIST:
24342 
          self.orderIds = []
6188 rajveer 24343 
          (_etype573, _size570) = iprot.readListBegin()
24344 
          for _i574 in xrange(_size570):
24345 
            _elem575 = iprot.readI64();
24346 
            self.orderIds.append(_elem575)
4715 varun.gupt 24347 
          iprot.readListEnd()
24348 
        else:
24349 
          iprot.skip(ftype)
24350 
      else:
24351 
        iprot.skip(ftype)
24352 
      iprot.readFieldEnd()
24353 
    iprot.readStructEnd()
24354 
 
24355 
  def write(self, oprot):
24356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24358 
      return
24359 
    oprot.writeStructBegin('getReshippedOrderIds_args')
24360 
    if self.orderIds is not None:
24361 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
24362 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 24363 
      for iter576 in self.orderIds:
24364 
        oprot.writeI64(iter576)
4715 varun.gupt 24365 
      oprot.writeListEnd()
24366 
      oprot.writeFieldEnd()
24367 
    oprot.writeFieldStop()
24368 
    oprot.writeStructEnd()
24369 
 
24370 
  def validate(self):
24371 
    return
24372 
 
24373 
 
24374 
  def __repr__(self):
24375 
    L = ['%s=%r' % (key, value)
24376 
      for key, value in self.__dict__.iteritems()]
24377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24378 
 
24379 
  def __eq__(self, other):
24380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24381 
 
24382 
  def __ne__(self, other):
24383 
    return not (self == other)
24384 
 
24385 
class getReshippedOrderIds_result:
24386 
  """
24387 
  Attributes:
24388 
   - success
24389 
   - ex
24390 
  """
24391 
 
24392 
  thrift_spec = (
24393 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24394 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24395 
  )
24396 
 
24397 
  def __init__(self, success=None, ex=None,):
24398 
    self.success = success
24399 
    self.ex = ex
24400 
 
24401 
  def read(self, iprot):
24402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24404 
      return
24405 
    iprot.readStructBegin()
24406 
    while True:
24407 
      (fname, ftype, fid) = iprot.readFieldBegin()
24408 
      if ftype == TType.STOP:
24409 
        break
24410 
      if fid == 0:
24411 
        if ftype == TType.LIST:
24412 
          self.success = []
6188 rajveer 24413 
          (_etype580, _size577) = iprot.readListBegin()
24414 
          for _i581 in xrange(_size577):
24415 
            _elem582 = iprot.readI64();
24416 
            self.success.append(_elem582)
4715 varun.gupt 24417 
          iprot.readListEnd()
24418 
        else:
24419 
          iprot.skip(ftype)
24420 
      elif fid == 1:
24421 
        if ftype == TType.STRUCT:
24422 
          self.ex = TransactionServiceException()
24423 
          self.ex.read(iprot)
24424 
        else:
24425 
          iprot.skip(ftype)
24426 
      else:
24427 
        iprot.skip(ftype)
24428 
      iprot.readFieldEnd()
24429 
    iprot.readStructEnd()
24430 
 
24431 
  def write(self, oprot):
24432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24434 
      return
24435 
    oprot.writeStructBegin('getReshippedOrderIds_result')
24436 
    if self.success is not None:
24437 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24438 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24439 
      for iter583 in self.success:
24440 
        oprot.writeI64(iter583)
4715 varun.gupt 24441 
      oprot.writeListEnd()
24442 
      oprot.writeFieldEnd()
24443 
    if self.ex is not None:
24444 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24445 
      self.ex.write(oprot)
24446 
      oprot.writeFieldEnd()
24447 
    oprot.writeFieldStop()
24448 
    oprot.writeStructEnd()
24449 
 
24450 
  def validate(self):
24451 
    return
24452 
 
24453 
 
24454 
  def __repr__(self):
24455 
    L = ['%s=%r' % (key, value)
24456 
      for key, value in self.__dict__.iteritems()]
24457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24458 
 
24459 
  def __eq__(self, other):
24460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24461 
 
24462 
  def __ne__(self, other):
24463 
    return not (self == other)
4757 mandeep.dh 24464 
 
5481 phani.kuma 24465 
class getBilledOrders_args:
4875 varun.gupt 24466 
  """
24467 
  Attributes:
24468 
   - vendorId
5481 phani.kuma 24469 
   - onlyVendorNotPaid
24470 
   - billingDateFrom
24471 
   - billingDateTo
4875 varun.gupt 24472 
  """
24473 
 
24474 
  thrift_spec = (
24475 
    None, # 0
24476 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 24477 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
24478 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
24479 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 24480 
  )
24481 
 
5481 phani.kuma 24482 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 24483 
    self.vendorId = vendorId
5481 phani.kuma 24484 
    self.onlyVendorNotPaid = onlyVendorNotPaid
24485 
    self.billingDateFrom = billingDateFrom
24486 
    self.billingDateTo = billingDateTo
4875 varun.gupt 24487 
 
24488 
  def read(self, iprot):
24489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24491 
      return
24492 
    iprot.readStructBegin()
24493 
    while True:
24494 
      (fname, ftype, fid) = iprot.readFieldBegin()
24495 
      if ftype == TType.STOP:
24496 
        break
24497 
      if fid == 1:
24498 
        if ftype == TType.I64:
24499 
          self.vendorId = iprot.readI64();
24500 
        else:
24501 
          iprot.skip(ftype)
5481 phani.kuma 24502 
      elif fid == 2:
24503 
        if ftype == TType.BOOL:
24504 
          self.onlyVendorNotPaid = iprot.readBool();
24505 
        else:
24506 
          iprot.skip(ftype)
24507 
      elif fid == 3:
24508 
        if ftype == TType.I64:
24509 
          self.billingDateFrom = iprot.readI64();
24510 
        else:
24511 
          iprot.skip(ftype)
24512 
      elif fid == 4:
24513 
        if ftype == TType.I64:
24514 
          self.billingDateTo = iprot.readI64();
24515 
        else:
24516 
          iprot.skip(ftype)
4875 varun.gupt 24517 
      else:
24518 
        iprot.skip(ftype)
24519 
      iprot.readFieldEnd()
24520 
    iprot.readStructEnd()
24521 
 
24522 
  def write(self, oprot):
24523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24525 
      return
5481 phani.kuma 24526 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 24527 
    if self.vendorId is not None:
24528 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
24529 
      oprot.writeI64(self.vendorId)
24530 
      oprot.writeFieldEnd()
5481 phani.kuma 24531 
    if self.onlyVendorNotPaid is not None:
24532 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
24533 
      oprot.writeBool(self.onlyVendorNotPaid)
24534 
      oprot.writeFieldEnd()
24535 
    if self.billingDateFrom is not None:
24536 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
24537 
      oprot.writeI64(self.billingDateFrom)
24538 
      oprot.writeFieldEnd()
24539 
    if self.billingDateTo is not None:
24540 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
24541 
      oprot.writeI64(self.billingDateTo)
24542 
      oprot.writeFieldEnd()
4875 varun.gupt 24543 
    oprot.writeFieldStop()
24544 
    oprot.writeStructEnd()
24545 
 
24546 
  def validate(self):
24547 
    return
24548 
 
24549 
 
24550 
  def __repr__(self):
24551 
    L = ['%s=%r' % (key, value)
24552 
      for key, value in self.__dict__.iteritems()]
24553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24554 
 
24555 
  def __eq__(self, other):
24556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24557 
 
24558 
  def __ne__(self, other):
24559 
    return not (self == other)
24560 
 
5481 phani.kuma 24561 
class getBilledOrders_result:
4875 varun.gupt 24562 
  """
24563 
  Attributes:
24564 
   - success
24565 
   - ex
24566 
  """
24567 
 
24568 
  thrift_spec = (
24569 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24570 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24571 
  )
24572 
 
24573 
  def __init__(self, success=None, ex=None,):
24574 
    self.success = success
24575 
    self.ex = ex
24576 
 
24577 
  def read(self, iprot):
24578 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24579 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24580 
      return
24581 
    iprot.readStructBegin()
24582 
    while True:
24583 
      (fname, ftype, fid) = iprot.readFieldBegin()
24584 
      if ftype == TType.STOP:
24585 
        break
24586 
      if fid == 0:
24587 
        if ftype == TType.LIST:
24588 
          self.success = []
6188 rajveer 24589 
          (_etype587, _size584) = iprot.readListBegin()
24590 
          for _i588 in xrange(_size584):
24591 
            _elem589 = Order()
24592 
            _elem589.read(iprot)
24593 
            self.success.append(_elem589)
4875 varun.gupt 24594 
          iprot.readListEnd()
24595 
        else:
24596 
          iprot.skip(ftype)
24597 
      elif fid == 1:
24598 
        if ftype == TType.STRUCT:
24599 
          self.ex = TransactionServiceException()
24600 
          self.ex.read(iprot)
24601 
        else:
24602 
          iprot.skip(ftype)
24603 
      else:
24604 
        iprot.skip(ftype)
24605 
      iprot.readFieldEnd()
24606 
    iprot.readStructEnd()
24607 
 
24608 
  def write(self, oprot):
24609 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24610 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24611 
      return
5481 phani.kuma 24612 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 24613 
    if self.success is not None:
24614 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24615 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24616 
      for iter590 in self.success:
24617 
        iter590.write(oprot)
4875 varun.gupt 24618 
      oprot.writeListEnd()
24619 
      oprot.writeFieldEnd()
24620 
    if self.ex is not None:
24621 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24622 
      self.ex.write(oprot)
24623 
      oprot.writeFieldEnd()
24624 
    oprot.writeFieldStop()
24625 
    oprot.writeStructEnd()
24626 
 
24627 
  def validate(self):
24628 
    return
24629 
 
24630 
 
24631 
  def __repr__(self):
24632 
    L = ['%s=%r' % (key, value)
24633 
      for key, value in self.__dict__.iteritems()]
24634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24635 
 
24636 
  def __eq__(self, other):
24637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24638 
 
24639 
  def __ne__(self, other):
24640 
    return not (self == other)
5031 varun.gupt 24641 
 
24642 
class getStatusDistributionOfOrders_args:
24643 
  """
24644 
  Attributes:
24645 
   - startDate
24646 
   - endDate
24647 
  """
24648 
 
24649 
  thrift_spec = (
24650 
    None, # 0
24651 
    (1, TType.I64, 'startDate', None, None, ), # 1
24652 
    (2, TType.I64, 'endDate', None, None, ), # 2
24653 
  )
24654 
 
24655 
  def __init__(self, startDate=None, endDate=None,):
24656 
    self.startDate = startDate
24657 
    self.endDate = endDate
24658 
 
24659 
  def read(self, iprot):
24660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24662 
      return
24663 
    iprot.readStructBegin()
24664 
    while True:
24665 
      (fname, ftype, fid) = iprot.readFieldBegin()
24666 
      if ftype == TType.STOP:
24667 
        break
24668 
      if fid == 1:
24669 
        if ftype == TType.I64:
24670 
          self.startDate = iprot.readI64();
24671 
        else:
24672 
          iprot.skip(ftype)
24673 
      elif fid == 2:
24674 
        if ftype == TType.I64:
24675 
          self.endDate = iprot.readI64();
24676 
        else:
24677 
          iprot.skip(ftype)
24678 
      else:
24679 
        iprot.skip(ftype)
24680 
      iprot.readFieldEnd()
24681 
    iprot.readStructEnd()
24682 
 
24683 
  def write(self, oprot):
24684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24686 
      return
24687 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24688 
    if self.startDate is not None:
24689 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24690 
      oprot.writeI64(self.startDate)
24691 
      oprot.writeFieldEnd()
24692 
    if self.endDate is not None:
24693 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24694 
      oprot.writeI64(self.endDate)
24695 
      oprot.writeFieldEnd()
24696 
    oprot.writeFieldStop()
24697 
    oprot.writeStructEnd()
24698 
 
24699 
  def validate(self):
24700 
    return
24701 
 
24702 
 
24703 
  def __repr__(self):
24704 
    L = ['%s=%r' % (key, value)
24705 
      for key, value in self.__dict__.iteritems()]
24706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24707 
 
24708 
  def __eq__(self, other):
24709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24710 
 
24711 
  def __ne__(self, other):
24712 
    return not (self == other)
24713 
 
24714 
class getStatusDistributionOfOrders_result:
24715 
  """
24716 
  Attributes:
24717 
   - success
24718 
   - ex
24719 
  """
24720 
 
24721 
  thrift_spec = (
24722 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
24723 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24724 
  )
24725 
 
24726 
  def __init__(self, success=None, ex=None,):
24727 
    self.success = success
24728 
    self.ex = ex
24729 
 
24730 
  def read(self, iprot):
24731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24733 
      return
24734 
    iprot.readStructBegin()
24735 
    while True:
24736 
      (fname, ftype, fid) = iprot.readFieldBegin()
24737 
      if ftype == TType.STOP:
24738 
        break
24739 
      if fid == 0:
24740 
        if ftype == TType.MAP:
24741 
          self.success = {}
6188 rajveer 24742 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
24743 
          for _i595 in xrange(_size591):
24744 
            _key596 = iprot.readI64();
24745 
            _val597 = iprot.readI64();
24746 
            self.success[_key596] = _val597
5031 varun.gupt 24747 
          iprot.readMapEnd()
24748 
        else:
24749 
          iprot.skip(ftype)
24750 
      elif fid == 1:
24751 
        if ftype == TType.STRUCT:
24752 
          self.ex = TransactionServiceException()
24753 
          self.ex.read(iprot)
24754 
        else:
24755 
          iprot.skip(ftype)
24756 
      else:
24757 
        iprot.skip(ftype)
24758 
      iprot.readFieldEnd()
24759 
    iprot.readStructEnd()
24760 
 
24761 
  def write(self, oprot):
24762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24764 
      return
24765 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
24766 
    if self.success is not None:
24767 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24768 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 24769 
      for kiter598,viter599 in self.success.items():
24770 
        oprot.writeI64(kiter598)
24771 
        oprot.writeI64(viter599)
5031 varun.gupt 24772 
      oprot.writeMapEnd()
24773 
      oprot.writeFieldEnd()
24774 
    if self.ex is not None:
24775 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24776 
      self.ex.write(oprot)
24777 
      oprot.writeFieldEnd()
24778 
    oprot.writeFieldStop()
24779 
    oprot.writeStructEnd()
24780 
 
24781 
  def validate(self):
24782 
    return
24783 
 
24784 
 
24785 
  def __repr__(self):
24786 
    L = ['%s=%r' % (key, value)
24787 
      for key, value in self.__dict__.iteritems()]
24788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24789 
 
24790 
  def __eq__(self, other):
24791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24792 
 
24793 
  def __ne__(self, other):
24794 
    return not (self == other)
5067 varun.gupt 24795 
 
24796 
class getOrderIdsForStatus_args:
24797 
  """
24798 
  Attributes:
24799 
   - status
24800 
   - startDatetime
24801 
   - endDatetime
24802 
  """
24803 
 
24804 
  thrift_spec = (
24805 
    None, # 0
24806 
    (1, TType.I64, 'status', None, None, ), # 1
24807 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
24808 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
24809 
  )
24810 
 
24811 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
24812 
    self.status = status
24813 
    self.startDatetime = startDatetime
24814 
    self.endDatetime = endDatetime
24815 
 
24816 
  def read(self, iprot):
24817 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24818 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24819 
      return
24820 
    iprot.readStructBegin()
24821 
    while True:
24822 
      (fname, ftype, fid) = iprot.readFieldBegin()
24823 
      if ftype == TType.STOP:
24824 
        break
24825 
      if fid == 1:
24826 
        if ftype == TType.I64:
24827 
          self.status = iprot.readI64();
24828 
        else:
24829 
          iprot.skip(ftype)
24830 
      elif fid == 2:
24831 
        if ftype == TType.I64:
24832 
          self.startDatetime = iprot.readI64();
24833 
        else:
24834 
          iprot.skip(ftype)
24835 
      elif fid == 3:
24836 
        if ftype == TType.I64:
24837 
          self.endDatetime = iprot.readI64();
24838 
        else:
24839 
          iprot.skip(ftype)
24840 
      else:
24841 
        iprot.skip(ftype)
24842 
      iprot.readFieldEnd()
24843 
    iprot.readStructEnd()
24844 
 
24845 
  def write(self, oprot):
24846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24848 
      return
24849 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
24850 
    if self.status is not None:
24851 
      oprot.writeFieldBegin('status', TType.I64, 1)
24852 
      oprot.writeI64(self.status)
24853 
      oprot.writeFieldEnd()
24854 
    if self.startDatetime is not None:
24855 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
24856 
      oprot.writeI64(self.startDatetime)
24857 
      oprot.writeFieldEnd()
24858 
    if self.endDatetime is not None:
24859 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
24860 
      oprot.writeI64(self.endDatetime)
24861 
      oprot.writeFieldEnd()
24862 
    oprot.writeFieldStop()
24863 
    oprot.writeStructEnd()
24864 
 
24865 
  def validate(self):
24866 
    return
24867 
 
24868 
 
24869 
  def __repr__(self):
24870 
    L = ['%s=%r' % (key, value)
24871 
      for key, value in self.__dict__.iteritems()]
24872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24873 
 
24874 
  def __eq__(self, other):
24875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24876 
 
24877 
  def __ne__(self, other):
24878 
    return not (self == other)
24879 
 
24880 
class getOrderIdsForStatus_result:
24881 
  """
24882 
  Attributes:
24883 
   - success
24884 
   - ex
24885 
  """
24886 
 
24887 
  thrift_spec = (
24888 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24889 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24890 
  )
24891 
 
24892 
  def __init__(self, success=None, ex=None,):
24893 
    self.success = success
24894 
    self.ex = ex
24895 
 
24896 
  def read(self, iprot):
24897 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24898 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24899 
      return
24900 
    iprot.readStructBegin()
24901 
    while True:
24902 
      (fname, ftype, fid) = iprot.readFieldBegin()
24903 
      if ftype == TType.STOP:
24904 
        break
24905 
      if fid == 0:
24906 
        if ftype == TType.LIST:
24907 
          self.success = []
6188 rajveer 24908 
          (_etype603, _size600) = iprot.readListBegin()
24909 
          for _i604 in xrange(_size600):
24910 
            _elem605 = iprot.readI64();
24911 
            self.success.append(_elem605)
5067 varun.gupt 24912 
          iprot.readListEnd()
24913 
        else:
24914 
          iprot.skip(ftype)
24915 
      elif fid == 1:
24916 
        if ftype == TType.STRUCT:
24917 
          self.ex = TransactionServiceException()
24918 
          self.ex.read(iprot)
24919 
        else:
24920 
          iprot.skip(ftype)
24921 
      else:
24922 
        iprot.skip(ftype)
24923 
      iprot.readFieldEnd()
24924 
    iprot.readStructEnd()
24925 
 
24926 
  def write(self, oprot):
24927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24929 
      return
24930 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
24931 
    if self.success is not None:
24932 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24933 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24934 
      for iter606 in self.success:
24935 
        oprot.writeI64(iter606)
5067 varun.gupt 24936 
      oprot.writeListEnd()
24937 
      oprot.writeFieldEnd()
24938 
    if self.ex is not None:
24939 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24940 
      self.ex.write(oprot)
24941 
      oprot.writeFieldEnd()
24942 
    oprot.writeFieldStop()
24943 
    oprot.writeStructEnd()
24944 
 
24945 
  def validate(self):
24946 
    return
24947 
 
24948 
 
24949 
  def __repr__(self):
24950 
    L = ['%s=%r' % (key, value)
24951 
      for key, value in self.__dict__.iteritems()]
24952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24953 
 
24954 
  def __eq__(self, other):
24955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24956 
 
24957 
  def __ne__(self, other):
24958 
    return not (self == other)
5099 varun.gupt 24959 
 
5348 anupam.sin 24960 
class updateCODAgent_args:
24961 
  """
24962 
  Attributes:
24963 
   - agent
24964 
   - orderId
24965 
  """
24966 
 
24967 
  thrift_spec = (
24968 
    None, # 0
24969 
    (1, TType.STRING, 'agent', None, None, ), # 1
24970 
    (2, TType.I64, 'orderId', None, None, ), # 2
24971 
  )
24972 
 
24973 
  def __init__(self, agent=None, orderId=None,):
24974 
    self.agent = agent
24975 
    self.orderId = orderId
24976 
 
24977 
  def read(self, iprot):
24978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24980 
      return
24981 
    iprot.readStructBegin()
24982 
    while True:
24983 
      (fname, ftype, fid) = iprot.readFieldBegin()
24984 
      if ftype == TType.STOP:
24985 
        break
24986 
      if fid == 1:
24987 
        if ftype == TType.STRING:
24988 
          self.agent = iprot.readString();
24989 
        else:
24990 
          iprot.skip(ftype)
24991 
      elif fid == 2:
24992 
        if ftype == TType.I64:
24993 
          self.orderId = iprot.readI64();
24994 
        else:
24995 
          iprot.skip(ftype)
24996 
      else:
24997 
        iprot.skip(ftype)
24998 
      iprot.readFieldEnd()
24999 
    iprot.readStructEnd()
25000 
 
25001 
  def write(self, oprot):
25002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25004 
      return
25005 
    oprot.writeStructBegin('updateCODAgent_args')
25006 
    if self.agent is not None:
25007 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
25008 
      oprot.writeString(self.agent)
25009 
      oprot.writeFieldEnd()
25010 
    if self.orderId is not None:
25011 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
25012 
      oprot.writeI64(self.orderId)
25013 
      oprot.writeFieldEnd()
25014 
    oprot.writeFieldStop()
25015 
    oprot.writeStructEnd()
25016 
 
25017 
  def validate(self):
25018 
    return
25019 
 
25020 
 
25021 
  def __repr__(self):
25022 
    L = ['%s=%r' % (key, value)
25023 
      for key, value in self.__dict__.iteritems()]
25024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25025 
 
25026 
  def __eq__(self, other):
25027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25028 
 
25029 
  def __ne__(self, other):
25030 
    return not (self == other)
25031 
 
25032 
class updateCODAgent_result:
25033 
  """
25034 
  Attributes:
25035 
   - ex
25036 
  """
25037 
 
25038 
  thrift_spec = (
25039 
    None, # 0
25040 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25041 
  )
25042 
 
25043 
  def __init__(self, ex=None,):
25044 
    self.ex = ex
25045 
 
25046 
  def read(self, iprot):
25047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25049 
      return
25050 
    iprot.readStructBegin()
25051 
    while True:
25052 
      (fname, ftype, fid) = iprot.readFieldBegin()
25053 
      if ftype == TType.STOP:
25054 
        break
25055 
      if fid == 1:
25056 
        if ftype == TType.STRUCT:
25057 
          self.ex = TransactionServiceException()
25058 
          self.ex.read(iprot)
25059 
        else:
25060 
          iprot.skip(ftype)
25061 
      else:
25062 
        iprot.skip(ftype)
25063 
      iprot.readFieldEnd()
25064 
    iprot.readStructEnd()
25065 
 
25066 
  def write(self, oprot):
25067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25069 
      return
25070 
    oprot.writeStructBegin('updateCODAgent_result')
25071 
    if self.ex is not None:
25072 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25073 
      self.ex.write(oprot)
25074 
      oprot.writeFieldEnd()
25075 
    oprot.writeFieldStop()
25076 
    oprot.writeStructEnd()
25077 
 
25078 
  def validate(self):
25079 
    return
25080 
 
25081 
 
25082 
  def __repr__(self):
25083 
    L = ['%s=%r' % (key, value)
25084 
      for key, value in self.__dict__.iteritems()]
25085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25086 
 
25087 
  def __eq__(self, other):
25088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25089 
 
25090 
  def __ne__(self, other):
25091 
    return not (self == other)
25092 
 
5099 varun.gupt 25093 
class updateOrderAsPaidToVendor_args:
25094 
  """
25095 
  Attributes:
25096 
   - orderId
25097 
  """
25098 
 
25099 
  thrift_spec = (
25100 
    None, # 0
25101 
    (1, TType.I64, 'orderId', None, None, ), # 1
25102 
  )
25103 
 
25104 
  def __init__(self, orderId=None,):
25105 
    self.orderId = orderId
25106 
 
25107 
  def read(self, iprot):
25108 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25109 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25110 
      return
25111 
    iprot.readStructBegin()
25112 
    while True:
25113 
      (fname, ftype, fid) = iprot.readFieldBegin()
25114 
      if ftype == TType.STOP:
25115 
        break
25116 
      if fid == 1:
25117 
        if ftype == TType.I64:
25118 
          self.orderId = iprot.readI64();
25119 
        else:
25120 
          iprot.skip(ftype)
25121 
      else:
25122 
        iprot.skip(ftype)
25123 
      iprot.readFieldEnd()
25124 
    iprot.readStructEnd()
25125 
 
25126 
  def write(self, oprot):
25127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25129 
      return
25130 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
25131 
    if self.orderId is not None:
25132 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25133 
      oprot.writeI64(self.orderId)
25134 
      oprot.writeFieldEnd()
25135 
    oprot.writeFieldStop()
25136 
    oprot.writeStructEnd()
25137 
 
25138 
  def validate(self):
25139 
    return
25140 
 
25141 
 
25142 
  def __repr__(self):
25143 
    L = ['%s=%r' % (key, value)
25144 
      for key, value in self.__dict__.iteritems()]
25145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25146 
 
25147 
  def __eq__(self, other):
25148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25149 
 
25150 
  def __ne__(self, other):
25151 
    return not (self == other)
25152 
 
25153 
class updateOrderAsPaidToVendor_result:
25154 
  """
25155 
  Attributes:
25156 
   - ex
25157 
  """
25158 
 
25159 
  thrift_spec = (
25160 
    None, # 0
25161 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25162 
  )
25163 
 
25164 
  def __init__(self, ex=None,):
25165 
    self.ex = ex
25166 
 
25167 
  def read(self, iprot):
25168 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25169 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25170 
      return
25171 
    iprot.readStructBegin()
25172 
    while True:
25173 
      (fname, ftype, fid) = iprot.readFieldBegin()
25174 
      if ftype == TType.STOP:
25175 
        break
25176 
      if fid == 1:
25177 
        if ftype == TType.STRUCT:
25178 
          self.ex = TransactionServiceException()
25179 
          self.ex.read(iprot)
25180 
        else:
25181 
          iprot.skip(ftype)
25182 
      else:
25183 
        iprot.skip(ftype)
25184 
      iprot.readFieldEnd()
25185 
    iprot.readStructEnd()
25186 
 
25187 
  def write(self, oprot):
25188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25190 
      return
25191 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
25192 
    if self.ex is not None:
25193 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25194 
      self.ex.write(oprot)
25195 
      oprot.writeFieldEnd()
25196 
    oprot.writeFieldStop()
25197 
    oprot.writeStructEnd()
25198 
 
25199 
  def validate(self):
25200 
    return
25201 
 
25202 
 
25203 
  def __repr__(self):
25204 
    L = ['%s=%r' % (key, value)
25205 
      for key, value in self.__dict__.iteritems()]
25206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25207 
 
25208 
  def __eq__(self, other):
25209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25210 
 
25211 
  def __ne__(self, other):
25212 
    return not (self == other)
5208 varun.gupt 25213 
 
5386 phani.kuma 25214 
class updateOrderOnlyAsPaidToVendor_args:
25215 
  """
25216 
  Attributes:
25217 
   - orderId
25218 
  """
25219 
 
25220 
  thrift_spec = (
25221 
    None, # 0
25222 
    (1, TType.I64, 'orderId', None, None, ), # 1
25223 
  )
25224 
 
25225 
  def __init__(self, orderId=None,):
25226 
    self.orderId = orderId
25227 
 
25228 
  def read(self, iprot):
25229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25231 
      return
25232 
    iprot.readStructBegin()
25233 
    while True:
25234 
      (fname, ftype, fid) = iprot.readFieldBegin()
25235 
      if ftype == TType.STOP:
25236 
        break
25237 
      if fid == 1:
25238 
        if ftype == TType.I64:
25239 
          self.orderId = iprot.readI64();
25240 
        else:
25241 
          iprot.skip(ftype)
25242 
      else:
25243 
        iprot.skip(ftype)
25244 
      iprot.readFieldEnd()
25245 
    iprot.readStructEnd()
25246 
 
25247 
  def write(self, oprot):
25248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25250 
      return
25251 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
25252 
    if self.orderId is not None:
25253 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25254 
      oprot.writeI64(self.orderId)
25255 
      oprot.writeFieldEnd()
25256 
    oprot.writeFieldStop()
25257 
    oprot.writeStructEnd()
25258 
 
25259 
  def validate(self):
25260 
    return
25261 
 
25262 
 
25263 
  def __repr__(self):
25264 
    L = ['%s=%r' % (key, value)
25265 
      for key, value in self.__dict__.iteritems()]
25266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25267 
 
25268 
  def __eq__(self, other):
25269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25270 
 
25271 
  def __ne__(self, other):
25272 
    return not (self == other)
25273 
 
25274 
class updateOrderOnlyAsPaidToVendor_result:
25275 
  """
25276 
  Attributes:
25277 
   - ex
25278 
  """
25279 
 
25280 
  thrift_spec = (
25281 
    None, # 0
25282 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25283 
  )
25284 
 
25285 
  def __init__(self, ex=None,):
25286 
    self.ex = ex
25287 
 
25288 
  def read(self, iprot):
25289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25291 
      return
25292 
    iprot.readStructBegin()
25293 
    while True:
25294 
      (fname, ftype, fid) = iprot.readFieldBegin()
25295 
      if ftype == TType.STOP:
25296 
        break
25297 
      if fid == 1:
25298 
        if ftype == TType.STRUCT:
25299 
          self.ex = TransactionServiceException()
25300 
          self.ex.read(iprot)
25301 
        else:
25302 
          iprot.skip(ftype)
25303 
      else:
25304 
        iprot.skip(ftype)
25305 
      iprot.readFieldEnd()
25306 
    iprot.readStructEnd()
25307 
 
25308 
  def write(self, oprot):
25309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25311 
      return
25312 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
25313 
    if self.ex is not None:
25314 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25315 
      self.ex.write(oprot)
25316 
      oprot.writeFieldEnd()
25317 
    oprot.writeFieldStop()
25318 
    oprot.writeStructEnd()
25319 
 
25320 
  def validate(self):
25321 
    return
25322 
 
25323 
 
25324 
  def __repr__(self):
25325 
    L = ['%s=%r' % (key, value)
25326 
      for key, value in self.__dict__.iteritems()]
25327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25328 
 
25329 
  def __eq__(self, other):
25330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25331 
 
25332 
  def __ne__(self, other):
25333 
    return not (self == other)
25334 
 
5208 varun.gupt 25335 
class getRefundedOrdersMarkedPaid_args:
25336 
 
25337 
  thrift_spec = (
25338 
  )
25339 
 
25340 
  def read(self, iprot):
25341 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25342 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25343 
      return
25344 
    iprot.readStructBegin()
25345 
    while True:
25346 
      (fname, ftype, fid) = iprot.readFieldBegin()
25347 
      if ftype == TType.STOP:
25348 
        break
25349 
      else:
25350 
        iprot.skip(ftype)
25351 
      iprot.readFieldEnd()
25352 
    iprot.readStructEnd()
25353 
 
25354 
  def write(self, oprot):
25355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25357 
      return
25358 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
25359 
    oprot.writeFieldStop()
25360 
    oprot.writeStructEnd()
25361 
 
25362 
  def validate(self):
25363 
    return
25364 
 
25365 
 
25366 
  def __repr__(self):
25367 
    L = ['%s=%r' % (key, value)
25368 
      for key, value in self.__dict__.iteritems()]
25369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25370 
 
25371 
  def __eq__(self, other):
25372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25373 
 
25374 
  def __ne__(self, other):
25375 
    return not (self == other)
25376 
 
25377 
class getRefundedOrdersMarkedPaid_result:
25378 
  """
25379 
  Attributes:
25380 
   - success
25381 
   - ex
25382 
  """
25383 
 
25384 
  thrift_spec = (
25385 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25386 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25387 
  )
25388 
 
25389 
  def __init__(self, success=None, ex=None,):
25390 
    self.success = success
25391 
    self.ex = ex
25392 
 
25393 
  def read(self, iprot):
25394 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25395 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25396 
      return
25397 
    iprot.readStructBegin()
25398 
    while True:
25399 
      (fname, ftype, fid) = iprot.readFieldBegin()
25400 
      if ftype == TType.STOP:
25401 
        break
25402 
      if fid == 0:
25403 
        if ftype == TType.LIST:
25404 
          self.success = []
6188 rajveer 25405 
          (_etype610, _size607) = iprot.readListBegin()
25406 
          for _i611 in xrange(_size607):
25407 
            _elem612 = Order()
25408 
            _elem612.read(iprot)
25409 
            self.success.append(_elem612)
5208 varun.gupt 25410 
          iprot.readListEnd()
25411 
        else:
25412 
          iprot.skip(ftype)
25413 
      elif fid == 1:
25414 
        if ftype == TType.STRUCT:
25415 
          self.ex = TransactionServiceException()
25416 
          self.ex.read(iprot)
25417 
        else:
25418 
          iprot.skip(ftype)
25419 
      else:
25420 
        iprot.skip(ftype)
25421 
      iprot.readFieldEnd()
25422 
    iprot.readStructEnd()
25423 
 
25424 
  def write(self, oprot):
25425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25427 
      return
25428 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
25429 
    if self.success is not None:
25430 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25431 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25432 
      for iter613 in self.success:
25433 
        iter613.write(oprot)
5208 varun.gupt 25434 
      oprot.writeListEnd()
25435 
      oprot.writeFieldEnd()
25436 
    if self.ex is not None:
25437 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25438 
      self.ex.write(oprot)
25439 
      oprot.writeFieldEnd()
25440 
    oprot.writeFieldStop()
25441 
    oprot.writeStructEnd()
25442 
 
25443 
  def validate(self):
25444 
    return
25445 
 
25446 
 
25447 
  def __repr__(self):
25448 
    L = ['%s=%r' % (key, value)
25449 
      for key, value in self.__dict__.iteritems()]
25450 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25451 
 
25452 
  def __eq__(self, other):
25453 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25454 
 
25455 
  def __ne__(self, other):
25456 
    return not (self == other)
5447 anupam.sin 25457 
 
25458 
class getAllVerificationAgents_args:
25459 
  """
25460 
  Attributes:
25461 
   - minOrderId
25462 
   - maxOrderId
25463 
  """
25464 
 
25465 
  thrift_spec = (
25466 
    None, # 0
25467 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
25468 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
25469 
  )
25470 
 
25471 
  def __init__(self, minOrderId=None, maxOrderId=None,):
25472 
    self.minOrderId = minOrderId
25473 
    self.maxOrderId = maxOrderId
25474 
 
25475 
  def read(self, iprot):
25476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25478 
      return
25479 
    iprot.readStructBegin()
25480 
    while True:
25481 
      (fname, ftype, fid) = iprot.readFieldBegin()
25482 
      if ftype == TType.STOP:
25483 
        break
25484 
      if fid == 1:
25485 
        if ftype == TType.I64:
25486 
          self.minOrderId = iprot.readI64();
25487 
        else:
25488 
          iprot.skip(ftype)
25489 
      elif fid == 2:
25490 
        if ftype == TType.I64:
25491 
          self.maxOrderId = iprot.readI64();
25492 
        else:
25493 
          iprot.skip(ftype)
25494 
      else:
25495 
        iprot.skip(ftype)
25496 
      iprot.readFieldEnd()
25497 
    iprot.readStructEnd()
25498 
 
25499 
  def write(self, oprot):
25500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25502 
      return
25503 
    oprot.writeStructBegin('getAllVerificationAgents_args')
25504 
    if self.minOrderId is not None:
25505 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
25506 
      oprot.writeI64(self.minOrderId)
25507 
      oprot.writeFieldEnd()
25508 
    if self.maxOrderId is not None:
25509 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
25510 
      oprot.writeI64(self.maxOrderId)
25511 
      oprot.writeFieldEnd()
25512 
    oprot.writeFieldStop()
25513 
    oprot.writeStructEnd()
25514 
 
25515 
  def validate(self):
25516 
    return
25517 
 
25518 
 
25519 
  def __repr__(self):
25520 
    L = ['%s=%r' % (key, value)
25521 
      for key, value in self.__dict__.iteritems()]
25522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25523 
 
25524 
  def __eq__(self, other):
25525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25526 
 
25527 
  def __ne__(self, other):
25528 
    return not (self == other)
25529 
 
25530 
class getAllVerificationAgents_result:
25531 
  """
25532 
  Attributes:
25533 
   - success
25534 
  """
25535 
 
25536 
  thrift_spec = (
25537 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
25538 
  )
25539 
 
25540 
  def __init__(self, success=None,):
25541 
    self.success = success
25542 
 
25543 
  def read(self, iprot):
25544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25546 
      return
25547 
    iprot.readStructBegin()
25548 
    while True:
25549 
      (fname, ftype, fid) = iprot.readFieldBegin()
25550 
      if ftype == TType.STOP:
25551 
        break
25552 
      if fid == 0:
25553 
        if ftype == TType.LIST:
25554 
          self.success = []
6188 rajveer 25555 
          (_etype617, _size614) = iprot.readListBegin()
25556 
          for _i618 in xrange(_size614):
25557 
            _elem619 = CODVerificationAgent()
25558 
            _elem619.read(iprot)
25559 
            self.success.append(_elem619)
5447 anupam.sin 25560 
          iprot.readListEnd()
25561 
        else:
25562 
          iprot.skip(ftype)
25563 
      else:
25564 
        iprot.skip(ftype)
25565 
      iprot.readFieldEnd()
25566 
    iprot.readStructEnd()
25567 
 
25568 
  def write(self, oprot):
25569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25571 
      return
25572 
    oprot.writeStructBegin('getAllVerificationAgents_result')
25573 
    if self.success is not None:
25574 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25575 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25576 
      for iter620 in self.success:
25577 
        iter620.write(oprot)
5447 anupam.sin 25578 
      oprot.writeListEnd()
25579 
      oprot.writeFieldEnd()
25580 
    oprot.writeFieldStop()
25581 
    oprot.writeStructEnd()
25582 
 
25583 
  def validate(self):
25584 
    return
25585 
 
25586 
 
25587 
  def __repr__(self):
25588 
    L = ['%s=%r' % (key, value)
25589 
      for key, value in self.__dict__.iteritems()]
25590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25591 
 
25592 
  def __eq__(self, other):
25593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25594 
 
25595 
  def __ne__(self, other):
25596 
    return not (self == other)
5527 anupam.sin 25597 
 
25598 
class getAllAttributesForOrderId_args:
25599 
  """
25600 
  Attributes:
25601 
   - orderId
25602 
  """
25603 
 
25604 
  thrift_spec = (
25605 
    None, # 0
25606 
    (1, TType.I64, 'orderId', None, None, ), # 1
25607 
  )
25608 
 
25609 
  def __init__(self, orderId=None,):
25610 
    self.orderId = orderId
25611 
 
25612 
  def read(self, iprot):
25613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25615 
      return
25616 
    iprot.readStructBegin()
25617 
    while True:
25618 
      (fname, ftype, fid) = iprot.readFieldBegin()
25619 
      if ftype == TType.STOP:
25620 
        break
25621 
      if fid == 1:
25622 
        if ftype == TType.I64:
25623 
          self.orderId = iprot.readI64();
25624 
        else:
25625 
          iprot.skip(ftype)
25626 
      else:
25627 
        iprot.skip(ftype)
25628 
      iprot.readFieldEnd()
25629 
    iprot.readStructEnd()
25630 
 
25631 
  def write(self, oprot):
25632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25634 
      return
25635 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
25636 
    if self.orderId is not None:
25637 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25638 
      oprot.writeI64(self.orderId)
25639 
      oprot.writeFieldEnd()
25640 
    oprot.writeFieldStop()
25641 
    oprot.writeStructEnd()
25642 
 
25643 
  def validate(self):
25644 
    return
25645 
 
25646 
 
25647 
  def __repr__(self):
25648 
    L = ['%s=%r' % (key, value)
25649 
      for key, value in self.__dict__.iteritems()]
25650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25651 
 
25652 
  def __eq__(self, other):
25653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25654 
 
25655 
  def __ne__(self, other):
25656 
    return not (self == other)
25657 
 
25658 
class getAllAttributesForOrderId_result:
25659 
  """
25660 
  Attributes:
25661 
   - success
25662 
  """
25663 
 
25664 
  thrift_spec = (
25665 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25666 
  )
25667 
 
25668 
  def __init__(self, success=None,):
25669 
    self.success = success
25670 
 
25671 
  def read(self, iprot):
25672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25674 
      return
25675 
    iprot.readStructBegin()
25676 
    while True:
25677 
      (fname, ftype, fid) = iprot.readFieldBegin()
25678 
      if ftype == TType.STOP:
25679 
        break
25680 
      if fid == 0:
25681 
        if ftype == TType.LIST:
25682 
          self.success = []
6188 rajveer 25683 
          (_etype624, _size621) = iprot.readListBegin()
25684 
          for _i625 in xrange(_size621):
25685 
            _elem626 = Attribute()
25686 
            _elem626.read(iprot)
25687 
            self.success.append(_elem626)
5527 anupam.sin 25688 
          iprot.readListEnd()
25689 
        else:
25690 
          iprot.skip(ftype)
25691 
      else:
25692 
        iprot.skip(ftype)
25693 
      iprot.readFieldEnd()
25694 
    iprot.readStructEnd()
25695 
 
25696 
  def write(self, oprot):
25697 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25698 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25699 
      return
25700 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
25701 
    if self.success is not None:
25702 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25703 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25704 
      for iter627 in self.success:
25705 
        iter627.write(oprot)
5527 anupam.sin 25706 
      oprot.writeListEnd()
25707 
      oprot.writeFieldEnd()
25708 
    oprot.writeFieldStop()
25709 
    oprot.writeStructEnd()
25710 
 
25711 
  def validate(self):
25712 
    return
25713 
 
25714 
 
25715 
  def __repr__(self):
25716 
    L = ['%s=%r' % (key, value)
25717 
      for key, value in self.__dict__.iteritems()]
25718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25719 
 
25720 
  def __eq__(self, other):
25721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25722 
 
25723 
  def __ne__(self, other):
25724 
    return not (self == other)
25725 
 
5676 rajveer 25726 
class setOrderAttributes_args:
25727 
  """
25728 
  Attributes:
25729 
   - orderId
25730 
   - attributes
25731 
  """
25732 
 
25733 
  thrift_spec = None
25734 
  def __init__(self, orderId=None, attributes=None,):
25735 
    self.orderId = orderId
25736 
    self.attributes = attributes
25737 
 
25738 
  def read(self, iprot):
25739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25741 
      return
25742 
    iprot.readStructBegin()
25743 
    while True:
25744 
      (fname, ftype, fid) = iprot.readFieldBegin()
25745 
      if ftype == TType.STOP:
25746 
        break
25747 
      if fid == 1:
25748 
        if ftype == TType.I64:
25749 
          self.orderId = iprot.readI64();
25750 
        else:
25751 
          iprot.skip(ftype)
25752 
      elif fid == -1:
25753 
        if ftype == TType.LIST:
25754 
          self.attributes = []
6188 rajveer 25755 
          (_etype631, _size628) = iprot.readListBegin()
25756 
          for _i632 in xrange(_size628):
25757 
            _elem633 = Attribute()
25758 
            _elem633.read(iprot)
25759 
            self.attributes.append(_elem633)
5676 rajveer 25760 
          iprot.readListEnd()
25761 
        else:
25762 
          iprot.skip(ftype)
25763 
      else:
25764 
        iprot.skip(ftype)
25765 
      iprot.readFieldEnd()
25766 
    iprot.readStructEnd()
25767 
 
25768 
  def write(self, oprot):
25769 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25770 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25771 
      return
25772 
    oprot.writeStructBegin('setOrderAttributes_args')
25773 
    if self.attributes is not None:
25774 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
25775 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 25776 
      for iter634 in self.attributes:
25777 
        iter634.write(oprot)
5676 rajveer 25778 
      oprot.writeListEnd()
25779 
      oprot.writeFieldEnd()
25780 
    if self.orderId is not None:
25781 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25782 
      oprot.writeI64(self.orderId)
25783 
      oprot.writeFieldEnd()
25784 
    oprot.writeFieldStop()
25785 
    oprot.writeStructEnd()
25786 
 
25787 
  def validate(self):
25788 
    return
25789 
 
25790 
 
25791 
  def __repr__(self):
25792 
    L = ['%s=%r' % (key, value)
25793 
      for key, value in self.__dict__.iteritems()]
25794 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25795 
 
25796 
  def __eq__(self, other):
25797 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25798 
 
25799 
  def __ne__(self, other):
25800 
    return not (self == other)
25801 
 
25802 
class setOrderAttributes_result:
25803 
 
25804 
  thrift_spec = (
25805 
  )
25806 
 
25807 
  def read(self, iprot):
25808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25810 
      return
25811 
    iprot.readStructBegin()
25812 
    while True:
25813 
      (fname, ftype, fid) = iprot.readFieldBegin()
25814 
      if ftype == TType.STOP:
25815 
        break
25816 
      else:
25817 
        iprot.skip(ftype)
25818 
      iprot.readFieldEnd()
25819 
    iprot.readStructEnd()
25820 
 
25821 
  def write(self, oprot):
25822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25824 
      return
25825 
    oprot.writeStructBegin('setOrderAttributes_result')
25826 
    oprot.writeFieldStop()
25827 
    oprot.writeStructEnd()
25828 
 
25829 
  def validate(self):
25830 
    return
25831 
 
25832 
 
25833 
  def __repr__(self):
25834 
    L = ['%s=%r' % (key, value)
25835 
      for key, value in self.__dict__.iteritems()]
25836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25837 
 
25838 
  def __eq__(self, other):
25839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25840 
 
25841 
  def __ne__(self, other):
25842 
    return not (self == other)
25843 
 
5527 anupam.sin 25844 
class setOrderAttributeForTransaction_args:
25845 
  """
25846 
  Attributes:
25847 
   - transactionId
25848 
   - attribute
25849 
  """
25850 
 
25851 
  thrift_spec = None
25852 
  def __init__(self, transactionId=None, attribute=None,):
25853 
    self.transactionId = transactionId
25854 
    self.attribute = attribute
25855 
 
25856 
  def read(self, iprot):
25857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25859 
      return
25860 
    iprot.readStructBegin()
25861 
    while True:
25862 
      (fname, ftype, fid) = iprot.readFieldBegin()
25863 
      if ftype == TType.STOP:
25864 
        break
25865 
      if fid == 1:
25866 
        if ftype == TType.I64:
25867 
          self.transactionId = iprot.readI64();
25868 
        else:
25869 
          iprot.skip(ftype)
25870 
      elif fid == -1:
25871 
        if ftype == TType.STRUCT:
25872 
          self.attribute = Attribute()
25873 
          self.attribute.read(iprot)
25874 
        else:
25875 
          iprot.skip(ftype)
25876 
      else:
25877 
        iprot.skip(ftype)
25878 
      iprot.readFieldEnd()
25879 
    iprot.readStructEnd()
25880 
 
25881 
  def write(self, oprot):
25882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25884 
      return
25885 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
25886 
    if self.attribute is not None:
25887 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
25888 
      self.attribute.write(oprot)
25889 
      oprot.writeFieldEnd()
25890 
    if self.transactionId is not None:
25891 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
25892 
      oprot.writeI64(self.transactionId)
25893 
      oprot.writeFieldEnd()
25894 
    oprot.writeFieldStop()
25895 
    oprot.writeStructEnd()
25896 
 
25897 
  def validate(self):
25898 
    return
25899 
 
25900 
 
25901 
  def __repr__(self):
25902 
    L = ['%s=%r' % (key, value)
25903 
      for key, value in self.__dict__.iteritems()]
25904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25905 
 
25906 
  def __eq__(self, other):
25907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25908 
 
25909 
  def __ne__(self, other):
25910 
    return not (self == other)
25911 
 
25912 
class setOrderAttributeForTransaction_result:
25913 
 
25914 
  thrift_spec = (
25915 
  )
25916 
 
25917 
  def read(self, iprot):
25918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25920 
      return
25921 
    iprot.readStructBegin()
25922 
    while True:
25923 
      (fname, ftype, fid) = iprot.readFieldBegin()
25924 
      if ftype == TType.STOP:
25925 
        break
25926 
      else:
25927 
        iprot.skip(ftype)
25928 
      iprot.readFieldEnd()
25929 
    iprot.readStructEnd()
25930 
 
25931 
  def write(self, oprot):
25932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25934 
      return
25935 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
25936 
    oprot.writeFieldStop()
25937 
    oprot.writeStructEnd()
25938 
 
25939 
  def validate(self):
25940 
    return
25941 
 
25942 
 
25943 
  def __repr__(self):
25944 
    L = ['%s=%r' % (key, value)
25945 
      for key, value in self.__dict__.iteritems()]
25946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25947 
 
25948 
  def __eq__(self, other):
25949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25950 
 
25951 
  def __ne__(self, other):
25952 
    return not (self == other)
5553 rajveer 25953 
 
25954 
class getReceivePendingOrders_args:
25955 
  """
25956 
  Attributes:
25957 
   - storeId
25958 
  """
25959 
 
25960 
  thrift_spec = (
25961 
    None, # 0
25962 
    (1, TType.I64, 'storeId', None, None, ), # 1
25963 
  )
25964 
 
25965 
  def __init__(self, storeId=None,):
25966 
    self.storeId = storeId
25967 
 
25968 
  def read(self, iprot):
25969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25971 
      return
25972 
    iprot.readStructBegin()
25973 
    while True:
25974 
      (fname, ftype, fid) = iprot.readFieldBegin()
25975 
      if ftype == TType.STOP:
25976 
        break
25977 
      if fid == 1:
25978 
        if ftype == TType.I64:
25979 
          self.storeId = iprot.readI64();
25980 
        else:
25981 
          iprot.skip(ftype)
25982 
      else:
25983 
        iprot.skip(ftype)
25984 
      iprot.readFieldEnd()
25985 
    iprot.readStructEnd()
25986 
 
25987 
  def write(self, oprot):
25988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25990 
      return
25991 
    oprot.writeStructBegin('getReceivePendingOrders_args')
25992 
    if self.storeId is not None:
25993 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25994 
      oprot.writeI64(self.storeId)
25995 
      oprot.writeFieldEnd()
25996 
    oprot.writeFieldStop()
25997 
    oprot.writeStructEnd()
25998 
 
25999 
  def validate(self):
26000 
    return
26001 
 
26002 
 
26003 
  def __repr__(self):
26004 
    L = ['%s=%r' % (key, value)
26005 
      for key, value in self.__dict__.iteritems()]
26006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26007 
 
26008 
  def __eq__(self, other):
26009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26010 
 
26011 
  def __ne__(self, other):
26012 
    return not (self == other)
26013 
 
26014 
class getReceivePendingOrders_result:
26015 
  """
26016 
  Attributes:
26017 
   - success
26018 
  """
26019 
 
26020 
  thrift_spec = (
26021 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26022 
  )
26023 
 
26024 
  def __init__(self, success=None,):
26025 
    self.success = success
26026 
 
26027 
  def read(self, iprot):
26028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26030 
      return
26031 
    iprot.readStructBegin()
26032 
    while True:
26033 
      (fname, ftype, fid) = iprot.readFieldBegin()
26034 
      if ftype == TType.STOP:
26035 
        break
26036 
      if fid == 0:
26037 
        if ftype == TType.LIST:
26038 
          self.success = []
6188 rajveer 26039 
          (_etype638, _size635) = iprot.readListBegin()
26040 
          for _i639 in xrange(_size635):
26041 
            _elem640 = Order()
26042 
            _elem640.read(iprot)
26043 
            self.success.append(_elem640)
5553 rajveer 26044 
          iprot.readListEnd()
26045 
        else:
26046 
          iprot.skip(ftype)
26047 
      else:
26048 
        iprot.skip(ftype)
26049 
      iprot.readFieldEnd()
26050 
    iprot.readStructEnd()
26051 
 
26052 
  def write(self, oprot):
26053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26055 
      return
26056 
    oprot.writeStructBegin('getReceivePendingOrders_result')
26057 
    if self.success is not None:
26058 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26059 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26060 
      for iter641 in self.success:
26061 
        iter641.write(oprot)
5553 rajveer 26062 
      oprot.writeListEnd()
26063 
      oprot.writeFieldEnd()
26064 
    oprot.writeFieldStop()
26065 
    oprot.writeStructEnd()
26066 
 
26067 
  def validate(self):
26068 
    return
26069 
 
26070 
 
26071 
  def __repr__(self):
26072 
    L = ['%s=%r' % (key, value)
26073 
      for key, value in self.__dict__.iteritems()]
26074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26075 
 
26076 
  def __eq__(self, other):
26077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26078 
 
26079 
  def __ne__(self, other):
26080 
    return not (self == other)
26081 
 
26082 
class getReceivedAtStoreOrders_args:
26083 
  """
26084 
  Attributes:
26085 
   - storeId
26086 
  """
26087 
 
26088 
  thrift_spec = (
26089 
    None, # 0
26090 
    (1, TType.I64, 'storeId', None, None, ), # 1
26091 
  )
26092 
 
26093 
  def __init__(self, storeId=None,):
26094 
    self.storeId = storeId
26095 
 
26096 
  def read(self, iprot):
26097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26099 
      return
26100 
    iprot.readStructBegin()
26101 
    while True:
26102 
      (fname, ftype, fid) = iprot.readFieldBegin()
26103 
      if ftype == TType.STOP:
26104 
        break
26105 
      if fid == 1:
26106 
        if ftype == TType.I64:
26107 
          self.storeId = iprot.readI64();
26108 
        else:
26109 
          iprot.skip(ftype)
26110 
      else:
26111 
        iprot.skip(ftype)
26112 
      iprot.readFieldEnd()
26113 
    iprot.readStructEnd()
26114 
 
26115 
  def write(self, oprot):
26116 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26117 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26118 
      return
26119 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
26120 
    if self.storeId is not None:
26121 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26122 
      oprot.writeI64(self.storeId)
26123 
      oprot.writeFieldEnd()
26124 
    oprot.writeFieldStop()
26125 
    oprot.writeStructEnd()
26126 
 
26127 
  def validate(self):
26128 
    return
26129 
 
26130 
 
26131 
  def __repr__(self):
26132 
    L = ['%s=%r' % (key, value)
26133 
      for key, value in self.__dict__.iteritems()]
26134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26135 
 
26136 
  def __eq__(self, other):
26137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26138 
 
26139 
  def __ne__(self, other):
26140 
    return not (self == other)
26141 
 
26142 
class getReceivedAtStoreOrders_result:
26143 
  """
26144 
  Attributes:
26145 
   - success
26146 
  """
26147 
 
26148 
  thrift_spec = (
26149 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26150 
  )
26151 
 
26152 
  def __init__(self, success=None,):
26153 
    self.success = success
26154 
 
26155 
  def read(self, iprot):
26156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26158 
      return
26159 
    iprot.readStructBegin()
26160 
    while True:
26161 
      (fname, ftype, fid) = iprot.readFieldBegin()
26162 
      if ftype == TType.STOP:
26163 
        break
26164 
      if fid == 0:
26165 
        if ftype == TType.LIST:
26166 
          self.success = []
6188 rajveer 26167 
          (_etype645, _size642) = iprot.readListBegin()
26168 
          for _i646 in xrange(_size642):
26169 
            _elem647 = Order()
26170 
            _elem647.read(iprot)
26171 
            self.success.append(_elem647)
5553 rajveer 26172 
          iprot.readListEnd()
26173 
        else:
26174 
          iprot.skip(ftype)
26175 
      else:
26176 
        iprot.skip(ftype)
26177 
      iprot.readFieldEnd()
26178 
    iprot.readStructEnd()
26179 
 
26180 
  def write(self, oprot):
26181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26183 
      return
26184 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
26185 
    if self.success is not None:
26186 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26187 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26188 
      for iter648 in self.success:
26189 
        iter648.write(oprot)
5553 rajveer 26190 
      oprot.writeListEnd()
26191 
      oprot.writeFieldEnd()
26192 
    oprot.writeFieldStop()
26193 
    oprot.writeStructEnd()
26194 
 
26195 
  def validate(self):
26196 
    return
26197 
 
26198 
 
26199 
  def __repr__(self):
26200 
    L = ['%s=%r' % (key, value)
26201 
      for key, value in self.__dict__.iteritems()]
26202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26203 
 
26204 
  def __eq__(self, other):
26205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26206 
 
26207 
  def __ne__(self, other):
26208 
    return not (self == other)
5593 mandeep.dh 26209 
 
5713 rajveer 26210 
class getOrdersCollectionAtStore_args:
26211 
  """
26212 
  Attributes:
26213 
   - storeId
26214 
   - fromDate
26215 
   - toDate
26216 
   - onlyCod
26217 
  """
26218 
 
26219 
  thrift_spec = (
26220 
    None, # 0
26221 
    (1, TType.I64, 'storeId', None, None, ), # 1
26222 
    (2, TType.I64, 'fromDate', None, None, ), # 2
26223 
    (3, TType.I64, 'toDate', None, None, ), # 3
26224 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
26225 
  )
26226 
 
26227 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
26228 
    self.storeId = storeId
26229 
    self.fromDate = fromDate
26230 
    self.toDate = toDate
26231 
    self.onlyCod = onlyCod
26232 
 
26233 
  def read(self, iprot):
26234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26236 
      return
26237 
    iprot.readStructBegin()
26238 
    while True:
26239 
      (fname, ftype, fid) = iprot.readFieldBegin()
26240 
      if ftype == TType.STOP:
26241 
        break
26242 
      if fid == 1:
26243 
        if ftype == TType.I64:
26244 
          self.storeId = iprot.readI64();
26245 
        else:
26246 
          iprot.skip(ftype)
26247 
      elif fid == 2:
26248 
        if ftype == TType.I64:
26249 
          self.fromDate = iprot.readI64();
26250 
        else:
26251 
          iprot.skip(ftype)
26252 
      elif fid == 3:
26253 
        if ftype == TType.I64:
26254 
          self.toDate = iprot.readI64();
26255 
        else:
26256 
          iprot.skip(ftype)
26257 
      elif fid == 4:
26258 
        if ftype == TType.BOOL:
26259 
          self.onlyCod = iprot.readBool();
26260 
        else:
26261 
          iprot.skip(ftype)
26262 
      else:
26263 
        iprot.skip(ftype)
26264 
      iprot.readFieldEnd()
26265 
    iprot.readStructEnd()
26266 
 
26267 
  def write(self, oprot):
26268 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26269 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26270 
      return
26271 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
26272 
    if self.storeId is not None:
26273 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26274 
      oprot.writeI64(self.storeId)
26275 
      oprot.writeFieldEnd()
26276 
    if self.fromDate is not None:
26277 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
26278 
      oprot.writeI64(self.fromDate)
26279 
      oprot.writeFieldEnd()
26280 
    if self.toDate is not None:
26281 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
26282 
      oprot.writeI64(self.toDate)
26283 
      oprot.writeFieldEnd()
26284 
    if self.onlyCod is not None:
26285 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
26286 
      oprot.writeBool(self.onlyCod)
26287 
      oprot.writeFieldEnd()
26288 
    oprot.writeFieldStop()
26289 
    oprot.writeStructEnd()
26290 
 
26291 
  def validate(self):
26292 
    return
26293 
 
26294 
 
26295 
  def __repr__(self):
26296 
    L = ['%s=%r' % (key, value)
26297 
      for key, value in self.__dict__.iteritems()]
26298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26299 
 
26300 
  def __eq__(self, other):
26301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26302 
 
26303 
  def __ne__(self, other):
26304 
    return not (self == other)
26305 
 
26306 
class getOrdersCollectionAtStore_result:
26307 
  """
26308 
  Attributes:
26309 
   - success
26310 
  """
26311 
 
26312 
  thrift_spec = (
26313 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26314 
  )
26315 
 
26316 
  def __init__(self, success=None,):
26317 
    self.success = success
26318 
 
26319 
  def read(self, iprot):
26320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26322 
      return
26323 
    iprot.readStructBegin()
26324 
    while True:
26325 
      (fname, ftype, fid) = iprot.readFieldBegin()
26326 
      if ftype == TType.STOP:
26327 
        break
26328 
      if fid == 0:
26329 
        if ftype == TType.LIST:
26330 
          self.success = []
6188 rajveer 26331 
          (_etype652, _size649) = iprot.readListBegin()
26332 
          for _i653 in xrange(_size649):
26333 
            _elem654 = Order()
26334 
            _elem654.read(iprot)
26335 
            self.success.append(_elem654)
5713 rajveer 26336 
          iprot.readListEnd()
26337 
        else:
26338 
          iprot.skip(ftype)
26339 
      else:
26340 
        iprot.skip(ftype)
26341 
      iprot.readFieldEnd()
26342 
    iprot.readStructEnd()
26343 
 
26344 
  def write(self, oprot):
26345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26347 
      return
26348 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
26349 
    if self.success is not None:
26350 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26351 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26352 
      for iter655 in self.success:
26353 
        iter655.write(oprot)
5713 rajveer 26354 
      oprot.writeListEnd()
26355 
      oprot.writeFieldEnd()
26356 
    oprot.writeFieldStop()
26357 
    oprot.writeStructEnd()
26358 
 
26359 
  def validate(self):
26360 
    return
26361 
 
26362 
 
26363 
  def __repr__(self):
26364 
    L = ['%s=%r' % (key, value)
26365 
      for key, value in self.__dict__.iteritems()]
26366 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26367 
 
26368 
  def __eq__(self, other):
26369 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26370 
 
26371 
  def __ne__(self, other):
26372 
    return not (self == other)
26373 
 
5833 rajveer 26374 
class getOrderAttributeValue_args:
26375 
  """
26376 
  Attributes:
26377 
   - orderId
26378 
   - attributeName
26379 
  """
26380 
 
26381 
  thrift_spec = None
26382 
  def __init__(self, orderId=None, attributeName=None,):
26383 
    self.orderId = orderId
26384 
    self.attributeName = attributeName
26385 
 
26386 
  def read(self, iprot):
26387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26389 
      return
26390 
    iprot.readStructBegin()
26391 
    while True:
26392 
      (fname, ftype, fid) = iprot.readFieldBegin()
26393 
      if ftype == TType.STOP:
26394 
        break
26395 
      if fid == 1:
26396 
        if ftype == TType.I64:
26397 
          self.orderId = iprot.readI64();
26398 
        else:
26399 
          iprot.skip(ftype)
26400 
      elif fid == -1:
26401 
        if ftype == TType.STRING:
26402 
          self.attributeName = iprot.readString();
26403 
        else:
26404 
          iprot.skip(ftype)
26405 
      else:
26406 
        iprot.skip(ftype)
26407 
      iprot.readFieldEnd()
26408 
    iprot.readStructEnd()
26409 
 
26410 
  def write(self, oprot):
26411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26413 
      return
26414 
    oprot.writeStructBegin('getOrderAttributeValue_args')
26415 
    if self.attributeName is not None:
26416 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
26417 
      oprot.writeString(self.attributeName)
26418 
      oprot.writeFieldEnd()
26419 
    if self.orderId is not None:
26420 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26421 
      oprot.writeI64(self.orderId)
26422 
      oprot.writeFieldEnd()
26423 
    oprot.writeFieldStop()
26424 
    oprot.writeStructEnd()
26425 
 
26426 
  def validate(self):
26427 
    return
26428 
 
26429 
 
26430 
  def __repr__(self):
26431 
    L = ['%s=%r' % (key, value)
26432 
      for key, value in self.__dict__.iteritems()]
26433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26434 
 
26435 
  def __eq__(self, other):
26436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26437 
 
26438 
  def __ne__(self, other):
26439 
    return not (self == other)
26440 
 
26441 
class getOrderAttributeValue_result:
26442 
  """
26443 
  Attributes:
26444 
   - success
26445 
  """
26446 
 
26447 
  thrift_spec = (
26448 
    (0, TType.STRING, 'success', None, None, ), # 0
26449 
  )
26450 
 
26451 
  def __init__(self, success=None,):
26452 
    self.success = success
26453 
 
26454 
  def read(self, iprot):
26455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26457 
      return
26458 
    iprot.readStructBegin()
26459 
    while True:
26460 
      (fname, ftype, fid) = iprot.readFieldBegin()
26461 
      if ftype == TType.STOP:
26462 
        break
26463 
      if fid == 0:
26464 
        if ftype == TType.STRING:
26465 
          self.success = iprot.readString();
26466 
        else:
26467 
          iprot.skip(ftype)
26468 
      else:
26469 
        iprot.skip(ftype)
26470 
      iprot.readFieldEnd()
26471 
    iprot.readStructEnd()
26472 
 
26473 
  def write(self, oprot):
26474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26476 
      return
26477 
    oprot.writeStructBegin('getOrderAttributeValue_result')
26478 
    if self.success is not None:
26479 
      oprot.writeFieldBegin('success', TType.STRING, 0)
26480 
      oprot.writeString(self.success)
26481 
      oprot.writeFieldEnd()
26482 
    oprot.writeFieldStop()
26483 
    oprot.writeStructEnd()
26484 
 
26485 
  def validate(self):
26486 
    return
26487 
 
26488 
 
26489 
  def __repr__(self):
26490 
    L = ['%s=%r' % (key, value)
26491 
      for key, value in self.__dict__.iteritems()]
26492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26493 
 
26494 
  def __eq__(self, other):
26495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26496 
 
26497 
  def __ne__(self, other):
26498 
    return not (self == other)
26499 
 
6019 rajveer 26500 
class changeJacketNumber_args:
26501 
  """
26502 
  Attributes:
26503 
   - orderId
26504 
   - jacketNumber
26505 
  """
26506 
 
26507 
  thrift_spec = (
26508 
    None, # 0
26509 
    (1, TType.I64, 'orderId', None, None, ), # 1
26510 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
26511 
  )
26512 
 
26513 
  def __init__(self, orderId=None, jacketNumber=None,):
26514 
    self.orderId = orderId
26515 
    self.jacketNumber = jacketNumber
26516 
 
26517 
  def read(self, iprot):
26518 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26519 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26520 
      return
26521 
    iprot.readStructBegin()
26522 
    while True:
26523 
      (fname, ftype, fid) = iprot.readFieldBegin()
26524 
      if ftype == TType.STOP:
26525 
        break
26526 
      if fid == 1:
26527 
        if ftype == TType.I64:
26528 
          self.orderId = iprot.readI64();
26529 
        else:
26530 
          iprot.skip(ftype)
26531 
      elif fid == 2:
26532 
        if ftype == TType.I64:
26533 
          self.jacketNumber = iprot.readI64();
26534 
        else:
26535 
          iprot.skip(ftype)
26536 
      else:
26537 
        iprot.skip(ftype)
26538 
      iprot.readFieldEnd()
26539 
    iprot.readStructEnd()
26540 
 
26541 
  def write(self, oprot):
26542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26544 
      return
26545 
    oprot.writeStructBegin('changeJacketNumber_args')
26546 
    if self.orderId is not None:
26547 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26548 
      oprot.writeI64(self.orderId)
26549 
      oprot.writeFieldEnd()
26550 
    if self.jacketNumber is not None:
26551 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
26552 
      oprot.writeI64(self.jacketNumber)
26553 
      oprot.writeFieldEnd()
26554 
    oprot.writeFieldStop()
26555 
    oprot.writeStructEnd()
26556 
 
26557 
  def validate(self):
26558 
    return
26559 
 
26560 
 
26561 
  def __repr__(self):
26562 
    L = ['%s=%r' % (key, value)
26563 
      for key, value in self.__dict__.iteritems()]
26564 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26565 
 
26566 
  def __eq__(self, other):
26567 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26568 
 
26569 
  def __ne__(self, other):
26570 
    return not (self == other)
26571 
 
26572 
class changeJacketNumber_result:
26573 
  """
26574 
  Attributes:
26575 
   - success
26576 
  """
26577 
 
26578 
  thrift_spec = (
26579 
    (0, TType.BOOL, 'success', None, None, ), # 0
26580 
  )
26581 
 
26582 
  def __init__(self, success=None,):
26583 
    self.success = success
26584 
 
26585 
  def read(self, iprot):
26586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26588 
      return
26589 
    iprot.readStructBegin()
26590 
    while True:
26591 
      (fname, ftype, fid) = iprot.readFieldBegin()
26592 
      if ftype == TType.STOP:
26593 
        break
26594 
      if fid == 0:
26595 
        if ftype == TType.BOOL:
26596 
          self.success = iprot.readBool();
26597 
        else:
26598 
          iprot.skip(ftype)
26599 
      else:
26600 
        iprot.skip(ftype)
26601 
      iprot.readFieldEnd()
26602 
    iprot.readStructEnd()
26603 
 
26604 
  def write(self, oprot):
26605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26607 
      return
26608 
    oprot.writeStructBegin('changeJacketNumber_result')
26609 
    if self.success is not None:
26610 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26611 
      oprot.writeBool(self.success)
26612 
      oprot.writeFieldEnd()
26613 
    oprot.writeFieldStop()
26614 
    oprot.writeStructEnd()
26615 
 
26616 
  def validate(self):
26617 
    return
26618 
 
26619 
 
26620 
  def __repr__(self):
26621 
    L = ['%s=%r' % (key, value)
26622 
      for key, value in self.__dict__.iteritems()]
26623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26624 
 
26625 
  def __eq__(self, other):
26626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26627 
 
26628 
  def __ne__(self, other):
26629 
    return not (self == other)
26630 
 
26631 
class markOrderAsRtoInTransit_args:
26632 
  """
26633 
  Attributes:
26634 
   - orderId
26635 
  """
26636 
 
26637 
  thrift_spec = (
26638 
    None, # 0
26639 
    (1, TType.I64, 'orderId', None, None, ), # 1
26640 
  )
26641 
 
26642 
  def __init__(self, orderId=None,):
26643 
    self.orderId = orderId
26644 
 
26645 
  def read(self, iprot):
26646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26648 
      return
26649 
    iprot.readStructBegin()
26650 
    while True:
26651 
      (fname, ftype, fid) = iprot.readFieldBegin()
26652 
      if ftype == TType.STOP:
26653 
        break
26654 
      if fid == 1:
26655 
        if ftype == TType.I64:
26656 
          self.orderId = iprot.readI64();
26657 
        else:
26658 
          iprot.skip(ftype)
26659 
      else:
26660 
        iprot.skip(ftype)
26661 
      iprot.readFieldEnd()
26662 
    iprot.readStructEnd()
26663 
 
26664 
  def write(self, oprot):
26665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26667 
      return
26668 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26669 
    if self.orderId is not None:
26670 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26671 
      oprot.writeI64(self.orderId)
26672 
      oprot.writeFieldEnd()
26673 
    oprot.writeFieldStop()
26674 
    oprot.writeStructEnd()
26675 
 
26676 
  def validate(self):
26677 
    return
26678 
 
26679 
 
26680 
  def __repr__(self):
26681 
    L = ['%s=%r' % (key, value)
26682 
      for key, value in self.__dict__.iteritems()]
26683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26684 
 
26685 
  def __eq__(self, other):
26686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26687 
 
26688 
  def __ne__(self, other):
26689 
    return not (self == other)
26690 
 
26691 
class markOrderAsRtoInTransit_result:
26692 
  """
26693 
  Attributes:
26694 
   - success
26695 
  """
26696 
 
26697 
  thrift_spec = (
26698 
    (0, TType.BOOL, 'success', None, None, ), # 0
26699 
  )
26700 
 
26701 
  def __init__(self, success=None,):
26702 
    self.success = success
26703 
 
26704 
  def read(self, iprot):
26705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26707 
      return
26708 
    iprot.readStructBegin()
26709 
    while True:
26710 
      (fname, ftype, fid) = iprot.readFieldBegin()
26711 
      if ftype == TType.STOP:
26712 
        break
26713 
      if fid == 0:
26714 
        if ftype == TType.BOOL:
26715 
          self.success = iprot.readBool();
26716 
        else:
26717 
          iprot.skip(ftype)
26718 
      else:
26719 
        iprot.skip(ftype)
26720 
      iprot.readFieldEnd()
26721 
    iprot.readStructEnd()
26722 
 
26723 
  def write(self, oprot):
26724 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26725 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26726 
      return
26727 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
26728 
    if self.success is not None:
26729 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26730 
      oprot.writeBool(self.success)
26731 
      oprot.writeFieldEnd()
26732 
    oprot.writeFieldStop()
26733 
    oprot.writeStructEnd()
26734 
 
26735 
  def validate(self):
26736 
    return
26737 
 
26738 
 
26739 
  def __repr__(self):
26740 
    L = ['%s=%r' % (key, value)
26741 
      for key, value in self.__dict__.iteritems()]
26742 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26743 
 
26744 
  def __eq__(self, other):
26745 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26746 
 
26747 
  def __ne__(self, other):
26748 
    return not (self == other)
26749 
 
5593 mandeep.dh 26750 
class acceptOrderForItem_args:
26751 
  """
26752 
  Attributes:
26753 
   - itemId
26754 
   - quantity
26755 
   - fulfilmentWarehouseId
26756 
   - billingWarehouseId
26757 
  """
26758 
 
26759 
  thrift_spec = (
26760 
    None, # 0
26761 
    (1, TType.I64, 'itemId', None, None, ), # 1
26762 
    (2, TType.I64, 'quantity', None, None, ), # 2
26763 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
26764 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
26765 
  )
26766 
 
26767 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
26768 
    self.itemId = itemId
26769 
    self.quantity = quantity
26770 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
26771 
    self.billingWarehouseId = billingWarehouseId
26772 
 
26773 
  def read(self, iprot):
26774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26776 
      return
26777 
    iprot.readStructBegin()
26778 
    while True:
26779 
      (fname, ftype, fid) = iprot.readFieldBegin()
26780 
      if ftype == TType.STOP:
26781 
        break
26782 
      if fid == 1:
26783 
        if ftype == TType.I64:
26784 
          self.itemId = iprot.readI64();
26785 
        else:
26786 
          iprot.skip(ftype)
26787 
      elif fid == 2:
26788 
        if ftype == TType.I64:
26789 
          self.quantity = iprot.readI64();
26790 
        else:
26791 
          iprot.skip(ftype)
26792 
      elif fid == 3:
26793 
        if ftype == TType.I64:
26794 
          self.fulfilmentWarehouseId = iprot.readI64();
26795 
        else:
26796 
          iprot.skip(ftype)
26797 
      elif fid == 4:
26798 
        if ftype == TType.I64:
26799 
          self.billingWarehouseId = iprot.readI64();
26800 
        else:
26801 
          iprot.skip(ftype)
26802 
      else:
26803 
        iprot.skip(ftype)
26804 
      iprot.readFieldEnd()
26805 
    iprot.readStructEnd()
26806 
 
26807 
  def write(self, oprot):
26808 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26809 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26810 
      return
26811 
    oprot.writeStructBegin('acceptOrderForItem_args')
26812 
    if self.itemId is not None:
26813 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26814 
      oprot.writeI64(self.itemId)
26815 
      oprot.writeFieldEnd()
26816 
    if self.quantity is not None:
26817 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
26818 
      oprot.writeI64(self.quantity)
26819 
      oprot.writeFieldEnd()
26820 
    if self.fulfilmentWarehouseId is not None:
26821 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26822 
      oprot.writeI64(self.fulfilmentWarehouseId)
26823 
      oprot.writeFieldEnd()
26824 
    if self.billingWarehouseId is not None:
26825 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26826 
      oprot.writeI64(self.billingWarehouseId)
26827 
      oprot.writeFieldEnd()
26828 
    oprot.writeFieldStop()
26829 
    oprot.writeStructEnd()
26830 
 
26831 
  def validate(self):
26832 
    return
26833 
 
26834 
 
26835 
  def __repr__(self):
26836 
    L = ['%s=%r' % (key, value)
26837 
      for key, value in self.__dict__.iteritems()]
26838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26839 
 
26840 
  def __eq__(self, other):
26841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26842 
 
26843 
  def __ne__(self, other):
26844 
    return not (self == other)
26845 
 
26846 
class acceptOrderForItem_result:
26847 
 
26848 
  thrift_spec = (
26849 
  )
26850 
 
26851 
  def read(self, iprot):
26852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26854 
      return
26855 
    iprot.readStructBegin()
26856 
    while True:
26857 
      (fname, ftype, fid) = iprot.readFieldBegin()
26858 
      if ftype == TType.STOP:
26859 
        break
26860 
      else:
26861 
        iprot.skip(ftype)
26862 
      iprot.readFieldEnd()
26863 
    iprot.readStructEnd()
26864 
 
26865 
  def write(self, oprot):
26866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26868 
      return
26869 
    oprot.writeStructBegin('acceptOrderForItem_result')
26870 
    oprot.writeFieldStop()
26871 
    oprot.writeStructEnd()
26872 
 
26873 
  def validate(self):
26874 
    return
26875 
 
26876 
 
26877 
  def __repr__(self):
26878 
    L = ['%s=%r' % (key, value)
26879 
      for key, value in self.__dict__.iteritems()]
26880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26881 
 
26882 
  def __eq__(self, other):
26883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26884 
 
26885 
  def __ne__(self, other):
26886 
    return not (self == other)
6000 mandeep.dh 26887 
 
26888 
class createRechargeOrder_args:
26889 
  """
26890 
  Attributes:
26891 
   - rechargeOrder
26892 
  """
26893 
 
26894 
  thrift_spec = (
26895 
    None, # 0
26896 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
26897 
  )
26898 
 
26899 
  def __init__(self, rechargeOrder=None,):
26900 
    self.rechargeOrder = rechargeOrder
26901 
 
26902 
  def read(self, iprot):
26903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26905 
      return
26906 
    iprot.readStructBegin()
26907 
    while True:
26908 
      (fname, ftype, fid) = iprot.readFieldBegin()
26909 
      if ftype == TType.STOP:
26910 
        break
26911 
      if fid == 1:
26912 
        if ftype == TType.STRUCT:
26913 
          self.rechargeOrder = RechargeOrder()
26914 
          self.rechargeOrder.read(iprot)
26915 
        else:
26916 
          iprot.skip(ftype)
26917 
      else:
26918 
        iprot.skip(ftype)
26919 
      iprot.readFieldEnd()
26920 
    iprot.readStructEnd()
26921 
 
26922 
  def write(self, oprot):
26923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26925 
      return
26926 
    oprot.writeStructBegin('createRechargeOrder_args')
26927 
    if self.rechargeOrder is not None:
26928 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
26929 
      self.rechargeOrder.write(oprot)
26930 
      oprot.writeFieldEnd()
26931 
    oprot.writeFieldStop()
26932 
    oprot.writeStructEnd()
26933 
 
26934 
  def validate(self):
26935 
    return
26936 
 
26937 
 
26938 
  def __repr__(self):
26939 
    L = ['%s=%r' % (key, value)
26940 
      for key, value in self.__dict__.iteritems()]
26941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26942 
 
26943 
  def __eq__(self, other):
26944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26945 
 
26946 
  def __ne__(self, other):
26947 
    return not (self == other)
26948 
 
26949 
class createRechargeOrder_result:
26950 
  """
26951 
  Attributes:
26952 
   - success
26953 
   - ex
26954 
  """
26955 
 
26956 
  thrift_spec = (
26957 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26958 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26959 
  )
26960 
 
26961 
  def __init__(self, success=None, ex=None,):
26962 
    self.success = success
26963 
    self.ex = ex
26964 
 
26965 
  def read(self, iprot):
26966 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26967 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26968 
      return
26969 
    iprot.readStructBegin()
26970 
    while True:
26971 
      (fname, ftype, fid) = iprot.readFieldBegin()
26972 
      if ftype == TType.STOP:
26973 
        break
26974 
      if fid == 0:
26975 
        if ftype == TType.STRUCT:
26976 
          self.success = RechargeOrder()
26977 
          self.success.read(iprot)
26978 
        else:
26979 
          iprot.skip(ftype)
26980 
      elif fid == 1:
26981 
        if ftype == TType.STRUCT:
26982 
          self.ex = TransactionServiceException()
26983 
          self.ex.read(iprot)
26984 
        else:
26985 
          iprot.skip(ftype)
26986 
      else:
26987 
        iprot.skip(ftype)
26988 
      iprot.readFieldEnd()
26989 
    iprot.readStructEnd()
26990 
 
26991 
  def write(self, oprot):
26992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26994 
      return
26995 
    oprot.writeStructBegin('createRechargeOrder_result')
26996 
    if self.success is not None:
26997 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26998 
      self.success.write(oprot)
26999 
      oprot.writeFieldEnd()
27000 
    if self.ex is not None:
27001 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27002 
      self.ex.write(oprot)
27003 
      oprot.writeFieldEnd()
27004 
    oprot.writeFieldStop()
27005 
    oprot.writeStructEnd()
27006 
 
27007 
  def validate(self):
27008 
    return
27009 
 
27010 
 
27011 
  def __repr__(self):
27012 
    L = ['%s=%r' % (key, value)
27013 
      for key, value in self.__dict__.iteritems()]
27014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27015 
 
27016 
  def __eq__(self, other):
27017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27018 
 
27019 
  def __ne__(self, other):
27020 
    return not (self == other)
27021 
 
6031 rajveer 27022 
class getRechargeOrder_args:
27023 
  """
27024 
  Attributes:
27025 
   - rechargeRrderId
27026 
  """
27027 
 
27028 
  thrift_spec = (
27029 
    None, # 0
27030 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
27031 
  )
27032 
 
27033 
  def __init__(self, rechargeRrderId=None,):
27034 
    self.rechargeRrderId = rechargeRrderId
27035 
 
27036 
  def read(self, iprot):
27037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27039 
      return
27040 
    iprot.readStructBegin()
27041 
    while True:
27042 
      (fname, ftype, fid) = iprot.readFieldBegin()
27043 
      if ftype == TType.STOP:
27044 
        break
27045 
      if fid == 1:
27046 
        if ftype == TType.I64:
27047 
          self.rechargeRrderId = iprot.readI64();
27048 
        else:
27049 
          iprot.skip(ftype)
27050 
      else:
27051 
        iprot.skip(ftype)
27052 
      iprot.readFieldEnd()
27053 
    iprot.readStructEnd()
27054 
 
27055 
  def write(self, oprot):
27056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27058 
      return
27059 
    oprot.writeStructBegin('getRechargeOrder_args')
27060 
    if self.rechargeRrderId is not None:
27061 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
27062 
      oprot.writeI64(self.rechargeRrderId)
27063 
      oprot.writeFieldEnd()
27064 
    oprot.writeFieldStop()
27065 
    oprot.writeStructEnd()
27066 
 
27067 
  def validate(self):
27068 
    return
27069 
 
27070 
 
27071 
  def __repr__(self):
27072 
    L = ['%s=%r' % (key, value)
27073 
      for key, value in self.__dict__.iteritems()]
27074 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27075 
 
27076 
  def __eq__(self, other):
27077 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27078 
 
27079 
  def __ne__(self, other):
27080 
    return not (self == other)
27081 
 
27082 
class getRechargeOrder_result:
27083 
  """
27084 
  Attributes:
27085 
   - success
27086 
   - ex
27087 
  """
27088 
 
27089 
  thrift_spec = (
27090 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27091 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27092 
  )
27093 
 
27094 
  def __init__(self, success=None, ex=None,):
27095 
    self.success = success
27096 
    self.ex = ex
27097 
 
27098 
  def read(self, iprot):
27099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27101 
      return
27102 
    iprot.readStructBegin()
27103 
    while True:
27104 
      (fname, ftype, fid) = iprot.readFieldBegin()
27105 
      if ftype == TType.STOP:
27106 
        break
27107 
      if fid == 0:
27108 
        if ftype == TType.STRUCT:
27109 
          self.success = RechargeOrder()
27110 
          self.success.read(iprot)
27111 
        else:
27112 
          iprot.skip(ftype)
27113 
      elif fid == 1:
27114 
        if ftype == TType.STRUCT:
27115 
          self.ex = TransactionServiceException()
27116 
          self.ex.read(iprot)
27117 
        else:
27118 
          iprot.skip(ftype)
27119 
      else:
27120 
        iprot.skip(ftype)
27121 
      iprot.readFieldEnd()
27122 
    iprot.readStructEnd()
27123 
 
27124 
  def write(self, oprot):
27125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27127 
      return
27128 
    oprot.writeStructBegin('getRechargeOrder_result')
27129 
    if self.success is not None:
27130 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27131 
      self.success.write(oprot)
27132 
      oprot.writeFieldEnd()
27133 
    if self.ex is not None:
27134 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27135 
      self.ex.write(oprot)
27136 
      oprot.writeFieldEnd()
27137 
    oprot.writeFieldStop()
27138 
    oprot.writeStructEnd()
27139 
 
27140 
  def validate(self):
27141 
    return
27142 
 
27143 
 
27144 
  def __repr__(self):
27145 
    L = ['%s=%r' % (key, value)
27146 
      for key, value in self.__dict__.iteritems()]
27147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27148 
 
27149 
  def __eq__(self, other):
27150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27151 
 
27152 
  def __ne__(self, other):
27153 
    return not (self == other)
27154 
 
27155 
class getRechargeOrders_args:
27156 
  """
27157 
  Attributes:
27158 
   - userId
27159 
  """
27160 
 
27161 
  thrift_spec = (
27162 
    None, # 0
27163 
    (1, TType.I64, 'userId', None, None, ), # 1
27164 
  )
27165 
 
27166 
  def __init__(self, userId=None,):
27167 
    self.userId = userId
27168 
 
27169 
  def read(self, iprot):
27170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27172 
      return
27173 
    iprot.readStructBegin()
27174 
    while True:
27175 
      (fname, ftype, fid) = iprot.readFieldBegin()
27176 
      if ftype == TType.STOP:
27177 
        break
27178 
      if fid == 1:
27179 
        if ftype == TType.I64:
27180 
          self.userId = iprot.readI64();
27181 
        else:
27182 
          iprot.skip(ftype)
27183 
      else:
27184 
        iprot.skip(ftype)
27185 
      iprot.readFieldEnd()
27186 
    iprot.readStructEnd()
27187 
 
27188 
  def write(self, oprot):
27189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27191 
      return
27192 
    oprot.writeStructBegin('getRechargeOrders_args')
27193 
    if self.userId is not None:
27194 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27195 
      oprot.writeI64(self.userId)
27196 
      oprot.writeFieldEnd()
27197 
    oprot.writeFieldStop()
27198 
    oprot.writeStructEnd()
27199 
 
27200 
  def validate(self):
27201 
    return
27202 
 
27203 
 
27204 
  def __repr__(self):
27205 
    L = ['%s=%r' % (key, value)
27206 
      for key, value in self.__dict__.iteritems()]
27207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27208 
 
27209 
  def __eq__(self, other):
27210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27211 
 
27212 
  def __ne__(self, other):
27213 
    return not (self == other)
27214 
 
27215 
class getRechargeOrders_result:
27216 
  """
27217 
  Attributes:
27218 
   - success
27219 
  """
27220 
 
27221 
  thrift_spec = (
27222 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27223 
  )
27224 
 
27225 
  def __init__(self, success=None,):
27226 
    self.success = success
27227 
 
27228 
  def read(self, iprot):
27229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27231 
      return
27232 
    iprot.readStructBegin()
27233 
    while True:
27234 
      (fname, ftype, fid) = iprot.readFieldBegin()
27235 
      if ftype == TType.STOP:
27236 
        break
27237 
      if fid == 0:
27238 
        if ftype == TType.LIST:
27239 
          self.success = []
6188 rajveer 27240 
          (_etype659, _size656) = iprot.readListBegin()
27241 
          for _i660 in xrange(_size656):
27242 
            _elem661 = RechargeOrder()
27243 
            _elem661.read(iprot)
27244 
            self.success.append(_elem661)
6031 rajveer 27245 
          iprot.readListEnd()
27246 
        else:
27247 
          iprot.skip(ftype)
27248 
      else:
27249 
        iprot.skip(ftype)
27250 
      iprot.readFieldEnd()
27251 
    iprot.readStructEnd()
27252 
 
27253 
  def write(self, oprot):
27254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27256 
      return
27257 
    oprot.writeStructBegin('getRechargeOrders_result')
27258 
    if self.success is not None:
27259 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27260 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27261 
      for iter662 in self.success:
27262 
        iter662.write(oprot)
6031 rajveer 27263 
      oprot.writeListEnd()
27264 
      oprot.writeFieldEnd()
27265 
    oprot.writeFieldStop()
27266 
    oprot.writeStructEnd()
27267 
 
27268 
  def validate(self):
27269 
    return
27270 
 
27271 
 
27272 
  def __repr__(self):
27273 
    L = ['%s=%r' % (key, value)
27274 
      for key, value in self.__dict__.iteritems()]
27275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27276 
 
27277 
  def __eq__(self, other):
27278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27279 
 
27280 
  def __ne__(self, other):
27281 
    return not (self == other)
27282 
 
6000 mandeep.dh 27283 
class updateRechargeOrderStatus_args:
27284 
  """
27285 
  Attributes:
27286 
   - rechargeOrderId
27287 
   - rechargeOrderStatus
27288 
  """
27289 
 
27290 
  thrift_spec = (
27291 
    None, # 0
27292 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
27293 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
27294 
  )
27295 
 
27296 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
27297 
    self.rechargeOrderId = rechargeOrderId
27298 
    self.rechargeOrderStatus = rechargeOrderStatus
27299 
 
27300 
  def read(self, iprot):
27301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27303 
      return
27304 
    iprot.readStructBegin()
27305 
    while True:
27306 
      (fname, ftype, fid) = iprot.readFieldBegin()
27307 
      if ftype == TType.STOP:
27308 
        break
27309 
      if fid == 1:
27310 
        if ftype == TType.I64:
27311 
          self.rechargeOrderId = iprot.readI64();
27312 
        else:
27313 
          iprot.skip(ftype)
27314 
      elif fid == 2:
27315 
        if ftype == TType.I32:
27316 
          self.rechargeOrderStatus = iprot.readI32();
27317 
        else:
27318 
          iprot.skip(ftype)
27319 
      else:
27320 
        iprot.skip(ftype)
27321 
      iprot.readFieldEnd()
27322 
    iprot.readStructEnd()
27323 
 
27324 
  def write(self, oprot):
27325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27327 
      return
27328 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
27329 
    if self.rechargeOrderId is not None:
27330 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27331 
      oprot.writeI64(self.rechargeOrderId)
27332 
      oprot.writeFieldEnd()
27333 
    if self.rechargeOrderStatus is not None:
27334 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
27335 
      oprot.writeI32(self.rechargeOrderStatus)
27336 
      oprot.writeFieldEnd()
27337 
    oprot.writeFieldStop()
27338 
    oprot.writeStructEnd()
27339 
 
27340 
  def validate(self):
27341 
    return
27342 
 
27343 
 
27344 
  def __repr__(self):
27345 
    L = ['%s=%r' % (key, value)
27346 
      for key, value in self.__dict__.iteritems()]
27347 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27348 
 
27349 
  def __eq__(self, other):
27350 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27351 
 
27352 
  def __ne__(self, other):
27353 
    return not (self == other)
27354 
 
27355 
class updateRechargeOrderStatus_result:
27356 
  """
27357 
  Attributes:
6031 rajveer 27358 
   - success
6000 mandeep.dh 27359 
   - ex
27360 
  """
27361 
 
27362 
  thrift_spec = (
6031 rajveer 27363 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27364 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27365 
  )
27366 
 
6031 rajveer 27367 
  def __init__(self, success=None, ex=None,):
27368 
    self.success = success
6000 mandeep.dh 27369 
    self.ex = ex
27370 
 
27371 
  def read(self, iprot):
27372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27374 
      return
27375 
    iprot.readStructBegin()
27376 
    while True:
27377 
      (fname, ftype, fid) = iprot.readFieldBegin()
27378 
      if ftype == TType.STOP:
27379 
        break
6031 rajveer 27380 
      if fid == 0:
27381 
        if ftype == TType.BOOL:
27382 
          self.success = iprot.readBool();
27383 
        else:
27384 
          iprot.skip(ftype)
27385 
      elif fid == 1:
6000 mandeep.dh 27386 
        if ftype == TType.STRUCT:
27387 
          self.ex = TransactionServiceException()
27388 
          self.ex.read(iprot)
27389 
        else:
27390 
          iprot.skip(ftype)
27391 
      else:
27392 
        iprot.skip(ftype)
27393 
      iprot.readFieldEnd()
27394 
    iprot.readStructEnd()
27395 
 
27396 
  def write(self, oprot):
27397 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27398 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27399 
      return
27400 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 27401 
    if self.success is not None:
27402 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27403 
      oprot.writeBool(self.success)
27404 
      oprot.writeFieldEnd()
6000 mandeep.dh 27405 
    if self.ex is not None:
27406 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27407 
      self.ex.write(oprot)
27408 
      oprot.writeFieldEnd()
27409 
    oprot.writeFieldStop()
27410 
    oprot.writeStructEnd()
27411 
 
27412 
  def validate(self):
27413 
    return
27414 
 
27415 
 
27416 
  def __repr__(self):
27417 
    L = ['%s=%r' % (key, value)
27418 
      for key, value in self.__dict__.iteritems()]
27419 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27420 
 
27421 
  def __eq__(self, other):
27422 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27423 
 
27424 
  def __ne__(self, other):
27425 
    return not (self == other)
27426 
 
27427 
class activateRechargeTxn_args:
27428 
  """
27429 
  Attributes:
6031 rajveer 27430 
   - rechargeOrderId
6000 mandeep.dh 27431 
  """
27432 
 
27433 
  thrift_spec = (
27434 
    None, # 0
6031 rajveer 27435 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 27436 
  )
27437 
 
6031 rajveer 27438 
  def __init__(self, rechargeOrderId=None,):
27439 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 27440 
 
27441 
  def read(self, iprot):
27442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27444 
      return
27445 
    iprot.readStructBegin()
27446 
    while True:
27447 
      (fname, ftype, fid) = iprot.readFieldBegin()
27448 
      if ftype == TType.STOP:
27449 
        break
27450 
      if fid == 1:
6031 rajveer 27451 
        if ftype == TType.I64:
27452 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 27453 
        else:
27454 
          iprot.skip(ftype)
27455 
      else:
27456 
        iprot.skip(ftype)
27457 
      iprot.readFieldEnd()
27458 
    iprot.readStructEnd()
27459 
 
27460 
  def write(self, oprot):
27461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27463 
      return
27464 
    oprot.writeStructBegin('activateRechargeTxn_args')
6031 rajveer 27465 
    if self.rechargeOrderId is not None:
27466 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27467 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 27468 
      oprot.writeFieldEnd()
27469 
    oprot.writeFieldStop()
27470 
    oprot.writeStructEnd()
27471 
 
27472 
  def validate(self):
27473 
    return
27474 
 
27475 
 
27476 
  def __repr__(self):
27477 
    L = ['%s=%r' % (key, value)
27478 
      for key, value in self.__dict__.iteritems()]
27479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27480 
 
27481 
  def __eq__(self, other):
27482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27483 
 
27484 
  def __ne__(self, other):
27485 
    return not (self == other)
27486 
 
27487 
class activateRechargeTxn_result:
27488 
  """
27489 
  Attributes:
27490 
   - success
27491 
   - ex
27492 
  """
27493 
 
27494 
  thrift_spec = (
6031 rajveer 27495 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27496 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27497 
  )
27498 
 
27499 
  def __init__(self, success=None, ex=None,):
27500 
    self.success = success
27501 
    self.ex = ex
27502 
 
27503 
  def read(self, iprot):
27504 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27505 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27506 
      return
27507 
    iprot.readStructBegin()
27508 
    while True:
27509 
      (fname, ftype, fid) = iprot.readFieldBegin()
27510 
      if ftype == TType.STOP:
27511 
        break
27512 
      if fid == 0:
6031 rajveer 27513 
        if ftype == TType.BOOL:
27514 
          self.success = iprot.readBool();
6000 mandeep.dh 27515 
        else:
27516 
          iprot.skip(ftype)
27517 
      elif fid == 1:
27518 
        if ftype == TType.STRUCT:
27519 
          self.ex = TransactionServiceException()
27520 
          self.ex.read(iprot)
27521 
        else:
27522 
          iprot.skip(ftype)
27523 
      else:
27524 
        iprot.skip(ftype)
27525 
      iprot.readFieldEnd()
27526 
    iprot.readStructEnd()
27527 
 
27528 
  def write(self, oprot):
27529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27531 
      return
27532 
    oprot.writeStructBegin('activateRechargeTxn_result')
27533 
    if self.success is not None:
6031 rajveer 27534 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27535 
      oprot.writeBool(self.success)
6000 mandeep.dh 27536 
      oprot.writeFieldEnd()
27537 
    if self.ex is not None:
27538 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27539 
      self.ex.write(oprot)
27540 
      oprot.writeFieldEnd()
27541 
    oprot.writeFieldStop()
27542 
    oprot.writeStructEnd()
27543 
 
27544 
  def validate(self):
27545 
    return
27546 
 
27547 
 
27548 
  def __repr__(self):
27549 
    L = ['%s=%r' % (key, value)
27550 
      for key, value in self.__dict__.iteritems()]
27551 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27552 
 
27553 
  def __eq__(self, other):
27554 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27555 
 
27556 
  def __ne__(self, other):
27557 
    return not (self == other)
27558 
 
6031 rajveer 27559 
class getUserWallet_args:
6000 mandeep.dh 27560 
  """
27561 
  Attributes:
6031 rajveer 27562 
   - userId
6000 mandeep.dh 27563 
  """
27564 
 
27565 
  thrift_spec = (
27566 
    None, # 0
6031 rajveer 27567 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27568 
  )
27569 
 
6031 rajveer 27570 
  def __init__(self, userId=None,):
27571 
    self.userId = userId
6000 mandeep.dh 27572 
 
27573 
  def read(self, iprot):
27574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27576 
      return
27577 
    iprot.readStructBegin()
27578 
    while True:
27579 
      (fname, ftype, fid) = iprot.readFieldBegin()
27580 
      if ftype == TType.STOP:
27581 
        break
27582 
      if fid == 1:
27583 
        if ftype == TType.I64:
6031 rajveer 27584 
          self.userId = iprot.readI64();
6000 mandeep.dh 27585 
        else:
27586 
          iprot.skip(ftype)
27587 
      else:
27588 
        iprot.skip(ftype)
27589 
      iprot.readFieldEnd()
27590 
    iprot.readStructEnd()
27591 
 
27592 
  def write(self, oprot):
27593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27595 
      return
6031 rajveer 27596 
    oprot.writeStructBegin('getUserWallet_args')
27597 
    if self.userId is not None:
27598 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27599 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27600 
      oprot.writeFieldEnd()
27601 
    oprot.writeFieldStop()
27602 
    oprot.writeStructEnd()
27603 
 
27604 
  def validate(self):
27605 
    return
27606 
 
27607 
 
27608 
  def __repr__(self):
27609 
    L = ['%s=%r' % (key, value)
27610 
      for key, value in self.__dict__.iteritems()]
27611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27612 
 
27613 
  def __eq__(self, other):
27614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27615 
 
27616 
  def __ne__(self, other):
27617 
    return not (self == other)
27618 
 
6031 rajveer 27619 
class getUserWallet_result:
6000 mandeep.dh 27620 
  """
27621 
  Attributes:
27622 
   - success
27623 
  """
27624 
 
27625 
  thrift_spec = (
6031 rajveer 27626 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 27627 
  )
27628 
 
27629 
  def __init__(self, success=None,):
27630 
    self.success = success
27631 
 
27632 
  def read(self, iprot):
27633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27635 
      return
27636 
    iprot.readStructBegin()
27637 
    while True:
27638 
      (fname, ftype, fid) = iprot.readFieldBegin()
27639 
      if ftype == TType.STOP:
27640 
        break
27641 
      if fid == 0:
6031 rajveer 27642 
        if ftype == TType.STRUCT:
27643 
          self.success = UserWallet()
27644 
          self.success.read(iprot)
6000 mandeep.dh 27645 
        else:
27646 
          iprot.skip(ftype)
27647 
      else:
27648 
        iprot.skip(ftype)
27649 
      iprot.readFieldEnd()
27650 
    iprot.readStructEnd()
27651 
 
27652 
  def write(self, oprot):
27653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27655 
      return
6031 rajveer 27656 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27657 
    if self.success is not None:
6031 rajveer 27658 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27659 
      self.success.write(oprot)
6000 mandeep.dh 27660 
      oprot.writeFieldEnd()
27661 
    oprot.writeFieldStop()
27662 
    oprot.writeStructEnd()
27663 
 
27664 
  def validate(self):
27665 
    return
27666 
 
27667 
 
27668 
  def __repr__(self):
27669 
    L = ['%s=%r' % (key, value)
27670 
      for key, value in self.__dict__.iteritems()]
27671 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27672 
 
27673 
  def __eq__(self, other):
27674 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27675 
 
27676 
  def __ne__(self, other):
27677 
    return not (self == other)
27678 
 
6031 rajveer 27679 
class getUserWalletHistory_args:
6000 mandeep.dh 27680 
  """
27681 
  Attributes:
6031 rajveer 27682 
   - userId
6000 mandeep.dh 27683 
  """
27684 
 
27685 
  thrift_spec = (
27686 
    None, # 0
6031 rajveer 27687 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27688 
  )
27689 
 
6031 rajveer 27690 
  def __init__(self, userId=None,):
27691 
    self.userId = userId
6000 mandeep.dh 27692 
 
27693 
  def read(self, iprot):
27694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27696 
      return
27697 
    iprot.readStructBegin()
27698 
    while True:
27699 
      (fname, ftype, fid) = iprot.readFieldBegin()
27700 
      if ftype == TType.STOP:
27701 
        break
27702 
      if fid == 1:
27703 
        if ftype == TType.I64:
6031 rajveer 27704 
          self.userId = iprot.readI64();
6000 mandeep.dh 27705 
        else:
27706 
          iprot.skip(ftype)
27707 
      else:
27708 
        iprot.skip(ftype)
27709 
      iprot.readFieldEnd()
27710 
    iprot.readStructEnd()
27711 
 
27712 
  def write(self, oprot):
27713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27715 
      return
6031 rajveer 27716 
    oprot.writeStructBegin('getUserWalletHistory_args')
27717 
    if self.userId is not None:
27718 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27719 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27720 
      oprot.writeFieldEnd()
27721 
    oprot.writeFieldStop()
27722 
    oprot.writeStructEnd()
27723 
 
27724 
  def validate(self):
27725 
    return
27726 
 
27727 
 
27728 
  def __repr__(self):
27729 
    L = ['%s=%r' % (key, value)
27730 
      for key, value in self.__dict__.iteritems()]
27731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27732 
 
27733 
  def __eq__(self, other):
27734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27735 
 
27736 
  def __ne__(self, other):
27737 
    return not (self == other)
27738 
 
6031 rajveer 27739 
class getUserWalletHistory_result:
6000 mandeep.dh 27740 
  """
27741 
  Attributes:
27742 
   - success
27743 
  """
27744 
 
27745 
  thrift_spec = (
6031 rajveer 27746 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 27747 
  )
27748 
 
27749 
  def __init__(self, success=None,):
27750 
    self.success = success
27751 
 
27752 
  def read(self, iprot):
27753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27755 
      return
27756 
    iprot.readStructBegin()
27757 
    while True:
27758 
      (fname, ftype, fid) = iprot.readFieldBegin()
27759 
      if ftype == TType.STOP:
27760 
        break
27761 
      if fid == 0:
27762 
        if ftype == TType.LIST:
27763 
          self.success = []
6188 rajveer 27764 
          (_etype666, _size663) = iprot.readListBegin()
27765 
          for _i667 in xrange(_size663):
27766 
            _elem668 = UserWalletHistory()
27767 
            _elem668.read(iprot)
27768 
            self.success.append(_elem668)
6000 mandeep.dh 27769 
          iprot.readListEnd()
27770 
        else:
27771 
          iprot.skip(ftype)
27772 
      else:
27773 
        iprot.skip(ftype)
27774 
      iprot.readFieldEnd()
27775 
    iprot.readStructEnd()
27776 
 
27777 
  def write(self, oprot):
27778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27780 
      return
6031 rajveer 27781 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 27782 
    if self.success is not None:
27783 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27784 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27785 
      for iter669 in self.success:
27786 
        iter669.write(oprot)
6000 mandeep.dh 27787 
      oprot.writeListEnd()
27788 
      oprot.writeFieldEnd()
27789 
    oprot.writeFieldStop()
27790 
    oprot.writeStructEnd()
27791 
 
27792 
  def validate(self):
27793 
    return
27794 
 
27795 
 
27796 
  def __repr__(self):
27797 
    L = ['%s=%r' % (key, value)
27798 
      for key, value in self.__dict__.iteritems()]
27799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27800 
 
27801 
  def __eq__(self, other):
27802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27803 
 
27804 
  def __ne__(self, other):
27805 
    return not (self == other)
6048 rajveer 27806 
 
6050 anupam.sin 27807 
class getRechargeOrdersForTransaction_args:
27808 
  """
27809 
  Attributes:
27810 
   - txnId
27811 
  """
27812 
 
27813 
  thrift_spec = (
27814 
    None, # 0
27815 
    (1, TType.I64, 'txnId', None, None, ), # 1
27816 
  )
27817 
 
27818 
  def __init__(self, txnId=None,):
27819 
    self.txnId = txnId
27820 
 
27821 
  def read(self, iprot):
27822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27824 
      return
27825 
    iprot.readStructBegin()
27826 
    while True:
27827 
      (fname, ftype, fid) = iprot.readFieldBegin()
27828 
      if ftype == TType.STOP:
27829 
        break
27830 
      if fid == 1:
27831 
        if ftype == TType.I64:
27832 
          self.txnId = iprot.readI64();
27833 
        else:
27834 
          iprot.skip(ftype)
27835 
      else:
27836 
        iprot.skip(ftype)
27837 
      iprot.readFieldEnd()
27838 
    iprot.readStructEnd()
27839 
 
27840 
  def write(self, oprot):
27841 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27842 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27843 
      return
27844 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
27845 
    if self.txnId is not None:
27846 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
27847 
      oprot.writeI64(self.txnId)
27848 
      oprot.writeFieldEnd()
27849 
    oprot.writeFieldStop()
27850 
    oprot.writeStructEnd()
27851 
 
27852 
  def validate(self):
27853 
    return
27854 
 
27855 
 
27856 
  def __repr__(self):
27857 
    L = ['%s=%r' % (key, value)
27858 
      for key, value in self.__dict__.iteritems()]
27859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27860 
 
27861 
  def __eq__(self, other):
27862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27863 
 
27864 
  def __ne__(self, other):
27865 
    return not (self == other)
27866 
 
27867 
class getRechargeOrdersForTransaction_result:
27868 
  """
27869 
  Attributes:
27870 
   - success
27871 
   - ex
27872 
  """
27873 
 
27874 
  thrift_spec = (
27875 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27876 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27877 
  )
27878 
 
27879 
  def __init__(self, success=None, ex=None,):
27880 
    self.success = success
27881 
    self.ex = ex
27882 
 
27883 
  def read(self, iprot):
27884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27886 
      return
27887 
    iprot.readStructBegin()
27888 
    while True:
27889 
      (fname, ftype, fid) = iprot.readFieldBegin()
27890 
      if ftype == TType.STOP:
27891 
        break
27892 
      if fid == 0:
27893 
        if ftype == TType.STRUCT:
27894 
          self.success = RechargeOrder()
27895 
          self.success.read(iprot)
27896 
        else:
27897 
          iprot.skip(ftype)
27898 
      elif fid == 1:
27899 
        if ftype == TType.STRUCT:
27900 
          self.ex = TransactionServiceException()
27901 
          self.ex.read(iprot)
27902 
        else:
27903 
          iprot.skip(ftype)
27904 
      else:
27905 
        iprot.skip(ftype)
27906 
      iprot.readFieldEnd()
27907 
    iprot.readStructEnd()
27908 
 
27909 
  def write(self, oprot):
27910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27912 
      return
27913 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
27914 
    if self.success is not None:
27915 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27916 
      self.success.write(oprot)
27917 
      oprot.writeFieldEnd()
27918 
    if self.ex is not None:
27919 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27920 
      self.ex.write(oprot)
27921 
      oprot.writeFieldEnd()
27922 
    oprot.writeFieldStop()
27923 
    oprot.writeStructEnd()
27924 
 
27925 
  def validate(self):
27926 
    return
27927 
 
27928 
 
27929 
  def __repr__(self):
27930 
    L = ['%s=%r' % (key, value)
27931 
      for key, value in self.__dict__.iteritems()]
27932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27933 
 
27934 
  def __eq__(self, other):
27935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27936 
 
27937 
  def __ne__(self, other):
27938 
    return not (self == other)
27939 
 
6048 rajveer 27940 
class getServiceProviders_args:
27941 
  """
27942 
  Attributes:
27943 
   - rechargeType
6206 rajveer 27944 
   - onlyActive
6048 rajveer 27945 
  """
27946 
 
27947 
  thrift_spec = (
27948 
    None, # 0
27949 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 27950 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 27951 
  )
27952 
 
6206 rajveer 27953 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 27954 
    self.rechargeType = rechargeType
6206 rajveer 27955 
    self.onlyActive = onlyActive
6048 rajveer 27956 
 
27957 
  def read(self, iprot):
27958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27960 
      return
27961 
    iprot.readStructBegin()
27962 
    while True:
27963 
      (fname, ftype, fid) = iprot.readFieldBegin()
27964 
      if ftype == TType.STOP:
27965 
        break
27966 
      if fid == 1:
27967 
        if ftype == TType.I32:
27968 
          self.rechargeType = iprot.readI32();
27969 
        else:
27970 
          iprot.skip(ftype)
6206 rajveer 27971 
      elif fid == 2:
27972 
        if ftype == TType.BOOL:
27973 
          self.onlyActive = iprot.readBool();
27974 
        else:
27975 
          iprot.skip(ftype)
6048 rajveer 27976 
      else:
27977 
        iprot.skip(ftype)
27978 
      iprot.readFieldEnd()
27979 
    iprot.readStructEnd()
27980 
 
27981 
  def write(self, oprot):
27982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27984 
      return
27985 
    oprot.writeStructBegin('getServiceProviders_args')
27986 
    if self.rechargeType is not None:
27987 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27988 
      oprot.writeI32(self.rechargeType)
27989 
      oprot.writeFieldEnd()
6206 rajveer 27990 
    if self.onlyActive is not None:
27991 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
27992 
      oprot.writeBool(self.onlyActive)
27993 
      oprot.writeFieldEnd()
6048 rajveer 27994 
    oprot.writeFieldStop()
27995 
    oprot.writeStructEnd()
27996 
 
27997 
  def validate(self):
27998 
    return
27999 
 
28000 
 
28001 
  def __repr__(self):
28002 
    L = ['%s=%r' % (key, value)
28003 
      for key, value in self.__dict__.iteritems()]
28004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28005 
 
28006 
  def __eq__(self, other):
28007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28008 
 
28009 
  def __ne__(self, other):
28010 
    return not (self == other)
28011 
 
28012 
class getServiceProviders_result:
28013 
  """
28014 
  Attributes:
28015 
   - success
28016 
  """
28017 
 
28018 
  thrift_spec = (
28019 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
28020 
  )
28021 
 
28022 
  def __init__(self, success=None,):
28023 
    self.success = success
28024 
 
28025 
  def read(self, iprot):
28026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28028 
      return
28029 
    iprot.readStructBegin()
28030 
    while True:
28031 
      (fname, ftype, fid) = iprot.readFieldBegin()
28032 
      if ftype == TType.STOP:
28033 
        break
28034 
      if fid == 0:
28035 
        if ftype == TType.MAP:
28036 
          self.success = {}
6188 rajveer 28037 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
28038 
          for _i674 in xrange(_size670):
28039 
            _key675 = iprot.readI64();
28040 
            _val676 = iprot.readString();
28041 
            self.success[_key675] = _val676
6048 rajveer 28042 
          iprot.readMapEnd()
28043 
        else:
28044 
          iprot.skip(ftype)
28045 
      else:
28046 
        iprot.skip(ftype)
28047 
      iprot.readFieldEnd()
28048 
    iprot.readStructEnd()
28049 
 
28050 
  def write(self, oprot):
28051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28053 
      return
28054 
    oprot.writeStructBegin('getServiceProviders_result')
28055 
    if self.success is not None:
28056 
      oprot.writeFieldBegin('success', TType.MAP, 0)
28057 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 28058 
      for kiter677,viter678 in self.success.items():
28059 
        oprot.writeI64(kiter677)
28060 
        oprot.writeString(viter678)
6048 rajveer 28061 
      oprot.writeMapEnd()
28062 
      oprot.writeFieldEnd()
28063 
    oprot.writeFieldStop()
28064 
    oprot.writeStructEnd()
28065 
 
28066 
  def validate(self):
28067 
    return
28068 
 
28069 
 
28070 
  def __repr__(self):
28071 
    L = ['%s=%r' % (key, value)
28072 
      for key, value in self.__dict__.iteritems()]
28073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28074 
 
28075 
  def __eq__(self, other):
28076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28077 
 
28078 
  def __ne__(self, other):
28079 
    return not (self == other)
28080 
 
28081 
class getServiceProviderForDevice_args:
28082 
  """
28083 
  Attributes:
6049 rajveer 28084 
   - rechargeType
6048 rajveer 28085 
   - deviceNumber
28086 
  """
28087 
 
28088 
  thrift_spec = (
28089 
    None, # 0
6049 rajveer 28090 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28091 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 28092 
  )
28093 
 
6049 rajveer 28094 
  def __init__(self, rechargeType=None, deviceNumber=None,):
28095 
    self.rechargeType = rechargeType
6048 rajveer 28096 
    self.deviceNumber = deviceNumber
28097 
 
28098 
  def read(self, iprot):
28099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28101 
      return
28102 
    iprot.readStructBegin()
28103 
    while True:
28104 
      (fname, ftype, fid) = iprot.readFieldBegin()
28105 
      if ftype == TType.STOP:
28106 
        break
28107 
      if fid == 1:
6049 rajveer 28108 
        if ftype == TType.I32:
28109 
          self.rechargeType = iprot.readI32();
28110 
        else:
28111 
          iprot.skip(ftype)
28112 
      elif fid == 2:
6048 rajveer 28113 
        if ftype == TType.STRING:
28114 
          self.deviceNumber = iprot.readString();
28115 
        else:
28116 
          iprot.skip(ftype)
28117 
      else:
28118 
        iprot.skip(ftype)
28119 
      iprot.readFieldEnd()
28120 
    iprot.readStructEnd()
28121 
 
28122 
  def write(self, oprot):
28123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28125 
      return
28126 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 28127 
    if self.rechargeType is not None:
28128 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28129 
      oprot.writeI32(self.rechargeType)
28130 
      oprot.writeFieldEnd()
6048 rajveer 28131 
    if self.deviceNumber is not None:
6049 rajveer 28132 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 28133 
      oprot.writeString(self.deviceNumber)
28134 
      oprot.writeFieldEnd()
28135 
    oprot.writeFieldStop()
28136 
    oprot.writeStructEnd()
28137 
 
28138 
  def validate(self):
28139 
    return
28140 
 
28141 
 
28142 
  def __repr__(self):
28143 
    L = ['%s=%r' % (key, value)
28144 
      for key, value in self.__dict__.iteritems()]
28145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28146 
 
28147 
  def __eq__(self, other):
28148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28149 
 
28150 
  def __ne__(self, other):
28151 
    return not (self == other)
28152 
 
28153 
class getServiceProviderForDevice_result:
28154 
  """
28155 
  Attributes:
28156 
   - success
28157 
  """
28158 
 
28159 
  thrift_spec = (
6289 anupam.sin 28160 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 28161 
  )
28162 
 
28163 
  def __init__(self, success=None,):
28164 
    self.success = success
28165 
 
28166 
  def read(self, iprot):
28167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28169 
      return
28170 
    iprot.readStructBegin()
28171 
    while True:
28172 
      (fname, ftype, fid) = iprot.readFieldBegin()
28173 
      if ftype == TType.STOP:
28174 
        break
28175 
      if fid == 0:
6289 anupam.sin 28176 
        if ftype == TType.STRUCT:
28177 
          self.success = DeviceNumberInfo()
28178 
          self.success.read(iprot)
6048 rajveer 28179 
        else:
28180 
          iprot.skip(ftype)
28181 
      else:
28182 
        iprot.skip(ftype)
28183 
      iprot.readFieldEnd()
28184 
    iprot.readStructEnd()
28185 
 
28186 
  def write(self, oprot):
28187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28189 
      return
28190 
    oprot.writeStructBegin('getServiceProviderForDevice_result')
28191 
    if self.success is not None:
6289 anupam.sin 28192 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28193 
      self.success.write(oprot)
6048 rajveer 28194 
      oprot.writeFieldEnd()
28195 
    oprot.writeFieldStop()
28196 
    oprot.writeStructEnd()
28197 
 
28198 
  def validate(self):
28199 
    return
28200 
 
28201 
 
28202 
  def __repr__(self):
28203 
    L = ['%s=%r' % (key, value)
28204 
      for key, value in self.__dict__.iteritems()]
28205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28206 
 
28207 
  def __eq__(self, other):
28208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28209 
 
28210 
  def __ne__(self, other):
28211 
    return not (self == other)
6094 rajveer 28212 
 
6269 rajveer 28213 
class validateRecharge_args:
28214 
  """
28215 
  Attributes:
28216 
   - rechargeType
28217 
   - deviceNumber
6307 anupam.sin 28218 
   - userSelectedProviderId
6591 anupam.sin 28219 
   - clientAddress
6269 rajveer 28220 
  """
28221 
 
28222 
  thrift_spec = (
28223 
    None, # 0
28224 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28225 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 28226 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6591 anupam.sin 28227 
    (4, TType.STRING, 'clientAddress', None, None, ), # 4
6269 rajveer 28228 
  )
28229 
 
6591 anupam.sin 28230 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None, clientAddress=None,):
6269 rajveer 28231 
    self.rechargeType = rechargeType
28232 
    self.deviceNumber = deviceNumber
6307 anupam.sin 28233 
    self.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 28234 
    self.clientAddress = clientAddress
6269 rajveer 28235 
 
28236 
  def read(self, iprot):
28237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28239 
      return
28240 
    iprot.readStructBegin()
28241 
    while True:
28242 
      (fname, ftype, fid) = iprot.readFieldBegin()
28243 
      if ftype == TType.STOP:
28244 
        break
28245 
      if fid == 1:
28246 
        if ftype == TType.I32:
28247 
          self.rechargeType = iprot.readI32();
28248 
        else:
28249 
          iprot.skip(ftype)
28250 
      elif fid == 2:
28251 
        if ftype == TType.STRING:
28252 
          self.deviceNumber = iprot.readString();
28253 
        else:
28254 
          iprot.skip(ftype)
6307 anupam.sin 28255 
      elif fid == 3:
28256 
        if ftype == TType.I64:
28257 
          self.userSelectedProviderId = iprot.readI64();
28258 
        else:
28259 
          iprot.skip(ftype)
6591 anupam.sin 28260 
      elif fid == 4:
28261 
        if ftype == TType.STRING:
28262 
          self.clientAddress = iprot.readString();
28263 
        else:
28264 
          iprot.skip(ftype)
6269 rajveer 28265 
      else:
28266 
        iprot.skip(ftype)
28267 
      iprot.readFieldEnd()
28268 
    iprot.readStructEnd()
28269 
 
28270 
  def write(self, oprot):
28271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28273 
      return
28274 
    oprot.writeStructBegin('validateRecharge_args')
28275 
    if self.rechargeType is not None:
28276 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28277 
      oprot.writeI32(self.rechargeType)
28278 
      oprot.writeFieldEnd()
28279 
    if self.deviceNumber is not None:
28280 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
28281 
      oprot.writeString(self.deviceNumber)
28282 
      oprot.writeFieldEnd()
6307 anupam.sin 28283 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 28284 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 28285 
      oprot.writeI64(self.userSelectedProviderId)
28286 
      oprot.writeFieldEnd()
6591 anupam.sin 28287 
    if self.clientAddress is not None:
28288 
      oprot.writeFieldBegin('clientAddress', TType.STRING, 4)
28289 
      oprot.writeString(self.clientAddress)
28290 
      oprot.writeFieldEnd()
6269 rajveer 28291 
    oprot.writeFieldStop()
28292 
    oprot.writeStructEnd()
28293 
 
28294 
  def validate(self):
28295 
    return
28296 
 
28297 
 
28298 
  def __repr__(self):
28299 
    L = ['%s=%r' % (key, value)
28300 
      for key, value in self.__dict__.iteritems()]
28301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28302 
 
28303 
  def __eq__(self, other):
28304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28305 
 
28306 
  def __ne__(self, other):
28307 
    return not (self == other)
28308 
 
28309 
class validateRecharge_result:
28310 
  """
28311 
  Attributes:
28312 
   - success
28313 
  """
28314 
 
28315 
  thrift_spec = (
28316 
    (0, TType.STRING, 'success', None, None, ), # 0
28317 
  )
28318 
 
28319 
  def __init__(self, success=None,):
28320 
    self.success = success
28321 
 
28322 
  def read(self, iprot):
28323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28325 
      return
28326 
    iprot.readStructBegin()
28327 
    while True:
28328 
      (fname, ftype, fid) = iprot.readFieldBegin()
28329 
      if ftype == TType.STOP:
28330 
        break
28331 
      if fid == 0:
28332 
        if ftype == TType.STRING:
28333 
          self.success = iprot.readString();
28334 
        else:
28335 
          iprot.skip(ftype)
28336 
      else:
28337 
        iprot.skip(ftype)
28338 
      iprot.readFieldEnd()
28339 
    iprot.readStructEnd()
28340 
 
28341 
  def write(self, oprot):
28342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28344 
      return
28345 
    oprot.writeStructBegin('validateRecharge_result')
28346 
    if self.success is not None:
28347 
      oprot.writeFieldBegin('success', TType.STRING, 0)
28348 
      oprot.writeString(self.success)
28349 
      oprot.writeFieldEnd()
28350 
    oprot.writeFieldStop()
28351 
    oprot.writeStructEnd()
28352 
 
28353 
  def validate(self):
28354 
    return
28355 
 
28356 
 
28357 
  def __repr__(self):
28358 
    L = ['%s=%r' % (key, value)
28359 
      for key, value in self.__dict__.iteritems()]
28360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28361 
 
28362 
  def __eq__(self, other):
28363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28364 
 
28365 
  def __ne__(self, other):
28366 
    return not (self == other)
28367 
 
6094 rajveer 28368 
class getRechargeOrdersForDevice_args:
28369 
  """
28370 
  Attributes:
28371 
   - deviceNumber
28372 
  """
28373 
 
28374 
  thrift_spec = (
28375 
    None, # 0
28376 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
28377 
  )
28378 
 
28379 
  def __init__(self, deviceNumber=None,):
28380 
    self.deviceNumber = deviceNumber
28381 
 
28382 
  def read(self, iprot):
28383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28385 
      return
28386 
    iprot.readStructBegin()
28387 
    while True:
28388 
      (fname, ftype, fid) = iprot.readFieldBegin()
28389 
      if ftype == TType.STOP:
28390 
        break
28391 
      if fid == 1:
28392 
        if ftype == TType.STRING:
28393 
          self.deviceNumber = iprot.readString();
28394 
        else:
28395 
          iprot.skip(ftype)
28396 
      else:
28397 
        iprot.skip(ftype)
28398 
      iprot.readFieldEnd()
28399 
    iprot.readStructEnd()
28400 
 
28401 
  def write(self, oprot):
28402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28404 
      return
28405 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
28406 
    if self.deviceNumber is not None:
28407 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
28408 
      oprot.writeString(self.deviceNumber)
28409 
      oprot.writeFieldEnd()
28410 
    oprot.writeFieldStop()
28411 
    oprot.writeStructEnd()
28412 
 
28413 
  def validate(self):
28414 
    return
28415 
 
28416 
 
28417 
  def __repr__(self):
28418 
    L = ['%s=%r' % (key, value)
28419 
      for key, value in self.__dict__.iteritems()]
28420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28421 
 
28422 
  def __eq__(self, other):
28423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28424 
 
28425 
  def __ne__(self, other):
28426 
    return not (self == other)
28427 
 
28428 
class getRechargeOrdersForDevice_result:
28429 
  """
28430 
  Attributes:
28431 
   - success
28432 
  """
28433 
 
28434 
  thrift_spec = (
28435 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28436 
  )
28437 
 
28438 
  def __init__(self, success=None,):
28439 
    self.success = success
28440 
 
28441 
  def read(self, iprot):
28442 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28443 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28444 
      return
28445 
    iprot.readStructBegin()
28446 
    while True:
28447 
      (fname, ftype, fid) = iprot.readFieldBegin()
28448 
      if ftype == TType.STOP:
28449 
        break
28450 
      if fid == 0:
28451 
        if ftype == TType.LIST:
28452 
          self.success = []
6188 rajveer 28453 
          (_etype682, _size679) = iprot.readListBegin()
28454 
          for _i683 in xrange(_size679):
28455 
            _elem684 = RechargeOrder()
28456 
            _elem684.read(iprot)
28457 
            self.success.append(_elem684)
6094 rajveer 28458 
          iprot.readListEnd()
28459 
        else:
28460 
          iprot.skip(ftype)
28461 
      else:
28462 
        iprot.skip(ftype)
28463 
      iprot.readFieldEnd()
28464 
    iprot.readStructEnd()
28465 
 
28466 
  def write(self, oprot):
28467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28469 
      return
28470 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
28471 
    if self.success is not None:
28472 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28473 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28474 
      for iter685 in self.success:
28475 
        iter685.write(oprot)
6094 rajveer 28476 
      oprot.writeListEnd()
28477 
      oprot.writeFieldEnd()
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 addAmountToWallet_args:
28497 
  """
28498 
  Attributes:
28499 
   - userId
28500 
   - orderId
28501 
   - amount
28502 
  """
28503 
 
28504 
  thrift_spec = (
28505 
    None, # 0
28506 
    (1, TType.I64, 'userId', None, None, ), # 1
28507 
    (2, TType.I64, 'orderId', None, None, ), # 2
28508 
    (3, TType.I64, 'amount', None, None, ), # 3
28509 
  )
28510 
 
28511 
  def __init__(self, userId=None, orderId=None, amount=None,):
28512 
    self.userId = userId
28513 
    self.orderId = orderId
28514 
    self.amount = amount
28515 
 
28516 
  def read(self, iprot):
28517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28519 
      return
28520 
    iprot.readStructBegin()
28521 
    while True:
28522 
      (fname, ftype, fid) = iprot.readFieldBegin()
28523 
      if ftype == TType.STOP:
28524 
        break
28525 
      if fid == 1:
28526 
        if ftype == TType.I64:
28527 
          self.userId = iprot.readI64();
28528 
        else:
28529 
          iprot.skip(ftype)
28530 
      elif fid == 2:
28531 
        if ftype == TType.I64:
28532 
          self.orderId = iprot.readI64();
28533 
        else:
28534 
          iprot.skip(ftype)
28535 
      elif fid == 3:
28536 
        if ftype == TType.I64:
28537 
          self.amount = iprot.readI64();
28538 
        else:
28539 
          iprot.skip(ftype)
28540 
      else:
28541 
        iprot.skip(ftype)
28542 
      iprot.readFieldEnd()
28543 
    iprot.readStructEnd()
28544 
 
28545 
  def write(self, oprot):
28546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28548 
      return
28549 
    oprot.writeStructBegin('addAmountToWallet_args')
28550 
    if self.userId is not None:
28551 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28552 
      oprot.writeI64(self.userId)
28553 
      oprot.writeFieldEnd()
28554 
    if self.orderId is not None:
28555 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
28556 
      oprot.writeI64(self.orderId)
28557 
      oprot.writeFieldEnd()
28558 
    if self.amount is not None:
28559 
      oprot.writeFieldBegin('amount', TType.I64, 3)
28560 
      oprot.writeI64(self.amount)
28561 
      oprot.writeFieldEnd()
28562 
    oprot.writeFieldStop()
28563 
    oprot.writeStructEnd()
28564 
 
28565 
  def validate(self):
28566 
    return
28567 
 
28568 
 
28569 
  def __repr__(self):
28570 
    L = ['%s=%r' % (key, value)
28571 
      for key, value in self.__dict__.iteritems()]
28572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28573 
 
28574 
  def __eq__(self, other):
28575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28576 
 
28577 
  def __ne__(self, other):
28578 
    return not (self == other)
28579 
 
28580 
class addAmountToWallet_result:
28581 
 
28582 
  thrift_spec = (
28583 
  )
28584 
 
28585 
  def read(self, iprot):
28586 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28587 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28588 
      return
28589 
    iprot.readStructBegin()
28590 
    while True:
28591 
      (fname, ftype, fid) = iprot.readFieldBegin()
28592 
      if ftype == TType.STOP:
28593 
        break
28594 
      else:
28595 
        iprot.skip(ftype)
28596 
      iprot.readFieldEnd()
28597 
    iprot.readStructEnd()
28598 
 
28599 
  def write(self, oprot):
28600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28602 
      return
28603 
    oprot.writeStructBegin('addAmountToWallet_result')
28604 
    oprot.writeFieldStop()
28605 
    oprot.writeStructEnd()
28606 
 
28607 
  def validate(self):
28608 
    return
28609 
 
28610 
 
28611 
  def __repr__(self):
28612 
    L = ['%s=%r' % (key, value)
28613 
      for key, value in self.__dict__.iteritems()]
28614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28615 
 
28616 
  def __eq__(self, other):
28617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28618 
 
28619 
  def __ne__(self, other):
28620 
    return not (self == other)
6154 rajveer 28621 
 
6188 rajveer 28622 
class getRechargeStatistics_args:
28623 
 
28624 
  thrift_spec = (
28625 
  )
28626 
 
28627 
  def read(self, iprot):
28628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28630 
      return
28631 
    iprot.readStructBegin()
28632 
    while True:
28633 
      (fname, ftype, fid) = iprot.readFieldBegin()
28634 
      if ftype == TType.STOP:
28635 
        break
28636 
      else:
28637 
        iprot.skip(ftype)
28638 
      iprot.readFieldEnd()
28639 
    iprot.readStructEnd()
28640 
 
28641 
  def write(self, oprot):
28642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28644 
      return
28645 
    oprot.writeStructBegin('getRechargeStatistics_args')
28646 
    oprot.writeFieldStop()
28647 
    oprot.writeStructEnd()
28648 
 
28649 
  def validate(self):
28650 
    return
28651 
 
28652 
 
28653 
  def __repr__(self):
28654 
    L = ['%s=%r' % (key, value)
28655 
      for key, value in self.__dict__.iteritems()]
28656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28657 
 
28658 
  def __eq__(self, other):
28659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28660 
 
28661 
  def __ne__(self, other):
28662 
    return not (self == other)
28663 
 
28664 
class getRechargeStatistics_result:
28665 
  """
28666 
  Attributes:
28667 
   - success
28668 
  """
28669 
 
28670 
  thrift_spec = (
28671 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
28672 
  )
28673 
 
28674 
  def __init__(self, success=None,):
28675 
    self.success = success
28676 
 
28677 
  def read(self, iprot):
28678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28680 
      return
28681 
    iprot.readStructBegin()
28682 
    while True:
28683 
      (fname, ftype, fid) = iprot.readFieldBegin()
28684 
      if ftype == TType.STOP:
28685 
        break
28686 
      if fid == 0:
28687 
        if ftype == TType.STRUCT:
28688 
          self.success = RechargeStatistics()
28689 
          self.success.read(iprot)
28690 
        else:
28691 
          iprot.skip(ftype)
28692 
      else:
28693 
        iprot.skip(ftype)
28694 
      iprot.readFieldEnd()
28695 
    iprot.readStructEnd()
28696 
 
28697 
  def write(self, oprot):
28698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28700 
      return
28701 
    oprot.writeStructBegin('getRechargeStatistics_result')
28702 
    if self.success is not None:
28703 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28704 
      self.success.write(oprot)
28705 
      oprot.writeFieldEnd()
28706 
    oprot.writeFieldStop()
28707 
    oprot.writeStructEnd()
28708 
 
28709 
  def validate(self):
28710 
    return
28711 
 
28712 
 
28713 
  def __repr__(self):
28714 
    L = ['%s=%r' % (key, value)
28715 
      for key, value in self.__dict__.iteritems()]
28716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28717 
 
28718 
  def __eq__(self, other):
28719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28720 
 
28721 
  def __ne__(self, other):
28722 
    return not (self == other)
28723 
 
6154 rajveer 28724 
class getRechargeOrdersForStatus_args:
28725 
  """
28726 
  Attributes:
28727 
   - status
28728 
  """
28729 
 
28730 
  thrift_spec = (
28731 
    None, # 0
28732 
    (1, TType.I64, 'status', None, None, ), # 1
28733 
  )
28734 
 
28735 
  def __init__(self, status=None,):
28736 
    self.status = status
28737 
 
28738 
  def read(self, iprot):
28739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28741 
      return
28742 
    iprot.readStructBegin()
28743 
    while True:
28744 
      (fname, ftype, fid) = iprot.readFieldBegin()
28745 
      if ftype == TType.STOP:
28746 
        break
28747 
      if fid == 1:
28748 
        if ftype == TType.I64:
28749 
          self.status = iprot.readI64();
28750 
        else:
28751 
          iprot.skip(ftype)
28752 
      else:
28753 
        iprot.skip(ftype)
28754 
      iprot.readFieldEnd()
28755 
    iprot.readStructEnd()
28756 
 
28757 
  def write(self, oprot):
28758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28760 
      return
28761 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
28762 
    if self.status is not None:
28763 
      oprot.writeFieldBegin('status', TType.I64, 1)
28764 
      oprot.writeI64(self.status)
28765 
      oprot.writeFieldEnd()
28766 
    oprot.writeFieldStop()
28767 
    oprot.writeStructEnd()
28768 
 
28769 
  def validate(self):
28770 
    return
28771 
 
28772 
 
28773 
  def __repr__(self):
28774 
    L = ['%s=%r' % (key, value)
28775 
      for key, value in self.__dict__.iteritems()]
28776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28777 
 
28778 
  def __eq__(self, other):
28779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28780 
 
28781 
  def __ne__(self, other):
28782 
    return not (self == other)
28783 
 
28784 
class getRechargeOrdersForStatus_result:
28785 
  """
28786 
  Attributes:
28787 
   - success
28788 
  """
28789 
 
28790 
  thrift_spec = (
28791 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28792 
  )
28793 
 
28794 
  def __init__(self, success=None,):
28795 
    self.success = success
28796 
 
28797 
  def read(self, iprot):
28798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28800 
      return
28801 
    iprot.readStructBegin()
28802 
    while True:
28803 
      (fname, ftype, fid) = iprot.readFieldBegin()
28804 
      if ftype == TType.STOP:
28805 
        break
28806 
      if fid == 0:
28807 
        if ftype == TType.LIST:
28808 
          self.success = []
6188 rajveer 28809 
          (_etype689, _size686) = iprot.readListBegin()
28810 
          for _i690 in xrange(_size686):
28811 
            _elem691 = RechargeOrder()
28812 
            _elem691.read(iprot)
28813 
            self.success.append(_elem691)
6154 rajveer 28814 
          iprot.readListEnd()
28815 
        else:
28816 
          iprot.skip(ftype)
28817 
      else:
28818 
        iprot.skip(ftype)
28819 
      iprot.readFieldEnd()
28820 
    iprot.readStructEnd()
28821 
 
28822 
  def write(self, oprot):
28823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28825 
      return
28826 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
28827 
    if self.success is not None:
28828 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28829 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28830 
      for iter692 in self.success:
28831 
        iter692.write(oprot)
6154 rajveer 28832 
      oprot.writeListEnd()
28833 
      oprot.writeFieldEnd()
28834 
    oprot.writeFieldStop()
28835 
    oprot.writeStructEnd()
28836 
 
28837 
  def validate(self):
28838 
    return
28839 
 
28840 
 
28841 
  def __repr__(self):
28842 
    L = ['%s=%r' % (key, value)
28843 
      for key, value in self.__dict__.iteritems()]
28844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28845 
 
28846 
  def __eq__(self, other):
28847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28848 
 
28849 
  def __ne__(self, other):
28850 
    return not (self == other)
6159 rajveer 28851 
 
28852 
class getPlansForOperator_args:
28853 
  """
28854 
  Attributes:
28855 
   - operatorId
28856 
  """
28857 
 
28858 
  thrift_spec = (
28859 
    None, # 0
28860 
    (1, TType.I64, 'operatorId', None, None, ), # 1
28861 
  )
28862 
 
28863 
  def __init__(self, operatorId=None,):
28864 
    self.operatorId = operatorId
28865 
 
28866 
  def read(self, iprot):
28867 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28868 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28869 
      return
28870 
    iprot.readStructBegin()
28871 
    while True:
28872 
      (fname, ftype, fid) = iprot.readFieldBegin()
28873 
      if ftype == TType.STOP:
28874 
        break
28875 
      if fid == 1:
28876 
        if ftype == TType.I64:
28877 
          self.operatorId = iprot.readI64();
28878 
        else:
28879 
          iprot.skip(ftype)
28880 
      else:
28881 
        iprot.skip(ftype)
28882 
      iprot.readFieldEnd()
28883 
    iprot.readStructEnd()
28884 
 
28885 
  def write(self, oprot):
28886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28888 
      return
28889 
    oprot.writeStructBegin('getPlansForOperator_args')
28890 
    if self.operatorId is not None:
28891 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28892 
      oprot.writeI64(self.operatorId)
28893 
      oprot.writeFieldEnd()
28894 
    oprot.writeFieldStop()
28895 
    oprot.writeStructEnd()
28896 
 
28897 
  def validate(self):
28898 
    return
28899 
 
28900 
 
28901 
  def __repr__(self):
28902 
    L = ['%s=%r' % (key, value)
28903 
      for key, value in self.__dict__.iteritems()]
28904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28905 
 
28906 
  def __eq__(self, other):
28907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28908 
 
28909 
  def __ne__(self, other):
28910 
    return not (self == other)
28911 
 
28912 
class getPlansForOperator_result:
28913 
  """
28914 
  Attributes:
28915 
   - success
28916 
  """
28917 
 
28918 
  thrift_spec = (
28919 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
28920 
  )
28921 
 
28922 
  def __init__(self, success=None,):
28923 
    self.success = success
28924 
 
28925 
  def read(self, iprot):
28926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28928 
      return
28929 
    iprot.readStructBegin()
28930 
    while True:
28931 
      (fname, ftype, fid) = iprot.readFieldBegin()
28932 
      if ftype == TType.STOP:
28933 
        break
28934 
      if fid == 0:
28935 
        if ftype == TType.LIST:
28936 
          self.success = []
6188 rajveer 28937 
          (_etype696, _size693) = iprot.readListBegin()
28938 
          for _i697 in xrange(_size693):
28939 
            _elem698 = RechargePlan()
28940 
            _elem698.read(iprot)
28941 
            self.success.append(_elem698)
6159 rajveer 28942 
          iprot.readListEnd()
28943 
        else:
28944 
          iprot.skip(ftype)
28945 
      else:
28946 
        iprot.skip(ftype)
28947 
      iprot.readFieldEnd()
28948 
    iprot.readStructEnd()
28949 
 
28950 
  def write(self, oprot):
28951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28953 
      return
28954 
    oprot.writeStructBegin('getPlansForOperator_result')
28955 
    if self.success is not None:
28956 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28957 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28958 
      for iter699 in self.success:
28959 
        iter699.write(oprot)
6159 rajveer 28960 
      oprot.writeListEnd()
28961 
      oprot.writeFieldEnd()
28962 
    oprot.writeFieldStop()
28963 
    oprot.writeStructEnd()
28964 
 
28965 
  def validate(self):
28966 
    return
28967 
 
28968 
 
28969 
  def __repr__(self):
28970 
    L = ['%s=%r' % (key, value)
28971 
      for key, value in self.__dict__.iteritems()]
28972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28973 
 
28974 
  def __eq__(self, other):
28975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28976 
 
28977 
  def __ne__(self, other):
28978 
    return not (self == other)
6289 anupam.sin 28979 
 
28980 
class getRechargeDenominations_args:
28981 
  """
28982 
  Attributes:
28983 
   - operatorId
6307 anupam.sin 28984 
   - circleCode
6289 anupam.sin 28985 
   - denominationType
28986 
  """
28987 
 
28988 
  thrift_spec = (
28989 
    None, # 0
28990 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 28991 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 28992 
    (3, TType.I32, 'denominationType', None, None, ), # 3
28993 
  )
28994 
 
6307 anupam.sin 28995 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 28996 
    self.operatorId = operatorId
6307 anupam.sin 28997 
    self.circleCode = circleCode
6289 anupam.sin 28998 
    self.denominationType = denominationType
28999 
 
29000 
  def read(self, iprot):
29001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29003 
      return
29004 
    iprot.readStructBegin()
29005 
    while True:
29006 
      (fname, ftype, fid) = iprot.readFieldBegin()
29007 
      if ftype == TType.STOP:
29008 
        break
29009 
      if fid == 1:
29010 
        if ftype == TType.I64:
29011 
          self.operatorId = iprot.readI64();
29012 
        else:
29013 
          iprot.skip(ftype)
29014 
      elif fid == 2:
29015 
        if ftype == TType.STRING:
6307 anupam.sin 29016 
          self.circleCode = iprot.readString();
6289 anupam.sin 29017 
        else:
29018 
          iprot.skip(ftype)
29019 
      elif fid == 3:
29020 
        if ftype == TType.I32:
29021 
          self.denominationType = iprot.readI32();
29022 
        else:
29023 
          iprot.skip(ftype)
29024 
      else:
29025 
        iprot.skip(ftype)
29026 
      iprot.readFieldEnd()
29027 
    iprot.readStructEnd()
29028 
 
29029 
  def write(self, oprot):
29030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29032 
      return
29033 
    oprot.writeStructBegin('getRechargeDenominations_args')
29034 
    if self.operatorId is not None:
29035 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29036 
      oprot.writeI64(self.operatorId)
29037 
      oprot.writeFieldEnd()
6307 anupam.sin 29038 
    if self.circleCode is not None:
29039 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
29040 
      oprot.writeString(self.circleCode)
6289 anupam.sin 29041 
      oprot.writeFieldEnd()
29042 
    if self.denominationType is not None:
29043 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
29044 
      oprot.writeI32(self.denominationType)
29045 
      oprot.writeFieldEnd()
29046 
    oprot.writeFieldStop()
29047 
    oprot.writeStructEnd()
29048 
 
29049 
  def validate(self):
29050 
    return
29051 
 
29052 
 
29053 
  def __repr__(self):
29054 
    L = ['%s=%r' % (key, value)
29055 
      for key, value in self.__dict__.iteritems()]
29056 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29057 
 
29058 
  def __eq__(self, other):
29059 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29060 
 
29061 
  def __ne__(self, other):
29062 
    return not (self == other)
29063 
 
29064 
class getRechargeDenominations_result:
29065 
  """
29066 
  Attributes:
29067 
   - success
29068 
   - ex
29069 
  """
29070 
 
29071 
  thrift_spec = (
29072 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
29073 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29074 
  )
29075 
 
29076 
  def __init__(self, success=None, ex=None,):
29077 
    self.success = success
29078 
    self.ex = ex
29079 
 
29080 
  def read(self, iprot):
29081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29083 
      return
29084 
    iprot.readStructBegin()
29085 
    while True:
29086 
      (fname, ftype, fid) = iprot.readFieldBegin()
29087 
      if ftype == TType.STOP:
29088 
        break
29089 
      if fid == 0:
29090 
        if ftype == TType.LIST:
29091 
          self.success = []
29092 
          (_etype703, _size700) = iprot.readListBegin()
29093 
          for _i704 in xrange(_size700):
29094 
            _elem705 = RechargeDenomination()
29095 
            _elem705.read(iprot)
29096 
            self.success.append(_elem705)
29097 
          iprot.readListEnd()
29098 
        else:
29099 
          iprot.skip(ftype)
29100 
      elif fid == 1:
29101 
        if ftype == TType.STRUCT:
29102 
          self.ex = TransactionServiceException()
29103 
          self.ex.read(iprot)
29104 
        else:
29105 
          iprot.skip(ftype)
29106 
      else:
29107 
        iprot.skip(ftype)
29108 
      iprot.readFieldEnd()
29109 
    iprot.readStructEnd()
29110 
 
29111 
  def write(self, oprot):
29112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29114 
      return
29115 
    oprot.writeStructBegin('getRechargeDenominations_result')
29116 
    if self.success is not None:
29117 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29118 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29119 
      for iter706 in self.success:
29120 
        iter706.write(oprot)
29121 
      oprot.writeListEnd()
29122 
      oprot.writeFieldEnd()
29123 
    if self.ex is not None:
29124 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29125 
      self.ex.write(oprot)
29126 
      oprot.writeFieldEnd()
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)
6371 rajveer 29144 
 
29145 
class updateAvailabilityStatus_args:
29146 
  """
29147 
  Attributes:
29148 
   - operatorId
29149 
   - circleId
29150 
   - isAvailable
29151 
  """
29152 
 
29153 
  thrift_spec = (
29154 
    None, # 0
29155 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29156 
    (2, TType.I64, 'circleId', None, None, ), # 2
29157 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
29158 
  )
29159 
 
29160 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
29161 
    self.operatorId = operatorId
29162 
    self.circleId = circleId
29163 
    self.isAvailable = isAvailable
29164 
 
29165 
  def read(self, iprot):
29166 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29167 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29168 
      return
29169 
    iprot.readStructBegin()
29170 
    while True:
29171 
      (fname, ftype, fid) = iprot.readFieldBegin()
29172 
      if ftype == TType.STOP:
29173 
        break
29174 
      if fid == 1:
29175 
        if ftype == TType.I64:
29176 
          self.operatorId = iprot.readI64();
29177 
        else:
29178 
          iprot.skip(ftype)
29179 
      elif fid == 2:
29180 
        if ftype == TType.I64:
29181 
          self.circleId = iprot.readI64();
29182 
        else:
29183 
          iprot.skip(ftype)
29184 
      elif fid == 3:
29185 
        if ftype == TType.BOOL:
29186 
          self.isAvailable = iprot.readBool();
29187 
        else:
29188 
          iprot.skip(ftype)
29189 
      else:
29190 
        iprot.skip(ftype)
29191 
      iprot.readFieldEnd()
29192 
    iprot.readStructEnd()
29193 
 
29194 
  def write(self, oprot):
29195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29197 
      return
29198 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
29199 
    if self.operatorId is not None:
29200 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29201 
      oprot.writeI64(self.operatorId)
29202 
      oprot.writeFieldEnd()
29203 
    if self.circleId is not None:
29204 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
29205 
      oprot.writeI64(self.circleId)
29206 
      oprot.writeFieldEnd()
29207 
    if self.isAvailable is not None:
29208 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
29209 
      oprot.writeBool(self.isAvailable)
29210 
      oprot.writeFieldEnd()
29211 
    oprot.writeFieldStop()
29212 
    oprot.writeStructEnd()
29213 
 
29214 
  def validate(self):
29215 
    return
29216 
 
29217 
 
29218 
  def __repr__(self):
29219 
    L = ['%s=%r' % (key, value)
29220 
      for key, value in self.__dict__.iteritems()]
29221 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29222 
 
29223 
  def __eq__(self, other):
29224 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29225 
 
29226 
  def __ne__(self, other):
29227 
    return not (self == other)
29228 
 
29229 
class updateAvailabilityStatus_result:
29230 
 
29231 
  thrift_spec = (
29232 
  )
29233 
 
29234 
  def read(self, iprot):
29235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29237 
      return
29238 
    iprot.readStructBegin()
29239 
    while True:
29240 
      (fname, ftype, fid) = iprot.readFieldBegin()
29241 
      if ftype == TType.STOP:
29242 
        break
29243 
      else:
29244 
        iprot.skip(ftype)
29245 
      iprot.readFieldEnd()
29246 
    iprot.readStructEnd()
29247 
 
29248 
  def write(self, oprot):
29249 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29250 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29251 
      return
29252 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
29253 
    oprot.writeFieldStop()
29254 
    oprot.writeStructEnd()
29255 
 
29256 
  def validate(self):
29257 
    return
29258 
 
29259 
 
29260 
  def __repr__(self):
29261 
    L = ['%s=%r' % (key, value)
29262 
      for key, value in self.__dict__.iteritems()]
29263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29264 
 
29265 
  def __eq__(self, other):
29266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29267 
 
29268 
  def __ne__(self, other):
29269 
    return not (self == other)
6389 rajveer 29270 
 
29271 
class getAvailableEmiSchemes_args:
29272 
 
29273 
  thrift_spec = (
29274 
  )
29275 
 
29276 
  def read(self, iprot):
29277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29279 
      return
29280 
    iprot.readStructBegin()
29281 
    while True:
29282 
      (fname, ftype, fid) = iprot.readFieldBegin()
29283 
      if ftype == TType.STOP:
29284 
        break
29285 
      else:
29286 
        iprot.skip(ftype)
29287 
      iprot.readFieldEnd()
29288 
    iprot.readStructEnd()
29289 
 
29290 
  def write(self, oprot):
29291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29293 
      return
29294 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
29295 
    oprot.writeFieldStop()
29296 
    oprot.writeStructEnd()
29297 
 
29298 
  def validate(self):
29299 
    return
29300 
 
29301 
 
29302 
  def __repr__(self):
29303 
    L = ['%s=%r' % (key, value)
29304 
      for key, value in self.__dict__.iteritems()]
29305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29306 
 
29307 
  def __eq__(self, other):
29308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29309 
 
29310 
  def __ne__(self, other):
29311 
    return not (self == other)
29312 
 
29313 
class getAvailableEmiSchemes_result:
29314 
  """
29315 
  Attributes:
29316 
   - success
29317 
  """
29318 
 
29319 
  thrift_spec = (
29320 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
29321 
  )
29322 
 
29323 
  def __init__(self, success=None,):
29324 
    self.success = success
29325 
 
29326 
  def read(self, iprot):
29327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29329 
      return
29330 
    iprot.readStructBegin()
29331 
    while True:
29332 
      (fname, ftype, fid) = iprot.readFieldBegin()
29333 
      if ftype == TType.STOP:
29334 
        break
29335 
      if fid == 0:
29336 
        if ftype == TType.LIST:
29337 
          self.success = []
29338 
          (_etype710, _size707) = iprot.readListBegin()
29339 
          for _i711 in xrange(_size707):
29340 
            _elem712 = EmiScheme()
29341 
            _elem712.read(iprot)
29342 
            self.success.append(_elem712)
29343 
          iprot.readListEnd()
29344 
        else:
29345 
          iprot.skip(ftype)
29346 
      else:
29347 
        iprot.skip(ftype)
29348 
      iprot.readFieldEnd()
29349 
    iprot.readStructEnd()
29350 
 
29351 
  def write(self, oprot):
29352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29354 
      return
29355 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
29356 
    if self.success is not None:
29357 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29358 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29359 
      for iter713 in self.success:
29360 
        iter713.write(oprot)
29361 
      oprot.writeListEnd()
29362 
      oprot.writeFieldEnd()
29363 
    oprot.writeFieldStop()
29364 
    oprot.writeStructEnd()
29365 
 
29366 
  def validate(self):
29367 
    return
29368 
 
29369 
 
29370 
  def __repr__(self):
29371 
    L = ['%s=%r' % (key, value)
29372 
      for key, value in self.__dict__.iteritems()]
29373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29374 
 
29375 
  def __eq__(self, other):
29376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29377 
 
29378 
  def __ne__(self, other):
29379 
    return not (self == other)
29380 
 
29381 
class getMiscCharges_args:
29382 
  """
29383 
  Attributes:
29384 
   - transactionId
29385 
  """
29386 
 
29387 
  thrift_spec = (
29388 
    None, # 0
29389 
    (1, TType.I64, 'transactionId', None, None, ), # 1
29390 
  )
29391 
 
29392 
  def __init__(self, transactionId=None,):
29393 
    self.transactionId = transactionId
29394 
 
29395 
  def read(self, iprot):
29396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29398 
      return
29399 
    iprot.readStructBegin()
29400 
    while True:
29401 
      (fname, ftype, fid) = iprot.readFieldBegin()
29402 
      if ftype == TType.STOP:
29403 
        break
29404 
      if fid == 1:
29405 
        if ftype == TType.I64:
29406 
          self.transactionId = iprot.readI64();
29407 
        else:
29408 
          iprot.skip(ftype)
29409 
      else:
29410 
        iprot.skip(ftype)
29411 
      iprot.readFieldEnd()
29412 
    iprot.readStructEnd()
29413 
 
29414 
  def write(self, oprot):
29415 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29416 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29417 
      return
29418 
    oprot.writeStructBegin('getMiscCharges_args')
29419 
    if self.transactionId is not None:
29420 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
29421 
      oprot.writeI64(self.transactionId)
29422 
      oprot.writeFieldEnd()
29423 
    oprot.writeFieldStop()
29424 
    oprot.writeStructEnd()
29425 
 
29426 
  def validate(self):
29427 
    return
29428 
 
29429 
 
29430 
  def __repr__(self):
29431 
    L = ['%s=%r' % (key, value)
29432 
      for key, value in self.__dict__.iteritems()]
29433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29434 
 
29435 
  def __eq__(self, other):
29436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29437 
 
29438 
  def __ne__(self, other):
29439 
    return not (self == other)
29440 
 
29441 
class getMiscCharges_result:
29442 
  """
29443 
  Attributes:
29444 
   - success
29445 
  """
29446 
 
29447 
  thrift_spec = (
6412 rajveer 29448 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 29449 
  )
29450 
 
29451 
  def __init__(self, success=None,):
29452 
    self.success = success
29453 
 
29454 
  def read(self, iprot):
29455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29457 
      return
29458 
    iprot.readStructBegin()
29459 
    while True:
29460 
      (fname, ftype, fid) = iprot.readFieldBegin()
29461 
      if ftype == TType.STOP:
29462 
        break
29463 
      if fid == 0:
29464 
        if ftype == TType.MAP:
29465 
          self.success = {}
29466 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
29467 
          for _i718 in xrange(_size714):
29468 
            _key719 = iprot.readI64();
6412 rajveer 29469 
            _val720 = iprot.readDouble();
6389 rajveer 29470 
            self.success[_key719] = _val720
29471 
          iprot.readMapEnd()
29472 
        else:
29473 
          iprot.skip(ftype)
29474 
      else:
29475 
        iprot.skip(ftype)
29476 
      iprot.readFieldEnd()
29477 
    iprot.readStructEnd()
29478 
 
29479 
  def write(self, oprot):
29480 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29481 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29482 
      return
29483 
    oprot.writeStructBegin('getMiscCharges_result')
29484 
    if self.success is not None:
29485 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 29486 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 29487 
      for kiter721,viter722 in self.success.items():
29488 
        oprot.writeI64(kiter721)
6412 rajveer 29489 
        oprot.writeDouble(viter722)
6389 rajveer 29490 
      oprot.writeMapEnd()
29491 
      oprot.writeFieldEnd()
29492 
    oprot.writeFieldStop()
29493 
    oprot.writeStructEnd()
29494 
 
29495 
  def validate(self):
29496 
    return
29497 
 
29498 
 
29499 
  def __repr__(self):
29500 
    L = ['%s=%r' % (key, value)
29501 
      for key, value in self.__dict__.iteritems()]
29502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29503 
 
29504 
  def __eq__(self, other):
29505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29506 
 
29507 
  def __ne__(self, other):
29508 
    return not (self == other)
6507 anupam.sin 29509 
 
29510 
class refundRechargeOrder_args:
29511 
  """
29512 
  Attributes:
29513 
   - rechargeOrderId
29514 
  """
29515 
 
29516 
  thrift_spec = (
29517 
    None, # 0
29518 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
29519 
  )
29520 
 
29521 
  def __init__(self, rechargeOrderId=None,):
29522 
    self.rechargeOrderId = rechargeOrderId
29523 
 
29524 
  def read(self, iprot):
29525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29527 
      return
29528 
    iprot.readStructBegin()
29529 
    while True:
29530 
      (fname, ftype, fid) = iprot.readFieldBegin()
29531 
      if ftype == TType.STOP:
29532 
        break
29533 
      if fid == 1:
29534 
        if ftype == TType.I64:
29535 
          self.rechargeOrderId = iprot.readI64();
29536 
        else:
29537 
          iprot.skip(ftype)
29538 
      else:
29539 
        iprot.skip(ftype)
29540 
      iprot.readFieldEnd()
29541 
    iprot.readStructEnd()
29542 
 
29543 
  def write(self, oprot):
29544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29546 
      return
29547 
    oprot.writeStructBegin('refundRechargeOrder_args')
29548 
    if self.rechargeOrderId is not None:
29549 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
29550 
      oprot.writeI64(self.rechargeOrderId)
29551 
      oprot.writeFieldEnd()
29552 
    oprot.writeFieldStop()
29553 
    oprot.writeStructEnd()
29554 
 
29555 
  def validate(self):
29556 
    return
29557 
 
29558 
 
29559 
  def __repr__(self):
29560 
    L = ['%s=%r' % (key, value)
29561 
      for key, value in self.__dict__.iteritems()]
29562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29563 
 
29564 
  def __eq__(self, other):
29565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29566 
 
29567 
  def __ne__(self, other):
29568 
    return not (self == other)
29569 
 
29570 
class refundRechargeOrder_result:
29571 
  """
29572 
  Attributes:
29573 
   - success
29574 
   - ex
29575 
  """
29576 
 
29577 
  thrift_spec = (
29578 
    (0, TType.BOOL, 'success', None, None, ), # 0
29579 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29580 
  )
29581 
 
29582 
  def __init__(self, success=None, ex=None,):
29583 
    self.success = success
29584 
    self.ex = ex
29585 
 
29586 
  def read(self, iprot):
29587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29589 
      return
29590 
    iprot.readStructBegin()
29591 
    while True:
29592 
      (fname, ftype, fid) = iprot.readFieldBegin()
29593 
      if ftype == TType.STOP:
29594 
        break
29595 
      if fid == 0:
29596 
        if ftype == TType.BOOL:
29597 
          self.success = iprot.readBool();
29598 
        else:
29599 
          iprot.skip(ftype)
29600 
      elif fid == 1:
29601 
        if ftype == TType.STRUCT:
29602 
          self.ex = TransactionServiceException()
29603 
          self.ex.read(iprot)
29604 
        else:
29605 
          iprot.skip(ftype)
29606 
      else:
29607 
        iprot.skip(ftype)
29608 
      iprot.readFieldEnd()
29609 
    iprot.readStructEnd()
29610 
 
29611 
  def write(self, oprot):
29612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29614 
      return
29615 
    oprot.writeStructBegin('refundRechargeOrder_result')
29616 
    if self.success is not None:
29617 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
29618 
      oprot.writeBool(self.success)
29619 
      oprot.writeFieldEnd()
29620 
    if self.ex is not None:
29621 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29622 
      self.ex.write(oprot)
29623 
      oprot.writeFieldEnd()
29624 
    oprot.writeFieldStop()
29625 
    oprot.writeStructEnd()
29626 
 
29627 
  def validate(self):
29628 
    return
29629 
 
29630 
 
29631 
  def __repr__(self):
29632 
    L = ['%s=%r' % (key, value)
29633 
      for key, value in self.__dict__.iteritems()]
29634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29635 
 
29636 
  def __eq__(self, other):
29637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29638 
 
29639 
  def __ne__(self, other):
29640 
    return not (self == other)
6821 amar.kumar 29641 
 
29642 
class getPhysicalOrders_args:
29643 
  """
29644 
  Attributes:
29645 
   - fromDate
29646 
   - toDate
29647 
  """
29648 
 
29649 
  thrift_spec = (
29650 
    None, # 0
29651 
    (1, TType.I64, 'fromDate', None, None, ), # 1
29652 
    (2, TType.I64, 'toDate', None, None, ), # 2
29653 
  )
29654 
 
29655 
  def __init__(self, fromDate=None, toDate=None,):
29656 
    self.fromDate = fromDate
29657 
    self.toDate = toDate
29658 
 
29659 
  def read(self, iprot):
29660 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29661 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29662 
      return
29663 
    iprot.readStructBegin()
29664 
    while True:
29665 
      (fname, ftype, fid) = iprot.readFieldBegin()
29666 
      if ftype == TType.STOP:
29667 
        break
29668 
      if fid == 1:
29669 
        if ftype == TType.I64:
29670 
          self.fromDate = iprot.readI64();
29671 
        else:
29672 
          iprot.skip(ftype)
29673 
      elif fid == 2:
29674 
        if ftype == TType.I64:
29675 
          self.toDate = iprot.readI64();
29676 
        else:
29677 
          iprot.skip(ftype)
29678 
      else:
29679 
        iprot.skip(ftype)
29680 
      iprot.readFieldEnd()
29681 
    iprot.readStructEnd()
29682 
 
29683 
  def write(self, oprot):
29684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29686 
      return
29687 
    oprot.writeStructBegin('getPhysicalOrders_args')
29688 
    if self.fromDate is not None:
29689 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
29690 
      oprot.writeI64(self.fromDate)
29691 
      oprot.writeFieldEnd()
29692 
    if self.toDate is not None:
29693 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
29694 
      oprot.writeI64(self.toDate)
29695 
      oprot.writeFieldEnd()
29696 
    oprot.writeFieldStop()
29697 
    oprot.writeStructEnd()
29698 
 
29699 
  def validate(self):
29700 
    return
29701 
 
29702 
 
29703 
  def __repr__(self):
29704 
    L = ['%s=%r' % (key, value)
29705 
      for key, value in self.__dict__.iteritems()]
29706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29707 
 
29708 
  def __eq__(self, other):
29709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29710 
 
29711 
  def __ne__(self, other):
29712 
    return not (self == other)
29713 
 
29714 
class getPhysicalOrders_result:
29715 
  """
29716 
  Attributes:
29717 
   - success
29718 
  """
29719 
 
29720 
  thrift_spec = (
29721 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
29722 
  )
29723 
 
29724 
  def __init__(self, success=None,):
29725 
    self.success = success
29726 
 
29727 
  def read(self, iprot):
29728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29730 
      return
29731 
    iprot.readStructBegin()
29732 
    while True:
29733 
      (fname, ftype, fid) = iprot.readFieldBegin()
29734 
      if ftype == TType.STOP:
29735 
        break
29736 
      if fid == 0:
29737 
        if ftype == TType.LIST:
29738 
          self.success = []
29739 
          (_etype726, _size723) = iprot.readListBegin()
29740 
          for _i727 in xrange(_size723):
29741 
            _elem728 = Order()
29742 
            _elem728.read(iprot)
29743 
            self.success.append(_elem728)
29744 
          iprot.readListEnd()
29745 
        else:
29746 
          iprot.skip(ftype)
29747 
      else:
29748 
        iprot.skip(ftype)
29749 
      iprot.readFieldEnd()
29750 
    iprot.readStructEnd()
29751 
 
29752 
  def write(self, oprot):
29753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29755 
      return
29756 
    oprot.writeStructBegin('getPhysicalOrders_result')
29757 
    if self.success is not None:
29758 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29759 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29760 
      for iter729 in self.success:
29761 
        iter729.write(oprot)
29762 
      oprot.writeListEnd()
29763 
      oprot.writeFieldEnd()
29764 
    oprot.writeFieldStop()
29765 
    oprot.writeStructEnd()
29766 
 
29767 
  def validate(self):
29768 
    return
29769 
 
29770 
 
29771 
  def __repr__(self):
29772 
    L = ['%s=%r' % (key, value)
29773 
      for key, value in self.__dict__.iteritems()]
29774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29775 
 
29776 
  def __eq__(self, other):
29777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29778 
 
29779 
  def __ne__(self, other):
29780 
    return not (self == other)
6906 rajveer 29781 
 
29782 
class getDocument_args:
29783 
  """
29784 
  Attributes:
29785 
   - docType
29786 
   - docSource
29787 
  """
29788 
 
29789 
  thrift_spec = (
29790 
    None, # 0
29791 
    (1, TType.I64, 'docType', None, None, ), # 1
29792 
    (2, TType.I64, 'docSource', None, None, ), # 2
29793 
  )
29794 
 
29795 
  def __init__(self, docType=None, docSource=None,):
29796 
    self.docType = docType
29797 
    self.docSource = docSource
29798 
 
29799 
  def read(self, iprot):
29800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29802 
      return
29803 
    iprot.readStructBegin()
29804 
    while True:
29805 
      (fname, ftype, fid) = iprot.readFieldBegin()
29806 
      if ftype == TType.STOP:
29807 
        break
29808 
      if fid == 1:
29809 
        if ftype == TType.I64:
29810 
          self.docType = iprot.readI64();
29811 
        else:
29812 
          iprot.skip(ftype)
29813 
      elif fid == 2:
29814 
        if ftype == TType.I64:
29815 
          self.docSource = iprot.readI64();
29816 
        else:
29817 
          iprot.skip(ftype)
29818 
      else:
29819 
        iprot.skip(ftype)
29820 
      iprot.readFieldEnd()
29821 
    iprot.readStructEnd()
29822 
 
29823 
  def write(self, oprot):
29824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29826 
      return
29827 
    oprot.writeStructBegin('getDocument_args')
29828 
    if self.docType is not None:
29829 
      oprot.writeFieldBegin('docType', TType.I64, 1)
29830 
      oprot.writeI64(self.docType)
29831 
      oprot.writeFieldEnd()
29832 
    if self.docSource is not None:
29833 
      oprot.writeFieldBegin('docSource', TType.I64, 2)
29834 
      oprot.writeI64(self.docSource)
29835 
      oprot.writeFieldEnd()
29836 
    oprot.writeFieldStop()
29837 
    oprot.writeStructEnd()
29838 
 
29839 
  def validate(self):
29840 
    return
29841 
 
29842 
 
29843 
  def __repr__(self):
29844 
    L = ['%s=%r' % (key, value)
29845 
      for key, value in self.__dict__.iteritems()]
29846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29847 
 
29848 
  def __eq__(self, other):
29849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29850 
 
29851 
  def __ne__(self, other):
29852 
    return not (self == other)
29853 
 
29854 
class getDocument_result:
29855 
  """
29856 
  Attributes:
29857 
   - success
29858 
  """
29859 
 
29860 
  thrift_spec = (
29861 
    (0, TType.STRING, 'success', None, None, ), # 0
29862 
  )
29863 
 
29864 
  def __init__(self, success=None,):
29865 
    self.success = success
29866 
 
29867 
  def read(self, iprot):
29868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29870 
      return
29871 
    iprot.readStructBegin()
29872 
    while True:
29873 
      (fname, ftype, fid) = iprot.readFieldBegin()
29874 
      if ftype == TType.STOP:
29875 
        break
29876 
      if fid == 0:
29877 
        if ftype == TType.STRING:
29878 
          self.success = iprot.readString();
29879 
        else:
29880 
          iprot.skip(ftype)
29881 
      else:
29882 
        iprot.skip(ftype)
29883 
      iprot.readFieldEnd()
29884 
    iprot.readStructEnd()
29885 
 
29886 
  def write(self, oprot):
29887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29889 
      return
29890 
    oprot.writeStructBegin('getDocument_result')
29891 
    if self.success is not None:
29892 
      oprot.writeFieldBegin('success', TType.STRING, 0)
29893 
      oprot.writeString(self.success)
29894 
      oprot.writeFieldEnd()
29895 
    oprot.writeFieldStop()
29896 
    oprot.writeStructEnd()
29897 
 
29898 
  def validate(self):
29899 
    return
29900 
 
29901 
 
29902 
  def __repr__(self):
29903 
    L = ['%s=%r' % (key, value)
29904 
      for key, value in self.__dict__.iteritems()]
29905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29906 
 
29907 
  def __eq__(self, other):
29908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29909 
 
29910 
  def __ne__(self, other):
29911 
    return not (self == other)
6985 anupam.sin 29912 
 
29913 
class changeShippingAddress_args:
29914 
  """
29915 
  Attributes:
29916 
   - orderId
29917 
   - line1
29918 
   - line2
29919 
   - city
29920 
   - state
29921 
   - pin
29922 
  """
29923 
 
29924 
  thrift_spec = (
29925 
    None, # 0
29926 
    (1, TType.I64, 'orderId', None, None, ), # 1
29927 
    (2, TType.STRING, 'line1', None, None, ), # 2
29928 
    (3, TType.STRING, 'line2', None, None, ), # 3
29929 
    (4, TType.STRING, 'city', None, None, ), # 4
29930 
    (5, TType.STRING, 'state', None, None, ), # 5
29931 
    (6, TType.STRING, 'pin', None, None, ), # 6
29932 
  )
29933 
 
29934 
  def __init__(self, orderId=None, line1=None, line2=None, city=None, state=None, pin=None,):
29935 
    self.orderId = orderId
29936 
    self.line1 = line1
29937 
    self.line2 = line2
29938 
    self.city = city
29939 
    self.state = state
29940 
    self.pin = pin
29941 
 
29942 
  def read(self, iprot):
29943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29945 
      return
29946 
    iprot.readStructBegin()
29947 
    while True:
29948 
      (fname, ftype, fid) = iprot.readFieldBegin()
29949 
      if ftype == TType.STOP:
29950 
        break
29951 
      if fid == 1:
29952 
        if ftype == TType.I64:
29953 
          self.orderId = iprot.readI64();
29954 
        else:
29955 
          iprot.skip(ftype)
29956 
      elif fid == 2:
29957 
        if ftype == TType.STRING:
29958 
          self.line1 = iprot.readString();
29959 
        else:
29960 
          iprot.skip(ftype)
29961 
      elif fid == 3:
29962 
        if ftype == TType.STRING:
29963 
          self.line2 = iprot.readString();
29964 
        else:
29965 
          iprot.skip(ftype)
29966 
      elif fid == 4:
29967 
        if ftype == TType.STRING:
29968 
          self.city = iprot.readString();
29969 
        else:
29970 
          iprot.skip(ftype)
29971 
      elif fid == 5:
29972 
        if ftype == TType.STRING:
29973 
          self.state = iprot.readString();
29974 
        else:
29975 
          iprot.skip(ftype)
29976 
      elif fid == 6:
29977 
        if ftype == TType.STRING:
29978 
          self.pin = iprot.readString();
29979 
        else:
29980 
          iprot.skip(ftype)
29981 
      else:
29982 
        iprot.skip(ftype)
29983 
      iprot.readFieldEnd()
29984 
    iprot.readStructEnd()
29985 
 
29986 
  def write(self, oprot):
29987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29989 
      return
29990 
    oprot.writeStructBegin('changeShippingAddress_args')
29991 
    if self.orderId is not None:
29992 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
29993 
      oprot.writeI64(self.orderId)
29994 
      oprot.writeFieldEnd()
29995 
    if self.line1 is not None:
29996 
      oprot.writeFieldBegin('line1', TType.STRING, 2)
29997 
      oprot.writeString(self.line1)
29998 
      oprot.writeFieldEnd()
29999 
    if self.line2 is not None:
30000 
      oprot.writeFieldBegin('line2', TType.STRING, 3)
30001 
      oprot.writeString(self.line2)
30002 
      oprot.writeFieldEnd()
30003 
    if self.city is not None:
30004 
      oprot.writeFieldBegin('city', TType.STRING, 4)
30005 
      oprot.writeString(self.city)
30006 
      oprot.writeFieldEnd()
30007 
    if self.state is not None:
30008 
      oprot.writeFieldBegin('state', TType.STRING, 5)
30009 
      oprot.writeString(self.state)
30010 
      oprot.writeFieldEnd()
30011 
    if self.pin is not None:
30012 
      oprot.writeFieldBegin('pin', TType.STRING, 6)
30013 
      oprot.writeString(self.pin)
30014 
      oprot.writeFieldEnd()
30015 
    oprot.writeFieldStop()
30016 
    oprot.writeStructEnd()
30017 
 
30018 
  def validate(self):
30019 
    return
30020 
 
30021 
 
30022 
  def __repr__(self):
30023 
    L = ['%s=%r' % (key, value)
30024 
      for key, value in self.__dict__.iteritems()]
30025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30026 
 
30027 
  def __eq__(self, other):
30028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30029 
 
30030 
  def __ne__(self, other):
30031 
    return not (self == other)
30032 
 
30033 
class changeShippingAddress_result:
30034 
  """
30035 
  Attributes:
30036 
   - success
30037 
  """
30038 
 
30039 
  thrift_spec = (
30040 
    (0, TType.BOOL, 'success', None, None, ), # 0
30041 
  )
30042 
 
30043 
  def __init__(self, success=None,):
30044 
    self.success = success
30045 
 
30046 
  def read(self, iprot):
30047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
30048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
30049 
      return
30050 
    iprot.readStructBegin()
30051 
    while True:
30052 
      (fname, ftype, fid) = iprot.readFieldBegin()
30053 
      if ftype == TType.STOP:
30054 
        break
30055 
      if fid == 0:
30056 
        if ftype == TType.BOOL:
30057 
          self.success = iprot.readBool();
30058 
        else:
30059 
          iprot.skip(ftype)
30060 
      else:
30061 
        iprot.skip(ftype)
30062 
      iprot.readFieldEnd()
30063 
    iprot.readStructEnd()
30064 
 
30065 
  def write(self, oprot):
30066 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
30067 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
30068 
      return
30069 
    oprot.writeStructBegin('changeShippingAddress_result')
30070 
    if self.success is not None:
30071 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
30072 
      oprot.writeBool(self.success)
30073 
      oprot.writeFieldEnd()
30074 
    oprot.writeFieldStop()
30075 
    oprot.writeStructEnd()
30076 
 
30077 
  def validate(self):
30078 
    return
30079 
 
30080 
 
30081 
  def __repr__(self):
30082 
    L = ['%s=%r' % (key, value)
30083 
      for key, value in self.__dict__.iteritems()]
30084 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
30085 
 
30086 
  def __eq__(self, other):
30087 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
30088 
 
30089 
  def __ne__(self, other):
30090 
    return not (self == other)