Subversion Repositories SmartDukaan

Rev

Rev 6821 | Rev 6985 | 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 
 
6906 rajveer 1463 
 
3376 rajveer 1464 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 1465 
  def __init__(self, iprot, oprot=None):
3376 rajveer 1466 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 1467 
 
1468 
  def createTransaction(self, transaction):
1469 
    """
1470 
    Parameters:
1471 
     - transaction
1472 
    """
1473 
    self.send_createTransaction(transaction)
132 ashish 1474 
    return self.recv_createTransaction()
94 ashish 1475 
 
1476 
  def send_createTransaction(self, transaction):
1477 
    self._oprot.writeMessageBegin('createTransaction', TMessageType.CALL, self._seqid)
1478 
    args = createTransaction_args()
1479 
    args.transaction = transaction
1480 
    args.write(self._oprot)
1481 
    self._oprot.writeMessageEnd()
1482 
    self._oprot.trans.flush()
1483 
 
1484 
  def recv_createTransaction(self, ):
1485 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1486 
    if mtype == TMessageType.EXCEPTION:
1487 
      x = TApplicationException()
1488 
      x.read(self._iprot)
1489 
      self._iprot.readMessageEnd()
1490 
      raise x
1491 
    result = createTransaction_result()
1492 
    result.read(self._iprot)
1493 
    self._iprot.readMessageEnd()
3431 rajveer 1494 
    if result.success is not None:
132 ashish 1495 
      return result.success
3431 rajveer 1496 
    if result.ex is not None:
94 ashish 1497 
      raise result.ex
132 ashish 1498 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
94 ashish 1499 
 
1500 
  def getTransaction(self, id):
1501 
    """
1502 
    Parameters:
1503 
     - id
1504 
    """
1505 
    self.send_getTransaction(id)
1506 
    return self.recv_getTransaction()
1507 
 
1508 
  def send_getTransaction(self, id):
1509 
    self._oprot.writeMessageBegin('getTransaction', TMessageType.CALL, self._seqid)
1510 
    args = getTransaction_args()
1511 
    args.id = id
1512 
    args.write(self._oprot)
1513 
    self._oprot.writeMessageEnd()
1514 
    self._oprot.trans.flush()
1515 
 
1516 
  def recv_getTransaction(self, ):
1517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1518 
    if mtype == TMessageType.EXCEPTION:
1519 
      x = TApplicationException()
1520 
      x.read(self._iprot)
1521 
      self._iprot.readMessageEnd()
1522 
      raise x
1523 
    result = getTransaction_result()
1524 
    result.read(self._iprot)
1525 
    self._iprot.readMessageEnd()
3431 rajveer 1526 
    if result.success is not None:
94 ashish 1527 
      return result.success
3431 rajveer 1528 
    if result.ex is not None:
94 ashish 1529 
      raise result.ex
1530 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
1531 
 
1532 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1533 
    """
1534 
    Parameters:
1535 
     - customerId
1536 
     - from_date
1537 
     - to_date
1538 
     - status
1539 
    """
1540 
    self.send_getTransactionsForCustomer(customerId, from_date, to_date, status)
1541 
    return self.recv_getTransactionsForCustomer()
1542 
 
1543 
  def send_getTransactionsForCustomer(self, customerId, from_date, to_date, status):
1544 
    self._oprot.writeMessageBegin('getTransactionsForCustomer', TMessageType.CALL, self._seqid)
1545 
    args = getTransactionsForCustomer_args()
1546 
    args.customerId = customerId
1547 
    args.from_date = from_date
1548 
    args.to_date = to_date
1549 
    args.status = status
1550 
    args.write(self._oprot)
1551 
    self._oprot.writeMessageEnd()
1552 
    self._oprot.trans.flush()
1553 
 
1554 
  def recv_getTransactionsForCustomer(self, ):
1555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1556 
    if mtype == TMessageType.EXCEPTION:
1557 
      x = TApplicationException()
1558 
      x.read(self._iprot)
1559 
      self._iprot.readMessageEnd()
1560 
      raise x
1561 
    result = getTransactionsForCustomer_result()
1562 
    result.read(self._iprot)
1563 
    self._iprot.readMessageEnd()
3431 rajveer 1564 
    if result.success is not None:
94 ashish 1565 
      return result.success
3431 rajveer 1566 
    if result.ex is not None:
94 ashish 1567 
      raise result.ex
1568 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
1569 
 
132 ashish 1570 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
1571 
    """
1572 
    Parameters:
1573 
     - shoppingCartId
1574 
    """
1575 
    self.send_getTransactionsForShoppingCartId(shoppingCartId)
1576 
    return self.recv_getTransactionsForShoppingCartId()
1577 
 
1578 
  def send_getTransactionsForShoppingCartId(self, shoppingCartId):
1579 
    self._oprot.writeMessageBegin('getTransactionsForShoppingCartId', TMessageType.CALL, self._seqid)
1580 
    args = getTransactionsForShoppingCartId_args()
1581 
    args.shoppingCartId = shoppingCartId
1582 
    args.write(self._oprot)
1583 
    self._oprot.writeMessageEnd()
1584 
    self._oprot.trans.flush()
1585 
 
1586 
  def recv_getTransactionsForShoppingCartId(self, ):
1587 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1588 
    if mtype == TMessageType.EXCEPTION:
1589 
      x = TApplicationException()
1590 
      x.read(self._iprot)
1591 
      self._iprot.readMessageEnd()
1592 
      raise x
1593 
    result = getTransactionsForShoppingCartId_result()
1594 
    result.read(self._iprot)
1595 
    self._iprot.readMessageEnd()
3431 rajveer 1596 
    if result.success is not None:
132 ashish 1597 
      return result.success
3431 rajveer 1598 
    if result.ex is not None:
132 ashish 1599 
      raise result.ex
1600 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
1601 
 
94 ashish 1602 
  def getTransactionStatus(self, transactionId):
1603 
    """
1604 
    Parameters:
1605 
     - transactionId
1606 
    """
1607 
    self.send_getTransactionStatus(transactionId)
1608 
    return self.recv_getTransactionStatus()
1609 
 
1610 
  def send_getTransactionStatus(self, transactionId):
1611 
    self._oprot.writeMessageBegin('getTransactionStatus', TMessageType.CALL, self._seqid)
1612 
    args = getTransactionStatus_args()
1613 
    args.transactionId = transactionId
1614 
    args.write(self._oprot)
1615 
    self._oprot.writeMessageEnd()
1616 
    self._oprot.trans.flush()
1617 
 
1618 
  def recv_getTransactionStatus(self, ):
1619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1620 
    if mtype == TMessageType.EXCEPTION:
1621 
      x = TApplicationException()
1622 
      x.read(self._iprot)
1623 
      self._iprot.readMessageEnd()
1624 
      raise x
1625 
    result = getTransactionStatus_result()
1626 
    result.read(self._iprot)
1627 
    self._iprot.readMessageEnd()
3431 rajveer 1628 
    if result.success is not None:
94 ashish 1629 
      return result.success
3431 rajveer 1630 
    if result.ex is not None:
94 ashish 1631 
      raise result.ex
1632 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
1633 
 
5527 anupam.sin 1634 
  def changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1635 
    """
1636 
    Parameters:
1637 
     - transactionId
1638 
     - status
1639 
     - description
5527 anupam.sin 1640 
     - pickUp
1641 
     - orderType
94 ashish 1642 
    """
5527 anupam.sin 1643 
    self.send_changeTransactionStatus(transactionId, status, description, pickUp, orderType)
94 ashish 1644 
    return self.recv_changeTransactionStatus()
1645 
 
5527 anupam.sin 1646 
  def send_changeTransactionStatus(self, transactionId, status, description, pickUp, orderType):
94 ashish 1647 
    self._oprot.writeMessageBegin('changeTransactionStatus', TMessageType.CALL, self._seqid)
1648 
    args = changeTransactionStatus_args()
1649 
    args.transactionId = transactionId
1650 
    args.status = status
1651 
    args.description = description
5527 anupam.sin 1652 
    args.pickUp = pickUp
1653 
    args.orderType = orderType
94 ashish 1654 
    args.write(self._oprot)
1655 
    self._oprot.writeMessageEnd()
1656 
    self._oprot.trans.flush()
1657 
 
1658 
  def recv_changeTransactionStatus(self, ):
1659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1660 
    if mtype == TMessageType.EXCEPTION:
1661 
      x = TApplicationException()
1662 
      x.read(self._iprot)
1663 
      self._iprot.readMessageEnd()
1664 
      raise x
1665 
    result = changeTransactionStatus_result()
1666 
    result.read(self._iprot)
1667 
    self._iprot.readMessageEnd()
3431 rajveer 1668 
    if result.success is not None:
94 ashish 1669 
      return result.success
3431 rajveer 1670 
    if result.ex is not None:
94 ashish 1671 
      raise result.ex
1672 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
1673 
 
1398 varun.gupt 1674 
  def enqueueTransactionInfoEmail(self, transactionId):
1382 varun.gupt 1675 
    """
1676 
    Parameters:
1677 
     - transactionId
1678 
    """
1398 varun.gupt 1679 
    self.send_enqueueTransactionInfoEmail(transactionId)
1680 
    return self.recv_enqueueTransactionInfoEmail()
1382 varun.gupt 1681 
 
1398 varun.gupt 1682 
  def send_enqueueTransactionInfoEmail(self, transactionId):
1683 
    self._oprot.writeMessageBegin('enqueueTransactionInfoEmail', TMessageType.CALL, self._seqid)
1684 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 1685 
    args.transactionId = transactionId
1686 
    args.write(self._oprot)
1687 
    self._oprot.writeMessageEnd()
1688 
    self._oprot.trans.flush()
1689 
 
1398 varun.gupt 1690 
  def recv_enqueueTransactionInfoEmail(self, ):
1382 varun.gupt 1691 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1692 
    if mtype == TMessageType.EXCEPTION:
1693 
      x = TApplicationException()
1694 
      x.read(self._iprot)
1695 
      self._iprot.readMessageEnd()
1696 
      raise x
1398 varun.gupt 1697 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 1698 
    result.read(self._iprot)
1699 
    self._iprot.readMessageEnd()
3431 rajveer 1700 
    if result.success is not None:
1382 varun.gupt 1701 
      return result.success
3431 rajveer 1702 
    if result.ex is not None:
1382 varun.gupt 1703 
      raise result.ex
1398 varun.gupt 1704 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
1382 varun.gupt 1705 
 
4801 anupam.sin 1706 
  def getAllOrders(self, statuses, from_date, to_date, warehouse_id):
94 ashish 1707 
    """
1708 
    Parameters:
4801 anupam.sin 1709 
     - statuses
483 rajveer 1710 
     - from_date
1711 
     - to_date
1712 
     - warehouse_id
94 ashish 1713 
    """
4801 anupam.sin 1714 
    self.send_getAllOrders(statuses, from_date, to_date, warehouse_id)
483 rajveer 1715 
    return self.recv_getAllOrders()
94 ashish 1716 
 
4801 anupam.sin 1717 
  def send_getAllOrders(self, statuses, from_date, to_date, warehouse_id):
483 rajveer 1718 
    self._oprot.writeMessageBegin('getAllOrders', TMessageType.CALL, self._seqid)
1719 
    args = getAllOrders_args()
4801 anupam.sin 1720 
    args.statuses = statuses
483 rajveer 1721 
    args.from_date = from_date
1722 
    args.to_date = to_date
1723 
    args.warehouse_id = warehouse_id
94 ashish 1724 
    args.write(self._oprot)
1725 
    self._oprot.writeMessageEnd()
1726 
    self._oprot.trans.flush()
1727 
 
483 rajveer 1728 
  def recv_getAllOrders(self, ):
94 ashish 1729 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1730 
    if mtype == TMessageType.EXCEPTION:
1731 
      x = TApplicationException()
1732 
      x.read(self._iprot)
1733 
      self._iprot.readMessageEnd()
1734 
      raise x
483 rajveer 1735 
    result = getAllOrders_result()
94 ashish 1736 
    result.read(self._iprot)
1737 
    self._iprot.readMessageEnd()
3431 rajveer 1738 
    if result.success is not None:
94 ashish 1739 
      return result.success
3431 rajveer 1740 
    if result.ex is not None:
94 ashish 1741 
      raise result.ex
483 rajveer 1742 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
94 ashish 1743 
 
4133 chandransh 1744 
  def getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1745 
    """
1746 
    Returns at most 'limit' orders with the given statuses for the given warehouse starting from the given offset.
1747 
    Pass the status as null and the limit as 0 to ignore them.
1748 
 
1749 
    Parameters:
1750 
     - statuses
1751 
     - offset
1752 
     - limit
1753 
     - warehouse_id
1754 
    """
1755 
    self.send_getOrdersInBatch(statuses, offset, limit, warehouse_id)
1756 
    return self.recv_getOrdersInBatch()
1757 
 
1758 
  def send_getOrdersInBatch(self, statuses, offset, limit, warehouse_id):
1759 
    self._oprot.writeMessageBegin('getOrdersInBatch', TMessageType.CALL, self._seqid)
1760 
    args = getOrdersInBatch_args()
1761 
    args.statuses = statuses
1762 
    args.offset = offset
1763 
    args.limit = limit
1764 
    args.warehouse_id = warehouse_id
1765 
    args.write(self._oprot)
1766 
    self._oprot.writeMessageEnd()
1767 
    self._oprot.trans.flush()
1768 
 
1769 
  def recv_getOrdersInBatch(self, ):
1770 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1771 
    if mtype == TMessageType.EXCEPTION:
1772 
      x = TApplicationException()
1773 
      x.read(self._iprot)
1774 
      self._iprot.readMessageEnd()
1775 
      raise x
1776 
    result = getOrdersInBatch_result()
1777 
    result.read(self._iprot)
1778 
    self._iprot.readMessageEnd()
1779 
    if result.success is not None:
1780 
      return result.success
1781 
    if result.ex is not None:
1782 
      raise result.ex
1783 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersInBatch failed: unknown result");
1784 
 
1785 
  def getOrderCount(self, statuses, warehouseId):
1786 
    """
1787 
    Returns the count of orders with the given statuses assigned to the given warehouse.
1788 
 
1789 
    Parameters:
1790 
     - statuses
1791 
     - warehouseId
1792 
    """
1793 
    self.send_getOrderCount(statuses, warehouseId)
1794 
    return self.recv_getOrderCount()
1795 
 
1796 
  def send_getOrderCount(self, statuses, warehouseId):
1797 
    self._oprot.writeMessageBegin('getOrderCount', TMessageType.CALL, self._seqid)
1798 
    args = getOrderCount_args()
1799 
    args.statuses = statuses
1800 
    args.warehouseId = warehouseId
1801 
    args.write(self._oprot)
1802 
    self._oprot.writeMessageEnd()
1803 
    self._oprot.trans.flush()
1804 
 
1805 
  def recv_getOrderCount(self, ):
1806 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1807 
    if mtype == TMessageType.EXCEPTION:
1808 
      x = TApplicationException()
1809 
      x.read(self._iprot)
1810 
      self._iprot.readMessageEnd()
1811 
      raise x
1812 
    result = getOrderCount_result()
1813 
    result.read(self._iprot)
1814 
    self._iprot.readMessageEnd()
1815 
    if result.success is not None:
1816 
      return result.success
1817 
    if result.ex is not None:
1818 
      raise result.ex
1819 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderCount failed: unknown result");
1820 
 
999 varun.gupt 1821 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1822 
    """
1132 chandransh 1823 
    Returns orders within a range of their billing dates
3431 rajveer 1824 
 
999 varun.gupt 1825 
    Parameters:
1826 
     - status
1827 
     - start_billing_date
1828 
     - end_billing_date
1829 
     - warehouse_id
1830 
    """
1831 
    self.send_getOrdersByBillingDate(status, start_billing_date, end_billing_date, warehouse_id)
1832 
    return self.recv_getOrdersByBillingDate()
1833 
 
1834 
  def send_getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
1835 
    self._oprot.writeMessageBegin('getOrdersByBillingDate', TMessageType.CALL, self._seqid)
1836 
    args = getOrdersByBillingDate_args()
1837 
    args.status = status
1838 
    args.start_billing_date = start_billing_date
1839 
    args.end_billing_date = end_billing_date
1840 
    args.warehouse_id = warehouse_id
1841 
    args.write(self._oprot)
1842 
    self._oprot.writeMessageEnd()
1843 
    self._oprot.trans.flush()
1844 
 
1845 
  def recv_getOrdersByBillingDate(self, ):
1846 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1847 
    if mtype == TMessageType.EXCEPTION:
1848 
      x = TApplicationException()
1849 
      x.read(self._iprot)
1850 
      self._iprot.readMessageEnd()
1851 
      raise x
1852 
    result = getOrdersByBillingDate_result()
1853 
    result.read(self._iprot)
1854 
    self._iprot.readMessageEnd()
3431 rajveer 1855 
    if result.success is not None:
999 varun.gupt 1856 
      return result.success
3431 rajveer 1857 
    if result.ex is not None:
999 varun.gupt 1858 
      raise result.ex
1859 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
1860 
 
3451 chandransh 1861 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1862 
    """
1863 
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
3451 chandransh 1864 
    Returned orders comprise of COD orders if cod parameter is true. It comprises of prepaid orders otherwise.
1865 
    Pass providerId and warehouseId as -1 to ignore both these parameters.
3431 rajveer 1866 
 
3427 chandransh 1867 
    Parameters:
1868 
     - fromShippingDate
1869 
     - toShippingDate
1870 
     - providerId
1871 
     - warehouseId
3451 chandransh 1872 
     - cod
3427 chandransh 1873 
    """
3451 chandransh 1874 
    self.send_getOrdersByShippingDate(fromShippingDate, toShippingDate, providerId, warehouseId, cod)
3427 chandransh 1875 
    return self.recv_getOrdersByShippingDate()
1876 
 
3451 chandransh 1877 
  def send_getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId, cod):
3427 chandransh 1878 
    self._oprot.writeMessageBegin('getOrdersByShippingDate', TMessageType.CALL, self._seqid)
1879 
    args = getOrdersByShippingDate_args()
1880 
    args.fromShippingDate = fromShippingDate
1881 
    args.toShippingDate = toShippingDate
1882 
    args.providerId = providerId
1883 
    args.warehouseId = warehouseId
3451 chandransh 1884 
    args.cod = cod
3427 chandransh 1885 
    args.write(self._oprot)
1886 
    self._oprot.writeMessageEnd()
1887 
    self._oprot.trans.flush()
1888 
 
1889 
  def recv_getOrdersByShippingDate(self, ):
1890 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1891 
    if mtype == TMessageType.EXCEPTION:
1892 
      x = TApplicationException()
1893 
      x.read(self._iprot)
1894 
      self._iprot.readMessageEnd()
1895 
      raise x
1896 
    result = getOrdersByShippingDate_result()
1897 
    result.read(self._iprot)
1898 
    self._iprot.readMessageEnd()
3431 rajveer 1899 
    if result.success is not None:
3427 chandransh 1900 
      return result.success
3431 rajveer 1901 
    if result.ex is not None:
3427 chandransh 1902 
      raise result.ex
1903 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
1904 
 
1382 varun.gupt 1905 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
1906 
    """
1907 
    Returns order ids for orders which can be returned
3431 rajveer 1908 
 
1382 varun.gupt 1909 
    Parameters:
1910 
     - customer_id
1911 
     - limit
1912 
    """
1913 
    self.send_getReturnableOrdersForCustomer(customer_id, limit)
1914 
    return self.recv_getReturnableOrdersForCustomer()
1915 
 
1916 
  def send_getReturnableOrdersForCustomer(self, customer_id, limit):
1917 
    self._oprot.writeMessageBegin('getReturnableOrdersForCustomer', TMessageType.CALL, self._seqid)
1918 
    args = getReturnableOrdersForCustomer_args()
1919 
    args.customer_id = customer_id
1920 
    args.limit = limit
1921 
    args.write(self._oprot)
1922 
    self._oprot.writeMessageEnd()
1923 
    self._oprot.trans.flush()
1924 
 
1925 
  def recv_getReturnableOrdersForCustomer(self, ):
1926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1927 
    if mtype == TMessageType.EXCEPTION:
1928 
      x = TApplicationException()
1929 
      x.read(self._iprot)
1930 
      self._iprot.readMessageEnd()
1931 
      raise x
1932 
    result = getReturnableOrdersForCustomer_result()
1933 
    result.read(self._iprot)
1934 
    self._iprot.readMessageEnd()
3431 rajveer 1935 
    if result.success is not None:
1382 varun.gupt 1936 
      return result.success
3431 rajveer 1937 
    if result.ex is not None:
1382 varun.gupt 1938 
      raise result.ex
1939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
1940 
 
1941 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
1942 
    """
1943 
    Returns order ids for orders which can be cancelled
3431 rajveer 1944 
 
1382 varun.gupt 1945 
    Parameters:
1946 
     - customer_id
1947 
     - limit
1948 
    """
1949 
    self.send_getCancellableOrdersForCustomer(customer_id, limit)
1950 
    return self.recv_getCancellableOrdersForCustomer()
1951 
 
1952 
  def send_getCancellableOrdersForCustomer(self, customer_id, limit):
1953 
    self._oprot.writeMessageBegin('getCancellableOrdersForCustomer', TMessageType.CALL, self._seqid)
1954 
    args = getCancellableOrdersForCustomer_args()
1955 
    args.customer_id = customer_id
1956 
    args.limit = limit
1957 
    args.write(self._oprot)
1958 
    self._oprot.writeMessageEnd()
1959 
    self._oprot.trans.flush()
1960 
 
1961 
  def recv_getCancellableOrdersForCustomer(self, ):
1962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1963 
    if mtype == TMessageType.EXCEPTION:
1964 
      x = TApplicationException()
1965 
      x.read(self._iprot)
1966 
      self._iprot.readMessageEnd()
1967 
      raise x
1968 
    result = getCancellableOrdersForCustomer_result()
1969 
    result.read(self._iprot)
1970 
    self._iprot.readMessageEnd()
3431 rajveer 1971 
    if result.success is not None:
1382 varun.gupt 1972 
      return result.success
3431 rajveer 1973 
    if result.ex is not None:
1382 varun.gupt 1974 
      raise result.ex
1975 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
1976 
 
483 rajveer 1977 
  def changeOrderStatus(self, orderId, status, description):
94 ashish 1978 
    """
1979 
    Parameters:
483 rajveer 1980 
     - orderId
1981 
     - status
1982 
     - description
94 ashish 1983 
    """
483 rajveer 1984 
    self.send_changeOrderStatus(orderId, status, description)
1985 
    return self.recv_changeOrderStatus()
94 ashish 1986 
 
483 rajveer 1987 
  def send_changeOrderStatus(self, orderId, status, description):
1988 
    self._oprot.writeMessageBegin('changeOrderStatus', TMessageType.CALL, self._seqid)
1989 
    args = changeOrderStatus_args()
1990 
    args.orderId = orderId
1991 
    args.status = status
1992 
    args.description = description
94 ashish 1993 
    args.write(self._oprot)
1994 
    self._oprot.writeMessageEnd()
1995 
    self._oprot.trans.flush()
1996 
 
483 rajveer 1997 
  def recv_changeOrderStatus(self, ):
94 ashish 1998 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1999 
    if mtype == TMessageType.EXCEPTION:
2000 
      x = TApplicationException()
2001 
      x.read(self._iprot)
2002 
      self._iprot.readMessageEnd()
2003 
      raise x
483 rajveer 2004 
    result = changeOrderStatus_result()
94 ashish 2005 
    result.read(self._iprot)
2006 
    self._iprot.readMessageEnd()
3431 rajveer 2007 
    if result.success is not None:
94 ashish 2008 
      return result.success
3431 rajveer 2009 
    if result.ex is not None:
94 ashish 2010 
      raise result.ex
483 rajveer 2011 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
94 ashish 2012 
 
1528 ankur.sing 2013 
  def getOrdersForTransaction(self, transactionId, customerId):
94 ashish 2014 
    """
1528 ankur.sing 2015 
    Returns list of orders for given transaction Id. Also filters based on customer Id so that
2016 
    only user who owns the transaction can view its order details.
3431 rajveer 2017 
 
94 ashish 2018 
    Parameters:
2019 
     - transactionId
1528 ankur.sing 2020 
     - customerId
94 ashish 2021 
    """
1528 ankur.sing 2022 
    self.send_getOrdersForTransaction(transactionId, customerId)
483 rajveer 2023 
    return self.recv_getOrdersForTransaction()
94 ashish 2024 
 
1528 ankur.sing 2025 
  def send_getOrdersForTransaction(self, transactionId, customerId):
483 rajveer 2026 
    self._oprot.writeMessageBegin('getOrdersForTransaction', TMessageType.CALL, self._seqid)
2027 
    args = getOrdersForTransaction_args()
94 ashish 2028 
    args.transactionId = transactionId
1528 ankur.sing 2029 
    args.customerId = customerId
94 ashish 2030 
    args.write(self._oprot)
2031 
    self._oprot.writeMessageEnd()
2032 
    self._oprot.trans.flush()
2033 
 
483 rajveer 2034 
  def recv_getOrdersForTransaction(self, ):
94 ashish 2035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2036 
    if mtype == TMessageType.EXCEPTION:
2037 
      x = TApplicationException()
2038 
      x.read(self._iprot)
2039 
      self._iprot.readMessageEnd()
2040 
      raise x
483 rajveer 2041 
    result = getOrdersForTransaction_result()
94 ashish 2042 
    result.read(self._iprot)
2043 
    self._iprot.readMessageEnd()
3431 rajveer 2044 
    if result.success is not None:
94 ashish 2045 
      return result.success
3431 rajveer 2046 
    if result.ex is not None:
94 ashish 2047 
      raise result.ex
483 rajveer 2048 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
94 ashish 2049 
 
3014 chandransh 2050 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
94 ashish 2051 
    """
3014 chandransh 2052 
    Returns list of orders for the given customer created between the given dates and having the given statuses.
2053 
    Pass and empty list to ignore filtering on statuses.
3431 rajveer 2054 
 
94 ashish 2055 
    Parameters:
483 rajveer 2056 
     - customerId
2057 
     - from_date
2058 
     - to_date
3014 chandransh 2059 
     - statuses
94 ashish 2060 
    """
3014 chandransh 2061 
    self.send_getOrdersForCustomer(customerId, from_date, to_date, statuses)
483 rajveer 2062 
    return self.recv_getOrdersForCustomer()
94 ashish 2063 
 
3014 chandransh 2064 
  def send_getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
483 rajveer 2065 
    self._oprot.writeMessageBegin('getOrdersForCustomer', TMessageType.CALL, self._seqid)
2066 
    args = getOrdersForCustomer_args()
2067 
    args.customerId = customerId
2068 
    args.from_date = from_date
2069 
    args.to_date = to_date
3014 chandransh 2070 
    args.statuses = statuses
94 ashish 2071 
    args.write(self._oprot)
2072 
    self._oprot.writeMessageEnd()
2073 
    self._oprot.trans.flush()
2074 
 
483 rajveer 2075 
  def recv_getOrdersForCustomer(self, ):
94 ashish 2076 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2077 
    if mtype == TMessageType.EXCEPTION:
2078 
      x = TApplicationException()
2079 
      x.read(self._iprot)
2080 
      self._iprot.readMessageEnd()
2081 
      raise x
483 rajveer 2082 
    result = getOrdersForCustomer_result()
94 ashish 2083 
    result.read(self._iprot)
2084 
    self._iprot.readMessageEnd()
3431 rajveer 2085 
    if result.success is not None:
94 ashish 2086 
      return result.success
3431 rajveer 2087 
    if result.ex is not None:
94 ashish 2088 
      raise result.ex
483 rajveer 2089 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
94 ashish 2090 
 
483 rajveer 2091 
  def createOrder(self, order):
94 ashish 2092 
    """
2093 
    Parameters:
483 rajveer 2094 
     - order
94 ashish 2095 
    """
483 rajveer 2096 
    self.send_createOrder(order)
2097 
    return self.recv_createOrder()
94 ashish 2098 
 
483 rajveer 2099 
  def send_createOrder(self, order):
2100 
    self._oprot.writeMessageBegin('createOrder', TMessageType.CALL, self._seqid)
2101 
    args = createOrder_args()
2102 
    args.order = order
94 ashish 2103 
    args.write(self._oprot)
2104 
    self._oprot.writeMessageEnd()
2105 
    self._oprot.trans.flush()
2106 
 
483 rajveer 2107 
  def recv_createOrder(self, ):
94 ashish 2108 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2109 
    if mtype == TMessageType.EXCEPTION:
2110 
      x = TApplicationException()
2111 
      x.read(self._iprot)
2112 
      self._iprot.readMessageEnd()
2113 
      raise x
483 rajveer 2114 
    result = createOrder_result()
94 ashish 2115 
    result.read(self._iprot)
2116 
    self._iprot.readMessageEnd()
3431 rajveer 2117 
    if result.success is not None:
94 ashish 2118 
      return result.success
3431 rajveer 2119 
    if result.ex is not None:
94 ashish 2120 
      raise result.ex
483 rajveer 2121 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
94 ashish 2122 
 
483 rajveer 2123 
  def getOrder(self, id):
94 ashish 2124 
    """
2125 
    Parameters:
483 rajveer 2126 
     - id
94 ashish 2127 
    """
483 rajveer 2128 
    self.send_getOrder(id)
2129 
    return self.recv_getOrder()
94 ashish 2130 
 
483 rajveer 2131 
  def send_getOrder(self, id):
2132 
    self._oprot.writeMessageBegin('getOrder', TMessageType.CALL, self._seqid)
2133 
    args = getOrder_args()
2134 
    args.id = id
94 ashish 2135 
    args.write(self._oprot)
2136 
    self._oprot.writeMessageEnd()
2137 
    self._oprot.trans.flush()
2138 
 
483 rajveer 2139 
  def recv_getOrder(self, ):
94 ashish 2140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2141 
    if mtype == TMessageType.EXCEPTION:
2142 
      x = TApplicationException()
2143 
      x.read(self._iprot)
2144 
      self._iprot.readMessageEnd()
2145 
      raise x
483 rajveer 2146 
    result = getOrder_result()
94 ashish 2147 
    result.read(self._iprot)
2148 
    self._iprot.readMessageEnd()
3431 rajveer 2149 
    if result.success is not None:
94 ashish 2150 
      return result.success
3431 rajveer 2151 
    if result.ex is not None:
94 ashish 2152 
      raise result.ex
483 rajveer 2153 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
94 ashish 2154 
 
483 rajveer 2155 
  def getLineItemsForOrder(self, orderId):
94 ashish 2156 
    """
2157 
    Parameters:
483 rajveer 2158 
     - orderId
94 ashish 2159 
    """
483 rajveer 2160 
    self.send_getLineItemsForOrder(orderId)
2161 
    return self.recv_getLineItemsForOrder()
94 ashish 2162 
 
483 rajveer 2163 
  def send_getLineItemsForOrder(self, orderId):
2164 
    self._oprot.writeMessageBegin('getLineItemsForOrder', TMessageType.CALL, self._seqid)
2165 
    args = getLineItemsForOrder_args()
2166 
    args.orderId = orderId
94 ashish 2167 
    args.write(self._oprot)
2168 
    self._oprot.writeMessageEnd()
2169 
    self._oprot.trans.flush()
2170 
 
483 rajveer 2171 
  def recv_getLineItemsForOrder(self, ):
94 ashish 2172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2173 
    if mtype == TMessageType.EXCEPTION:
2174 
      x = TApplicationException()
2175 
      x.read(self._iprot)
2176 
      self._iprot.readMessageEnd()
2177 
      raise x
483 rajveer 2178 
    result = getLineItemsForOrder_result()
94 ashish 2179 
    result.read(self._iprot)
2180 
    self._iprot.readMessageEnd()
3431 rajveer 2181 
    if result.success is not None:
94 ashish 2182 
      return result.success
3431 rajveer 2183 
    if result.ex is not None:
94 ashish 2184 
      raise result.ex
483 rajveer 2185 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
94 ashish 2186 
 
4999 phani.kuma 2187 
  def getOrderList(self, order_ids):
2188 
    """
2189 
    Parameters:
2190 
     - order_ids
2191 
    """
2192 
    self.send_getOrderList(order_ids)
2193 
    return self.recv_getOrderList()
2194 
 
2195 
  def send_getOrderList(self, order_ids):
2196 
    self._oprot.writeMessageBegin('getOrderList', TMessageType.CALL, self._seqid)
2197 
    args = getOrderList_args()
2198 
    args.order_ids = order_ids
2199 
    args.write(self._oprot)
2200 
    self._oprot.writeMessageEnd()
2201 
    self._oprot.trans.flush()
2202 
 
2203 
  def recv_getOrderList(self, ):
2204 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2205 
    if mtype == TMessageType.EXCEPTION:
2206 
      x = TApplicationException()
2207 
      x.read(self._iprot)
2208 
      self._iprot.readMessageEnd()
2209 
      raise x
2210 
    result = getOrderList_result()
2211 
    result.read(self._iprot)
2212 
    self._iprot.readMessageEnd()
2213 
    if result.success is not None:
2214 
      return result.success
2215 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderList failed: unknown result");
2216 
 
5386 phani.kuma 2217 
  def getOrderListForVendor(self, order_ids, vendorId):
2218 
    """
2219 
    Parameters:
2220 
     - order_ids
2221 
     - vendorId
2222 
    """
2223 
    self.send_getOrderListForVendor(order_ids, vendorId)
2224 
    return self.recv_getOrderListForVendor()
2225 
 
2226 
  def send_getOrderListForVendor(self, order_ids, vendorId):
2227 
    self._oprot.writeMessageBegin('getOrderListForVendor', TMessageType.CALL, self._seqid)
2228 
    args = getOrderListForVendor_args()
2229 
    args.order_ids = order_ids
2230 
    args.vendorId = vendorId
2231 
    args.write(self._oprot)
2232 
    self._oprot.writeMessageEnd()
2233 
    self._oprot.trans.flush()
2234 
 
2235 
  def recv_getOrderListForVendor(self, ):
2236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2237 
    if mtype == TMessageType.EXCEPTION:
2238 
      x = TApplicationException()
2239 
      x.read(self._iprot)
2240 
      self._iprot.readMessageEnd()
2241 
      raise x
2242 
    result = getOrderListForVendor_result()
2243 
    result.read(self._iprot)
2244 
    self._iprot.readMessageEnd()
2245 
    if result.success is not None:
2246 
      return result.success
2247 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderListForVendor failed: unknown result");
2248 
 
1528 ankur.sing 2249 
  def getOrderForCustomer(self, orderId, customerId):
2250 
    """
2251 
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
2252 
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
3431 rajveer 2253 
 
1528 ankur.sing 2254 
    Parameters:
2255 
     - orderId
2256 
     - customerId
2257 
    """
2258 
    self.send_getOrderForCustomer(orderId, customerId)
2259 
    return self.recv_getOrderForCustomer()
2260 
 
2261 
  def send_getOrderForCustomer(self, orderId, customerId):
2262 
    self._oprot.writeMessageBegin('getOrderForCustomer', TMessageType.CALL, self._seqid)
2263 
    args = getOrderForCustomer_args()
2264 
    args.orderId = orderId
2265 
    args.customerId = customerId
2266 
    args.write(self._oprot)
2267 
    self._oprot.writeMessageEnd()
2268 
    self._oprot.trans.flush()
2269 
 
2270 
  def recv_getOrderForCustomer(self, ):
2271 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2272 
    if mtype == TMessageType.EXCEPTION:
2273 
      x = TApplicationException()
2274 
      x.read(self._iprot)
2275 
      self._iprot.readMessageEnd()
2276 
      raise x
2277 
    result = getOrderForCustomer_result()
2278 
    result.read(self._iprot)
2279 
    self._iprot.readMessageEnd()
3431 rajveer 2280 
    if result.success is not None:
1528 ankur.sing 2281 
      return result.success
3431 rajveer 2282 
    if result.ex is not None:
1528 ankur.sing 2283 
      raise result.ex
2284 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
2285 
 
4444 rajveer 2286 
  def getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2287 
    """
2288 
    Parameters:
4394 rajveer 2289 
     - type
4444 rajveer 2290 
     - warehouseId
4394 rajveer 2291 
     - status
2292 
     - timestamp
3064 chandransh 2293 
    """
4444 rajveer 2294 
    self.send_getAlerts(type, warehouseId, status, timestamp)
3064 chandransh 2295 
    return self.recv_getAlerts()
2296 
 
4444 rajveer 2297 
  def send_getAlerts(self, type, warehouseId, status, timestamp):
3064 chandransh 2298 
    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
2299 
    args = getAlerts_args()
4394 rajveer 2300 
    args.type = type
4444 rajveer 2301 
    args.warehouseId = warehouseId
4394 rajveer 2302 
    args.status = status
2303 
    args.timestamp = timestamp
3064 chandransh 2304 
    args.write(self._oprot)
2305 
    self._oprot.writeMessageEnd()
2306 
    self._oprot.trans.flush()
2307 
 
2308 
  def recv_getAlerts(self, ):
2309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2310 
    if mtype == TMessageType.EXCEPTION:
2311 
      x = TApplicationException()
2312 
      x.read(self._iprot)
2313 
      self._iprot.readMessageEnd()
2314 
      raise x
2315 
    result = getAlerts_result()
2316 
    result.read(self._iprot)
2317 
    self._iprot.readMessageEnd()
3431 rajveer 2318 
    if result.success is not None:
3064 chandransh 2319 
      return result.success
2320 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
2321 
 
4444 rajveer 2322 
  def addAlert(self, type, warehouseId, description):
3064 chandransh 2323 
    """
2324 
    Parameters:
2325 
     - type
4444 rajveer 2326 
     - warehouseId
4394 rajveer 2327 
     - description
3064 chandransh 2328 
    """
4444 rajveer 2329 
    self.send_addAlert(type, warehouseId, description)
4394 rajveer 2330 
    self.recv_addAlert()
3064 chandransh 2331 
 
4444 rajveer 2332 
  def send_addAlert(self, type, warehouseId, description):
4394 rajveer 2333 
    self._oprot.writeMessageBegin('addAlert', TMessageType.CALL, self._seqid)
2334 
    args = addAlert_args()
3064 chandransh 2335 
    args.type = type
4444 rajveer 2336 
    args.warehouseId = warehouseId
4394 rajveer 2337 
    args.description = description
3064 chandransh 2338 
    args.write(self._oprot)
2339 
    self._oprot.writeMessageEnd()
2340 
    self._oprot.trans.flush()
2341 
 
4394 rajveer 2342 
  def recv_addAlert(self, ):
3064 chandransh 2343 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2344 
    if mtype == TMessageType.EXCEPTION:
2345 
      x = TApplicationException()
2346 
      x.read(self._iprot)
2347 
      self._iprot.readMessageEnd()
2348 
      raise x
4394 rajveer 2349 
    result = addAlert_result()
3064 chandransh 2350 
    result.read(self._iprot)
2351 
    self._iprot.readMessageEnd()
2352 
    return
2353 
 
4444 rajveer 2354 
  def markAlertsAsSeen(self, warehouseId):
2355 
    """
2356 
    Parameters:
2357 
     - warehouseId
2358 
    """
2359 
    self.send_markAlertsAsSeen(warehouseId)
2360 
    self.recv_markAlertsAsSeen()
2361 
 
2362 
  def send_markAlertsAsSeen(self, warehouseId):
2363 
    self._oprot.writeMessageBegin('markAlertsAsSeen', TMessageType.CALL, self._seqid)
2364 
    args = markAlertsAsSeen_args()
2365 
    args.warehouseId = warehouseId
2366 
    args.write(self._oprot)
2367 
    self._oprot.writeMessageEnd()
2368 
    self._oprot.trans.flush()
2369 
 
2370 
  def recv_markAlertsAsSeen(self, ):
2371 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2372 
    if mtype == TMessageType.EXCEPTION:
2373 
      x = TApplicationException()
2374 
      x.read(self._iprot)
2375 
      self._iprot.readMessageEnd()
2376 
      raise x
2377 
    result = markAlertsAsSeen_result()
2378 
    result.read(self._iprot)
2379 
    self._iprot.readMessageEnd()
2380 
    return
2381 
 
3064 chandransh 2382 
  def getValidOrderCount(self, ):
2383 
    """
2384 
    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2385 
    """
2386 
    self.send_getValidOrderCount()
2387 
    return self.recv_getValidOrderCount()
2388 
 
2389 
  def send_getValidOrderCount(self, ):
2390 
    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
2391 
    args = getValidOrderCount_args()
2392 
    args.write(self._oprot)
2393 
    self._oprot.writeMessageEnd()
2394 
    self._oprot.trans.flush()
2395 
 
2396 
  def recv_getValidOrderCount(self, ):
2397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2398 
    if mtype == TMessageType.EXCEPTION:
2399 
      x = TApplicationException()
2400 
      x.read(self._iprot)
2401 
      self._iprot.readMessageEnd()
2402 
      raise x
2403 
    result = getValidOrderCount_result()
2404 
    result.read(self._iprot)
2405 
    self._iprot.readMessageEnd()
3431 rajveer 2406 
    if result.success is not None:
3064 chandransh 2407 
      return result.success
2408 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
2409 
 
2410 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
2411 
    """
2412 
    Returns the number of distinct customers who have done successful transactions
2413 
    """
2414 
    self.send_getNoOfCustomersWithSuccessfulTransaction()
2415 
    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
2416 
 
2417 
  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
2418 
    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
2419 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
2420 
    args.write(self._oprot)
2421 
    self._oprot.writeMessageEnd()
2422 
    self._oprot.trans.flush()
2423 
 
2424 
  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
2425 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2426 
    if mtype == TMessageType.EXCEPTION:
2427 
      x = TApplicationException()
2428 
      x.read(self._iprot)
2429 
      self._iprot.readMessageEnd()
2430 
      raise x
2431 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
2432 
    result.read(self._iprot)
2433 
    self._iprot.readMessageEnd()
3431 rajveer 2434 
    if result.success is not None:
3064 chandransh 2435 
      return result.success
2436 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
2437 
 
2438 
  def getValidOrdersAmountRange(self, ):
2439 
    """
2440 
    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
2441 
    List contains two values, first minimum amount and second maximum amount.
2442 
    """
2443 
    self.send_getValidOrdersAmountRange()
2444 
    return self.recv_getValidOrdersAmountRange()
2445 
 
2446 
  def send_getValidOrdersAmountRange(self, ):
2447 
    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
2448 
    args = getValidOrdersAmountRange_args()
2449 
    args.write(self._oprot)
2450 
    self._oprot.writeMessageEnd()
2451 
    self._oprot.trans.flush()
2452 
 
2453 
  def recv_getValidOrdersAmountRange(self, ):
2454 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2455 
    if mtype == TMessageType.EXCEPTION:
2456 
      x = TApplicationException()
2457 
      x.read(self._iprot)
2458 
      self._iprot.readMessageEnd()
2459 
      raise x
2460 
    result = getValidOrdersAmountRange_result()
2461 
    result.read(self._iprot)
2462 
    self._iprot.readMessageEnd()
3431 rajveer 2463 
    if result.success is not None:
3064 chandransh 2464 
      return result.success
2465 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
2466 
 
5874 rajveer 2467 
  def getValidOrders(self, limit, onlyStore):
3064 chandransh 2468 
    """
2469 
    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
2470 
    If limit is passed as 0, then all valid Orders are returned.
3431 rajveer 2471 
 
3064 chandransh 2472 
    Parameters:
2473 
     - limit
5874 rajveer 2474 
     - onlyStore
3064 chandransh 2475 
    """
5874 rajveer 2476 
    self.send_getValidOrders(limit, onlyStore)
3064 chandransh 2477 
    return self.recv_getValidOrders()
2478 
 
5874 rajveer 2479 
  def send_getValidOrders(self, limit, onlyStore):
3064 chandransh 2480 
    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
2481 
    args = getValidOrders_args()
2482 
    args.limit = limit
5874 rajveer 2483 
    args.onlyStore = onlyStore
3064 chandransh 2484 
    args.write(self._oprot)
2485 
    self._oprot.writeMessageEnd()
2486 
    self._oprot.trans.flush()
2487 
 
2488 
  def recv_getValidOrders(self, ):
2489 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2490 
    if mtype == TMessageType.EXCEPTION:
2491 
      x = TApplicationException()
2492 
      x.read(self._iprot)
2493 
      self._iprot.readMessageEnd()
2494 
      raise x
2495 
    result = getValidOrders_result()
2496 
    result.read(self._iprot)
2497 
    self._iprot.readMessageEnd()
3431 rajveer 2498 
    if result.success is not None:
3064 chandransh 2499 
      return result.success
2500 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
2501 
 
1220 chandransh 2502 
  def batchOrders(self, warehouseId):
2503 
    """
2504 
    Create a batch of all the pending orders for the given warehouse.
2505 
    The returned list is orderd by created_timestamp.
2506 
    If there are no pending orders, an empty list is returned.
3431 rajveer 2507 
 
1220 chandransh 2508 
    Parameters:
2509 
     - warehouseId
2510 
    """
2511 
    self.send_batchOrders(warehouseId)
2512 
    return self.recv_batchOrders()
2513 
 
2514 
  def send_batchOrders(self, warehouseId):
2515 
    self._oprot.writeMessageBegin('batchOrders', TMessageType.CALL, self._seqid)
2516 
    args = batchOrders_args()
2517 
    args.warehouseId = warehouseId
2518 
    args.write(self._oprot)
2519 
    self._oprot.writeMessageEnd()
2520 
    self._oprot.trans.flush()
2521 
 
2522 
  def recv_batchOrders(self, ):
2523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2524 
    if mtype == TMessageType.EXCEPTION:
2525 
      x = TApplicationException()
2526 
      x.read(self._iprot)
2527 
      self._iprot.readMessageEnd()
2528 
      raise x
2529 
    result = batchOrders_result()
2530 
    result.read(self._iprot)
2531 
    self._iprot.readMessageEnd()
3431 rajveer 2532 
    if result.success is not None:
1220 chandransh 2533 
      return result.success
3431 rajveer 2534 
    if result.ex is not None:
1220 chandransh 2535 
      raise result.ex
2536 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
2537 
 
1208 chandransh 2538 
  def markOrderAsOutOfStock(self, orderId):
2539 
    """
2540 
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
3431 rajveer 2541 
 
1208 chandransh 2542 
    Parameters:
2543 
     - orderId
2544 
    """
2545 
    self.send_markOrderAsOutOfStock(orderId)
2546 
    return self.recv_markOrderAsOutOfStock()
2547 
 
2548 
  def send_markOrderAsOutOfStock(self, orderId):
2549 
    self._oprot.writeMessageBegin('markOrderAsOutOfStock', TMessageType.CALL, self._seqid)
2550 
    args = markOrderAsOutOfStock_args()
2551 
    args.orderId = orderId
2552 
    args.write(self._oprot)
2553 
    self._oprot.writeMessageEnd()
2554 
    self._oprot.trans.flush()
2555 
 
2556 
  def recv_markOrderAsOutOfStock(self, ):
2557 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2558 
    if mtype == TMessageType.EXCEPTION:
2559 
      x = TApplicationException()
2560 
      x.read(self._iprot)
2561 
      self._iprot.readMessageEnd()
2562 
      raise x
2563 
    result = markOrderAsOutOfStock_result()
2564 
    result.read(self._iprot)
2565 
    self._iprot.readMessageEnd()
3431 rajveer 2566 
    if result.success is not None:
1208 chandransh 2567 
      return result.success
3431 rajveer 2568 
    if result.ex is not None:
1208 chandransh 2569 
      raise result.ex
2570 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
2571 
 
3064 chandransh 2572 
  def verifyOrder(self, orderId):
759 chandransh 2573 
    """
3064 chandransh 2574 
    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
2575 
    timestamp. It is intended to be used for COD orders but can be harmlessly
2576 
    used for all other orders as well.
2577 
    Throws an exception if no such order exists.
3431 rajveer 2578 
 
759 chandransh 2579 
    Parameters:
3064 chandransh 2580 
     - orderId
759 chandransh 2581 
    """
3064 chandransh 2582 
    self.send_verifyOrder(orderId)
2583 
    return self.recv_verifyOrder()
759 chandransh 2584 
 
3064 chandransh 2585 
  def send_verifyOrder(self, orderId):
2586 
    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
2587 
    args = verifyOrder_args()
2588 
    args.orderId = orderId
759 chandransh 2589 
    args.write(self._oprot)
2590 
    self._oprot.writeMessageEnd()
2591 
    self._oprot.trans.flush()
2592 
 
3064 chandransh 2593 
  def recv_verifyOrder(self, ):
759 chandransh 2594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2595 
    if mtype == TMessageType.EXCEPTION:
2596 
      x = TApplicationException()
2597 
      x.read(self._iprot)
2598 
      self._iprot.readMessageEnd()
2599 
      raise x
3064 chandransh 2600 
    result = verifyOrder_result()
759 chandransh 2601 
    result.read(self._iprot)
2602 
    self._iprot.readMessageEnd()
3431 rajveer 2603 
    if result.success is not None:
759 chandransh 2604 
      return result.success
3431 rajveer 2605 
    if result.ex is not None:
759 chandransh 2606 
      raise result.ex
3064 chandransh 2607 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
759 chandransh 2608 
 
3064 chandransh 2609 
  def acceptOrder(self, orderId):
1113 chandransh 2610 
    """
3064 chandransh 2611 
    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
2612 
    given order is not a COD order, it also captures the payment if the same has
2613 
    not been captured.
2614 
    Throws an exception if no such order exists.
3431 rajveer 2615 
 
1113 chandransh 2616 
    Parameters:
3064 chandransh 2617 
     - orderId
1113 chandransh 2618 
    """
3064 chandransh 2619 
    self.send_acceptOrder(orderId)
2620 
    return self.recv_acceptOrder()
1113 chandransh 2621 
 
3064 chandransh 2622 
  def send_acceptOrder(self, orderId):
2623 
    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
2624 
    args = acceptOrder_args()
2625 
    args.orderId = orderId
1113 chandransh 2626 
    args.write(self._oprot)
2627 
    self._oprot.writeMessageEnd()
2628 
    self._oprot.trans.flush()
2629 
 
3064 chandransh 2630 
  def recv_acceptOrder(self, ):
1113 chandransh 2631 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2632 
    if mtype == TMessageType.EXCEPTION:
2633 
      x = TApplicationException()
2634 
      x.read(self._iprot)
2635 
      self._iprot.readMessageEnd()
2636 
      raise x
3064 chandransh 2637 
    result = acceptOrder_result()
1113 chandransh 2638 
    result.read(self._iprot)
2639 
    self._iprot.readMessageEnd()
3431 rajveer 2640 
    if result.success is not None:
1113 chandransh 2641 
      return result.success
3431 rajveer 2642 
    if result.ex is not None:
1113 chandransh 2643 
      raise result.ex
3064 chandransh 2644 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
1113 chandransh 2645 
 
5110 mandeep.dh 2646 
  def addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
1132 chandransh 2647 
    """
3064 chandransh 2648 
    Add billing details such as the bill number and the biller to the Order.
4658 mandeep.dh 2649 
    Adds jacket number, item number and Serial no. to the order. Doesn't update
4283 anupam.sin 2650 
    the IMEI no. if a -1 is supplied.
2651 
    Also, it generates an invoice number for the order, marks the order as
2652 
    BILLED and sets the billing timestamp.
2653 
    Returns false if it doesn't find the order with the given ID.
3431 rajveer 2654 
 
1135 chandransh 2655 
    Parameters:
3064 chandransh 2656 
     - orderId
2657 
     - invoice_number
4658 mandeep.dh 2658 
     - serialNumber
4283 anupam.sin 2659 
     - itemNumber
3064 chandransh 2660 
     - billed_by
4264 rajveer 2661 
     - jacketNumber
4283 anupam.sin 2662 
     - billingType
5110 mandeep.dh 2663 
     - fulfilmentWarehouseId
4763 rajveer 2664 
     - authorize
1135 chandransh 2665 
    """
5110 mandeep.dh 2666 
    self.send_addBillingDetails(orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize)
3064 chandransh 2667 
    return self.recv_addBillingDetails()
1135 chandransh 2668 
 
5110 mandeep.dh 2669 
  def send_addBillingDetails(self, orderId, invoice_number, serialNumber, itemNumber, billed_by, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
3064 chandransh 2670 
    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
2671 
    args = addBillingDetails_args()
2672 
    args.orderId = orderId
2673 
    args.invoice_number = invoice_number
4658 mandeep.dh 2674 
    args.serialNumber = serialNumber
4283 anupam.sin 2675 
    args.itemNumber = itemNumber
3064 chandransh 2676 
    args.billed_by = billed_by
4264 rajveer 2677 
    args.jacketNumber = jacketNumber
4283 anupam.sin 2678 
    args.billingType = billingType
5110 mandeep.dh 2679 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 2680 
    args.authorize = authorize
1135 chandransh 2681 
    args.write(self._oprot)
2682 
    self._oprot.writeMessageEnd()
2683 
    self._oprot.trans.flush()
2684 
 
3064 chandransh 2685 
  def recv_addBillingDetails(self, ):
1135 chandransh 2686 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2687 
    if mtype == TMessageType.EXCEPTION:
2688 
      x = TApplicationException()
2689 
      x.read(self._iprot)
2690 
      self._iprot.readMessageEnd()
2691 
      raise x
3064 chandransh 2692 
    result = addBillingDetails_result()
1135 chandransh 2693 
    result.read(self._iprot)
2694 
    self._iprot.readMessageEnd()
3431 rajveer 2695 
    if result.success is not None:
3064 chandransh 2696 
      return result.success
3431 rajveer 2697 
    if result.ex is not None:
1135 chandransh 2698 
      raise result.ex
3064 chandransh 2699 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
1135 chandransh 2700 
 
6756 amar.kumar 2701 
  def addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2702 
    """
2703 
    Add the invoice number to the order.
2704 
 
2705 
    Parameters:
2706 
     - orderId
2707 
     - invoiceNumber
4763 rajveer 2708 
     - color
6756 amar.kumar 2709 
     - serialNumber
2710 
     - itemNumber
4579 rajveer 2711 
    """
6756 amar.kumar 2712 
    self.send_addInvoiceNumber(orderId, invoiceNumber, color, serialNumber, itemNumber)
4579 rajveer 2713 
    self.recv_addInvoiceNumber()
2714 
 
6756 amar.kumar 2715 
  def send_addInvoiceNumber(self, orderId, invoiceNumber, color, serialNumber, itemNumber):
4579 rajveer 2716 
    self._oprot.writeMessageBegin('addInvoiceNumber', TMessageType.CALL, self._seqid)
2717 
    args = addInvoiceNumber_args()
2718 
    args.orderId = orderId
2719 
    args.invoiceNumber = invoiceNumber
4763 rajveer 2720 
    args.color = color
6756 amar.kumar 2721 
    args.serialNumber = serialNumber
2722 
    args.itemNumber = itemNumber
4579 rajveer 2723 
    args.write(self._oprot)
2724 
    self._oprot.writeMessageEnd()
2725 
    self._oprot.trans.flush()
2726 
 
2727 
  def recv_addInvoiceNumber(self, ):
2728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2729 
    if mtype == TMessageType.EXCEPTION:
2730 
      x = TApplicationException()
2731 
      x.read(self._iprot)
2732 
      self._iprot.readMessageEnd()
2733 
      raise x
2734 
    result = addInvoiceNumber_result()
2735 
    result.read(self._iprot)
2736 
    self._iprot.readMessageEnd()
2737 
    if result.ex is not None:
2738 
      raise result.ex
2739 
    return
2740 
 
4910 phani.kuma 2741 
  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
1408 ankur.sing 2742 
    """
3064 chandransh 2743 
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
4910 phani.kuma 2744 
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
3431 rajveer 2745 
 
1408 ankur.sing 2746 
    Parameters:
3064 chandransh 2747 
     - warehouseId
1408 ankur.sing 2748 
     - providerId
3064 chandransh 2749 
     - cod
4910 phani.kuma 2750 
     - orderIds
1408 ankur.sing 2751 
    """
4910 phani.kuma 2752 
    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
2753 
    return self.recv_markOrdersAsShippedFromWarehouse()
1408 ankur.sing 2754 
 
4910 phani.kuma 2755 
  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
2756 
    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
2757 
    args = markOrdersAsShippedFromWarehouse_args()
3064 chandransh 2758 
    args.warehouseId = warehouseId
1408 ankur.sing 2759 
    args.providerId = providerId
3064 chandransh 2760 
    args.cod = cod
4910 phani.kuma 2761 
    args.orderIds = orderIds
1408 ankur.sing 2762 
    args.write(self._oprot)
2763 
    self._oprot.writeMessageEnd()
2764 
    self._oprot.trans.flush()
2765 
 
4910 phani.kuma 2766 
  def recv_markOrdersAsShippedFromWarehouse(self, ):
1408 ankur.sing 2767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2768 
    if mtype == TMessageType.EXCEPTION:
2769 
      x = TApplicationException()
2770 
      x.read(self._iprot)
2771 
      self._iprot.readMessageEnd()
2772 
      raise x
4910 phani.kuma 2773 
    result = markOrdersAsShippedFromWarehouse_result()
1408 ankur.sing 2774 
    result.read(self._iprot)
2775 
    self._iprot.readMessageEnd()
3431 rajveer 2776 
    if result.success is not None:
1408 ankur.sing 2777 
      return result.success
3431 rajveer 2778 
    if result.ex is not None:
3064 chandransh 2779 
      raise result.ex
4910 phani.kuma 2780 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
1408 ankur.sing 2781 
 
5713 rajveer 2782 
  def markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2783 
    """
2784 
    Parameters:
2785 
     - providerId
2786 
     - orderIds
5713 rajveer 2787 
     - awbs
5676 rajveer 2788 
    """
5713 rajveer 2789 
    self.send_markOrdersAsReturnedFromStore(providerId, orderIds, awbs)
5676 rajveer 2790 
    return self.recv_markOrdersAsReturnedFromStore()
2791 
 
5713 rajveer 2792 
  def send_markOrdersAsReturnedFromStore(self, providerId, orderIds, awbs):
5676 rajveer 2793 
    self._oprot.writeMessageBegin('markOrdersAsReturnedFromStore', TMessageType.CALL, self._seqid)
2794 
    args = markOrdersAsReturnedFromStore_args()
2795 
    args.providerId = providerId
2796 
    args.orderIds = orderIds
5713 rajveer 2797 
    args.awbs = awbs
5676 rajveer 2798 
    args.write(self._oprot)
2799 
    self._oprot.writeMessageEnd()
2800 
    self._oprot.trans.flush()
2801 
 
2802 
  def recv_markOrdersAsReturnedFromStore(self, ):
2803 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2804 
    if mtype == TMessageType.EXCEPTION:
2805 
      x = TApplicationException()
2806 
      x.read(self._iprot)
2807 
      self._iprot.readMessageEnd()
2808 
      raise x
2809 
    result = markOrdersAsReturnedFromStore_result()
2810 
    result.read(self._iprot)
2811 
    self._iprot.readMessageEnd()
2812 
    if result.success is not None:
2813 
      return result.success
2814 
    if result.ex is not None:
2815 
      raise result.ex
2816 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsReturnedFromStore failed: unknown result");
2817 
 
4910 phani.kuma 2818 
  def markOrdersAsPickedUp(self, providerId, pickupDetails):
4410 rajveer 2819 
    """
4910 phani.kuma 2820 
    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
2821 
    Raises an exception if we encounter report for an AWB number that we did not ship.
4410 rajveer 2822 
 
2823 
    Parameters:
2824 
     - providerId
4910 phani.kuma 2825 
     - pickupDetails
4410 rajveer 2826 
    """
4910 phani.kuma 2827 
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
2828 
    self.recv_markOrdersAsPickedUp()
4410 rajveer 2829 
 
4910 phani.kuma 2830 
  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
2831 
    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
2832 
    args = markOrdersAsPickedUp_args()
4410 rajveer 2833 
    args.providerId = providerId
4910 phani.kuma 2834 
    args.pickupDetails = pickupDetails
4410 rajveer 2835 
    args.write(self._oprot)
2836 
    self._oprot.writeMessageEnd()
2837 
    self._oprot.trans.flush()
2838 
 
4910 phani.kuma 2839 
  def recv_markOrdersAsPickedUp(self, ):
4410 rajveer 2840 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2841 
    if mtype == TMessageType.EXCEPTION:
2842 
      x = TApplicationException()
2843 
      x.read(self._iprot)
2844 
      self._iprot.readMessageEnd()
2845 
      raise x
4910 phani.kuma 2846 
    result = markOrdersAsPickedUp_result()
4410 rajveer 2847 
    result.read(self._iprot)
2848 
    self._iprot.readMessageEnd()
2849 
    if result.ex is not None:
2850 
      raise result.ex
4910 phani.kuma 2851 
    return
4410 rajveer 2852 
 
4910 phani.kuma 2853 
  def getOrdersNotPickedUp(self, providerId):
94 ashish 2854 
    """
3064 chandransh 2855 
    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
3431 rajveer 2856 
 
94 ashish 2857 
    Parameters:
3064 chandransh 2858 
     - providerId
304 ashish 2859 
    """
4910 phani.kuma 2860 
    self.send_getOrdersNotPickedUp(providerId)
2861 
    return self.recv_getOrdersNotPickedUp()
94 ashish 2862 
 
4910 phani.kuma 2863 
  def send_getOrdersNotPickedUp(self, providerId):
2864 
    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
2865 
    args = getOrdersNotPickedUp_args()
3064 chandransh 2866 
    args.providerId = providerId
304 ashish 2867 
    args.write(self._oprot)
2868 
    self._oprot.writeMessageEnd()
2869 
    self._oprot.trans.flush()
2870 
 
4910 phani.kuma 2871 
  def recv_getOrdersNotPickedUp(self, ):
304 ashish 2872 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2873 
    if mtype == TMessageType.EXCEPTION:
2874 
      x = TApplicationException()
2875 
      x.read(self._iprot)
2876 
      self._iprot.readMessageEnd()
2877 
      raise x
4910 phani.kuma 2878 
    result = getOrdersNotPickedUp_result()
304 ashish 2879 
    result.read(self._iprot)
2880 
    self._iprot.readMessageEnd()
3431 rajveer 2881 
    if result.success is not None:
304 ashish 2882 
      return result.success
4910 phani.kuma 2883 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
304 ashish 2884 
 
3064 chandransh 2885 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
304 ashish 2886 
    """
3064 chandransh 2887 
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
2888 
    the name of the receiver.
2889 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2890 
 
304 ashish 2891 
    Parameters:
3064 chandransh 2892 
     - providerId
2893 
     - deliveredOrders
304 ashish 2894 
    """
3064 chandransh 2895 
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
2896 
    self.recv_markOrdersAsDelivered()
304 ashish 2897 
 
3064 chandransh 2898 
  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
2899 
    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
2900 
    args = markOrdersAsDelivered_args()
2901 
    args.providerId = providerId
2902 
    args.deliveredOrders = deliveredOrders
304 ashish 2903 
    args.write(self._oprot)
2904 
    self._oprot.writeMessageEnd()
2905 
    self._oprot.trans.flush()
2906 
 
3064 chandransh 2907 
  def recv_markOrdersAsDelivered(self, ):
304 ashish 2908 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2909 
    if mtype == TMessageType.EXCEPTION:
2910 
      x = TApplicationException()
2911 
      x.read(self._iprot)
2912 
      self._iprot.readMessageEnd()
2913 
      raise x
3064 chandransh 2914 
    result = markOrdersAsDelivered_result()
304 ashish 2915 
    result.read(self._iprot)
2916 
    self._iprot.readMessageEnd()
3431 rajveer 2917 
    if result.ex is not None:
3064 chandransh 2918 
      raise result.ex
304 ashish 2919 
    return
2920 
 
4910 phani.kuma 2921 
  def markAsRTOrders(self, providerId, returnedOrders):
1596 ankur.sing 2922 
    """
4910 phani.kuma 2923 
    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
3064 chandransh 2924 
    Raises an exception if we encounter report for an AWB number that we did not ship.
3431 rajveer 2925 
 
3064 chandransh 2926 
    Parameters:
2927 
     - providerId
2928 
     - returnedOrders
1596 ankur.sing 2929 
    """
4910 phani.kuma 2930 
    self.send_markAsRTOrders(providerId, returnedOrders)
2931 
    self.recv_markAsRTOrders()
304 ashish 2932 
 
4910 phani.kuma 2933 
  def send_markAsRTOrders(self, providerId, returnedOrders):
2934 
    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
2935 
    args = markAsRTOrders_args()
3064 chandransh 2936 
    args.providerId = providerId
2937 
    args.returnedOrders = returnedOrders
1596 ankur.sing 2938 
    args.write(self._oprot)
2939 
    self._oprot.writeMessageEnd()
2940 
    self._oprot.trans.flush()
2941 
 
4910 phani.kuma 2942 
  def recv_markAsRTOrders(self, ):
1596 ankur.sing 2943 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2944 
    if mtype == TMessageType.EXCEPTION:
2945 
      x = TApplicationException()
2946 
      x.read(self._iprot)
2947 
      self._iprot.readMessageEnd()
2948 
      raise x
4910 phani.kuma 2949 
    result = markAsRTOrders_result()
1596 ankur.sing 2950 
    result.read(self._iprot)
2951 
    self._iprot.readMessageEnd()
3431 rajveer 2952 
    if result.ex is not None:
3064 chandransh 2953 
      raise result.ex
2954 
    return
1596 ankur.sing 2955 
 
4910 phani.kuma 2956 
  def getRTOrders(self, providerId):
2957 
    """
2958 
    Returns a list of orders that were returned by courier.
2959 
 
2960 
    Parameters:
2961 
     - providerId
2962 
    """
2963 
    self.send_getRTOrders(providerId)
2964 
    return self.recv_getRTOrders()
2965 
 
2966 
  def send_getRTOrders(self, providerId):
2967 
    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
2968 
    args = getRTOrders_args()
2969 
    args.providerId = providerId
2970 
    args.write(self._oprot)
2971 
    self._oprot.writeMessageEnd()
2972 
    self._oprot.trans.flush()
2973 
 
2974 
  def recv_getRTOrders(self, ):
2975 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2976 
    if mtype == TMessageType.EXCEPTION:
2977 
      x = TApplicationException()
2978 
      x.read(self._iprot)
2979 
      self._iprot.readMessageEnd()
2980 
      raise x
2981 
    result = getRTOrders_result()
2982 
    result.read(self._iprot)
2983 
    self._iprot.readMessageEnd()
2984 
    if result.success is not None:
2985 
      return result.success
2986 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
2987 
 
3064 chandransh 2988 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
1627 ankur.sing 2989 
    """
3064 chandransh 2990 
    Update the status description of orders whose AWB numbers are keys of the Map.
3431 rajveer 2991 
 
3064 chandransh 2992 
    Parameters:
2993 
     - providerId
2994 
     - undeliveredOrders
1627 ankur.sing 2995 
    """
3064 chandransh 2996 
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
4910 phani.kuma 2997 
    self.recv_updateNonDeliveryReason()
1596 ankur.sing 2998 
 
3064 chandransh 2999 
  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
3000 
    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
3001 
    args = updateNonDeliveryReason_args()
3002 
    args.providerId = providerId
3003 
    args.undeliveredOrders = undeliveredOrders
1627 ankur.sing 3004 
    args.write(self._oprot)
3005 
    self._oprot.writeMessageEnd()
3006 
    self._oprot.trans.flush()
3007 
 
3064 chandransh 3008 
  def recv_updateNonDeliveryReason(self, ):
1627 ankur.sing 3009 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3010 
    if mtype == TMessageType.EXCEPTION:
3011 
      x = TApplicationException()
3012 
      x.read(self._iprot)
3013 
      self._iprot.readMessageEnd()
3014 
      raise x
3064 chandransh 3015 
    result = updateNonDeliveryReason_result()
1627 ankur.sing 3016 
    result.read(self._iprot)
3017 
    self._iprot.readMessageEnd()
4910 phani.kuma 3018 
    if result.ex is not None:
3019 
      raise result.ex
3020 
    return
3021 
 
3022 
  def getNonDeliveredOrdersbyCourier(self, providerId):
3023 
    """
3024 
    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
3025 
 
3026 
    Parameters:
3027 
     - providerId
3028 
    """
3029 
    self.send_getNonDeliveredOrdersbyCourier(providerId)
3030 
    return self.recv_getNonDeliveredOrdersbyCourier()
3031 
 
3032 
  def send_getNonDeliveredOrdersbyCourier(self, providerId):
3033 
    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
3034 
    args = getNonDeliveredOrdersbyCourier_args()
3035 
    args.providerId = providerId
3036 
    args.write(self._oprot)
3037 
    self._oprot.writeMessageEnd()
3038 
    self._oprot.trans.flush()
3039 
 
3040 
  def recv_getNonDeliveredOrdersbyCourier(self, ):
3041 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3042 
    if mtype == TMessageType.EXCEPTION:
3043 
      x = TApplicationException()
3044 
      x.read(self._iprot)
3045 
      self._iprot.readMessageEnd()
3046 
      raise x
3047 
    result = getNonDeliveredOrdersbyCourier_result()
3048 
    result.read(self._iprot)
3049 
    self._iprot.readMessageEnd()
4581 phani.kuma 3050 
    if result.success is not None:
3051 
      return result.success
4910 phani.kuma 3052 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
3053 
 
3054 
  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3055 
    """
3056 
    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
3057 
 
3058 
    Parameters:
3059 
     - providerId
3060 
     - local_connected_orders
3061 
    """
3062 
    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
3063 
    self.recv_markOrdersAsLocalConnected()
3064 
 
3065 
  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
3066 
    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
3067 
    args = markOrdersAsLocalConnected_args()
3068 
    args.providerId = providerId
3069 
    args.local_connected_orders = local_connected_orders
3070 
    args.write(self._oprot)
3071 
    self._oprot.writeMessageEnd()
3072 
    self._oprot.trans.flush()
3073 
 
3074 
  def recv_markOrdersAsLocalConnected(self, ):
3075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3076 
    if mtype == TMessageType.EXCEPTION:
3077 
      x = TApplicationException()
3078 
      x.read(self._iprot)
3079 
      self._iprot.readMessageEnd()
3080 
      raise x
3081 
    result = markOrdersAsLocalConnected_result()
3082 
    result.read(self._iprot)
3083 
    self._iprot.readMessageEnd()
3431 rajveer 3084 
    if result.ex is not None:
3064 chandransh 3085 
      raise result.ex
4910 phani.kuma 3086 
    return
1627 ankur.sing 3087 
 
4910 phani.kuma 3088 
  def getOrdersNotLocalConnected(self, providerId):
3089 
    """
3090 
    Returns a list of orders that were picked up or shipped but pending local connection.
3091 
 
3092 
    Parameters:
3093 
     - providerId
3094 
    """
3095 
    self.send_getOrdersNotLocalConnected(providerId)
3096 
    return self.recv_getOrdersNotLocalConnected()
3097 
 
3098 
  def send_getOrdersNotLocalConnected(self, providerId):
3099 
    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
3100 
    args = getOrdersNotLocalConnected_args()
3101 
    args.providerId = providerId
3102 
    args.write(self._oprot)
3103 
    self._oprot.writeMessageEnd()
3104 
    self._oprot.trans.flush()
3105 
 
3106 
  def recv_getOrdersNotLocalConnected(self, ):
3107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3108 
    if mtype == TMessageType.EXCEPTION:
3109 
      x = TApplicationException()
3110 
      x.read(self._iprot)
3111 
      self._iprot.readMessageEnd()
3112 
      raise x
3113 
    result = getOrdersNotLocalConnected_result()
3114 
    result.read(self._iprot)
3115 
    self._iprot.readMessageEnd()
3116 
    if result.success is not None:
3117 
      return result.success
3118 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
3119 
 
3120 
  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3121 
    """
3122 
    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
3123 
 
3124 
    Parameters:
3125 
     - providerId
3126 
     - destination_city_reached_orders
3127 
    """
3128 
    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
3129 
    self.recv_markOrdersAsDestinationCityReached()
3130 
 
3131 
  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
3132 
    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
3133 
    args = markOrdersAsDestinationCityReached_args()
3134 
    args.providerId = providerId
3135 
    args.destination_city_reached_orders = destination_city_reached_orders
3136 
    args.write(self._oprot)
3137 
    self._oprot.writeMessageEnd()
3138 
    self._oprot.trans.flush()
3139 
 
3140 
  def recv_markOrdersAsDestinationCityReached(self, ):
3141 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3142 
    if mtype == TMessageType.EXCEPTION:
3143 
      x = TApplicationException()
3144 
      x.read(self._iprot)
3145 
      self._iprot.readMessageEnd()
3146 
      raise x
3147 
    result = markOrdersAsDestinationCityReached_result()
3148 
    result.read(self._iprot)
3149 
    self._iprot.readMessageEnd()
3150 
    if result.ex is not None:
3151 
      raise result.ex
3152 
    return
3153 
 
3154 
  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3155 
    """
3156 
    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
3157 
 
3158 
    Parameters:
3159 
     - providerId
3160 
     - first_atdl_orders
3161 
    """
3162 
    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
3163 
    self.recv_markOrdersAsFirstDeliveryAttempted()
3164 
 
3165 
  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
3166 
    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
3167 
    args = markOrdersAsFirstDeliveryAttempted_args()
3168 
    args.providerId = providerId
3169 
    args.first_atdl_orders = first_atdl_orders
3170 
    args.write(self._oprot)
3171 
    self._oprot.writeMessageEnd()
3172 
    self._oprot.trans.flush()
3173 
 
3174 
  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
3175 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3176 
    if mtype == TMessageType.EXCEPTION:
3177 
      x = TApplicationException()
3178 
      x.read(self._iprot)
3179 
      self._iprot.readMessageEnd()
3180 
      raise x
3181 
    result = markOrdersAsFirstDeliveryAttempted_result()
3182 
    result.read(self._iprot)
3183 
    self._iprot.readMessageEnd()
3184 
    if result.ex is not None:
3185 
      raise result.ex
3186 
    return
3187 
 
3064 chandransh 3188 
  def getUndeliveredOrders(self, providerId, warehouseId):
1627 ankur.sing 3189 
    """
3064 chandransh 3190 
    Returns the list of orders whose delivery time has passed but have not been
3191 
    delivered yet for the given provider and warehouse. To get a complete list of
3192 
    undelivered orders, pass them as -1.
3193 
    Returns an empty list if no such orders exist.
3431 rajveer 3194 
 
1886 ankur.sing 3195 
    Parameters:
3064 chandransh 3196 
     - providerId
3197 
     - warehouseId
1886 ankur.sing 3198 
    """
3064 chandransh 3199 
    self.send_getUndeliveredOrders(providerId, warehouseId)
3200 
    return self.recv_getUndeliveredOrders()
1627 ankur.sing 3201 
 
3064 chandransh 3202 
  def send_getUndeliveredOrders(self, providerId, warehouseId):
3203 
    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
3204 
    args = getUndeliveredOrders_args()
3205 
    args.providerId = providerId
3206 
    args.warehouseId = warehouseId
1886 ankur.sing 3207 
    args.write(self._oprot)
3208 
    self._oprot.writeMessageEnd()
3209 
    self._oprot.trans.flush()
3210 
 
3064 chandransh 3211 
  def recv_getUndeliveredOrders(self, ):
1886 ankur.sing 3212 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3213 
    if mtype == TMessageType.EXCEPTION:
3214 
      x = TApplicationException()
3215 
      x.read(self._iprot)
3216 
      self._iprot.readMessageEnd()
3217 
      raise x
3064 chandransh 3218 
    result = getUndeliveredOrders_result()
1886 ankur.sing 3219 
    result.read(self._iprot)
3220 
    self._iprot.readMessageEnd()
3431 rajveer 3221 
    if result.success is not None:
1886 ankur.sing 3222 
      return result.success
3064 chandransh 3223 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
1886 ankur.sing 3224 
 
4783 phani.kuma 3225 
  def getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3226 
    """
3227 
    Returns the list of orders whose expected delivery date has passed but have not been
3228 
    delivered yet.
3229 
    Returns an empty list if no such orders exist.
3230 
    """
3231 
    self.send_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3232 
    return self.recv_getUndeliveredOrdersExpectedDeliveryDateNotMet()
3233 
 
3234 
  def send_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3235 
    self._oprot.writeMessageBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet', TMessageType.CALL, self._seqid)
3236 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
3237 
    args.write(self._oprot)
3238 
    self._oprot.writeMessageEnd()
3239 
    self._oprot.trans.flush()
3240 
 
3241 
  def recv_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, ):
3242 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3243 
    if mtype == TMessageType.EXCEPTION:
3244 
      x = TApplicationException()
3245 
      x.read(self._iprot)
3246 
      self._iprot.readMessageEnd()
3247 
      raise x
3248 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
3249 
    result.read(self._iprot)
3250 
    self._iprot.readMessageEnd()
3251 
    if result.success is not None:
3252 
      return result.success
3253 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrdersExpectedDeliveryDateNotMet failed: unknown result");
3254 
 
2536 chandransh 3255 
  def toggleDOAFlag(self, orderId):
3256 
    """
3257 
    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.
3258 
    Returns the final flag status.
3259 
    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 3260 
 
2536 chandransh 3261 
    Parameters:
3262 
     - orderId
3263 
    """
3264 
    self.send_toggleDOAFlag(orderId)
3265 
    return self.recv_toggleDOAFlag()
1886 ankur.sing 3266 
 
2536 chandransh 3267 
  def send_toggleDOAFlag(self, orderId):
3268 
    self._oprot.writeMessageBegin('toggleDOAFlag', TMessageType.CALL, self._seqid)
3269 
    args = toggleDOAFlag_args()
3270 
    args.orderId = orderId
3271 
    args.write(self._oprot)
3272 
    self._oprot.writeMessageEnd()
3273 
    self._oprot.trans.flush()
3274 
 
3275 
  def recv_toggleDOAFlag(self, ):
3276 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3277 
    if mtype == TMessageType.EXCEPTION:
3278 
      x = TApplicationException()
3279 
      x.read(self._iprot)
3280 
      self._iprot.readMessageEnd()
3281 
      raise x
3282 
    result = toggleDOAFlag_result()
3283 
    result.read(self._iprot)
3284 
    self._iprot.readMessageEnd()
3431 rajveer 3285 
    if result.success is not None:
2536 chandransh 3286 
      return result.success
3431 rajveer 3287 
    if result.ex is not None:
2536 chandransh 3288 
      raise result.ex
3289 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
3290 
 
4712 rajveer 3291 
  def markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3292 
    """
3293 
    Parameters:
3294 
     - orderId
3295 
     - deliveryTimestamp
3296 
     - receiver
3297 
    """
3298 
    self.send_markOrderAsDelivered(orderId, deliveryTimestamp, receiver)
3299 
    self.recv_markOrderAsDelivered()
3300 
 
3301 
  def send_markOrderAsDelivered(self, orderId, deliveryTimestamp, receiver):
3302 
    self._oprot.writeMessageBegin('markOrderAsDelivered', TMessageType.CALL, self._seqid)
3303 
    args = markOrderAsDelivered_args()
3304 
    args.orderId = orderId
3305 
    args.deliveryTimestamp = deliveryTimestamp
3306 
    args.receiver = receiver
3307 
    args.write(self._oprot)
3308 
    self._oprot.writeMessageEnd()
3309 
    self._oprot.trans.flush()
3310 
 
3311 
  def recv_markOrderAsDelivered(self, ):
3312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3313 
    if mtype == TMessageType.EXCEPTION:
3314 
      x = TApplicationException()
3315 
      x.read(self._iprot)
3316 
      self._iprot.readMessageEnd()
3317 
      raise x
3318 
    result = markOrderAsDelivered_result()
3319 
    result.read(self._iprot)
3320 
    self._iprot.readMessageEnd()
3321 
    if result.ex is not None:
3322 
      raise result.ex
3323 
    return
3324 
 
5553 rajveer 3325 
  def markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3326 
    """
3327 
    Parameters:
3328 
     - orderId
3329 
     - deliveryTimestamp
3330 
    """
3331 
    self.send_markOrderAsReceivedAtStore(orderId, deliveryTimestamp)
3332 
    self.recv_markOrderAsReceivedAtStore()
3333 
 
3334 
  def send_markOrderAsReceivedAtStore(self, orderId, deliveryTimestamp):
3335 
    self._oprot.writeMessageBegin('markOrderAsReceivedAtStore', TMessageType.CALL, self._seqid)
3336 
    args = markOrderAsReceivedAtStore_args()
3337 
    args.orderId = orderId
3338 
    args.deliveryTimestamp = deliveryTimestamp
3339 
    args.write(self._oprot)
3340 
    self._oprot.writeMessageEnd()
3341 
    self._oprot.trans.flush()
3342 
 
3343 
  def recv_markOrderAsReceivedAtStore(self, ):
3344 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3345 
    if mtype == TMessageType.EXCEPTION:
3346 
      x = TApplicationException()
3347 
      x.read(self._iprot)
3348 
      self._iprot.readMessageEnd()
3349 
      raise x
3350 
    result = markOrderAsReceivedAtStore_result()
3351 
    result.read(self._iprot)
3352 
    self._iprot.readMessageEnd()
3353 
    if result.ex is not None:
3354 
      raise result.ex
3355 
    return
3356 
 
4454 rajveer 3357 
  def markOrderDoaRequestReceived(self, orderId):
3358 
    """
3359 
    Once user raise the request for a DOA, order status will be changed from DELVIERY_SUCCESS to DOA_REQUEST_RECEIVED
3360 
 
3361 
    Parameters:
3362 
     - orderId
3363 
    """
3364 
    self.send_markOrderDoaRequestReceived(orderId)
3365 
    return self.recv_markOrderDoaRequestReceived()
3366 
 
3367 
  def send_markOrderDoaRequestReceived(self, orderId):
3368 
    self._oprot.writeMessageBegin('markOrderDoaRequestReceived', TMessageType.CALL, self._seqid)
3369 
    args = markOrderDoaRequestReceived_args()
3370 
    args.orderId = orderId
3371 
    args.write(self._oprot)
3372 
    self._oprot.writeMessageEnd()
3373 
    self._oprot.trans.flush()
3374 
 
3375 
  def recv_markOrderDoaRequestReceived(self, ):
3376 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3377 
    if mtype == TMessageType.EXCEPTION:
3378 
      x = TApplicationException()
3379 
      x.read(self._iprot)
3380 
      self._iprot.readMessageEnd()
3381 
      raise x
3382 
    result = markOrderDoaRequestReceived_result()
3383 
    result.read(self._iprot)
3384 
    self._iprot.readMessageEnd()
3385 
    if result.success is not None:
3386 
      return result.success
3387 
    if result.ex is not None:
3388 
      raise result.ex
3389 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestReceived failed: unknown result");
3390 
 
3391 
  def markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3392 
    """
3393 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from DOA_REQUEST_RECEIVED
3394 
    to DOA_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3395 
 
3396 
    Parameters:
3397 
     - orderId
3398 
     - isAuthorized
3399 
    """
3400 
    self.send_markOrderDoaRequestAuthorized(orderId, isAuthorized)
3401 
    return self.recv_markOrderDoaRequestAuthorized()
3402 
 
3403 
  def send_markOrderDoaRequestAuthorized(self, orderId, isAuthorized):
3404 
    self._oprot.writeMessageBegin('markOrderDoaRequestAuthorized', TMessageType.CALL, self._seqid)
3405 
    args = markOrderDoaRequestAuthorized_args()
3406 
    args.orderId = orderId
3407 
    args.isAuthorized = isAuthorized
3408 
    args.write(self._oprot)
3409 
    self._oprot.writeMessageEnd()
3410 
    self._oprot.trans.flush()
3411 
 
3412 
  def recv_markOrderDoaRequestAuthorized(self, ):
3413 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3414 
    if mtype == TMessageType.EXCEPTION:
3415 
      x = TApplicationException()
3416 
      x.read(self._iprot)
3417 
      self._iprot.readMessageEnd()
3418 
      raise x
3419 
    result = markOrderDoaRequestAuthorized_result()
3420 
    result.read(self._iprot)
3421 
    self._iprot.readMessageEnd()
3422 
    if result.success is not None:
3423 
      return result.success
3424 
    if result.ex is not None:
3425 
      raise result.ex
3426 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderDoaRequestAuthorized failed: unknown result");
3427 
 
4488 rajveer 3428 
  def markOrderReturnRequestReceived(self, orderId):
3429 
    """
3430 
    Once user raise the request for a RET, order status will be changed from DELVIERY_SUCCESS to RET_REQUEST_RECEIVED
3431 
 
3432 
    Parameters:
3433 
     - orderId
3434 
    """
3435 
    self.send_markOrderReturnRequestReceived(orderId)
3436 
    return self.recv_markOrderReturnRequestReceived()
3437 
 
3438 
  def send_markOrderReturnRequestReceived(self, orderId):
3439 
    self._oprot.writeMessageBegin('markOrderReturnRequestReceived', TMessageType.CALL, self._seqid)
3440 
    args = markOrderReturnRequestReceived_args()
3441 
    args.orderId = orderId
3442 
    args.write(self._oprot)
3443 
    self._oprot.writeMessageEnd()
3444 
    self._oprot.trans.flush()
3445 
 
3446 
  def recv_markOrderReturnRequestReceived(self, ):
3447 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3448 
    if mtype == TMessageType.EXCEPTION:
3449 
      x = TApplicationException()
3450 
      x.read(self._iprot)
3451 
      self._iprot.readMessageEnd()
3452 
      raise x
3453 
    result = markOrderReturnRequestReceived_result()
3454 
    result.read(self._iprot)
3455 
    self._iprot.readMessageEnd()
3456 
    if result.success is not None:
3457 
      return result.success
3458 
    if result.ex is not None:
3459 
      raise result.ex
3460 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestReceived failed: unknown result");
3461 
 
3462 
  def markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3463 
    """
3464 
    CRM person can authorize or deny the request reised by customer. If he authorizes order will change from RET_REQUEST_RECEIVED
3465 
    to RET_REQUEST_AUTHORIZED. If he denies, status will be changed back to DELVIERY_SUCCESS.
3466 
 
3467 
    Parameters:
3468 
     - orderId
3469 
     - isAuthorized
3470 
    """
3471 
    self.send_markOrderReturnRequestAuthorized(orderId, isAuthorized)
3472 
    return self.recv_markOrderReturnRequestAuthorized()
3473 
 
3474 
  def send_markOrderReturnRequestAuthorized(self, orderId, isAuthorized):
3475 
    self._oprot.writeMessageBegin('markOrderReturnRequestAuthorized', TMessageType.CALL, self._seqid)
3476 
    args = markOrderReturnRequestAuthorized_args()
3477 
    args.orderId = orderId
3478 
    args.isAuthorized = isAuthorized
3479 
    args.write(self._oprot)
3480 
    self._oprot.writeMessageEnd()
3481 
    self._oprot.trans.flush()
3482 
 
3483 
  def recv_markOrderReturnRequestAuthorized(self, ):
3484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3485 
    if mtype == TMessageType.EXCEPTION:
3486 
      x = TApplicationException()
3487 
      x.read(self._iprot)
3488 
      self._iprot.readMessageEnd()
3489 
      raise x
3490 
    result = markOrderReturnRequestAuthorized_result()
3491 
    result.read(self._iprot)
3492 
    self._iprot.readMessageEnd()
3493 
    if result.success is not None:
3494 
      return result.success
3495 
    if result.ex is not None:
3496 
      raise result.ex
3497 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderReturnRequestAuthorized failed: unknown result");
3498 
 
4579 rajveer 3499 
  def requestPickupNumber(self, orderId, providerId):
2536 chandransh 3500 
    """
3501 
    Sends out an email to the account manager of the original courier provider used to ship the order.
4452 rajveer 3502 
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUEST_RAISED.
3503 
    If the order status was DOA_PICKUP_REQUEST_RAISED, it is left unchanged.
2536 chandransh 3504 
    For any other status, it returns false.
3505 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3506 
 
2536 chandransh 3507 
    Parameters:
3508 
     - orderId
4579 rajveer 3509 
     - providerId
2536 chandransh 3510 
    """
4579 rajveer 3511 
    self.send_requestPickupNumber(orderId, providerId)
2536 chandransh 3512 
    return self.recv_requestPickupNumber()
3513 
 
4579 rajveer 3514 
  def send_requestPickupNumber(self, orderId, providerId):
2536 chandransh 3515 
    self._oprot.writeMessageBegin('requestPickupNumber', TMessageType.CALL, self._seqid)
3516 
    args = requestPickupNumber_args()
3517 
    args.orderId = orderId
4579 rajveer 3518 
    args.providerId = providerId
2536 chandransh 3519 
    args.write(self._oprot)
3520 
    self._oprot.writeMessageEnd()
3521 
    self._oprot.trans.flush()
3522 
 
3523 
  def recv_requestPickupNumber(self, ):
3524 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3525 
    if mtype == TMessageType.EXCEPTION:
3526 
      x = TApplicationException()
3527 
      x.read(self._iprot)
3528 
      self._iprot.readMessageEnd()
3529 
      raise x
3530 
    result = requestPickupNumber_result()
3531 
    result.read(self._iprot)
3532 
    self._iprot.readMessageEnd()
3431 rajveer 3533 
    if result.success is not None:
2536 chandransh 3534 
      return result.success
3431 rajveer 3535 
    if result.ex is not None:
2536 chandransh 3536 
      raise result.ex
3537 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
3538 
 
4602 rajveer 3539 
  def authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3540 
    """
4452 rajveer 3541 
    If the order status is DOA_PICKUP_REQUEST_RAISED, it does the following
2536 chandransh 3542 
    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
3543 
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
3544 
    	3. Returns true
2591 chandransh 3545 
    If the order is in any other status, it returns false.
2536 chandransh 3546 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3547 
 
2536 chandransh 3548 
    Parameters:
3549 
     - orderId
3550 
     - pickupNumber
4602 rajveer 3551 
     - providerId
2536 chandransh 3552 
    """
4602 rajveer 3553 
    self.send_authorizePickup(orderId, pickupNumber, providerId)
2536 chandransh 3554 
    return self.recv_authorizePickup()
3555 
 
4602 rajveer 3556 
  def send_authorizePickup(self, orderId, pickupNumber, providerId):
2536 chandransh 3557 
    self._oprot.writeMessageBegin('authorizePickup', TMessageType.CALL, self._seqid)
3558 
    args = authorizePickup_args()
3559 
    args.orderId = orderId
3560 
    args.pickupNumber = pickupNumber
4602 rajveer 3561 
    args.providerId = providerId
2536 chandransh 3562 
    args.write(self._oprot)
3563 
    self._oprot.writeMessageEnd()
3564 
    self._oprot.trans.flush()
3565 
 
3566 
  def recv_authorizePickup(self, ):
3567 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3568 
    if mtype == TMessageType.EXCEPTION:
3569 
      x = TApplicationException()
3570 
      x.read(self._iprot)
3571 
      self._iprot.readMessageEnd()
3572 
      raise x
3573 
    result = authorizePickup_result()
3574 
    result.read(self._iprot)
3575 
    self._iprot.readMessageEnd()
3431 rajveer 3576 
    if result.success is not None:
2536 chandransh 3577 
      return result.success
3431 rajveer 3578 
    if result.ex is not None:
2536 chandransh 3579 
      raise result.ex
3580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
3581 
 
2764 chandransh 3582 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
3583 
    """
3584 
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
3431 rajveer 3585 
 
2764 chandransh 3586 
    Parameters:
3587 
     - providerId
3588 
     - pickupDetails
3589 
    """
3590 
    self.send_markDoasAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3591 
    self.recv_markDoasAsPickedUp()
2764 chandransh 3592 
 
3593 
  def send_markDoasAsPickedUp(self, providerId, pickupDetails):
3594 
    self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
3595 
    args = markDoasAsPickedUp_args()
3596 
    args.providerId = providerId
3597 
    args.pickupDetails = pickupDetails
3598 
    args.write(self._oprot)
3599 
    self._oprot.writeMessageEnd()
3600 
    self._oprot.trans.flush()
3601 
 
3602 
  def recv_markDoasAsPickedUp(self, ):
3603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3604 
    if mtype == TMessageType.EXCEPTION:
3605 
      x = TApplicationException()
3606 
      x.read(self._iprot)
3607 
      self._iprot.readMessageEnd()
3608 
      raise x
3609 
    result = markDoasAsPickedUp_result()
3610 
    result.read(self._iprot)
3611 
    self._iprot.readMessageEnd()
4910 phani.kuma 3612 
    return
3613 
 
3614 
  def getDoasNotPickedUp(self, providerId):
3615 
    """
3616 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3617 
 
3618 
    Parameters:
3619 
     - providerId
3620 
    """
3621 
    self.send_getDoasNotPickedUp(providerId)
3622 
    return self.recv_getDoasNotPickedUp()
3623 
 
3624 
  def send_getDoasNotPickedUp(self, providerId):
3625 
    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
3626 
    args = getDoasNotPickedUp_args()
3627 
    args.providerId = providerId
3628 
    args.write(self._oprot)
3629 
    self._oprot.writeMessageEnd()
3630 
    self._oprot.trans.flush()
3631 
 
3632 
  def recv_getDoasNotPickedUp(self, ):
3633 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3634 
    if mtype == TMessageType.EXCEPTION:
3635 
      x = TApplicationException()
3636 
      x.read(self._iprot)
3637 
      self._iprot.readMessageEnd()
3638 
      raise x
3639 
    result = getDoasNotPickedUp_result()
3640 
    result.read(self._iprot)
3641 
    self._iprot.readMessageEnd()
3431 rajveer 3642 
    if result.success is not None:
2764 chandransh 3643 
      return result.success
4910 phani.kuma 3644 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
2764 chandransh 3645 
 
4741 phani.kuma 3646 
  def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3647 
    """
3648 
    Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
3649 
 
3650 
    Parameters:
3651 
     - providerId
3652 
     - pickupDetails
3653 
    """
3654 
    self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
4910 phani.kuma 3655 
    self.recv_markReturnOrdersAsPickedUp()
4741 phani.kuma 3656 
 
3657 
  def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
3658 
    self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
3659 
    args = markReturnOrdersAsPickedUp_args()
3660 
    args.providerId = providerId
3661 
    args.pickupDetails = pickupDetails
3662 
    args.write(self._oprot)
3663 
    self._oprot.writeMessageEnd()
3664 
    self._oprot.trans.flush()
3665 
 
3666 
  def recv_markReturnOrdersAsPickedUp(self, ):
3667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3668 
    if mtype == TMessageType.EXCEPTION:
3669 
      x = TApplicationException()
3670 
      x.read(self._iprot)
3671 
      self._iprot.readMessageEnd()
3672 
      raise x
3673 
    result = markReturnOrdersAsPickedUp_result()
3674 
    result.read(self._iprot)
3675 
    self._iprot.readMessageEnd()
4910 phani.kuma 3676 
    return
3677 
 
3678 
  def getReturnOrdersNotPickedUp(self, providerId):
3679 
    """
3680 
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
3681 
 
3682 
    Parameters:
3683 
     - providerId
3684 
    """
3685 
    self.send_getReturnOrdersNotPickedUp(providerId)
3686 
    return self.recv_getReturnOrdersNotPickedUp()
3687 
 
3688 
  def send_getReturnOrdersNotPickedUp(self, providerId):
3689 
    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
3690 
    args = getReturnOrdersNotPickedUp_args()
3691 
    args.providerId = providerId
3692 
    args.write(self._oprot)
3693 
    self._oprot.writeMessageEnd()
3694 
    self._oprot.trans.flush()
3695 
 
3696 
  def recv_getReturnOrdersNotPickedUp(self, ):
3697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3698 
    if mtype == TMessageType.EXCEPTION:
3699 
      x = TApplicationException()
3700 
      x.read(self._iprot)
3701 
      self._iprot.readMessageEnd()
3702 
      raise x
3703 
    result = getReturnOrdersNotPickedUp_result()
3704 
    result.read(self._iprot)
3705 
    self._iprot.readMessageEnd()
4741 phani.kuma 3706 
    if result.success is not None:
3707 
      return result.success
4910 phani.kuma 3708 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
4741 phani.kuma 3709 
 
4479 rajveer 3710 
  def receiveReturn(self, orderId, receiveCondition):
2591 chandransh 3711 
    """
4452 rajveer 3712 
    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 3713 
    If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
2591 chandransh 3714 
    If the order is in any other state, it returns false.
3715 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3716 
 
2591 chandransh 3717 
    Parameters:
3718 
     - orderId
4479 rajveer 3719 
     - receiveCondition
2591 chandransh 3720 
    """
4479 rajveer 3721 
    self.send_receiveReturn(orderId, receiveCondition)
2616 chandransh 3722 
    return self.recv_receiveReturn()
2536 chandransh 3723 
 
4479 rajveer 3724 
  def send_receiveReturn(self, orderId, receiveCondition):
2616 chandransh 3725 
    self._oprot.writeMessageBegin('receiveReturn', TMessageType.CALL, self._seqid)
3726 
    args = receiveReturn_args()
2591 chandransh 3727 
    args.orderId = orderId
4479 rajveer 3728 
    args.receiveCondition = receiveCondition
2591 chandransh 3729 
    args.write(self._oprot)
3730 
    self._oprot.writeMessageEnd()
3731 
    self._oprot.trans.flush()
3732 
 
2616 chandransh 3733 
  def recv_receiveReturn(self, ):
2591 chandransh 3734 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3735 
    if mtype == TMessageType.EXCEPTION:
3736 
      x = TApplicationException()
3737 
      x.read(self._iprot)
3738 
      self._iprot.readMessageEnd()
3739 
      raise x
2616 chandransh 3740 
    result = receiveReturn_result()
2591 chandransh 3741 
    result.read(self._iprot)
3742 
    self._iprot.readMessageEnd()
3431 rajveer 3743 
    if result.success is not None:
2591 chandransh 3744 
      return result.success
3431 rajveer 3745 
    if result.ex is not None:
2591 chandransh 3746 
      raise result.ex
2616 chandransh 3747 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
2591 chandransh 3748 
 
3749 
  def validateDoa(self, orderId, isValid):
3750 
    """
4452 rajveer 3751 
    Used to validate the DOA certificate for an order in the DOA_RECEIVED_PRESTINE state. If the certificate is valid,
2616 chandransh 3752 
    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 3753 
    If the order is in any other state, it returns false.
3754 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3755 
 
2591 chandransh 3756 
    Parameters:
3757 
     - orderId
3758 
     - isValid
3759 
    """
3760 
    self.send_validateDoa(orderId, isValid)
3761 
    return self.recv_validateDoa()
3762 
 
3763 
  def send_validateDoa(self, orderId, isValid):
3764 
    self._oprot.writeMessageBegin('validateDoa', TMessageType.CALL, self._seqid)
3765 
    args = validateDoa_args()
3766 
    args.orderId = orderId
3767 
    args.isValid = isValid
3768 
    args.write(self._oprot)
3769 
    self._oprot.writeMessageEnd()
3770 
    self._oprot.trans.flush()
3771 
 
3772 
  def recv_validateDoa(self, ):
3773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3774 
    if mtype == TMessageType.EXCEPTION:
3775 
      x = TApplicationException()
3776 
      x.read(self._iprot)
3777 
      self._iprot.readMessageEnd()
3778 
      raise x
3779 
    result = validateDoa_result()
3780 
    result.read(self._iprot)
3781 
    self._iprot.readMessageEnd()
3431 rajveer 3782 
    if result.success is not None:
2591 chandransh 3783 
      return result.success
3431 rajveer 3784 
    if result.ex is not None:
2591 chandransh 3785 
      raise result.ex
3786 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
3787 
 
4495 rajveer 3788 
  def validateReturnProduct(self, orderId, isUsable):
3789 
    """
3790 
    Parameters:
3791 
     - orderId
3792 
     - isUsable
3793 
    """
3794 
    self.send_validateReturnProduct(orderId, isUsable)
3795 
    return self.recv_validateReturnProduct()
3796 
 
3797 
  def send_validateReturnProduct(self, orderId, isUsable):
3798 
    self._oprot.writeMessageBegin('validateReturnProduct', TMessageType.CALL, self._seqid)
3799 
    args = validateReturnProduct_args()
3800 
    args.orderId = orderId
3801 
    args.isUsable = isUsable
3802 
    args.write(self._oprot)
3803 
    self._oprot.writeMessageEnd()
3804 
    self._oprot.trans.flush()
3805 
 
3806 
  def recv_validateReturnProduct(self, ):
3807 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3808 
    if mtype == TMessageType.EXCEPTION:
3809 
      x = TApplicationException()
3810 
      x.read(self._iprot)
3811 
      self._iprot.readMessageEnd()
3812 
      raise x
3813 
    result = validateReturnProduct_result()
3814 
    result.read(self._iprot)
3815 
    self._iprot.readMessageEnd()
3816 
    if result.success is not None:
3817 
      return result.success
3818 
    if result.ex is not None:
3819 
      raise result.ex
3820 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateReturnProduct failed: unknown result");
3821 
 
2616 chandransh 3822 
  def reshipOrder(self, orderId):
3823 
    """
4484 rajveer 3824 
    If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3825 
    	1. Creates a new order for processing in the BILLED state. All billing information is saved.
4484 rajveer 3826 
    	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 3827 
 
3828 
    If the order is in DOA_CERT_VALID state, it does the following:
3829 
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
3830 
    	2. Creates a return order for the warehouse executive to return the DOA material.
4452 rajveer 3831 
    	3. Marks the current order as the final DOA_VALID_RESHIPPED state.
3431 rajveer 3832 
 
2616 chandransh 3833 
    Returns the id of the newly created order.
3431 rajveer 3834 
 
2616 chandransh 3835 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3836 
 
2616 chandransh 3837 
    Parameters:
3838 
     - orderId
3839 
    """
3840 
    self.send_reshipOrder(orderId)
3841 
    return self.recv_reshipOrder()
2591 chandransh 3842 
 
2616 chandransh 3843 
  def send_reshipOrder(self, orderId):
3844 
    self._oprot.writeMessageBegin('reshipOrder', TMessageType.CALL, self._seqid)
3845 
    args = reshipOrder_args()
3846 
    args.orderId = orderId
3847 
    args.write(self._oprot)
3848 
    self._oprot.writeMessageEnd()
3849 
    self._oprot.trans.flush()
3850 
 
3851 
  def recv_reshipOrder(self, ):
3852 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3853 
    if mtype == TMessageType.EXCEPTION:
3854 
      x = TApplicationException()
3855 
      x.read(self._iprot)
3856 
      self._iprot.readMessageEnd()
3857 
      raise x
3858 
    result = reshipOrder_result()
3859 
    result.read(self._iprot)
3860 
    self._iprot.readMessageEnd()
3431 rajveer 3861 
    if result.success is not None:
2616 chandransh 3862 
      return result.success
3431 rajveer 3863 
    if result.ex is not None:
2616 chandransh 3864 
      raise result.ex
3865 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
3866 
 
3226 chandransh 3867 
  def refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3868 
    """
4484 rajveer 3869 
    If the order is in RTO_RECEIVED_PRESTINE, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
2616 chandransh 3870 
    	1. Creates a refund request for batch processing.
3871 
    	2. Creates a return order for the warehouse executive to return the shipped material.
4484 rajveer 3872 
    	3. Marks the current order as RTO_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
3431 rajveer 3873 
 
2616 chandransh 3874 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3875 
    	1. Creates a refund request for batch processing.
3226 chandransh 3876 
    	2. Cancels the reservation of the item in the warehouse.
3877 
    	3. Marks the current order as the REFUNDED final state.
3431 rajveer 3878 
 
3226 chandransh 3879 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
3880 
    	1. Cancels the reservation of the item in the warehouse.
3881 
    	2. Marks the current order as CANCELED.
3882 
 
3883 
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
3884 
 
2616 chandransh 3885 
    Returns True if it is successful, False otherwise.
3431 rajveer 3886 
 
2616 chandransh 3887 
    Throws an exception if the order with the given id couldn't be found.
3431 rajveer 3888 
 
2616 chandransh 3889 
    Parameters:
3890 
     - orderId
3226 chandransh 3891 
     - refundedBy
3892 
     - reason
2616 chandransh 3893 
    """
3226 chandransh 3894 
    self.send_refundOrder(orderId, refundedBy, reason)
2616 chandransh 3895 
    return self.recv_refundOrder()
3896 
 
3226 chandransh 3897 
  def send_refundOrder(self, orderId, refundedBy, reason):
2616 chandransh 3898 
    self._oprot.writeMessageBegin('refundOrder', TMessageType.CALL, self._seqid)
3899 
    args = refundOrder_args()
3900 
    args.orderId = orderId
3226 chandransh 3901 
    args.refundedBy = refundedBy
3902 
    args.reason = reason
2616 chandransh 3903 
    args.write(self._oprot)
3904 
    self._oprot.writeMessageEnd()
3905 
    self._oprot.trans.flush()
3906 
 
3907 
  def recv_refundOrder(self, ):
3908 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3909 
    if mtype == TMessageType.EXCEPTION:
3910 
      x = TApplicationException()
3911 
      x.read(self._iprot)
3912 
      self._iprot.readMessageEnd()
3913 
      raise x
3914 
    result = refundOrder_result()
3915 
    result.read(self._iprot)
3916 
    self._iprot.readMessageEnd()
3431 rajveer 3917 
    if result.success is not None:
2616 chandransh 3918 
      return result.success
3431 rajveer 3919 
    if result.ex is not None:
2616 chandransh 3920 
      raise result.ex
3921 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
3922 
 
2690 chandransh 3923 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
3924 
    """
3925 
    Get all return orders created between the from and to dates for the given warehouse.
3926 
    Ignores the warehouse if it is passed as -1.
3431 rajveer 3927 
 
2690 chandransh 3928 
    Parameters:
3929 
     - warehouseId
3930 
     - fromDate
3931 
     - toDate
3932 
    """
3933 
    self.send_getReturnOrders(warehouseId, fromDate, toDate)
3934 
    return self.recv_getReturnOrders()
2616 chandransh 3935 
 
2690 chandransh 3936 
  def send_getReturnOrders(self, warehouseId, fromDate, toDate):
3937 
    self._oprot.writeMessageBegin('getReturnOrders', TMessageType.CALL, self._seqid)
3938 
    args = getReturnOrders_args()
3939 
    args.warehouseId = warehouseId
3940 
    args.fromDate = fromDate
3941 
    args.toDate = toDate
3942 
    args.write(self._oprot)
3943 
    self._oprot.writeMessageEnd()
3944 
    self._oprot.trans.flush()
3945 
 
3946 
  def recv_getReturnOrders(self, ):
3947 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3948 
    if mtype == TMessageType.EXCEPTION:
3949 
      x = TApplicationException()
3950 
      x.read(self._iprot)
3951 
      self._iprot.readMessageEnd()
3952 
      raise x
3953 
    result = getReturnOrders_result()
3954 
    result.read(self._iprot)
3955 
    self._iprot.readMessageEnd()
3431 rajveer 3956 
    if result.success is not None:
2690 chandransh 3957 
      return result.success
3958 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
3959 
 
5481 phani.kuma 3960 
  def getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3961 
    """
3962 
    Get all return orders created between the from and to dates.
3963 
 
3964 
    Parameters:
3965 
     - onlyNotProcessed
3966 
     - fromDate
3967 
     - toDate
3968 
    """
3969 
    self.send_getAllReturnOrders(onlyNotProcessed, fromDate, toDate)
3970 
    return self.recv_getAllReturnOrders()
3971 
 
3972 
  def send_getAllReturnOrders(self, onlyNotProcessed, fromDate, toDate):
3973 
    self._oprot.writeMessageBegin('getAllReturnOrders', TMessageType.CALL, self._seqid)
3974 
    args = getAllReturnOrders_args()
3975 
    args.onlyNotProcessed = onlyNotProcessed
3976 
    args.fromDate = fromDate
3977 
    args.toDate = toDate
3978 
    args.write(self._oprot)
3979 
    self._oprot.writeMessageEnd()
3980 
    self._oprot.trans.flush()
3981 
 
3982 
  def recv_getAllReturnOrders(self, ):
3983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
3984 
    if mtype == TMessageType.EXCEPTION:
3985 
      x = TApplicationException()
3986 
      x.read(self._iprot)
3987 
      self._iprot.readMessageEnd()
3988 
      raise x
3989 
    result = getAllReturnOrders_result()
3990 
    result.read(self._iprot)
3991 
    self._iprot.readMessageEnd()
3992 
    if result.success is not None:
3993 
      return result.success
3994 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllReturnOrders failed: unknown result");
3995 
 
2700 chandransh 3996 
  def getReturnOrder(self, id):
3997 
    """
3998 
    Returns the ReturnOrder corresponding to the given id.
3999 
    Throws an exception if the return order with the given id couldn't be found.
3431 rajveer 4000 
 
2700 chandransh 4001 
    Parameters:
4002 
     - id
4003 
    """
4004 
    self.send_getReturnOrder(id)
4005 
    return self.recv_getReturnOrder()
4006 
 
4007 
  def send_getReturnOrder(self, id):
4008 
    self._oprot.writeMessageBegin('getReturnOrder', TMessageType.CALL, self._seqid)
4009 
    args = getReturnOrder_args()
4010 
    args.id = id
4011 
    args.write(self._oprot)
4012 
    self._oprot.writeMessageEnd()
4013 
    self._oprot.trans.flush()
4014 
 
4015 
  def recv_getReturnOrder(self, ):
4016 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4017 
    if mtype == TMessageType.EXCEPTION:
4018 
      x = TApplicationException()
4019 
      x.read(self._iprot)
4020 
      self._iprot.readMessageEnd()
4021 
      raise x
4022 
    result = getReturnOrder_result()
4023 
    result.read(self._iprot)
4024 
    self._iprot.readMessageEnd()
3431 rajveer 4025 
    if result.success is not None:
2700 chandransh 4026 
      return result.success
3431 rajveer 4027 
    if result.ex is not None:
2700 chandransh 4028 
      raise result.ex
4029 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
4030 
 
2690 chandransh 4031 
  def processReturn(self, returnOrderId):
4032 
    """
4033 
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
3431 rajveer 4034 
 
2690 chandransh 4035 
    Parameters:
4036 
     - returnOrderId
4037 
    """
4038 
    self.send_processReturn(returnOrderId)
4039 
    self.recv_processReturn()
4040 
 
4041 
  def send_processReturn(self, returnOrderId):
4042 
    self._oprot.writeMessageBegin('processReturn', TMessageType.CALL, self._seqid)
4043 
    args = processReturn_args()
4044 
    args.returnOrderId = returnOrderId
4045 
    args.write(self._oprot)
4046 
    self._oprot.writeMessageEnd()
4047 
    self._oprot.trans.flush()
4048 
 
4049 
  def recv_processReturn(self, ):
4050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4051 
    if mtype == TMessageType.EXCEPTION:
4052 
      x = TApplicationException()
4053 
      x.read(self._iprot)
4054 
      self._iprot.readMessageEnd()
4055 
      raise x
4056 
    result = processReturn_result()
4057 
    result.read(self._iprot)
4058 
    self._iprot.readMessageEnd()
3431 rajveer 4059 
    if result.ex is not None:
2690 chandransh 4060 
      raise result.ex
4061 
    return
4062 
 
3451 chandransh 4063 
  def updateWeight(self, orderId, weight):
4064 
    """
4065 
    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 4066 
 
3451 chandransh 4067 
    Parameters:
4068 
     - orderId
4069 
     - weight
4070 
    """
4071 
    self.send_updateWeight(orderId, weight)
4072 
    return self.recv_updateWeight()
4073 
 
4074 
  def send_updateWeight(self, orderId, weight):
4075 
    self._oprot.writeMessageBegin('updateWeight', TMessageType.CALL, self._seqid)
4076 
    args = updateWeight_args()
4077 
    args.orderId = orderId
4078 
    args.weight = weight
4079 
    args.write(self._oprot)
4080 
    self._oprot.writeMessageEnd()
4081 
    self._oprot.trans.flush()
4082 
 
4083 
  def recv_updateWeight(self, ):
4084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4085 
    if mtype == TMessageType.EXCEPTION:
4086 
      x = TApplicationException()
4087 
      x.read(self._iprot)
4088 
      self._iprot.readMessageEnd()
4089 
      raise x
4090 
    result = updateWeight_result()
4091 
    result.read(self._iprot)
4092 
    self._iprot.readMessageEnd()
4093 
    if result.success is not None:
4094 
      return result.success
4095 
    if result.ex is not None:
4096 
      raise result.ex
4097 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateWeight failed: unknown result");
4098 
 
3469 chandransh 4099 
  def changeItem(self, orderId, itemId):
4100 
    """
4101 
    Change the item to be shipped for this order. Also adjusts the reservation in the inventory accordingly.
4102 
    Currently, it also ensures that only a different color of the given item is shipped.
3451 chandransh 4103 
 
3469 chandransh 4104 
    Parameters:
4105 
     - orderId
4106 
     - itemId
4107 
    """
4108 
    self.send_changeItem(orderId, itemId)
4109 
    return self.recv_changeItem()
4110 
 
4111 
  def send_changeItem(self, orderId, itemId):
4112 
    self._oprot.writeMessageBegin('changeItem', TMessageType.CALL, self._seqid)
4113 
    args = changeItem_args()
4114 
    args.orderId = orderId
4115 
    args.itemId = itemId
4116 
    args.write(self._oprot)
4117 
    self._oprot.writeMessageEnd()
4118 
    self._oprot.trans.flush()
4119 
 
4120 
  def recv_changeItem(self, ):
4121 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4122 
    if mtype == TMessageType.EXCEPTION:
4123 
      x = TApplicationException()
4124 
      x.read(self._iprot)
4125 
      self._iprot.readMessageEnd()
4126 
      raise x
4127 
    result = changeItem_result()
4128 
    result.read(self._iprot)
4129 
    self._iprot.readMessageEnd()
4130 
    if result.success is not None:
4131 
      return result.success
4132 
    if result.ex is not None:
4133 
      raise result.ex
4134 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeItem failed: unknown result");
4135 
 
4136 
  def shiftToWarehouse(self, orderId, warehouseId):
4137 
    """
4138 
    Moves the given order to the given warehouse. Also adjusts the inventory reservations accordingly.
4139 
 
4140 
    Parameters:
4141 
     - orderId
4142 
     - warehouseId
4143 
    """
4144 
    self.send_shiftToWarehouse(orderId, warehouseId)
4145 
    return self.recv_shiftToWarehouse()
4146 
 
4147 
  def send_shiftToWarehouse(self, orderId, warehouseId):
4148 
    self._oprot.writeMessageBegin('shiftToWarehouse', TMessageType.CALL, self._seqid)
4149 
    args = shiftToWarehouse_args()
4150 
    args.orderId = orderId
4151 
    args.warehouseId = warehouseId
4152 
    args.write(self._oprot)
4153 
    self._oprot.writeMessageEnd()
4154 
    self._oprot.trans.flush()
4155 
 
4156 
  def recv_shiftToWarehouse(self, ):
4157 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4158 
    if mtype == TMessageType.EXCEPTION:
4159 
      x = TApplicationException()
4160 
      x.read(self._iprot)
4161 
      self._iprot.readMessageEnd()
4162 
      raise x
4163 
    result = shiftToWarehouse_result()
4164 
    result.read(self._iprot)
4165 
    self._iprot.readMessageEnd()
4166 
    if result.success is not None:
4167 
      return result.success
4168 
    if result.ex is not None:
4169 
      raise result.ex
4170 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "shiftToWarehouse failed: unknown result");
4171 
 
4647 rajveer 4172 
  def addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4173 
    """
4174 
    Adds the given delay reason to the given order.
3986 chandransh 4175 
    Increases the expected delivery time of the given order by the given no. of days.
3553 chandransh 4176 
    Raises an exception if no order with the given id can be found.
3469 chandransh 4177 
 
3553 chandransh 4178 
    Parameters:
4179 
     - orderId
4180 
     - delayReason
3986 chandransh 4181 
     - furtherDelay
4647 rajveer 4182 
     - delayReasonText
3553 chandransh 4183 
    """
4647 rajveer 4184 
    self.send_addDelayReason(orderId, delayReason, furtherDelay, delayReasonText)
3553 chandransh 4185 
    return self.recv_addDelayReason()
4186 
 
4647 rajveer 4187 
  def send_addDelayReason(self, orderId, delayReason, furtherDelay, delayReasonText):
3553 chandransh 4188 
    self._oprot.writeMessageBegin('addDelayReason', TMessageType.CALL, self._seqid)
4189 
    args = addDelayReason_args()
4190 
    args.orderId = orderId
4191 
    args.delayReason = delayReason
3986 chandransh 4192 
    args.furtherDelay = furtherDelay
4647 rajveer 4193 
    args.delayReasonText = delayReasonText
3553 chandransh 4194 
    args.write(self._oprot)
4195 
    self._oprot.writeMessageEnd()
4196 
    self._oprot.trans.flush()
4197 
 
4198 
  def recv_addDelayReason(self, ):
4199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4200 
    if mtype == TMessageType.EXCEPTION:
4201 
      x = TApplicationException()
4202 
      x.read(self._iprot)
4203 
      self._iprot.readMessageEnd()
4204 
      raise x
4205 
    result = addDelayReason_result()
4206 
    result.read(self._iprot)
4207 
    self._iprot.readMessageEnd()
4208 
    if result.success is not None:
4209 
      return result.success
4210 
    if result.ex is not None:
4211 
      raise result.ex
4212 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addDelayReason failed: unknown result");
4213 
 
3956 chandransh 4214 
  def reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4215 
    """
4216 
    Marks the COD orders with given AWB nos. as having been processed.
4217 
    Updates the captured amount for the corresponding payment.
3553 chandransh 4218 
 
3956 chandransh 4219 
    Returns a map of AWBs which were not processed and the associated reason. An AWB is not processed if:
4220 
    1. There is no order corresponding to an AWB number.
4221 
    2. The captured amount for a payment exceeds the total payment.
4222 
    3. The order corresponding to an AWB no. is in a state prior to DELIVERY_SUCCESS.
4223 
 
4224 
    Parameters:
4225 
     - collectedAmountMap
4226 
     - xferBy
4227 
     - xferTxnId
4228 
     - xferDate
4229 
    """
4230 
    self.send_reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate)
4231 
    return self.recv_reconcileCodCollection()
4232 
 
4233 
  def send_reconcileCodCollection(self, collectedAmountMap, xferBy, xferTxnId, xferDate):
4234 
    self._oprot.writeMessageBegin('reconcileCodCollection', TMessageType.CALL, self._seqid)
4235 
    args = reconcileCodCollection_args()
4236 
    args.collectedAmountMap = collectedAmountMap
4237 
    args.xferBy = xferBy
4238 
    args.xferTxnId = xferTxnId
4239 
    args.xferDate = xferDate
4240 
    args.write(self._oprot)
4241 
    self._oprot.writeMessageEnd()
4242 
    self._oprot.trans.flush()
4243 
 
4244 
  def recv_reconcileCodCollection(self, ):
4245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4246 
    if mtype == TMessageType.EXCEPTION:
4247 
      x = TApplicationException()
4248 
      x.read(self._iprot)
4249 
      self._iprot.readMessageEnd()
4250 
      raise x
4251 
    result = reconcileCodCollection_result()
4252 
    result.read(self._iprot)
4253 
    self._iprot.readMessageEnd()
4254 
    if result.success is not None:
4255 
      return result.success
4256 
    if result.ex is not None:
4257 
      raise result.ex
4258 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reconcileCodCollection failed: unknown result");
4259 
 
4008 mandeep.dh 4260 
  def getTransactionsRequiringExtraProcessing(self, category):
4261 
    """
4065 mandeep.dh 4262 
    Returns the list of transaction ids that require some extra processing and
4008 mandeep.dh 4263 
    which belong to a particular category. This is currently used by CRM
4065 mandeep.dh 4264 
    application. If no such transaction ids are present, it returns an empty list.
3956 chandransh 4265 
 
4008 mandeep.dh 4266 
    Parameters:
4267 
     - category
4268 
    """
4269 
    self.send_getTransactionsRequiringExtraProcessing(category)
4270 
    return self.recv_getTransactionsRequiringExtraProcessing()
4271 
 
4272 
  def send_getTransactionsRequiringExtraProcessing(self, category):
4273 
    self._oprot.writeMessageBegin('getTransactionsRequiringExtraProcessing', TMessageType.CALL, self._seqid)
4274 
    args = getTransactionsRequiringExtraProcessing_args()
4275 
    args.category = category
4276 
    args.write(self._oprot)
4277 
    self._oprot.writeMessageEnd()
4278 
    self._oprot.trans.flush()
4279 
 
4280 
  def recv_getTransactionsRequiringExtraProcessing(self, ):
4281 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4282 
    if mtype == TMessageType.EXCEPTION:
4283 
      x = TApplicationException()
4284 
      x.read(self._iprot)
4285 
      self._iprot.readMessageEnd()
4286 
      raise x
4287 
    result = getTransactionsRequiringExtraProcessing_result()
4288 
    result.read(self._iprot)
4289 
    self._iprot.readMessageEnd()
4290 
    if result.success is not None:
4291 
      return result.success
4292 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsRequiringExtraProcessing failed: unknown result");
4293 
 
4294 
  def markTransactionAsProcessed(self, transactionId, category):
4295 
    """
4296 
    Marks a particular transaction as processed for a particular cateogory.
4065 mandeep.dh 4297 
    It essentially deletes the transaction id record for a particular
4298 
    processing type category (if present) from DB.
4299 
    This is currently used by CRM application.
4008 mandeep.dh 4300 
 
4301 
    Parameters:
4302 
     - transactionId
4303 
     - category
4304 
    """
4305 
    self.send_markTransactionAsProcessed(transactionId, category)
4306 
    self.recv_markTransactionAsProcessed()
4307 
 
4308 
  def send_markTransactionAsProcessed(self, transactionId, category):
4309 
    self._oprot.writeMessageBegin('markTransactionAsProcessed', TMessageType.CALL, self._seqid)
4310 
    args = markTransactionAsProcessed_args()
4311 
    args.transactionId = transactionId
4312 
    args.category = category
4313 
    args.write(self._oprot)
4314 
    self._oprot.writeMessageEnd()
4315 
    self._oprot.trans.flush()
4316 
 
4317 
  def recv_markTransactionAsProcessed(self, ):
4318 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4319 
    if mtype == TMessageType.EXCEPTION:
4320 
      x = TApplicationException()
4321 
      x.read(self._iprot)
4322 
      self._iprot.readMessageEnd()
4323 
      raise x
4324 
    result = markTransactionAsProcessed_result()
4325 
    result.read(self._iprot)
4326 
    self._iprot.readMessageEnd()
4327 
    return
4328 
 
4018 chandransh 4329 
  def getItemWiseRiskyOrdersCount(self, ):
4330 
    """
4331 
    Returns a map containing the number of risky orders keyed by item id. A risky order
4332 
    is defined as one whose shipping date is about to expire.
4333 
    """
4334 
    self.send_getItemWiseRiskyOrdersCount()
4335 
    return self.recv_getItemWiseRiskyOrdersCount()
4008 mandeep.dh 4336 
 
4018 chandransh 4337 
  def send_getItemWiseRiskyOrdersCount(self, ):
4338 
    self._oprot.writeMessageBegin('getItemWiseRiskyOrdersCount', TMessageType.CALL, self._seqid)
4339 
    args = getItemWiseRiskyOrdersCount_args()
4340 
    args.write(self._oprot)
4341 
    self._oprot.writeMessageEnd()
4342 
    self._oprot.trans.flush()
4343 
 
4344 
  def recv_getItemWiseRiskyOrdersCount(self, ):
4345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4346 
    if mtype == TMessageType.EXCEPTION:
4347 
      x = TApplicationException()
4348 
      x.read(self._iprot)
4349 
      self._iprot.readMessageEnd()
4350 
      raise x
4351 
    result = getItemWiseRiskyOrdersCount_result()
4352 
    result.read(self._iprot)
4353 
    self._iprot.readMessageEnd()
4354 
    if result.success is not None:
4355 
      return result.success
4356 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getItemWiseRiskyOrdersCount failed: unknown result");
4357 
 
4295 varun.gupt 4358 
  def getOrdersForItemIds(self, itemIds):
4359 
    """
4360 
    Returns a list of all orders which have items with given id
4361 
 
4362 
    Parameters:
4363 
     - itemIds
4364 
    """
4365 
    self.send_getOrdersForItemIds(itemIds)
4366 
    return self.recv_getOrdersForItemIds()
4367 
 
4368 
  def send_getOrdersForItemIds(self, itemIds):
4369 
    self._oprot.writeMessageBegin('getOrdersForItemIds', TMessageType.CALL, self._seqid)
4370 
    args = getOrdersForItemIds_args()
4371 
    args.itemIds = itemIds
4372 
    args.write(self._oprot)
4373 
    self._oprot.writeMessageEnd()
4374 
    self._oprot.trans.flush()
4375 
 
4376 
  def recv_getOrdersForItemIds(self, ):
4377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4378 
    if mtype == TMessageType.EXCEPTION:
4379 
      x = TApplicationException()
4380 
      x.read(self._iprot)
4381 
      self._iprot.readMessageEnd()
4382 
      raise x
4383 
    result = getOrdersForItemIds_result()
4384 
    result.read(self._iprot)
4385 
    self._iprot.readMessageEnd()
4386 
    if result.success is not None:
4387 
      return result.success
4388 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForItemIds failed: unknown result");
4389 
 
4247 rajveer 4390 
  def markOrderCancellationRequestReceived(self, orderId):
4391 
    """
4392 
    Mark order as cancellation request received. If customer sends request of cancellation of
4393 
    a particular order, this method will be called. It will just change status of the order
4394 
    depending on its current status. It also records the previous status, so that we can move
4395 
    back to that status if cancellation request is denied.
4018 chandransh 4396 
 
4247 rajveer 4397 
    Parameters:
4398 
     - orderId
4399 
    """
4400 
    self.send_markOrderCancellationRequestReceived(orderId)
4401 
    self.recv_markOrderCancellationRequestReceived()
4402 
 
4403 
  def send_markOrderCancellationRequestReceived(self, orderId):
4404 
    self._oprot.writeMessageBegin('markOrderCancellationRequestReceived', TMessageType.CALL, self._seqid)
4405 
    args = markOrderCancellationRequestReceived_args()
4406 
    args.orderId = orderId
4407 
    args.write(self._oprot)
4408 
    self._oprot.writeMessageEnd()
4409 
    self._oprot.trans.flush()
4410 
 
4411 
  def recv_markOrderCancellationRequestReceived(self, ):
4412 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4413 
    if mtype == TMessageType.EXCEPTION:
4414 
      x = TApplicationException()
4415 
      x.read(self._iprot)
4416 
      self._iprot.readMessageEnd()
4417 
      raise x
4418 
    result = markOrderCancellationRequestReceived_result()
4419 
    result.read(self._iprot)
4420 
    self._iprot.readMessageEnd()
4421 
    if result.ex is not None:
4422 
      raise result.ex
4423 
    return
4424 
 
4425 
  def markOrderCancellationRequestConfirmed(self, orderId):
4426 
    """
4427 
    If we decide to to cancel order, CRM will call this method to move the status of order to
4428 
    cancellation request confirmed. After this OM will be able to cancel the order.
4429 
 
4430 
    Parameters:
4431 
     - orderId
4432 
    """
4433 
    self.send_markOrderCancellationRequestConfirmed(orderId)
4434 
    self.recv_markOrderCancellationRequestConfirmed()
4435 
 
4436 
  def send_markOrderCancellationRequestConfirmed(self, orderId):
4437 
    self._oprot.writeMessageBegin('markOrderCancellationRequestConfirmed', TMessageType.CALL, self._seqid)
4438 
    args = markOrderCancellationRequestConfirmed_args()
4439 
    args.orderId = orderId
4440 
    args.write(self._oprot)
4441 
    self._oprot.writeMessageEnd()
4442 
    self._oprot.trans.flush()
4443 
 
4444 
  def recv_markOrderCancellationRequestConfirmed(self, ):
4445 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4446 
    if mtype == TMessageType.EXCEPTION:
4447 
      x = TApplicationException()
4448 
      x.read(self._iprot)
4449 
      self._iprot.readMessageEnd()
4450 
      raise x
4451 
    result = markOrderCancellationRequestConfirmed_result()
4452 
    result.read(self._iprot)
4453 
    self._iprot.readMessageEnd()
4454 
    if result.ex is not None:
4455 
      raise result.ex
4456 
    return
4457 
 
4458 
  def markOrderCancellationRequestDenied(self, orderId):
4459 
    """
4460 
    If we decide to not to cancel order, we will move the order ro previous status.
4461 
 
4462 
    Parameters:
4463 
     - orderId
4464 
    """
4465 
    self.send_markOrderCancellationRequestDenied(orderId)
4466 
    self.recv_markOrderCancellationRequestDenied()
4467 
 
4468 
  def send_markOrderCancellationRequestDenied(self, orderId):
4469 
    self._oprot.writeMessageBegin('markOrderCancellationRequestDenied', TMessageType.CALL, self._seqid)
4470 
    args = markOrderCancellationRequestDenied_args()
4471 
    args.orderId = orderId
4472 
    args.write(self._oprot)
4473 
    self._oprot.writeMessageEnd()
4474 
    self._oprot.trans.flush()
4475 
 
4476 
  def recv_markOrderCancellationRequestDenied(self, ):
4477 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4478 
    if mtype == TMessageType.EXCEPTION:
4479 
      x = TApplicationException()
4480 
      x.read(self._iprot)
4481 
      self._iprot.readMessageEnd()
4482 
      raise x
4483 
    result = markOrderCancellationRequestDenied_result()
4484 
    result.read(self._iprot)
4485 
    self._iprot.readMessageEnd()
4486 
    if result.ex is not None:
4487 
      raise result.ex
4488 
    return
4489 
 
4258 rajveer 4490 
  def markTransactionAsPaymentFlagRemoved(self, transactionId):
4247 rajveer 4491 
    """
4258 rajveer 4492 
    If we and/or payment gateway has decided to accept the payment, this method needs to be called.
4493 
    Changed transaction and all orders status to payment accepted.
4247 rajveer 4494 
 
4495 
    Parameters:
4258 rajveer 4496 
     - transactionId
4247 rajveer 4497 
    """
4258 rajveer 4498 
    self.send_markTransactionAsPaymentFlagRemoved(transactionId)
4499 
    self.recv_markTransactionAsPaymentFlagRemoved()
4247 rajveer 4500 
 
4258 rajveer 4501 
  def send_markTransactionAsPaymentFlagRemoved(self, transactionId):
4502 
    self._oprot.writeMessageBegin('markTransactionAsPaymentFlagRemoved', TMessageType.CALL, self._seqid)
4503 
    args = markTransactionAsPaymentFlagRemoved_args()
4504 
    args.transactionId = transactionId
4247 rajveer 4505 
    args.write(self._oprot)
4506 
    self._oprot.writeMessageEnd()
4507 
    self._oprot.trans.flush()
4508 
 
4258 rajveer 4509 
  def recv_markTransactionAsPaymentFlagRemoved(self, ):
4247 rajveer 4510 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4511 
    if mtype == TMessageType.EXCEPTION:
4512 
      x = TApplicationException()
4513 
      x.read(self._iprot)
4514 
      self._iprot.readMessageEnd()
4515 
      raise x
4258 rajveer 4516 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 4517 
    result.read(self._iprot)
4518 
    self._iprot.readMessageEnd()
4519 
    if result.ex is not None:
4520 
      raise result.ex
4521 
    return
4522 
 
4259 anupam.sin 4523 
  def refundTransaction(self, transactionId, refundedBy, reason):
4524 
    """
4525 
    This method is called when a flagged payment is deemed unserviceable and the corresponding orders
4526 
    need to be cancelled
4247 rajveer 4527 
 
4259 anupam.sin 4528 
    Parameters:
4529 
     - transactionId
4530 
     - refundedBy
4531 
     - reason
4532 
    """
4533 
    self.send_refundTransaction(transactionId, refundedBy, reason)
4534 
    self.recv_refundTransaction()
4535 
 
4536 
  def send_refundTransaction(self, transactionId, refundedBy, reason):
4537 
    self._oprot.writeMessageBegin('refundTransaction', TMessageType.CALL, self._seqid)
4538 
    args = refundTransaction_args()
4539 
    args.transactionId = transactionId
4540 
    args.refundedBy = refundedBy
4541 
    args.reason = reason
4542 
    args.write(self._oprot)
4543 
    self._oprot.writeMessageEnd()
4544 
    self._oprot.trans.flush()
4545 
 
4546 
  def recv_refundTransaction(self, ):
4547 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4548 
    if mtype == TMessageType.EXCEPTION:
4549 
      x = TApplicationException()
4550 
      x.read(self._iprot)
4551 
      self._iprot.readMessageEnd()
4552 
      raise x
4553 
    result = refundTransaction_result()
4554 
    result.read(self._iprot)
4555 
    self._iprot.readMessageEnd()
4556 
    if result.ex is not None:
4557 
      raise result.ex
4558 
    return
4559 
 
4324 mandeep.dh 4560 
  def updateShipmentAddress(self, orderId, addressId):
4561 
    """
4562 
    Updates shipment address of an order. Delivery and shipping date estimates
4563 
    etc. are also updated here.
4564 
 
4565 
    Throws TransactionServiceException in case address change is not
4566 
    possible due to certain reasons such as new pincode in address is
4567 
    not serviceable etc.
4568 
 
4569 
    Parameters:
4570 
     - orderId
4571 
     - addressId
4572 
    """
4573 
    self.send_updateShipmentAddress(orderId, addressId)
4574 
    self.recv_updateShipmentAddress()
4575 
 
4576 
  def send_updateShipmentAddress(self, orderId, addressId):
4577 
    self._oprot.writeMessageBegin('updateShipmentAddress', TMessageType.CALL, self._seqid)
4578 
    args = updateShipmentAddress_args()
4579 
    args.orderId = orderId
4580 
    args.addressId = addressId
4581 
    args.write(self._oprot)
4582 
    self._oprot.writeMessageEnd()
4583 
    self._oprot.trans.flush()
4584 
 
4585 
  def recv_updateShipmentAddress(self, ):
4586 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4587 
    if mtype == TMessageType.EXCEPTION:
4588 
      x = TApplicationException()
4589 
      x.read(self._iprot)
4590 
      self._iprot.readMessageEnd()
4591 
      raise x
4592 
    result = updateShipmentAddress_result()
4593 
    result.read(self._iprot)
4594 
    self._iprot.readMessageEnd()
4595 
    if result.ex is not None:
4596 
      raise result.ex
4597 
    return
4598 
 
4285 rajveer 4599 
  def acceptOrdersForItemId(self, itemId, inventory):
4600 
    """
4601 
    Marks the orders as ACCEPTED for the given itemId and inventory. It also updates the accepted timestamp. If the
4602 
    given order is not a COD order, it also captures the payment if the same has not been captured.
4259 anupam.sin 4603 
 
4285 rajveer 4604 
    Parameters:
4605 
     - itemId
4606 
     - inventory
4607 
    """
4608 
    self.send_acceptOrdersForItemId(itemId, inventory)
4609 
    return self.recv_acceptOrdersForItemId()
4610 
 
4611 
  def send_acceptOrdersForItemId(self, itemId, inventory):
4612 
    self._oprot.writeMessageBegin('acceptOrdersForItemId', TMessageType.CALL, self._seqid)
4613 
    args = acceptOrdersForItemId_args()
4614 
    args.itemId = itemId
4615 
    args.inventory = inventory
4616 
    args.write(self._oprot)
4617 
    self._oprot.writeMessageEnd()
4618 
    self._oprot.trans.flush()
4619 
 
4620 
  def recv_acceptOrdersForItemId(self, ):
4621 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4622 
    if mtype == TMessageType.EXCEPTION:
4623 
      x = TApplicationException()
4624 
      x.read(self._iprot)
4625 
      self._iprot.readMessageEnd()
4626 
      raise x
4627 
    result = acceptOrdersForItemId_result()
4628 
    result.read(self._iprot)
4629 
    self._iprot.readMessageEnd()
4630 
    if result.success is not None:
4631 
      return result.success
4632 
    if result.ex is not None:
4633 
      raise result.ex
4634 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrdersForItemId failed: unknown result");
4635 
 
4369 rajveer 4636 
  def markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4637 
    """
4638 
    Parameters:
4639 
     - vendorId
4640 
     - itemId
4641 
     - quantity
4642 
     - estimate
4369 rajveer 4643 
     - isReminder
4303 rajveer 4644 
    """
4369 rajveer 4645 
    self.send_markOrdersAsPORaised(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4646 
    self.recv_markOrdersAsPORaised()
4285 rajveer 4647 
 
4369 rajveer 4648 
  def send_markOrdersAsPORaised(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4649 
    self._oprot.writeMessageBegin('markOrdersAsPORaised', TMessageType.CALL, self._seqid)
4650 
    args = markOrdersAsPORaised_args()
4651 
    args.vendorId = vendorId
4652 
    args.itemId = itemId
4653 
    args.quantity = quantity
4654 
    args.estimate = estimate
4369 rajveer 4655 
    args.isReminder = isReminder
4303 rajveer 4656 
    args.write(self._oprot)
4657 
    self._oprot.writeMessageEnd()
4658 
    self._oprot.trans.flush()
4659 
 
4660 
  def recv_markOrdersAsPORaised(self, ):
4661 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4662 
    if mtype == TMessageType.EXCEPTION:
4663 
      x = TApplicationException()
4664 
      x.read(self._iprot)
4665 
      self._iprot.readMessageEnd()
4666 
      raise x
4667 
    result = markOrdersAsPORaised_result()
4668 
    result.read(self._iprot)
4669 
    self._iprot.readMessageEnd()
4670 
    if result.ex is not None:
4671 
      raise result.ex
4672 
    return
4673 
 
4369 rajveer 4674 
  def markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4675 
    """
4676 
    Parameters:
4677 
     - vendorId
4678 
     - itemId
4679 
     - quantity
4680 
     - estimate
4369 rajveer 4681 
     - isReminder
4303 rajveer 4682 
    """
4369 rajveer 4683 
    self.send_markOrdersAsReversalInitiated(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4684 
    self.recv_markOrdersAsReversalInitiated()
4685 
 
4369 rajveer 4686 
  def send_markOrdersAsReversalInitiated(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4687 
    self._oprot.writeMessageBegin('markOrdersAsReversalInitiated', TMessageType.CALL, self._seqid)
4688 
    args = markOrdersAsReversalInitiated_args()
4689 
    args.vendorId = vendorId
4690 
    args.itemId = itemId
4691 
    args.quantity = quantity
4692 
    args.estimate = estimate
4369 rajveer 4693 
    args.isReminder = isReminder
4303 rajveer 4694 
    args.write(self._oprot)
4695 
    self._oprot.writeMessageEnd()
4696 
    self._oprot.trans.flush()
4697 
 
4698 
  def recv_markOrdersAsReversalInitiated(self, ):
4699 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4700 
    if mtype == TMessageType.EXCEPTION:
4701 
      x = TApplicationException()
4702 
      x.read(self._iprot)
4703 
      self._iprot.readMessageEnd()
4704 
      raise x
4705 
    result = markOrdersAsReversalInitiated_result()
4706 
    result.read(self._iprot)
4707 
    self._iprot.readMessageEnd()
4708 
    if result.ex is not None:
4709 
      raise result.ex
4710 
    return
4711 
 
4369 rajveer 4712 
  def markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4713 
    """
4714 
    Parameters:
4715 
     - vendorId
4716 
     - itemId
4717 
     - quantity
4718 
     - estimate
4369 rajveer 4719 
     - isReminder
4303 rajveer 4720 
    """
4369 rajveer 4721 
    self.send_markOrdersAsNotAvailabke(vendorId, itemId, quantity, estimate, isReminder)
4303 rajveer 4722 
    self.recv_markOrdersAsNotAvailabke()
4723 
 
4369 rajveer 4724 
  def send_markOrdersAsNotAvailabke(self, vendorId, itemId, quantity, estimate, isReminder):
4303 rajveer 4725 
    self._oprot.writeMessageBegin('markOrdersAsNotAvailabke', TMessageType.CALL, self._seqid)
4726 
    args = markOrdersAsNotAvailabke_args()
4727 
    args.vendorId = vendorId
4728 
    args.itemId = itemId
4729 
    args.quantity = quantity
4730 
    args.estimate = estimate
4369 rajveer 4731 
    args.isReminder = isReminder
4303 rajveer 4732 
    args.write(self._oprot)
4733 
    self._oprot.writeMessageEnd()
4734 
    self._oprot.trans.flush()
4735 
 
4736 
  def recv_markOrdersAsNotAvailabke(self, ):
4737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4738 
    if mtype == TMessageType.EXCEPTION:
4739 
      x = TApplicationException()
4740 
      x.read(self._iprot)
4741 
      self._iprot.readMessageEnd()
4742 
      raise x
4743 
    result = markOrdersAsNotAvailabke_result()
4744 
    result.read(self._iprot)
4745 
    self._iprot.readMessageEnd()
4746 
    if result.ex is not None:
4747 
      raise result.ex
4748 
    return
4749 
 
4369 rajveer 4750 
  def markOrdersAsTimeout(self, vendorId):
4751 
    """
4752 
    Parameters:
4753 
     - vendorId
4754 
    """
4755 
    self.send_markOrdersAsTimeout(vendorId)
4756 
    return self.recv_markOrdersAsTimeout()
4303 rajveer 4757 
 
4369 rajveer 4758 
  def send_markOrdersAsTimeout(self, vendorId):
4759 
    self._oprot.writeMessageBegin('markOrdersAsTimeout', TMessageType.CALL, self._seqid)
4760 
    args = markOrdersAsTimeout_args()
4761 
    args.vendorId = vendorId
4762 
    args.write(self._oprot)
4763 
    self._oprot.writeMessageEnd()
4764 
    self._oprot.trans.flush()
4765 
 
4766 
  def recv_markOrdersAsTimeout(self, ):
4767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4768 
    if mtype == TMessageType.EXCEPTION:
4769 
      x = TApplicationException()
4770 
      x.read(self._iprot)
4771 
      self._iprot.readMessageEnd()
4772 
      raise x
4773 
    result = markOrdersAsTimeout_result()
4774 
    result.read(self._iprot)
4775 
    self._iprot.readMessageEnd()
4776 
    if result.success is not None:
4777 
      return result.success
4778 
    if result.ex is not None:
4779 
      raise result.ex
4780 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsTimeout failed: unknown result");
4781 
 
4662 rajveer 4782 
  def markOrderAsLostInTransit(self, orderId):
4783 
    """
4784 
    Mark order as LOST_IN_TRANSIT
4785 
 
4786 
    Parameters:
4787 
     - orderId
4788 
    """
4789 
    self.send_markOrderAsLostInTransit(orderId)
4790 
    return self.recv_markOrderAsLostInTransit()
4791 
 
4792 
  def send_markOrderAsLostInTransit(self, orderId):
4793 
    self._oprot.writeMessageBegin('markOrderAsLostInTransit', TMessageType.CALL, self._seqid)
4794 
    args = markOrderAsLostInTransit_args()
4795 
    args.orderId = orderId
4796 
    args.write(self._oprot)
4797 
    self._oprot.writeMessageEnd()
4798 
    self._oprot.trans.flush()
4799 
 
4800 
  def recv_markOrderAsLostInTransit(self, ):
4801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4802 
    if mtype == TMessageType.EXCEPTION:
4803 
      x = TApplicationException()
4804 
      x.read(self._iprot)
4805 
      self._iprot.readMessageEnd()
4806 
      raise x
4807 
    result = markOrderAsLostInTransit_result()
4808 
    result.read(self._iprot)
4809 
    self._iprot.readMessageEnd()
4810 
    if result.success is not None:
4811 
      return result.success
4812 
    if result.ex is not None:
4813 
      raise result.ex
4814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsLostInTransit failed: unknown result");
4815 
 
4386 anupam.sin 4816 
  def getOrderForAwb(self, awb):
4817 
    """
4818 
    Returns the order corresponding to an AWB number
4369 rajveer 4819 
 
4386 anupam.sin 4820 
    Parameters:
4821 
     - awb
4822 
    """
4823 
    self.send_getOrderForAwb(awb)
4824 
    return self.recv_getOrderForAwb()
4825 
 
4826 
  def send_getOrderForAwb(self, awb):
4827 
    self._oprot.writeMessageBegin('getOrderForAwb', TMessageType.CALL, self._seqid)
4828 
    args = getOrderForAwb_args()
4829 
    args.awb = awb
4830 
    args.write(self._oprot)
4831 
    self._oprot.writeMessageEnd()
4832 
    self._oprot.trans.flush()
4833 
 
4834 
  def recv_getOrderForAwb(self, ):
4835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4836 
    if mtype == TMessageType.EXCEPTION:
4837 
      x = TApplicationException()
4838 
      x.read(self._iprot)
4839 
      self._iprot.readMessageEnd()
4840 
      raise x
4841 
    result = getOrderForAwb_result()
4842 
    result.read(self._iprot)
4843 
    self._iprot.readMessageEnd()
4844 
    if result.success is not None:
4845 
      return result.success
4846 
    if result.ex is not None:
4847 
      raise result.ex
4848 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
4849 
 
4910 phani.kuma 4850 
  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4851 
    """
4910 phani.kuma 4852 
    Returns the order corresponding to a logistics provider id for a given list of order status
4386 anupam.sin 4853 
 
4506 phani.kuma 4854 
    Parameters:
4855 
     - logistics_provider_id
4910 phani.kuma 4856 
     - order_status_list
4506 phani.kuma 4857 
    """
4910 phani.kuma 4858 
    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
4506 phani.kuma 4859 
    return self.recv_getOrdersForProviderForStatus()
4860 
 
4910 phani.kuma 4861 
  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
4506 phani.kuma 4862 
    self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
4863 
    args = getOrdersForProviderForStatus_args()
4864 
    args.logistics_provider_id = logistics_provider_id
4910 phani.kuma 4865 
    args.order_status_list = order_status_list
4506 phani.kuma 4866 
    args.write(self._oprot)
4867 
    self._oprot.writeMessageEnd()
4868 
    self._oprot.trans.flush()
4869 
 
4870 
  def recv_getOrdersForProviderForStatus(self, ):
4871 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4872 
    if mtype == TMessageType.EXCEPTION:
4873 
      x = TApplicationException()
4874 
      x.read(self._iprot)
4875 
      self._iprot.readMessageEnd()
4876 
      raise x
4877 
    result = getOrdersForProviderForStatus_result()
4878 
    result.read(self._iprot)
4879 
    self._iprot.readMessageEnd()
4880 
    if result.success is not None:
4881 
      return result.success
4882 
    if result.ex is not None:
4883 
      raise result.ex
4884 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForProviderForStatus failed: unknown result");
4885 
 
4600 varun.gupt 4886 
  def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4887 
    """
4888 
    Returns list of orders fullfiled from a certain vendor and billed in a given date range
4506 phani.kuma 4889 
 
4600 varun.gupt 4890 
    Parameters:
4891 
     - vendorId
4892 
     - billingDateFrom
4893 
     - billingDateTo
4894 
    """
4895 
    self.send_getBilledOrdersForVendor(vendorId, billingDateFrom, billingDateTo)
4896 
    return self.recv_getBilledOrdersForVendor()
4897 
 
4898 
  def send_getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
4899 
    self._oprot.writeMessageBegin('getBilledOrdersForVendor', TMessageType.CALL, self._seqid)
4900 
    args = getBilledOrdersForVendor_args()
4901 
    args.vendorId = vendorId
4902 
    args.billingDateFrom = billingDateFrom
4903 
    args.billingDateTo = billingDateTo
4904 
    args.write(self._oprot)
4905 
    self._oprot.writeMessageEnd()
4906 
    self._oprot.trans.flush()
4907 
 
4908 
  def recv_getBilledOrdersForVendor(self, ):
4909 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4910 
    if mtype == TMessageType.EXCEPTION:
4911 
      x = TApplicationException()
4912 
      x.read(self._iprot)
4913 
      self._iprot.readMessageEnd()
4914 
      raise x
4915 
    result = getBilledOrdersForVendor_result()
4916 
    result.read(self._iprot)
4917 
    self._iprot.readMessageEnd()
4918 
    if result.success is not None:
4919 
      return result.success
4920 
    if result.ex is not None:
4921 
      raise result.ex
4922 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrdersForVendor failed: unknown result");
4923 
 
4607 rajveer 4924 
  def getSlippedSippingDateOrders(self, ):
4925 
    self.send_getSlippedSippingDateOrders()
4926 
    return self.recv_getSlippedSippingDateOrders()
4927 
 
4928 
  def send_getSlippedSippingDateOrders(self, ):
4929 
    self._oprot.writeMessageBegin('getSlippedSippingDateOrders', TMessageType.CALL, self._seqid)
4930 
    args = getSlippedSippingDateOrders_args()
4931 
    args.write(self._oprot)
4932 
    self._oprot.writeMessageEnd()
4933 
    self._oprot.trans.flush()
4934 
 
4935 
  def recv_getSlippedSippingDateOrders(self, ):
4936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4937 
    if mtype == TMessageType.EXCEPTION:
4938 
      x = TApplicationException()
4939 
      x.read(self._iprot)
4940 
      self._iprot.readMessageEnd()
4941 
      raise x
4942 
    result = getSlippedSippingDateOrders_result()
4943 
    result.read(self._iprot)
4944 
    self._iprot.readMessageEnd()
4945 
    if result.success is not None:
4946 
      return result.success
4947 
    if result.ex is not None:
4948 
      raise result.ex
4949 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSlippedSippingDateOrders failed: unknown result");
4950 
 
4709 rajveer 4951 
  def getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4952 
    """
4953 
    Parameters:
4954 
     - cancelDateFrom
4955 
     - cancelDateTo
4956 
    """
4957 
    self.send_getCancelledOrders(cancelDateFrom, cancelDateTo)
4958 
    return self.recv_getCancelledOrders()
4959 
 
4960 
  def send_getCancelledOrders(self, cancelDateFrom, cancelDateTo):
4961 
    self._oprot.writeMessageBegin('getCancelledOrders', TMessageType.CALL, self._seqid)
4962 
    args = getCancelledOrders_args()
4963 
    args.cancelDateFrom = cancelDateFrom
4964 
    args.cancelDateTo = cancelDateTo
4965 
    args.write(self._oprot)
4966 
    self._oprot.writeMessageEnd()
4967 
    self._oprot.trans.flush()
4968 
 
4969 
  def recv_getCancelledOrders(self, ):
4970 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
4971 
    if mtype == TMessageType.EXCEPTION:
4972 
      x = TApplicationException()
4973 
      x.read(self._iprot)
4974 
      self._iprot.readMessageEnd()
4975 
      raise x
4976 
    result = getCancelledOrders_result()
4977 
    result.read(self._iprot)
4978 
    self._iprot.readMessageEnd()
4979 
    if result.success is not None:
4980 
      return result.success
4981 
    if result.ex is not None:
4982 
      raise result.ex
4983 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancelledOrders failed: unknown result");
4984 
 
4600 varun.gupt 4985 
  def saveBluedartSettlements(self, mapAWBAndAmount):
4986 
    """
4987 
    Parameters:
4988 
     - mapAWBAndAmount
4989 
    """
4990 
    self.send_saveBluedartSettlements(mapAWBAndAmount)
4991 
    self.recv_saveBluedartSettlements()
4992 
 
4993 
  def send_saveBluedartSettlements(self, mapAWBAndAmount):
4994 
    self._oprot.writeMessageBegin('saveBluedartSettlements', TMessageType.CALL, self._seqid)
4995 
    args = saveBluedartSettlements_args()
4996 
    args.mapAWBAndAmount = mapAWBAndAmount
4997 
    args.write(self._oprot)
4998 
    self._oprot.writeMessageEnd()
4999 
    self._oprot.trans.flush()
5000 
 
5001 
  def recv_saveBluedartSettlements(self, ):
5002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5003 
    if mtype == TMessageType.EXCEPTION:
5004 
      x = TApplicationException()
5005 
      x.read(self._iprot)
5006 
      self._iprot.readMessageEnd()
5007 
      raise x
5008 
    result = saveBluedartSettlements_result()
5009 
    result.read(self._iprot)
5010 
    self._iprot.readMessageEnd()
5011 
    if result.ex is not None:
5012 
      raise result.ex
5013 
    return
5014 
 
4905 varun.gupt 5015 
  def savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5016 
    """
5017 
    Parameters:
5018 
     - settlementDate
5019 
     - paymentGatewayId
4905 varun.gupt 5020 
     - referenceId
4600 varun.gupt 5021 
     - serviceTax
5022 
     - otherCharges
5023 
     - netCollection
5024 
    """
4905 varun.gupt 5025 
    self.send_savePaymentSettlements(settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection)
4600 varun.gupt 5026 
    self.recv_savePaymentSettlements()
5027 
 
4905 varun.gupt 5028 
  def send_savePaymentSettlements(self, settlementDate, paymentGatewayId, referenceId, serviceTax, otherCharges, netCollection):
4600 varun.gupt 5029 
    self._oprot.writeMessageBegin('savePaymentSettlements', TMessageType.CALL, self._seqid)
5030 
    args = savePaymentSettlements_args()
5031 
    args.settlementDate = settlementDate
5032 
    args.paymentGatewayId = paymentGatewayId
4905 varun.gupt 5033 
    args.referenceId = referenceId
4600 varun.gupt 5034 
    args.serviceTax = serviceTax
5035 
    args.otherCharges = otherCharges
5036 
    args.netCollection = netCollection
5037 
    args.write(self._oprot)
5038 
    self._oprot.writeMessageEnd()
5039 
    self._oprot.trans.flush()
5040 
 
5041 
  def recv_savePaymentSettlements(self, ):
5042 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5043 
    if mtype == TMessageType.EXCEPTION:
5044 
      x = TApplicationException()
5045 
      x.read(self._iprot)
5046 
      self._iprot.readMessageEnd()
5047 
      raise x
5048 
    result = savePaymentSettlements_result()
5049 
    result.read(self._iprot)
5050 
    self._iprot.readMessageEnd()
5051 
    if result.ex is not None:
5052 
      raise result.ex
5053 
    return
5054 
 
5055 
  def saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5056 
    """
5057 
    Parameters:
5058 
     - settlementId
5059 
     - settlementDate
5060 
     - transactionDateFrom
5061 
     - transactionDateTo
5062 
     - amount
5063 
    """
5064 
    self.send_saveEBSSettlementSummary(settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount)
5065 
    self.recv_saveEBSSettlementSummary()
5066 
 
5067 
  def send_saveEBSSettlementSummary(self, settlementId, settlementDate, transactionDateFrom, transactionDateTo, amount):
5068 
    self._oprot.writeMessageBegin('saveEBSSettlementSummary', TMessageType.CALL, self._seqid)
5069 
    args = saveEBSSettlementSummary_args()
5070 
    args.settlementId = settlementId
5071 
    args.settlementDate = settlementDate
5072 
    args.transactionDateFrom = transactionDateFrom
5073 
    args.transactionDateTo = transactionDateTo
5074 
    args.amount = amount
5075 
    args.write(self._oprot)
5076 
    self._oprot.writeMessageEnd()
5077 
    self._oprot.trans.flush()
5078 
 
5079 
  def recv_saveEBSSettlementSummary(self, ):
5080 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5081 
    if mtype == TMessageType.EXCEPTION:
5082 
      x = TApplicationException()
5083 
      x.read(self._iprot)
5084 
      self._iprot.readMessageEnd()
5085 
      raise x
5086 
    result = saveEBSSettlementSummary_result()
5087 
    result.read(self._iprot)
5088 
    self._iprot.readMessageEnd()
5089 
    if result.ex is not None:
5090 
      raise result.ex
5091 
    return
5092 
 
5386 phani.kuma 5093 
  def getSettlementForPrepaid(self, referenceId, isRefund):
4600 varun.gupt 5094 
    """
5095 
    Parameters:
5189 varun.gupt 5096 
     - referenceId
5097 
     - isRefund
4600 varun.gupt 5098 
    """
5386 phani.kuma 5099 
    self.send_getSettlementForPrepaid(referenceId, isRefund)
5100 
    return self.recv_getSettlementForPrepaid()
4600 varun.gupt 5101 
 
5386 phani.kuma 5102 
  def send_getSettlementForPrepaid(self, referenceId, isRefund):
5103 
    self._oprot.writeMessageBegin('getSettlementForPrepaid', TMessageType.CALL, self._seqid)
5104 
    args = getSettlementForPrepaid_args()
5189 varun.gupt 5105 
    args.referenceId = referenceId
5106 
    args.isRefund = isRefund
4600 varun.gupt 5107 
    args.write(self._oprot)
5108 
    self._oprot.writeMessageEnd()
5109 
    self._oprot.trans.flush()
5110 
 
5386 phani.kuma 5111 
  def recv_getSettlementForPrepaid(self, ):
4600 varun.gupt 5112 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5113 
    if mtype == TMessageType.EXCEPTION:
5114 
      x = TApplicationException()
5115 
      x.read(self._iprot)
5116 
      self._iprot.readMessageEnd()
5117 
      raise x
5386 phani.kuma 5118 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 5119 
    result.read(self._iprot)
5120 
    self._iprot.readMessageEnd()
5121 
    if result.success is not None:
5122 
      return result.success
5123 
    if result.ex is not None:
5124 
      raise result.ex
5386 phani.kuma 5125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForPrepaid failed: unknown result");
4600 varun.gupt 5126 
 
5386 phani.kuma 5127 
  def getSettlementForCod(self, orderId, isRefund):
5128 
    """
5129 
    Parameters:
5130 
     - orderId
5131 
     - isRefund
5132 
    """
5133 
    self.send_getSettlementForCod(orderId, isRefund)
5134 
    return self.recv_getSettlementForCod()
5135 
 
5136 
  def send_getSettlementForCod(self, orderId, isRefund):
5137 
    self._oprot.writeMessageBegin('getSettlementForCod', TMessageType.CALL, self._seqid)
5138 
    args = getSettlementForCod_args()
5139 
    args.orderId = orderId
5140 
    args.isRefund = isRefund
5141 
    args.write(self._oprot)
5142 
    self._oprot.writeMessageEnd()
5143 
    self._oprot.trans.flush()
5144 
 
5145 
  def recv_getSettlementForCod(self, ):
5146 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5147 
    if mtype == TMessageType.EXCEPTION:
5148 
      x = TApplicationException()
5149 
      x.read(self._iprot)
5150 
      self._iprot.readMessageEnd()
5151 
      raise x
5152 
    result = getSettlementForCod_result()
5153 
    result.read(self._iprot)
5154 
    self._iprot.readMessageEnd()
5155 
    if result.success is not None:
5156 
      return result.success
5157 
    if result.ex is not None:
5158 
      raise result.ex
5159 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementForCod failed: unknown result");
5160 
 
4600 varun.gupt 5161 
  def getEBSSettlementSummaries(self, ):
5162 
    self.send_getEBSSettlementSummaries()
5163 
    return self.recv_getEBSSettlementSummaries()
5164 
 
5165 
  def send_getEBSSettlementSummaries(self, ):
5166 
    self._oprot.writeMessageBegin('getEBSSettlementSummaries', TMessageType.CALL, self._seqid)
5167 
    args = getEBSSettlementSummaries_args()
5168 
    args.write(self._oprot)
5169 
    self._oprot.writeMessageEnd()
5170 
    self._oprot.trans.flush()
5171 
 
5172 
  def recv_getEBSSettlementSummaries(self, ):
5173 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5174 
    if mtype == TMessageType.EXCEPTION:
5175 
      x = TApplicationException()
5176 
      x.read(self._iprot)
5177 
      self._iprot.readMessageEnd()
5178 
      raise x
5179 
    result = getEBSSettlementSummaries_result()
5180 
    result.read(self._iprot)
5181 
    self._iprot.readMessageEnd()
5182 
    if result.success is not None:
5183 
      return result.success
5184 
    if result.ex is not None:
5185 
      raise result.ex
5186 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementSummaries failed: unknown result");
5187 
 
5188 
  def markEBSSettlementUploaded(self, settlementId):
5189 
    """
5190 
    Parameters:
5191 
     - settlementId
5192 
    """
5193 
    self.send_markEBSSettlementUploaded(settlementId)
5194 
    self.recv_markEBSSettlementUploaded()
5195 
 
5196 
  def send_markEBSSettlementUploaded(self, settlementId):
5197 
    self._oprot.writeMessageBegin('markEBSSettlementUploaded', TMessageType.CALL, self._seqid)
5198 
    args = markEBSSettlementUploaded_args()
5199 
    args.settlementId = settlementId
5200 
    args.write(self._oprot)
5201 
    self._oprot.writeMessageEnd()
5202 
    self._oprot.trans.flush()
5203 
 
5204 
  def recv_markEBSSettlementUploaded(self, ):
5205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5206 
    if mtype == TMessageType.EXCEPTION:
5207 
      x = TApplicationException()
5208 
      x.read(self._iprot)
5209 
      self._iprot.readMessageEnd()
5210 
      raise x
5211 
    result = markEBSSettlementUploaded_result()
5212 
    result.read(self._iprot)
5213 
    self._iprot.readMessageEnd()
5214 
    if result.ex is not None:
5215 
      raise result.ex
5216 
    return
5217 
 
5218 
  def getEBSSettlementDate(self, settlementId):
5219 
    """
5220 
    Parameters:
5221 
     - settlementId
5222 
    """
5223 
    self.send_getEBSSettlementDate(settlementId)
5224 
    return self.recv_getEBSSettlementDate()
5225 
 
5226 
  def send_getEBSSettlementDate(self, settlementId):
5227 
    self._oprot.writeMessageBegin('getEBSSettlementDate', TMessageType.CALL, self._seqid)
5228 
    args = getEBSSettlementDate_args()
5229 
    args.settlementId = settlementId
5230 
    args.write(self._oprot)
5231 
    self._oprot.writeMessageEnd()
5232 
    self._oprot.trans.flush()
5233 
 
5234 
  def recv_getEBSSettlementDate(self, ):
5235 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5236 
    if mtype == TMessageType.EXCEPTION:
5237 
      x = TApplicationException()
5238 
      x.read(self._iprot)
5239 
      self._iprot.readMessageEnd()
5240 
      raise x
5241 
    result = getEBSSettlementDate_result()
5242 
    result.read(self._iprot)
5243 
    self._iprot.readMessageEnd()
5244 
    if result.success is not None:
5245 
      return result.success
5246 
    if result.ex is not None:
5247 
      raise result.ex
5248 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEBSSettlementDate failed: unknown result");
5249 
 
4715 varun.gupt 5250 
  def getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5251 
    """
5252 
    Parameters:
5253 
     - settlementDateFrom
5254 
     - settlementDateTo
5255 
     - isRefund
5256 
    """
5257 
    self.send_getSettlementsByDate(settlementDateFrom, settlementDateTo, isRefund)
5258 
    return self.recv_getSettlementsByDate()
4600 varun.gupt 5259 
 
4715 varun.gupt 5260 
  def send_getSettlementsByDate(self, settlementDateFrom, settlementDateTo, isRefund):
5261 
    self._oprot.writeMessageBegin('getSettlementsByDate', TMessageType.CALL, self._seqid)
5262 
    args = getSettlementsByDate_args()
5263 
    args.settlementDateFrom = settlementDateFrom
5264 
    args.settlementDateTo = settlementDateTo
5265 
    args.isRefund = isRefund
5266 
    args.write(self._oprot)
5267 
    self._oprot.writeMessageEnd()
5268 
    self._oprot.trans.flush()
5269 
 
5270 
  def recv_getSettlementsByDate(self, ):
5271 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5272 
    if mtype == TMessageType.EXCEPTION:
5273 
      x = TApplicationException()
5274 
      x.read(self._iprot)
5275 
      self._iprot.readMessageEnd()
5276 
      raise x
5277 
    result = getSettlementsByDate_result()
5278 
    result.read(self._iprot)
5279 
    self._iprot.readMessageEnd()
5280 
    if result.success is not None:
5281 
      return result.success
5282 
    if result.ex is not None:
5283 
      raise result.ex
5284 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getSettlementsByDate failed: unknown result");
5285 
 
5286 
  def getReshippedOrderIds(self, orderIds):
5287 
    """
5288 
    Returns list of Order Ids, which belong to reshiped orders, shortlisted from a given list of Order Ids
5289 
 
5290 
    Parameters:
5291 
     - orderIds
5292 
    """
5293 
    self.send_getReshippedOrderIds(orderIds)
5294 
    return self.recv_getReshippedOrderIds()
5295 
 
5296 
  def send_getReshippedOrderIds(self, orderIds):
5297 
    self._oprot.writeMessageBegin('getReshippedOrderIds', TMessageType.CALL, self._seqid)
5298 
    args = getReshippedOrderIds_args()
5299 
    args.orderIds = orderIds
5300 
    args.write(self._oprot)
5301 
    self._oprot.writeMessageEnd()
5302 
    self._oprot.trans.flush()
5303 
 
5304 
  def recv_getReshippedOrderIds(self, ):
5305 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5306 
    if mtype == TMessageType.EXCEPTION:
5307 
      x = TApplicationException()
5308 
      x.read(self._iprot)
5309 
      self._iprot.readMessageEnd()
5310 
      raise x
5311 
    result = getReshippedOrderIds_result()
5312 
    result.read(self._iprot)
5313 
    self._iprot.readMessageEnd()
5314 
    if result.success is not None:
5315 
      return result.success
5316 
    if result.ex is not None:
5317 
      raise result.ex
5318 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReshippedOrderIds failed: unknown result");
5319 
 
5481 phani.kuma 5320 
  def getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
4875 varun.gupt 5321 
    """
5322 
    Parameters:
5323 
     - vendorId
5481 phani.kuma 5324 
     - onlyVendorNotPaid
5325 
     - billingDateFrom
5326 
     - billingDateTo
4875 varun.gupt 5327 
    """
5481 phani.kuma 5328 
    self.send_getBilledOrders(vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo)
5329 
    return self.recv_getBilledOrders()
4757 mandeep.dh 5330 
 
5481 phani.kuma 5331 
  def send_getBilledOrders(self, vendorId, onlyVendorNotPaid, billingDateFrom, billingDateTo):
5332 
    self._oprot.writeMessageBegin('getBilledOrders', TMessageType.CALL, self._seqid)
5333 
    args = getBilledOrders_args()
4875 varun.gupt 5334 
    args.vendorId = vendorId
5481 phani.kuma 5335 
    args.onlyVendorNotPaid = onlyVendorNotPaid
5336 
    args.billingDateFrom = billingDateFrom
5337 
    args.billingDateTo = billingDateTo
4875 varun.gupt 5338 
    args.write(self._oprot)
5339 
    self._oprot.writeMessageEnd()
5340 
    self._oprot.trans.flush()
5341 
 
5481 phani.kuma 5342 
  def recv_getBilledOrders(self, ):
4875 varun.gupt 5343 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5344 
    if mtype == TMessageType.EXCEPTION:
5345 
      x = TApplicationException()
5346 
      x.read(self._iprot)
5347 
      self._iprot.readMessageEnd()
5348 
      raise x
5481 phani.kuma 5349 
    result = getBilledOrders_result()
4875 varun.gupt 5350 
    result.read(self._iprot)
5351 
    self._iprot.readMessageEnd()
5352 
    if result.success is not None:
5353 
      return result.success
5354 
    if result.ex is not None:
5355 
      raise result.ex
5481 phani.kuma 5356 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBilledOrders failed: unknown result");
4875 varun.gupt 5357 
 
5031 varun.gupt 5358 
  def getStatusDistributionOfOrders(self, startDate, endDate):
5359 
    """
5360 
    Parameters:
5361 
     - startDate
5362 
     - endDate
5363 
    """
5364 
    self.send_getStatusDistributionOfOrders(startDate, endDate)
5365 
    return self.recv_getStatusDistributionOfOrders()
4875 varun.gupt 5366 
 
5031 varun.gupt 5367 
  def send_getStatusDistributionOfOrders(self, startDate, endDate):
5368 
    self._oprot.writeMessageBegin('getStatusDistributionOfOrders', TMessageType.CALL, self._seqid)
5369 
    args = getStatusDistributionOfOrders_args()
5370 
    args.startDate = startDate
5371 
    args.endDate = endDate
5372 
    args.write(self._oprot)
5373 
    self._oprot.writeMessageEnd()
5374 
    self._oprot.trans.flush()
5375 
 
5376 
  def recv_getStatusDistributionOfOrders(self, ):
5377 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5378 
    if mtype == TMessageType.EXCEPTION:
5379 
      x = TApplicationException()
5380 
      x.read(self._iprot)
5381 
      self._iprot.readMessageEnd()
5382 
      raise x
5383 
    result = getStatusDistributionOfOrders_result()
5384 
    result.read(self._iprot)
5385 
    self._iprot.readMessageEnd()
5386 
    if result.success is not None:
5387 
      return result.success
5388 
    if result.ex is not None:
5389 
      raise result.ex
5390 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getStatusDistributionOfOrders failed: unknown result");
5391 
 
5067 varun.gupt 5392 
  def getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5393 
    """
5394 
    Parameters:
5395 
     - status
5396 
     - startDatetime
5397 
     - endDatetime
5398 
    """
5399 
    self.send_getOrderIdsForStatus(status, startDatetime, endDatetime)
5400 
    return self.recv_getOrderIdsForStatus()
5031 varun.gupt 5401 
 
5067 varun.gupt 5402 
  def send_getOrderIdsForStatus(self, status, startDatetime, endDatetime):
5403 
    self._oprot.writeMessageBegin('getOrderIdsForStatus', TMessageType.CALL, self._seqid)
5404 
    args = getOrderIdsForStatus_args()
5405 
    args.status = status
5406 
    args.startDatetime = startDatetime
5407 
    args.endDatetime = endDatetime
5408 
    args.write(self._oprot)
5409 
    self._oprot.writeMessageEnd()
5410 
    self._oprot.trans.flush()
5411 
 
5412 
  def recv_getOrderIdsForStatus(self, ):
5413 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5414 
    if mtype == TMessageType.EXCEPTION:
5415 
      x = TApplicationException()
5416 
      x.read(self._iprot)
5417 
      self._iprot.readMessageEnd()
5418 
      raise x
5419 
    result = getOrderIdsForStatus_result()
5420 
    result.read(self._iprot)
5421 
    self._iprot.readMessageEnd()
5422 
    if result.success is not None:
5423 
      return result.success
5424 
    if result.ex is not None:
5425 
      raise result.ex
5426 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderIdsForStatus failed: unknown result");
5427 
 
5348 anupam.sin 5428 
  def updateCODAgent(self, agent, orderId):
5429 
    """
5430 
    Updates the agent who handled the COD verification call
5431 
 
5432 
    Parameters:
5433 
     - agent
5434 
     - orderId
5435 
    """
5436 
    self.send_updateCODAgent(agent, orderId)
5437 
    self.recv_updateCODAgent()
5438 
 
5439 
  def send_updateCODAgent(self, agent, orderId):
5440 
    self._oprot.writeMessageBegin('updateCODAgent', TMessageType.CALL, self._seqid)
5441 
    args = updateCODAgent_args()
5442 
    args.agent = agent
5443 
    args.orderId = orderId
5444 
    args.write(self._oprot)
5445 
    self._oprot.writeMessageEnd()
5446 
    self._oprot.trans.flush()
5447 
 
5448 
  def recv_updateCODAgent(self, ):
5449 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5450 
    if mtype == TMessageType.EXCEPTION:
5451 
      x = TApplicationException()
5452 
      x.read(self._iprot)
5453 
      self._iprot.readMessageEnd()
5454 
      raise x
5455 
    result = updateCODAgent_result()
5456 
    result.read(self._iprot)
5457 
    self._iprot.readMessageEnd()
5458 
    if result.ex is not None:
5459 
      raise result.ex
5460 
    return
5461 
 
5099 varun.gupt 5462 
  def updateOrderAsPaidToVendor(self, orderId):
5463 
    """
5464 
    Parameters:
5465 
     - orderId
5466 
    """
5467 
    self.send_updateOrderAsPaidToVendor(orderId)
5468 
    self.recv_updateOrderAsPaidToVendor()
5067 varun.gupt 5469 
 
5099 varun.gupt 5470 
  def send_updateOrderAsPaidToVendor(self, orderId):
5471 
    self._oprot.writeMessageBegin('updateOrderAsPaidToVendor', TMessageType.CALL, self._seqid)
5472 
    args = updateOrderAsPaidToVendor_args()
5473 
    args.orderId = orderId
5474 
    args.write(self._oprot)
5475 
    self._oprot.writeMessageEnd()
5476 
    self._oprot.trans.flush()
5477 
 
5478 
  def recv_updateOrderAsPaidToVendor(self, ):
5479 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5480 
    if mtype == TMessageType.EXCEPTION:
5481 
      x = TApplicationException()
5482 
      x.read(self._iprot)
5483 
      self._iprot.readMessageEnd()
5484 
      raise x
5485 
    result = updateOrderAsPaidToVendor_result()
5486 
    result.read(self._iprot)
5487 
    self._iprot.readMessageEnd()
5488 
    if result.ex is not None:
5489 
      raise result.ex
5490 
    return
5491 
 
5386 phani.kuma 5492 
  def updateOrderOnlyAsPaidToVendor(self, orderId):
5493 
    """
5494 
    Parameters:
5495 
     - orderId
5496 
    """
5497 
    self.send_updateOrderOnlyAsPaidToVendor(orderId)
5498 
    self.recv_updateOrderOnlyAsPaidToVendor()
5499 
 
5500 
  def send_updateOrderOnlyAsPaidToVendor(self, orderId):
5501 
    self._oprot.writeMessageBegin('updateOrderOnlyAsPaidToVendor', TMessageType.CALL, self._seqid)
5502 
    args = updateOrderOnlyAsPaidToVendor_args()
5503 
    args.orderId = orderId
5504 
    args.write(self._oprot)
5505 
    self._oprot.writeMessageEnd()
5506 
    self._oprot.trans.flush()
5507 
 
5508 
  def recv_updateOrderOnlyAsPaidToVendor(self, ):
5509 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5510 
    if mtype == TMessageType.EXCEPTION:
5511 
      x = TApplicationException()
5512 
      x.read(self._iprot)
5513 
      self._iprot.readMessageEnd()
5514 
      raise x
5515 
    result = updateOrderOnlyAsPaidToVendor_result()
5516 
    result.read(self._iprot)
5517 
    self._iprot.readMessageEnd()
5518 
    if result.ex is not None:
5519 
      raise result.ex
5520 
    return
5521 
 
5208 varun.gupt 5522 
  def getRefundedOrdersMarkedPaid(self, ):
5523 
    self.send_getRefundedOrdersMarkedPaid()
5524 
    return self.recv_getRefundedOrdersMarkedPaid()
5099 varun.gupt 5525 
 
5208 varun.gupt 5526 
  def send_getRefundedOrdersMarkedPaid(self, ):
5527 
    self._oprot.writeMessageBegin('getRefundedOrdersMarkedPaid', TMessageType.CALL, self._seqid)
5528 
    args = getRefundedOrdersMarkedPaid_args()
5529 
    args.write(self._oprot)
5530 
    self._oprot.writeMessageEnd()
5531 
    self._oprot.trans.flush()
5532 
 
5533 
  def recv_getRefundedOrdersMarkedPaid(self, ):
5534 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5535 
    if mtype == TMessageType.EXCEPTION:
5536 
      x = TApplicationException()
5537 
      x.read(self._iprot)
5538 
      self._iprot.readMessageEnd()
5539 
      raise x
5540 
    result = getRefundedOrdersMarkedPaid_result()
5541 
    result.read(self._iprot)
5542 
    self._iprot.readMessageEnd()
5543 
    if result.success is not None:
5544 
      return result.success
5545 
    if result.ex is not None:
5546 
      raise result.ex
5547 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRefundedOrdersMarkedPaid failed: unknown result");
5548 
 
5447 anupam.sin 5549 
  def getAllVerificationAgents(self, minOrderId, maxOrderId):
5550 
    """
5551 
    gets all COD Verification Agents for all orderIds from a minId to maxId
5208 varun.gupt 5552 
 
5447 anupam.sin 5553 
 
5554 
    Parameters:
5555 
     - minOrderId
5556 
     - maxOrderId
5557 
    """
5558 
    self.send_getAllVerificationAgents(minOrderId, maxOrderId)
5559 
    return self.recv_getAllVerificationAgents()
5560 
 
5561 
  def send_getAllVerificationAgents(self, minOrderId, maxOrderId):
5562 
    self._oprot.writeMessageBegin('getAllVerificationAgents', TMessageType.CALL, self._seqid)
5563 
    args = getAllVerificationAgents_args()
5564 
    args.minOrderId = minOrderId
5565 
    args.maxOrderId = maxOrderId
5566 
    args.write(self._oprot)
5567 
    self._oprot.writeMessageEnd()
5568 
    self._oprot.trans.flush()
5569 
 
5570 
  def recv_getAllVerificationAgents(self, ):
5571 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5572 
    if mtype == TMessageType.EXCEPTION:
5573 
      x = TApplicationException()
5574 
      x.read(self._iprot)
5575 
      self._iprot.readMessageEnd()
5576 
      raise x
5577 
    result = getAllVerificationAgents_result()
5578 
    result.read(self._iprot)
5579 
    self._iprot.readMessageEnd()
5580 
    if result.success is not None:
5581 
      return result.success
5582 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllVerificationAgents failed: unknown result");
5583 
 
5527 anupam.sin 5584 
  def getAllAttributesForOrderId(self, orderId):
5585 
    """
5586 
    gets all attributes for a given orderId
5447 anupam.sin 5587 
 
5527 anupam.sin 5588 
    Parameters:
5589 
     - orderId
5590 
    """
5591 
    self.send_getAllAttributesForOrderId(orderId)
5592 
    return self.recv_getAllAttributesForOrderId()
5593 
 
5594 
  def send_getAllAttributesForOrderId(self, orderId):
5595 
    self._oprot.writeMessageBegin('getAllAttributesForOrderId', TMessageType.CALL, self._seqid)
5596 
    args = getAllAttributesForOrderId_args()
5597 
    args.orderId = orderId
5598 
    args.write(self._oprot)
5599 
    self._oprot.writeMessageEnd()
5600 
    self._oprot.trans.flush()
5601 
 
5602 
  def recv_getAllAttributesForOrderId(self, ):
5603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5604 
    if mtype == TMessageType.EXCEPTION:
5605 
      x = TApplicationException()
5606 
      x.read(self._iprot)
5607 
      self._iprot.readMessageEnd()
5608 
      raise x
5609 
    result = getAllAttributesForOrderId_result()
5610 
    result.read(self._iprot)
5611 
    self._iprot.readMessageEnd()
5612 
    if result.success is not None:
5613 
      return result.success
5614 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAttributesForOrderId failed: unknown result");
5615 
 
5676 rajveer 5616 
  def setOrderAttributes(self, orderId, attributes):
5617 
    """
5618 
    sets attributes for an order
5619 
 
5620 
    Parameters:
5621 
     - orderId
5622 
     - attributes
5623 
    """
5624 
    self.send_setOrderAttributes(orderId, attributes)
5625 
    self.recv_setOrderAttributes()
5626 
 
5627 
  def send_setOrderAttributes(self, orderId, attributes):
5628 
    self._oprot.writeMessageBegin('setOrderAttributes', TMessageType.CALL, self._seqid)
5629 
    args = setOrderAttributes_args()
5630 
    args.orderId = orderId
5631 
    args.attributes = attributes
5632 
    args.write(self._oprot)
5633 
    self._oprot.writeMessageEnd()
5634 
    self._oprot.trans.flush()
5635 
 
5636 
  def recv_setOrderAttributes(self, ):
5637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5638 
    if mtype == TMessageType.EXCEPTION:
5639 
      x = TApplicationException()
5640 
      x.read(self._iprot)
5641 
      self._iprot.readMessageEnd()
5642 
      raise x
5643 
    result = setOrderAttributes_result()
5644 
    result.read(self._iprot)
5645 
    self._iprot.readMessageEnd()
5646 
    return
5647 
 
5527 anupam.sin 5648 
  def setOrderAttributeForTransaction(self, transactionId, attribute):
5649 
    """
5650 
    sets attributes for all orders in a transaction
5651 
 
5652 
    Parameters:
5653 
     - transactionId
5654 
     - attribute
5655 
    """
5656 
    self.send_setOrderAttributeForTransaction(transactionId, attribute)
5657 
    self.recv_setOrderAttributeForTransaction()
5658 
 
5659 
  def send_setOrderAttributeForTransaction(self, transactionId, attribute):
5660 
    self._oprot.writeMessageBegin('setOrderAttributeForTransaction', TMessageType.CALL, self._seqid)
5661 
    args = setOrderAttributeForTransaction_args()
5662 
    args.transactionId = transactionId
5663 
    args.attribute = attribute
5664 
    args.write(self._oprot)
5665 
    self._oprot.writeMessageEnd()
5666 
    self._oprot.trans.flush()
5667 
 
5668 
  def recv_setOrderAttributeForTransaction(self, ):
5669 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5670 
    if mtype == TMessageType.EXCEPTION:
5671 
      x = TApplicationException()
5672 
      x.read(self._iprot)
5673 
      self._iprot.readMessageEnd()
5674 
      raise x
5675 
    result = setOrderAttributeForTransaction_result()
5676 
    result.read(self._iprot)
5677 
    self._iprot.readMessageEnd()
5678 
    return
5679 
 
5553 rajveer 5680 
  def getReceivePendingOrders(self, storeId):
5681 
    """
5682 
    Parameters:
5683 
     - storeId
5684 
    """
5685 
    self.send_getReceivePendingOrders(storeId)
5686 
    return self.recv_getReceivePendingOrders()
5527 anupam.sin 5687 
 
5553 rajveer 5688 
  def send_getReceivePendingOrders(self, storeId):
5689 
    self._oprot.writeMessageBegin('getReceivePendingOrders', TMessageType.CALL, self._seqid)
5690 
    args = getReceivePendingOrders_args()
5691 
    args.storeId = storeId
5692 
    args.write(self._oprot)
5693 
    self._oprot.writeMessageEnd()
5694 
    self._oprot.trans.flush()
5695 
 
5696 
  def recv_getReceivePendingOrders(self, ):
5697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5698 
    if mtype == TMessageType.EXCEPTION:
5699 
      x = TApplicationException()
5700 
      x.read(self._iprot)
5701 
      self._iprot.readMessageEnd()
5702 
      raise x
5703 
    result = getReceivePendingOrders_result()
5704 
    result.read(self._iprot)
5705 
    self._iprot.readMessageEnd()
5706 
    if result.success is not None:
5707 
      return result.success
5708 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivePendingOrders failed: unknown result");
5709 
 
5710 
  def getReceivedAtStoreOrders(self, storeId):
5711 
    """
5712 
    Parameters:
5713 
     - storeId
5714 
    """
5715 
    self.send_getReceivedAtStoreOrders(storeId)
5716 
    return self.recv_getReceivedAtStoreOrders()
5717 
 
5718 
  def send_getReceivedAtStoreOrders(self, storeId):
5719 
    self._oprot.writeMessageBegin('getReceivedAtStoreOrders', TMessageType.CALL, self._seqid)
5720 
    args = getReceivedAtStoreOrders_args()
5721 
    args.storeId = storeId
5722 
    args.write(self._oprot)
5723 
    self._oprot.writeMessageEnd()
5724 
    self._oprot.trans.flush()
5725 
 
5726 
  def recv_getReceivedAtStoreOrders(self, ):
5727 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5728 
    if mtype == TMessageType.EXCEPTION:
5729 
      x = TApplicationException()
5730 
      x.read(self._iprot)
5731 
      self._iprot.readMessageEnd()
5732 
      raise x
5733 
    result = getReceivedAtStoreOrders_result()
5734 
    result.read(self._iprot)
5735 
    self._iprot.readMessageEnd()
5736 
    if result.success is not None:
5737 
      return result.success
5738 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReceivedAtStoreOrders failed: unknown result");
5739 
 
5713 rajveer 5740 
  def getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5741 
    """
5742 
    Parameters:
5743 
     - storeId
5744 
     - fromDate
5745 
     - toDate
5746 
     - onlyCod
5747 
    """
5748 
    self.send_getOrdersCollectionAtStore(storeId, fromDate, toDate, onlyCod)
5749 
    return self.recv_getOrdersCollectionAtStore()
5750 
 
5751 
  def send_getOrdersCollectionAtStore(self, storeId, fromDate, toDate, onlyCod):
5752 
    self._oprot.writeMessageBegin('getOrdersCollectionAtStore', TMessageType.CALL, self._seqid)
5753 
    args = getOrdersCollectionAtStore_args()
5754 
    args.storeId = storeId
5755 
    args.fromDate = fromDate
5756 
    args.toDate = toDate
5757 
    args.onlyCod = onlyCod
5758 
    args.write(self._oprot)
5759 
    self._oprot.writeMessageEnd()
5760 
    self._oprot.trans.flush()
5761 
 
5762 
  def recv_getOrdersCollectionAtStore(self, ):
5763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5764 
    if mtype == TMessageType.EXCEPTION:
5765 
      x = TApplicationException()
5766 
      x.read(self._iprot)
5767 
      self._iprot.readMessageEnd()
5768 
      raise x
5769 
    result = getOrdersCollectionAtStore_result()
5770 
    result.read(self._iprot)
5771 
    self._iprot.readMessageEnd()
5772 
    if result.success is not None:
5773 
      return result.success
5774 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersCollectionAtStore failed: unknown result");
5775 
 
5833 rajveer 5776 
  def getOrderAttributeValue(self, orderId, attributeName):
5777 
    """
5778 
    Parameters:
5779 
     - orderId
5780 
     - attributeName
5781 
    """
5782 
    self.send_getOrderAttributeValue(orderId, attributeName)
5783 
    return self.recv_getOrderAttributeValue()
5784 
 
5785 
  def send_getOrderAttributeValue(self, orderId, attributeName):
5786 
    self._oprot.writeMessageBegin('getOrderAttributeValue', TMessageType.CALL, self._seqid)
5787 
    args = getOrderAttributeValue_args()
5788 
    args.orderId = orderId
5789 
    args.attributeName = attributeName
5790 
    args.write(self._oprot)
5791 
    self._oprot.writeMessageEnd()
5792 
    self._oprot.trans.flush()
5793 
 
5794 
  def recv_getOrderAttributeValue(self, ):
5795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5796 
    if mtype == TMessageType.EXCEPTION:
5797 
      x = TApplicationException()
5798 
      x.read(self._iprot)
5799 
      self._iprot.readMessageEnd()
5800 
      raise x
5801 
    result = getOrderAttributeValue_result()
5802 
    result.read(self._iprot)
5803 
    self._iprot.readMessageEnd()
5804 
    if result.success is not None:
5805 
      return result.success
5806 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderAttributeValue failed: unknown result");
5807 
 
6019 rajveer 5808 
  def changeJacketNumber(self, orderId, jacketNumber):
5809 
    """
5810 
    Parameters:
5811 
     - orderId
5812 
     - jacketNumber
5813 
    """
5814 
    self.send_changeJacketNumber(orderId, jacketNumber)
5815 
    return self.recv_changeJacketNumber()
5816 
 
5817 
  def send_changeJacketNumber(self, orderId, jacketNumber):
5818 
    self._oprot.writeMessageBegin('changeJacketNumber', TMessageType.CALL, self._seqid)
5819 
    args = changeJacketNumber_args()
5820 
    args.orderId = orderId
5821 
    args.jacketNumber = jacketNumber
5822 
    args.write(self._oprot)
5823 
    self._oprot.writeMessageEnd()
5824 
    self._oprot.trans.flush()
5825 
 
5826 
  def recv_changeJacketNumber(self, ):
5827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5828 
    if mtype == TMessageType.EXCEPTION:
5829 
      x = TApplicationException()
5830 
      x.read(self._iprot)
5831 
      self._iprot.readMessageEnd()
5832 
      raise x
5833 
    result = changeJacketNumber_result()
5834 
    result.read(self._iprot)
5835 
    self._iprot.readMessageEnd()
5836 
    if result.success is not None:
5837 
      return result.success
5838 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeJacketNumber failed: unknown result");
5839 
 
5840 
  def markOrderAsRtoInTransit(self, orderId):
5841 
    """
5842 
    Parameters:
5843 
     - orderId
5844 
    """
5845 
    self.send_markOrderAsRtoInTransit(orderId)
5846 
    return self.recv_markOrderAsRtoInTransit()
5847 
 
5848 
  def send_markOrderAsRtoInTransit(self, orderId):
5849 
    self._oprot.writeMessageBegin('markOrderAsRtoInTransit', TMessageType.CALL, self._seqid)
5850 
    args = markOrderAsRtoInTransit_args()
5851 
    args.orderId = orderId
5852 
    args.write(self._oprot)
5853 
    self._oprot.writeMessageEnd()
5854 
    self._oprot.trans.flush()
5855 
 
5856 
  def recv_markOrderAsRtoInTransit(self, ):
5857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5858 
    if mtype == TMessageType.EXCEPTION:
5859 
      x = TApplicationException()
5860 
      x.read(self._iprot)
5861 
      self._iprot.readMessageEnd()
5862 
      raise x
5863 
    result = markOrderAsRtoInTransit_result()
5864 
    result.read(self._iprot)
5865 
    self._iprot.readMessageEnd()
5866 
    if result.success is not None:
5867 
      return result.success
5868 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsRtoInTransit failed: unknown result");
5869 
 
5593 mandeep.dh 5870 
  def acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5871 
    """
5872 
    Accepts appropriate order for an item in a given billingWarehouse. Usually
5873 
    invoked while scanning IN of items.
5553 rajveer 5874 
 
5593 mandeep.dh 5875 
    Parameters:
5876 
     - itemId
5877 
     - quantity
5878 
     - fulfilmentWarehouseId
5879 
     - billingWarehouseId
5880 
    """
5881 
    self.send_acceptOrderForItem(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId)
5882 
    self.recv_acceptOrderForItem()
5883 
 
5884 
  def send_acceptOrderForItem(self, itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
5885 
    self._oprot.writeMessageBegin('acceptOrderForItem', TMessageType.CALL, self._seqid)
5886 
    args = acceptOrderForItem_args()
5887 
    args.itemId = itemId
5888 
    args.quantity = quantity
5889 
    args.fulfilmentWarehouseId = fulfilmentWarehouseId
5890 
    args.billingWarehouseId = billingWarehouseId
5891 
    args.write(self._oprot)
5892 
    self._oprot.writeMessageEnd()
5893 
    self._oprot.trans.flush()
5894 
 
5895 
  def recv_acceptOrderForItem(self, ):
5896 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5897 
    if mtype == TMessageType.EXCEPTION:
5898 
      x = TApplicationException()
5899 
      x.read(self._iprot)
5900 
      self._iprot.readMessageEnd()
5901 
      raise x
5902 
    result = acceptOrderForItem_result()
5903 
    result.read(self._iprot)
5904 
    self._iprot.readMessageEnd()
5905 
    return
5906 
 
6000 mandeep.dh 5907 
  def createRechargeOrder(self, rechargeOrder):
5908 
    """
5909 
    Parameters:
5910 
     - rechargeOrder
5911 
    """
5912 
    self.send_createRechargeOrder(rechargeOrder)
5913 
    return self.recv_createRechargeOrder()
5593 mandeep.dh 5914 
 
6000 mandeep.dh 5915 
  def send_createRechargeOrder(self, rechargeOrder):
5916 
    self._oprot.writeMessageBegin('createRechargeOrder', TMessageType.CALL, self._seqid)
5917 
    args = createRechargeOrder_args()
5918 
    args.rechargeOrder = rechargeOrder
5919 
    args.write(self._oprot)
5920 
    self._oprot.writeMessageEnd()
5921 
    self._oprot.trans.flush()
5922 
 
5923 
  def recv_createRechargeOrder(self, ):
5924 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5925 
    if mtype == TMessageType.EXCEPTION:
5926 
      x = TApplicationException()
5927 
      x.read(self._iprot)
5928 
      self._iprot.readMessageEnd()
5929 
      raise x
5930 
    result = createRechargeOrder_result()
5931 
    result.read(self._iprot)
5932 
    self._iprot.readMessageEnd()
5933 
    if result.success is not None:
5934 
      return result.success
5935 
    if result.ex is not None:
5936 
      raise result.ex
5937 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createRechargeOrder failed: unknown result");
5938 
 
6031 rajveer 5939 
  def getRechargeOrder(self, rechargeRrderId):
5940 
    """
5941 
    Parameters:
5942 
     - rechargeRrderId
5943 
    """
5944 
    self.send_getRechargeOrder(rechargeRrderId)
5945 
    return self.recv_getRechargeOrder()
5946 
 
5947 
  def send_getRechargeOrder(self, rechargeRrderId):
5948 
    self._oprot.writeMessageBegin('getRechargeOrder', TMessageType.CALL, self._seqid)
5949 
    args = getRechargeOrder_args()
5950 
    args.rechargeRrderId = rechargeRrderId
5951 
    args.write(self._oprot)
5952 
    self._oprot.writeMessageEnd()
5953 
    self._oprot.trans.flush()
5954 
 
5955 
  def recv_getRechargeOrder(self, ):
5956 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5957 
    if mtype == TMessageType.EXCEPTION:
5958 
      x = TApplicationException()
5959 
      x.read(self._iprot)
5960 
      self._iprot.readMessageEnd()
5961 
      raise x
5962 
    result = getRechargeOrder_result()
5963 
    result.read(self._iprot)
5964 
    self._iprot.readMessageEnd()
5965 
    if result.success is not None:
5966 
      return result.success
5967 
    if result.ex is not None:
5968 
      raise result.ex
5969 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrder failed: unknown result");
5970 
 
5971 
  def getRechargeOrders(self, userId):
5972 
    """
5973 
    Parameters:
5974 
     - userId
5975 
    """
5976 
    self.send_getRechargeOrders(userId)
5977 
    return self.recv_getRechargeOrders()
5978 
 
5979 
  def send_getRechargeOrders(self, userId):
5980 
    self._oprot.writeMessageBegin('getRechargeOrders', TMessageType.CALL, self._seqid)
5981 
    args = getRechargeOrders_args()
5982 
    args.userId = userId
5983 
    args.write(self._oprot)
5984 
    self._oprot.writeMessageEnd()
5985 
    self._oprot.trans.flush()
5986 
 
5987 
  def recv_getRechargeOrders(self, ):
5988 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
5989 
    if mtype == TMessageType.EXCEPTION:
5990 
      x = TApplicationException()
5991 
      x.read(self._iprot)
5992 
      self._iprot.readMessageEnd()
5993 
      raise x
5994 
    result = getRechargeOrders_result()
5995 
    result.read(self._iprot)
5996 
    self._iprot.readMessageEnd()
5997 
    if result.success is not None:
5998 
      return result.success
5999 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrders failed: unknown result");
6000 
 
6000 mandeep.dh 6001 
  def updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6002 
    """
6003 
    Parameters:
6004 
     - rechargeOrderId
6005 
     - rechargeOrderStatus
6006 
    """
6007 
    self.send_updateRechargeOrderStatus(rechargeOrderId, rechargeOrderStatus)
6031 rajveer 6008 
    return self.recv_updateRechargeOrderStatus()
6000 mandeep.dh 6009 
 
6010 
  def send_updateRechargeOrderStatus(self, rechargeOrderId, rechargeOrderStatus):
6011 
    self._oprot.writeMessageBegin('updateRechargeOrderStatus', TMessageType.CALL, self._seqid)
6012 
    args = updateRechargeOrderStatus_args()
6013 
    args.rechargeOrderId = rechargeOrderId
6014 
    args.rechargeOrderStatus = rechargeOrderStatus
6015 
    args.write(self._oprot)
6016 
    self._oprot.writeMessageEnd()
6017 
    self._oprot.trans.flush()
6018 
 
6019 
  def recv_updateRechargeOrderStatus(self, ):
6020 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6021 
    if mtype == TMessageType.EXCEPTION:
6022 
      x = TApplicationException()
6023 
      x.read(self._iprot)
6024 
      self._iprot.readMessageEnd()
6025 
      raise x
6026 
    result = updateRechargeOrderStatus_result()
6027 
    result.read(self._iprot)
6028 
    self._iprot.readMessageEnd()
6031 rajveer 6029 
    if result.success is not None:
6030 
      return result.success
6000 mandeep.dh 6031 
    if result.ex is not None:
6032 
      raise result.ex
6031 rajveer 6033 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateRechargeOrderStatus failed: unknown result");
6000 mandeep.dh 6034 
 
6031 rajveer 6035 
  def activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6036 
    """
6037 
    Parameters:
6031 rajveer 6038 
     - rechargeOrderId
6000 mandeep.dh 6039 
    """
6031 rajveer 6040 
    self.send_activateRechargeTxn(rechargeOrderId)
6000 mandeep.dh 6041 
    return self.recv_activateRechargeTxn()
6042 
 
6031 rajveer 6043 
  def send_activateRechargeTxn(self, rechargeOrderId):
6000 mandeep.dh 6044 
    self._oprot.writeMessageBegin('activateRechargeTxn', TMessageType.CALL, self._seqid)
6045 
    args = activateRechargeTxn_args()
6031 rajveer 6046 
    args.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 6047 
    args.write(self._oprot)
6048 
    self._oprot.writeMessageEnd()
6049 
    self._oprot.trans.flush()
6050 
 
6051 
  def recv_activateRechargeTxn(self, ):
6052 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6053 
    if mtype == TMessageType.EXCEPTION:
6054 
      x = TApplicationException()
6055 
      x.read(self._iprot)
6056 
      self._iprot.readMessageEnd()
6057 
      raise x
6058 
    result = activateRechargeTxn_result()
6059 
    result.read(self._iprot)
6060 
    self._iprot.readMessageEnd()
6061 
    if result.success is not None:
6062 
      return result.success
6063 
    if result.ex is not None:
6064 
      raise result.ex
6065 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "activateRechargeTxn failed: unknown result");
6066 
 
6031 rajveer 6067 
  def getUserWallet(self, userId):
6000 mandeep.dh 6068 
    """
6069 
    Parameters:
6031 rajveer 6070 
     - userId
6000 mandeep.dh 6071 
    """
6031 rajveer 6072 
    self.send_getUserWallet(userId)
6073 
    return self.recv_getUserWallet()
6000 mandeep.dh 6074 
 
6031 rajveer 6075 
  def send_getUserWallet(self, userId):
6076 
    self._oprot.writeMessageBegin('getUserWallet', TMessageType.CALL, self._seqid)
6077 
    args = getUserWallet_args()
6078 
    args.userId = userId
6000 mandeep.dh 6079 
    args.write(self._oprot)
6080 
    self._oprot.writeMessageEnd()
6081 
    self._oprot.trans.flush()
6082 
 
6031 rajveer 6083 
  def recv_getUserWallet(self, ):
6000 mandeep.dh 6084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6085 
    if mtype == TMessageType.EXCEPTION:
6086 
      x = TApplicationException()
6087 
      x.read(self._iprot)
6088 
      self._iprot.readMessageEnd()
6089 
      raise x
6031 rajveer 6090 
    result = getUserWallet_result()
6000 mandeep.dh 6091 
    result.read(self._iprot)
6092 
    self._iprot.readMessageEnd()
6093 
    if result.success is not None:
6094 
      return result.success
6031 rajveer 6095 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWallet failed: unknown result");
6000 mandeep.dh 6096 
 
6031 rajveer 6097 
  def getUserWalletHistory(self, userId):
6000 mandeep.dh 6098 
    """
6099 
    Parameters:
6031 rajveer 6100 
     - userId
6000 mandeep.dh 6101 
    """
6031 rajveer 6102 
    self.send_getUserWalletHistory(userId)
6103 
    return self.recv_getUserWalletHistory()
6000 mandeep.dh 6104 
 
6031 rajveer 6105 
  def send_getUserWalletHistory(self, userId):
6106 
    self._oprot.writeMessageBegin('getUserWalletHistory', TMessageType.CALL, self._seqid)
6107 
    args = getUserWalletHistory_args()
6108 
    args.userId = userId
6000 mandeep.dh 6109 
    args.write(self._oprot)
6110 
    self._oprot.writeMessageEnd()
6111 
    self._oprot.trans.flush()
6112 
 
6031 rajveer 6113 
  def recv_getUserWalletHistory(self, ):
6000 mandeep.dh 6114 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6115 
    if mtype == TMessageType.EXCEPTION:
6116 
      x = TApplicationException()
6117 
      x.read(self._iprot)
6118 
      self._iprot.readMessageEnd()
6119 
      raise x
6031 rajveer 6120 
    result = getUserWalletHistory_result()
6000 mandeep.dh 6121 
    result.read(self._iprot)
6122 
    self._iprot.readMessageEnd()
6123 
    if result.success is not None:
6124 
      return result.success
6031 rajveer 6125 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserWalletHistory failed: unknown result");
6000 mandeep.dh 6126 
 
6050 anupam.sin 6127 
  def getRechargeOrdersForTransaction(self, txnId):
6128 
    """
6129 
    Returns a recharge order for a given transactionId
6130 
 
6131 
    Parameters:
6132 
     - txnId
6133 
    """
6134 
    self.send_getRechargeOrdersForTransaction(txnId)
6135 
    return self.recv_getRechargeOrdersForTransaction()
6136 
 
6137 
  def send_getRechargeOrdersForTransaction(self, txnId):
6138 
    self._oprot.writeMessageBegin('getRechargeOrdersForTransaction', TMessageType.CALL, self._seqid)
6139 
    args = getRechargeOrdersForTransaction_args()
6140 
    args.txnId = txnId
6141 
    args.write(self._oprot)
6142 
    self._oprot.writeMessageEnd()
6143 
    self._oprot.trans.flush()
6144 
 
6145 
  def recv_getRechargeOrdersForTransaction(self, ):
6146 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6147 
    if mtype == TMessageType.EXCEPTION:
6148 
      x = TApplicationException()
6149 
      x.read(self._iprot)
6150 
      self._iprot.readMessageEnd()
6151 
      raise x
6152 
    result = getRechargeOrdersForTransaction_result()
6153 
    result.read(self._iprot)
6154 
    self._iprot.readMessageEnd()
6155 
    if result.success is not None:
6156 
      return result.success
6157 
    if result.ex is not None:
6158 
      raise result.ex
6159 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForTransaction failed: unknown result");
6160 
 
6206 rajveer 6161 
  def getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6162 
    """
6163 
    Parameters:
6164 
     - rechargeType
6206 rajveer 6165 
     - onlyActive
6048 rajveer 6166 
    """
6206 rajveer 6167 
    self.send_getServiceProviders(rechargeType, onlyActive)
6048 rajveer 6168 
    return self.recv_getServiceProviders()
6000 mandeep.dh 6169 
 
6206 rajveer 6170 
  def send_getServiceProviders(self, rechargeType, onlyActive):
6048 rajveer 6171 
    self._oprot.writeMessageBegin('getServiceProviders', TMessageType.CALL, self._seqid)
6172 
    args = getServiceProviders_args()
6173 
    args.rechargeType = rechargeType
6206 rajveer 6174 
    args.onlyActive = onlyActive
6048 rajveer 6175 
    args.write(self._oprot)
6176 
    self._oprot.writeMessageEnd()
6177 
    self._oprot.trans.flush()
6178 
 
6179 
  def recv_getServiceProviders(self, ):
6180 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6181 
    if mtype == TMessageType.EXCEPTION:
6182 
      x = TApplicationException()
6183 
      x.read(self._iprot)
6184 
      self._iprot.readMessageEnd()
6185 
      raise x
6186 
    result = getServiceProviders_result()
6187 
    result.read(self._iprot)
6188 
    self._iprot.readMessageEnd()
6189 
    if result.success is not None:
6190 
      return result.success
6191 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviders failed: unknown result");
6192 
 
6049 rajveer 6193 
  def getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6194 
    """
6195 
    Parameters:
6049 rajveer 6196 
     - rechargeType
6048 rajveer 6197 
     - deviceNumber
6198 
    """
6049 rajveer 6199 
    self.send_getServiceProviderForDevice(rechargeType, deviceNumber)
6048 rajveer 6200 
    return self.recv_getServiceProviderForDevice()
6201 
 
6049 rajveer 6202 
  def send_getServiceProviderForDevice(self, rechargeType, deviceNumber):
6048 rajveer 6203 
    self._oprot.writeMessageBegin('getServiceProviderForDevice', TMessageType.CALL, self._seqid)
6204 
    args = getServiceProviderForDevice_args()
6049 rajveer 6205 
    args.rechargeType = rechargeType
6048 rajveer 6206 
    args.deviceNumber = deviceNumber
6207 
    args.write(self._oprot)
6208 
    self._oprot.writeMessageEnd()
6209 
    self._oprot.trans.flush()
6210 
 
6211 
  def recv_getServiceProviderForDevice(self, ):
6212 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6213 
    if mtype == TMessageType.EXCEPTION:
6214 
      x = TApplicationException()
6215 
      x.read(self._iprot)
6216 
      self._iprot.readMessageEnd()
6217 
      raise x
6218 
    result = getServiceProviderForDevice_result()
6219 
    result.read(self._iprot)
6220 
    self._iprot.readMessageEnd()
6221 
    if result.success is not None:
6222 
      return result.success
6223 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getServiceProviderForDevice failed: unknown result");
6224 
 
6591 anupam.sin 6225 
  def validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6226 
    """
6227 
    Parameters:
6228 
     - rechargeType
6229 
     - deviceNumber
6307 anupam.sin 6230 
     - userSelectedProviderId
6591 anupam.sin 6231 
     - clientAddress
6269 rajveer 6232 
    """
6591 anupam.sin 6233 
    self.send_validateRecharge(rechargeType, deviceNumber, userSelectedProviderId, clientAddress)
6269 rajveer 6234 
    return self.recv_validateRecharge()
6235 
 
6591 anupam.sin 6236 
  def send_validateRecharge(self, rechargeType, deviceNumber, userSelectedProviderId, clientAddress):
6269 rajveer 6237 
    self._oprot.writeMessageBegin('validateRecharge', TMessageType.CALL, self._seqid)
6238 
    args = validateRecharge_args()
6239 
    args.rechargeType = rechargeType
6240 
    args.deviceNumber = deviceNumber
6307 anupam.sin 6241 
    args.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 6242 
    args.clientAddress = clientAddress
6269 rajveer 6243 
    args.write(self._oprot)
6244 
    self._oprot.writeMessageEnd()
6245 
    self._oprot.trans.flush()
6246 
 
6247 
  def recv_validateRecharge(self, ):
6248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6249 
    if mtype == TMessageType.EXCEPTION:
6250 
      x = TApplicationException()
6251 
      x.read(self._iprot)
6252 
      self._iprot.readMessageEnd()
6253 
      raise x
6254 
    result = validateRecharge_result()
6255 
    result.read(self._iprot)
6256 
    self._iprot.readMessageEnd()
6257 
    if result.success is not None:
6258 
      return result.success
6259 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateRecharge failed: unknown result");
6260 
 
6094 rajveer 6261 
  def getRechargeOrdersForDevice(self, deviceNumber):
6262 
    """
6263 
    Parameters:
6264 
     - deviceNumber
6265 
    """
6266 
    self.send_getRechargeOrdersForDevice(deviceNumber)
6267 
    return self.recv_getRechargeOrdersForDevice()
6048 rajveer 6268 
 
6094 rajveer 6269 
  def send_getRechargeOrdersForDevice(self, deviceNumber):
6270 
    self._oprot.writeMessageBegin('getRechargeOrdersForDevice', TMessageType.CALL, self._seqid)
6271 
    args = getRechargeOrdersForDevice_args()
6272 
    args.deviceNumber = deviceNumber
6273 
    args.write(self._oprot)
6274 
    self._oprot.writeMessageEnd()
6275 
    self._oprot.trans.flush()
6276 
 
6277 
  def recv_getRechargeOrdersForDevice(self, ):
6278 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6279 
    if mtype == TMessageType.EXCEPTION:
6280 
      x = TApplicationException()
6281 
      x.read(self._iprot)
6282 
      self._iprot.readMessageEnd()
6283 
      raise x
6284 
    result = getRechargeOrdersForDevice_result()
6285 
    result.read(self._iprot)
6286 
    self._iprot.readMessageEnd()
6287 
    if result.success is not None:
6288 
      return result.success
6289 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForDevice failed: unknown result");
6290 
 
6291 
  def addAmountToWallet(self, userId, orderId, amount):
6292 
    """
6293 
    Parameters:
6294 
     - userId
6295 
     - orderId
6296 
     - amount
6297 
    """
6298 
    self.send_addAmountToWallet(userId, orderId, amount)
6299 
    self.recv_addAmountToWallet()
6300 
 
6301 
  def send_addAmountToWallet(self, userId, orderId, amount):
6302 
    self._oprot.writeMessageBegin('addAmountToWallet', TMessageType.CALL, self._seqid)
6303 
    args = addAmountToWallet_args()
6304 
    args.userId = userId
6305 
    args.orderId = orderId
6306 
    args.amount = amount
6307 
    args.write(self._oprot)
6308 
    self._oprot.writeMessageEnd()
6309 
    self._oprot.trans.flush()
6310 
 
6311 
  def recv_addAmountToWallet(self, ):
6312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6313 
    if mtype == TMessageType.EXCEPTION:
6314 
      x = TApplicationException()
6315 
      x.read(self._iprot)
6316 
      self._iprot.readMessageEnd()
6317 
      raise x
6318 
    result = addAmountToWallet_result()
6319 
    result.read(self._iprot)
6320 
    self._iprot.readMessageEnd()
6321 
    return
6322 
 
6188 rajveer 6323 
  def getRechargeStatistics(self, ):
6324 
    self.send_getRechargeStatistics()
6325 
    return self.recv_getRechargeStatistics()
6326 
 
6327 
  def send_getRechargeStatistics(self, ):
6328 
    self._oprot.writeMessageBegin('getRechargeStatistics', TMessageType.CALL, self._seqid)
6329 
    args = getRechargeStatistics_args()
6330 
    args.write(self._oprot)
6331 
    self._oprot.writeMessageEnd()
6332 
    self._oprot.trans.flush()
6333 
 
6334 
  def recv_getRechargeStatistics(self, ):
6335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6336 
    if mtype == TMessageType.EXCEPTION:
6337 
      x = TApplicationException()
6338 
      x.read(self._iprot)
6339 
      self._iprot.readMessageEnd()
6340 
      raise x
6341 
    result = getRechargeStatistics_result()
6342 
    result.read(self._iprot)
6343 
    self._iprot.readMessageEnd()
6344 
    if result.success is not None:
6345 
      return result.success
6346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeStatistics failed: unknown result");
6347 
 
6154 rajveer 6348 
  def getRechargeOrdersForStatus(self, status):
6349 
    """
6350 
    Parameters:
6351 
     - status
6352 
    """
6353 
    self.send_getRechargeOrdersForStatus(status)
6354 
    return self.recv_getRechargeOrdersForStatus()
6094 rajveer 6355 
 
6154 rajveer 6356 
  def send_getRechargeOrdersForStatus(self, status):
6357 
    self._oprot.writeMessageBegin('getRechargeOrdersForStatus', TMessageType.CALL, self._seqid)
6358 
    args = getRechargeOrdersForStatus_args()
6359 
    args.status = status
6360 
    args.write(self._oprot)
6361 
    self._oprot.writeMessageEnd()
6362 
    self._oprot.trans.flush()
6363 
 
6364 
  def recv_getRechargeOrdersForStatus(self, ):
6365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6366 
    if mtype == TMessageType.EXCEPTION:
6367 
      x = TApplicationException()
6368 
      x.read(self._iprot)
6369 
      self._iprot.readMessageEnd()
6370 
      raise x
6371 
    result = getRechargeOrdersForStatus_result()
6372 
    result.read(self._iprot)
6373 
    self._iprot.readMessageEnd()
6374 
    if result.success is not None:
6375 
      return result.success
6376 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeOrdersForStatus failed: unknown result");
6377 
 
6159 rajveer 6378 
  def getPlansForOperator(self, operatorId):
6379 
    """
6380 
    Parameters:
6381 
     - operatorId
6382 
    """
6383 
    self.send_getPlansForOperator(operatorId)
6384 
    return self.recv_getPlansForOperator()
6154 rajveer 6385 
 
6159 rajveer 6386 
  def send_getPlansForOperator(self, operatorId):
6387 
    self._oprot.writeMessageBegin('getPlansForOperator', TMessageType.CALL, self._seqid)
6388 
    args = getPlansForOperator_args()
6389 
    args.operatorId = operatorId
6390 
    args.write(self._oprot)
6391 
    self._oprot.writeMessageEnd()
6392 
    self._oprot.trans.flush()
6393 
 
6394 
  def recv_getPlansForOperator(self, ):
6395 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6396 
    if mtype == TMessageType.EXCEPTION:
6397 
      x = TApplicationException()
6398 
      x.read(self._iprot)
6399 
      self._iprot.readMessageEnd()
6400 
      raise x
6401 
    result = getPlansForOperator_result()
6402 
    result.read(self._iprot)
6403 
    self._iprot.readMessageEnd()
6404 
    if result.success is not None:
6405 
      return result.success
6406 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPlansForOperator failed: unknown result");
6407 
 
6307 anupam.sin 6408 
  def getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6409 
    """
6410 
    Returns denominations for a given operator and circle
6159 rajveer 6411 
 
6289 anupam.sin 6412 
    Parameters:
6413 
     - operatorId
6307 anupam.sin 6414 
     - circleCode
6289 anupam.sin 6415 
     - denominationType
6416 
    """
6307 anupam.sin 6417 
    self.send_getRechargeDenominations(operatorId, circleCode, denominationType)
6289 anupam.sin 6418 
    return self.recv_getRechargeDenominations()
6419 
 
6307 anupam.sin 6420 
  def send_getRechargeDenominations(self, operatorId, circleCode, denominationType):
6289 anupam.sin 6421 
    self._oprot.writeMessageBegin('getRechargeDenominations', TMessageType.CALL, self._seqid)
6422 
    args = getRechargeDenominations_args()
6423 
    args.operatorId = operatorId
6307 anupam.sin 6424 
    args.circleCode = circleCode
6289 anupam.sin 6425 
    args.denominationType = denominationType
6426 
    args.write(self._oprot)
6427 
    self._oprot.writeMessageEnd()
6428 
    self._oprot.trans.flush()
6429 
 
6430 
  def recv_getRechargeDenominations(self, ):
6431 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6432 
    if mtype == TMessageType.EXCEPTION:
6433 
      x = TApplicationException()
6434 
      x.read(self._iprot)
6435 
      self._iprot.readMessageEnd()
6436 
      raise x
6437 
    result = getRechargeDenominations_result()
6438 
    result.read(self._iprot)
6439 
    self._iprot.readMessageEnd()
6440 
    if result.success is not None:
6441 
      return result.success
6442 
    if result.ex is not None:
6443 
      raise result.ex
6444 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRechargeDenominations failed: unknown result");
6445 
 
6371 rajveer 6446 
  def updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6447 
    """
6448 
    Parameters:
6449 
     - operatorId
6450 
     - circleId
6451 
     - isAvailable
6452 
    """
6453 
    self.send_updateAvailabilityStatus(operatorId, circleId, isAvailable)
6454 
    self.recv_updateAvailabilityStatus()
6289 anupam.sin 6455 
 
6371 rajveer 6456 
  def send_updateAvailabilityStatus(self, operatorId, circleId, isAvailable):
6457 
    self._oprot.writeMessageBegin('updateAvailabilityStatus', TMessageType.CALL, self._seqid)
6458 
    args = updateAvailabilityStatus_args()
6459 
    args.operatorId = operatorId
6460 
    args.circleId = circleId
6461 
    args.isAvailable = isAvailable
6462 
    args.write(self._oprot)
6463 
    self._oprot.writeMessageEnd()
6464 
    self._oprot.trans.flush()
6465 
 
6466 
  def recv_updateAvailabilityStatus(self, ):
6467 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6468 
    if mtype == TMessageType.EXCEPTION:
6469 
      x = TApplicationException()
6470 
      x.read(self._iprot)
6471 
      self._iprot.readMessageEnd()
6472 
      raise x
6473 
    result = updateAvailabilityStatus_result()
6474 
    result.read(self._iprot)
6475 
    self._iprot.readMessageEnd()
6476 
    return
6477 
 
6389 rajveer 6478 
  def getAvailableEmiSchemes(self, ):
6479 
    self.send_getAvailableEmiSchemes()
6480 
    return self.recv_getAvailableEmiSchemes()
6371 rajveer 6481 
 
6389 rajveer 6482 
  def send_getAvailableEmiSchemes(self, ):
6483 
    self._oprot.writeMessageBegin('getAvailableEmiSchemes', TMessageType.CALL, self._seqid)
6484 
    args = getAvailableEmiSchemes_args()
6485 
    args.write(self._oprot)
6486 
    self._oprot.writeMessageEnd()
6487 
    self._oprot.trans.flush()
6488 
 
6489 
  def recv_getAvailableEmiSchemes(self, ):
6490 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6491 
    if mtype == TMessageType.EXCEPTION:
6492 
      x = TApplicationException()
6493 
      x.read(self._iprot)
6494 
      self._iprot.readMessageEnd()
6495 
      raise x
6496 
    result = getAvailableEmiSchemes_result()
6497 
    result.read(self._iprot)
6498 
    self._iprot.readMessageEnd()
6499 
    if result.success is not None:
6500 
      return result.success
6501 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAvailableEmiSchemes failed: unknown result");
6502 
 
6503 
  def getMiscCharges(self, transactionId):
6504 
    """
6505 
    Parameters:
6506 
     - transactionId
6507 
    """
6508 
    self.send_getMiscCharges(transactionId)
6509 
    return self.recv_getMiscCharges()
6510 
 
6511 
  def send_getMiscCharges(self, transactionId):
6512 
    self._oprot.writeMessageBegin('getMiscCharges', TMessageType.CALL, self._seqid)
6513 
    args = getMiscCharges_args()
6514 
    args.transactionId = transactionId
6515 
    args.write(self._oprot)
6516 
    self._oprot.writeMessageEnd()
6517 
    self._oprot.trans.flush()
6518 
 
6519 
  def recv_getMiscCharges(self, ):
6520 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6521 
    if mtype == TMessageType.EXCEPTION:
6522 
      x = TApplicationException()
6523 
      x.read(self._iprot)
6524 
      self._iprot.readMessageEnd()
6525 
      raise x
6526 
    result = getMiscCharges_result()
6527 
    result.read(self._iprot)
6528 
    self._iprot.readMessageEnd()
6529 
    if result.success is not None:
6530 
      return result.success
6531 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMiscCharges failed: unknown result");
6532 
 
6507 anupam.sin 6533 
  def refundRechargeOrder(self, rechargeOrderId):
6534 
    """
6535 
    Parameters:
6536 
     - rechargeOrderId
6537 
    """
6538 
    self.send_refundRechargeOrder(rechargeOrderId)
6539 
    return self.recv_refundRechargeOrder()
6389 rajveer 6540 
 
6507 anupam.sin 6541 
  def send_refundRechargeOrder(self, rechargeOrderId):
6542 
    self._oprot.writeMessageBegin('refundRechargeOrder', TMessageType.CALL, self._seqid)
6543 
    args = refundRechargeOrder_args()
6544 
    args.rechargeOrderId = rechargeOrderId
6545 
    args.write(self._oprot)
6546 
    self._oprot.writeMessageEnd()
6547 
    self._oprot.trans.flush()
6548 
 
6549 
  def recv_refundRechargeOrder(self, ):
6550 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6551 
    if mtype == TMessageType.EXCEPTION:
6552 
      x = TApplicationException()
6553 
      x.read(self._iprot)
6554 
      self._iprot.readMessageEnd()
6555 
      raise x
6556 
    result = refundRechargeOrder_result()
6557 
    result.read(self._iprot)
6558 
    self._iprot.readMessageEnd()
6559 
    if result.success is not None:
6560 
      return result.success
6561 
    if result.ex is not None:
6562 
      raise result.ex
6563 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundRechargeOrder failed: unknown result");
6564 
 
6821 amar.kumar 6565 
  def getPhysicalOrders(self, fromDate, toDate):
6566 
    """
6567 
    Parameters:
6568 
     - fromDate
6569 
     - toDate
6570 
    """
6571 
    self.send_getPhysicalOrders(fromDate, toDate)
6572 
    return self.recv_getPhysicalOrders()
6507 anupam.sin 6573 
 
6821 amar.kumar 6574 
  def send_getPhysicalOrders(self, fromDate, toDate):
6575 
    self._oprot.writeMessageBegin('getPhysicalOrders', TMessageType.CALL, self._seqid)
6576 
    args = getPhysicalOrders_args()
6577 
    args.fromDate = fromDate
6578 
    args.toDate = toDate
6579 
    args.write(self._oprot)
6580 
    self._oprot.writeMessageEnd()
6581 
    self._oprot.trans.flush()
6582 
 
6583 
  def recv_getPhysicalOrders(self, ):
6584 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6585 
    if mtype == TMessageType.EXCEPTION:
6586 
      x = TApplicationException()
6587 
      x.read(self._iprot)
6588 
      self._iprot.readMessageEnd()
6589 
      raise x
6590 
    result = getPhysicalOrders_result()
6591 
    result.read(self._iprot)
6592 
    self._iprot.readMessageEnd()
6593 
    if result.success is not None:
6594 
      return result.success
6595 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPhysicalOrders failed: unknown result");
6596 
 
6906 rajveer 6597 
  def getDocument(self, docType, docSource):
6598 
    """
6599 
    Parameters:
6600 
     - docType
6601 
     - docSource
6602 
    """
6603 
    self.send_getDocument(docType, docSource)
6604 
    return self.recv_getDocument()
6821 amar.kumar 6605 
 
6906 rajveer 6606 
  def send_getDocument(self, docType, docSource):
6607 
    self._oprot.writeMessageBegin('getDocument', TMessageType.CALL, self._seqid)
6608 
    args = getDocument_args()
6609 
    args.docType = docType
6610 
    args.docSource = docSource
6611 
    args.write(self._oprot)
6612 
    self._oprot.writeMessageEnd()
6613 
    self._oprot.trans.flush()
6614 
 
6615 
  def recv_getDocument(self, ):
6616 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
6617 
    if mtype == TMessageType.EXCEPTION:
6618 
      x = TApplicationException()
6619 
      x.read(self._iprot)
6620 
      self._iprot.readMessageEnd()
6621 
      raise x
6622 
    result = getDocument_result()
6623 
    result.read(self._iprot)
6624 
    self._iprot.readMessageEnd()
6625 
    if result.success is not None:
6626 
      return result.success
6627 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDocument failed: unknown result");
6628 
 
6629 
 
3376 rajveer 6630 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 6631 
  def __init__(self, handler):
3376 rajveer 6632 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
94 ashish 6633 
    self._processMap["createTransaction"] = Processor.process_createTransaction
6634 
    self._processMap["getTransaction"] = Processor.process_getTransaction
6635 
    self._processMap["getTransactionsForCustomer"] = Processor.process_getTransactionsForCustomer
132 ashish 6636 
    self._processMap["getTransactionsForShoppingCartId"] = Processor.process_getTransactionsForShoppingCartId
94 ashish 6637 
    self._processMap["getTransactionStatus"] = Processor.process_getTransactionStatus
6638 
    self._processMap["changeTransactionStatus"] = Processor.process_changeTransactionStatus
1398 varun.gupt 6639 
    self._processMap["enqueueTransactionInfoEmail"] = Processor.process_enqueueTransactionInfoEmail
483 rajveer 6640 
    self._processMap["getAllOrders"] = Processor.process_getAllOrders
4133 chandransh 6641 
    self._processMap["getOrdersInBatch"] = Processor.process_getOrdersInBatch
6642 
    self._processMap["getOrderCount"] = Processor.process_getOrderCount
999 varun.gupt 6643 
    self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
3427 chandransh 6644 
    self._processMap["getOrdersByShippingDate"] = Processor.process_getOrdersByShippingDate
1382 varun.gupt 6645 
    self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
6646 
    self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
483 rajveer 6647 
    self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
6648 
    self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
6649 
    self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
6650 
    self._processMap["createOrder"] = Processor.process_createOrder
6651 
    self._processMap["getOrder"] = Processor.process_getOrder
6652 
    self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
4999 phani.kuma 6653 
    self._processMap["getOrderList"] = Processor.process_getOrderList
5386 phani.kuma 6654 
    self._processMap["getOrderListForVendor"] = Processor.process_getOrderListForVendor
1528 ankur.sing 6655 
    self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
3064 chandransh 6656 
    self._processMap["getAlerts"] = Processor.process_getAlerts
4394 rajveer 6657 
    self._processMap["addAlert"] = Processor.process_addAlert
4444 rajveer 6658 
    self._processMap["markAlertsAsSeen"] = Processor.process_markAlertsAsSeen
3064 chandransh 6659 
    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
6660 
    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
6661 
    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
6662 
    self._processMap["getValidOrders"] = Processor.process_getValidOrders
1220 chandransh 6663 
    self._processMap["batchOrders"] = Processor.process_batchOrders
1208 chandransh 6664 
    self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
3064 chandransh 6665 
    self._processMap["verifyOrder"] = Processor.process_verifyOrder
6666 
    self._processMap["acceptOrder"] = Processor.process_acceptOrder
6667 
    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
4579 rajveer 6668 
    self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
4410 rajveer 6669 
    self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
5676 rajveer 6670 
    self._processMap["markOrdersAsReturnedFromStore"] = Processor.process_markOrdersAsReturnedFromStore
1113 chandransh 6671 
    self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
4910 phani.kuma 6672 
    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
1132 chandransh 6673 
    self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
4910 phani.kuma 6674 
    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
6675 
    self._processMap["getRTOrders"] = Processor.process_getRTOrders
1246 chandransh 6676 
    self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
4910 phani.kuma 6677 
    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
6678 
    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
6679 
    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
6680 
    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
6681 
    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
1408 ankur.sing 6682 
    self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
4783 phani.kuma 6683 
    self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
2536 chandransh 6684 
    self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
4712 rajveer 6685 
    self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
5553 rajveer 6686 
    self._processMap["markOrderAsReceivedAtStore"] = Processor.process_markOrderAsReceivedAtStore
4454 rajveer 6687 
    self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
6688 
    self._processMap["markOrderDoaRequestAuthorized"] = Processor.process_markOrderDoaRequestAuthorized
4488 rajveer 6689 
    self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
6690 
    self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
2536 chandransh 6691 
    self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
6692 
    self._processMap["authorizePickup"] = Processor.process_authorizePickup
2764 chandransh 6693 
    self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
4910 phani.kuma 6694 
    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
4741 phani.kuma 6695 
    self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
4910 phani.kuma 6696 
    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
2616 chandransh 6697 
    self._processMap["receiveReturn"] = Processor.process_receiveReturn
2591 chandransh 6698 
    self._processMap["validateDoa"] = Processor.process_validateDoa
4495 rajveer 6699 
    self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
2616 chandransh 6700 
    self._processMap["reshipOrder"] = Processor.process_reshipOrder
6701 
    self._processMap["refundOrder"] = Processor.process_refundOrder
2690 chandransh 6702 
    self._processMap["getReturnOrders"] = Processor.process_getReturnOrders
5481 phani.kuma 6703 
    self._processMap["getAllReturnOrders"] = Processor.process_getAllReturnOrders
2700 chandransh 6704 
    self._processMap["getReturnOrder"] = Processor.process_getReturnOrder
2690 chandransh 6705 
    self._processMap["processReturn"] = Processor.process_processReturn
3451 chandransh 6706 
    self._processMap["updateWeight"] = Processor.process_updateWeight
3469 chandransh 6707 
    self._processMap["changeItem"] = Processor.process_changeItem
6708 
    self._processMap["shiftToWarehouse"] = Processor.process_shiftToWarehouse
3553 chandransh 6709 
    self._processMap["addDelayReason"] = Processor.process_addDelayReason
3956 chandransh 6710 
    self._processMap["reconcileCodCollection"] = Processor.process_reconcileCodCollection
4008 mandeep.dh 6711 
    self._processMap["getTransactionsRequiringExtraProcessing"] = Processor.process_getTransactionsRequiringExtraProcessing
6712 
    self._processMap["markTransactionAsProcessed"] = Processor.process_markTransactionAsProcessed
4018 chandransh 6713 
    self._processMap["getItemWiseRiskyOrdersCount"] = Processor.process_getItemWiseRiskyOrdersCount
4295 varun.gupt 6714 
    self._processMap["getOrdersForItemIds"] = Processor.process_getOrdersForItemIds
4247 rajveer 6715 
    self._processMap["markOrderCancellationRequestReceived"] = Processor.process_markOrderCancellationRequestReceived
6716 
    self._processMap["markOrderCancellationRequestConfirmed"] = Processor.process_markOrderCancellationRequestConfirmed
6717 
    self._processMap["markOrderCancellationRequestDenied"] = Processor.process_markOrderCancellationRequestDenied
4258 rajveer 6718 
    self._processMap["markTransactionAsPaymentFlagRemoved"] = Processor.process_markTransactionAsPaymentFlagRemoved
4259 anupam.sin 6719 
    self._processMap["refundTransaction"] = Processor.process_refundTransaction
4324 mandeep.dh 6720 
    self._processMap["updateShipmentAddress"] = Processor.process_updateShipmentAddress
4285 rajveer 6721 
    self._processMap["acceptOrdersForItemId"] = Processor.process_acceptOrdersForItemId
4303 rajveer 6722 
    self._processMap["markOrdersAsPORaised"] = Processor.process_markOrdersAsPORaised
6723 
    self._processMap["markOrdersAsReversalInitiated"] = Processor.process_markOrdersAsReversalInitiated
6724 
    self._processMap["markOrdersAsNotAvailabke"] = Processor.process_markOrdersAsNotAvailabke
4369 rajveer 6725 
    self._processMap["markOrdersAsTimeout"] = Processor.process_markOrdersAsTimeout
4662 rajveer 6726 
    self._processMap["markOrderAsLostInTransit"] = Processor.process_markOrderAsLostInTransit
4386 anupam.sin 6727 
    self._processMap["getOrderForAwb"] = Processor.process_getOrderForAwb
4506 phani.kuma 6728 
    self._processMap["getOrdersForProviderForStatus"] = Processor.process_getOrdersForProviderForStatus
4600 varun.gupt 6729 
    self._processMap["getBilledOrdersForVendor"] = Processor.process_getBilledOrdersForVendor
4607 rajveer 6730 
    self._processMap["getSlippedSippingDateOrders"] = Processor.process_getSlippedSippingDateOrders
4709 rajveer 6731 
    self._processMap["getCancelledOrders"] = Processor.process_getCancelledOrders
4600 varun.gupt 6732 
    self._processMap["saveBluedartSettlements"] = Processor.process_saveBluedartSettlements
6733 
    self._processMap["savePaymentSettlements"] = Processor.process_savePaymentSettlements
6734 
    self._processMap["saveEBSSettlementSummary"] = Processor.process_saveEBSSettlementSummary
5386 phani.kuma 6735 
    self._processMap["getSettlementForPrepaid"] = Processor.process_getSettlementForPrepaid
6736 
    self._processMap["getSettlementForCod"] = Processor.process_getSettlementForCod
4600 varun.gupt 6737 
    self._processMap["getEBSSettlementSummaries"] = Processor.process_getEBSSettlementSummaries
6738 
    self._processMap["markEBSSettlementUploaded"] = Processor.process_markEBSSettlementUploaded
6739 
    self._processMap["getEBSSettlementDate"] = Processor.process_getEBSSettlementDate
4715 varun.gupt 6740 
    self._processMap["getSettlementsByDate"] = Processor.process_getSettlementsByDate
6741 
    self._processMap["getReshippedOrderIds"] = Processor.process_getReshippedOrderIds
5481 phani.kuma 6742 
    self._processMap["getBilledOrders"] = Processor.process_getBilledOrders
5031 varun.gupt 6743 
    self._processMap["getStatusDistributionOfOrders"] = Processor.process_getStatusDistributionOfOrders
5067 varun.gupt 6744 
    self._processMap["getOrderIdsForStatus"] = Processor.process_getOrderIdsForStatus
5348 anupam.sin 6745 
    self._processMap["updateCODAgent"] = Processor.process_updateCODAgent
5099 varun.gupt 6746 
    self._processMap["updateOrderAsPaidToVendor"] = Processor.process_updateOrderAsPaidToVendor
5386 phani.kuma 6747 
    self._processMap["updateOrderOnlyAsPaidToVendor"] = Processor.process_updateOrderOnlyAsPaidToVendor
5208 varun.gupt 6748 
    self._processMap["getRefundedOrdersMarkedPaid"] = Processor.process_getRefundedOrdersMarkedPaid
5447 anupam.sin 6749 
    self._processMap["getAllVerificationAgents"] = Processor.process_getAllVerificationAgents
5527 anupam.sin 6750 
    self._processMap["getAllAttributesForOrderId"] = Processor.process_getAllAttributesForOrderId
5676 rajveer 6751 
    self._processMap["setOrderAttributes"] = Processor.process_setOrderAttributes
5527 anupam.sin 6752 
    self._processMap["setOrderAttributeForTransaction"] = Processor.process_setOrderAttributeForTransaction
5553 rajveer 6753 
    self._processMap["getReceivePendingOrders"] = Processor.process_getReceivePendingOrders
6754 
    self._processMap["getReceivedAtStoreOrders"] = Processor.process_getReceivedAtStoreOrders
5713 rajveer 6755 
    self._processMap["getOrdersCollectionAtStore"] = Processor.process_getOrdersCollectionAtStore
5833 rajveer 6756 
    self._processMap["getOrderAttributeValue"] = Processor.process_getOrderAttributeValue
6019 rajveer 6757 
    self._processMap["changeJacketNumber"] = Processor.process_changeJacketNumber
6758 
    self._processMap["markOrderAsRtoInTransit"] = Processor.process_markOrderAsRtoInTransit
5593 mandeep.dh 6759 
    self._processMap["acceptOrderForItem"] = Processor.process_acceptOrderForItem
6000 mandeep.dh 6760 
    self._processMap["createRechargeOrder"] = Processor.process_createRechargeOrder
6031 rajveer 6761 
    self._processMap["getRechargeOrder"] = Processor.process_getRechargeOrder
6762 
    self._processMap["getRechargeOrders"] = Processor.process_getRechargeOrders
6000 mandeep.dh 6763 
    self._processMap["updateRechargeOrderStatus"] = Processor.process_updateRechargeOrderStatus
6764 
    self._processMap["activateRechargeTxn"] = Processor.process_activateRechargeTxn
6031 rajveer 6765 
    self._processMap["getUserWallet"] = Processor.process_getUserWallet
6766 
    self._processMap["getUserWalletHistory"] = Processor.process_getUserWalletHistory
6050 anupam.sin 6767 
    self._processMap["getRechargeOrdersForTransaction"] = Processor.process_getRechargeOrdersForTransaction
6048 rajveer 6768 
    self._processMap["getServiceProviders"] = Processor.process_getServiceProviders
6769 
    self._processMap["getServiceProviderForDevice"] = Processor.process_getServiceProviderForDevice
6269 rajveer 6770 
    self._processMap["validateRecharge"] = Processor.process_validateRecharge
6094 rajveer 6771 
    self._processMap["getRechargeOrdersForDevice"] = Processor.process_getRechargeOrdersForDevice
6772 
    self._processMap["addAmountToWallet"] = Processor.process_addAmountToWallet
6188 rajveer 6773 
    self._processMap["getRechargeStatistics"] = Processor.process_getRechargeStatistics
6154 rajveer 6774 
    self._processMap["getRechargeOrdersForStatus"] = Processor.process_getRechargeOrdersForStatus
6159 rajveer 6775 
    self._processMap["getPlansForOperator"] = Processor.process_getPlansForOperator
6289 anupam.sin 6776 
    self._processMap["getRechargeDenominations"] = Processor.process_getRechargeDenominations
6371 rajveer 6777 
    self._processMap["updateAvailabilityStatus"] = Processor.process_updateAvailabilityStatus
6389 rajveer 6778 
    self._processMap["getAvailableEmiSchemes"] = Processor.process_getAvailableEmiSchemes
6779 
    self._processMap["getMiscCharges"] = Processor.process_getMiscCharges
6507 anupam.sin 6780 
    self._processMap["refundRechargeOrder"] = Processor.process_refundRechargeOrder
6821 amar.kumar 6781 
    self._processMap["getPhysicalOrders"] = Processor.process_getPhysicalOrders
6906 rajveer 6782 
    self._processMap["getDocument"] = Processor.process_getDocument
94 ashish 6783 
 
6784 
  def process(self, iprot, oprot):
6785 
    (name, type, seqid) = iprot.readMessageBegin()
6786 
    if name not in self._processMap:
6787 
      iprot.skip(TType.STRUCT)
6788 
      iprot.readMessageEnd()
6789 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
6790 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
6791 
      x.write(oprot)
6792 
      oprot.writeMessageEnd()
6793 
      oprot.trans.flush()
6794 
      return
6795 
    else:
6796 
      self._processMap[name](self, seqid, iprot, oprot)
6797 
    return True
6798 
 
6799 
  def process_createTransaction(self, seqid, iprot, oprot):
6800 
    args = createTransaction_args()
6801 
    args.read(iprot)
6802 
    iprot.readMessageEnd()
6803 
    result = createTransaction_result()
6804 
    try:
132 ashish 6805 
      result.success = self._handler.createTransaction(args.transaction)
94 ashish 6806 
    except TransactionServiceException, ex:
6807 
      result.ex = ex
6808 
    oprot.writeMessageBegin("createTransaction", TMessageType.REPLY, seqid)
6809 
    result.write(oprot)
6810 
    oprot.writeMessageEnd()
6811 
    oprot.trans.flush()
6812 
 
6813 
  def process_getTransaction(self, seqid, iprot, oprot):
6814 
    args = getTransaction_args()
6815 
    args.read(iprot)
6816 
    iprot.readMessageEnd()
6817 
    result = getTransaction_result()
6818 
    try:
6819 
      result.success = self._handler.getTransaction(args.id)
6820 
    except TransactionServiceException, ex:
6821 
      result.ex = ex
6822 
    oprot.writeMessageBegin("getTransaction", TMessageType.REPLY, seqid)
6823 
    result.write(oprot)
6824 
    oprot.writeMessageEnd()
6825 
    oprot.trans.flush()
6826 
 
6827 
  def process_getTransactionsForCustomer(self, seqid, iprot, oprot):
6828 
    args = getTransactionsForCustomer_args()
6829 
    args.read(iprot)
6830 
    iprot.readMessageEnd()
6831 
    result = getTransactionsForCustomer_result()
6832 
    try:
6833 
      result.success = self._handler.getTransactionsForCustomer(args.customerId, args.from_date, args.to_date, args.status)
6834 
    except TransactionServiceException, ex:
6835 
      result.ex = ex
6836 
    oprot.writeMessageBegin("getTransactionsForCustomer", TMessageType.REPLY, seqid)
6837 
    result.write(oprot)
6838 
    oprot.writeMessageEnd()
6839 
    oprot.trans.flush()
6840 
 
132 ashish 6841 
  def process_getTransactionsForShoppingCartId(self, seqid, iprot, oprot):
6842 
    args = getTransactionsForShoppingCartId_args()
6843 
    args.read(iprot)
6844 
    iprot.readMessageEnd()
6845 
    result = getTransactionsForShoppingCartId_result()
6846 
    try:
6847 
      result.success = self._handler.getTransactionsForShoppingCartId(args.shoppingCartId)
6848 
    except TransactionServiceException, ex:
6849 
      result.ex = ex
6850 
    oprot.writeMessageBegin("getTransactionsForShoppingCartId", TMessageType.REPLY, seqid)
6851 
    result.write(oprot)
6852 
    oprot.writeMessageEnd()
6853 
    oprot.trans.flush()
6854 
 
94 ashish 6855 
  def process_getTransactionStatus(self, seqid, iprot, oprot):
6856 
    args = getTransactionStatus_args()
6857 
    args.read(iprot)
6858 
    iprot.readMessageEnd()
6859 
    result = getTransactionStatus_result()
6860 
    try:
6861 
      result.success = self._handler.getTransactionStatus(args.transactionId)
6862 
    except TransactionServiceException, ex:
6863 
      result.ex = ex
6864 
    oprot.writeMessageBegin("getTransactionStatus", TMessageType.REPLY, seqid)
6865 
    result.write(oprot)
6866 
    oprot.writeMessageEnd()
6867 
    oprot.trans.flush()
6868 
 
6869 
  def process_changeTransactionStatus(self, seqid, iprot, oprot):
6870 
    args = changeTransactionStatus_args()
6871 
    args.read(iprot)
6872 
    iprot.readMessageEnd()
6873 
    result = changeTransactionStatus_result()
6874 
    try:
5527 anupam.sin 6875 
      result.success = self._handler.changeTransactionStatus(args.transactionId, args.status, args.description, args.pickUp, args.orderType)
94 ashish 6876 
    except TransactionServiceException, ex:
6877 
      result.ex = ex
6878 
    oprot.writeMessageBegin("changeTransactionStatus", TMessageType.REPLY, seqid)
6879 
    result.write(oprot)
6880 
    oprot.writeMessageEnd()
6881 
    oprot.trans.flush()
6882 
 
1398 varun.gupt 6883 
  def process_enqueueTransactionInfoEmail(self, seqid, iprot, oprot):
6884 
    args = enqueueTransactionInfoEmail_args()
1382 varun.gupt 6885 
    args.read(iprot)
6886 
    iprot.readMessageEnd()
1398 varun.gupt 6887 
    result = enqueueTransactionInfoEmail_result()
1382 varun.gupt 6888 
    try:
1398 varun.gupt 6889 
      result.success = self._handler.enqueueTransactionInfoEmail(args.transactionId)
1382 varun.gupt 6890 
    except TransactionServiceException, ex:
6891 
      result.ex = ex
1398 varun.gupt 6892 
    oprot.writeMessageBegin("enqueueTransactionInfoEmail", TMessageType.REPLY, seqid)
1382 varun.gupt 6893 
    result.write(oprot)
6894 
    oprot.writeMessageEnd()
6895 
    oprot.trans.flush()
6896 
 
483 rajveer 6897 
  def process_getAllOrders(self, seqid, iprot, oprot):
6898 
    args = getAllOrders_args()
94 ashish 6899 
    args.read(iprot)
6900 
    iprot.readMessageEnd()
483 rajveer 6901 
    result = getAllOrders_result()
94 ashish 6902 
    try:
4801 anupam.sin 6903 
      result.success = self._handler.getAllOrders(args.statuses, args.from_date, args.to_date, args.warehouse_id)
94 ashish 6904 
    except TransactionServiceException, ex:
6905 
      result.ex = ex
483 rajveer 6906 
    oprot.writeMessageBegin("getAllOrders", TMessageType.REPLY, seqid)
94 ashish 6907 
    result.write(oprot)
6908 
    oprot.writeMessageEnd()
6909 
    oprot.trans.flush()
6910 
 
4133 chandransh 6911 
  def process_getOrdersInBatch(self, seqid, iprot, oprot):
6912 
    args = getOrdersInBatch_args()
6913 
    args.read(iprot)
6914 
    iprot.readMessageEnd()
6915 
    result = getOrdersInBatch_result()
6916 
    try:
6917 
      result.success = self._handler.getOrdersInBatch(args.statuses, args.offset, args.limit, args.warehouse_id)
6918 
    except TransactionServiceException, ex:
6919 
      result.ex = ex
6920 
    oprot.writeMessageBegin("getOrdersInBatch", TMessageType.REPLY, seqid)
6921 
    result.write(oprot)
6922 
    oprot.writeMessageEnd()
6923 
    oprot.trans.flush()
6924 
 
6925 
  def process_getOrderCount(self, seqid, iprot, oprot):
6926 
    args = getOrderCount_args()
6927 
    args.read(iprot)
6928 
    iprot.readMessageEnd()
6929 
    result = getOrderCount_result()
6930 
    try:
6931 
      result.success = self._handler.getOrderCount(args.statuses, args.warehouseId)
6932 
    except TransactionServiceException, ex:
6933 
      result.ex = ex
6934 
    oprot.writeMessageBegin("getOrderCount", TMessageType.REPLY, seqid)
6935 
    result.write(oprot)
6936 
    oprot.writeMessageEnd()
6937 
    oprot.trans.flush()
6938 
 
999 varun.gupt 6939 
  def process_getOrdersByBillingDate(self, seqid, iprot, oprot):
6940 
    args = getOrdersByBillingDate_args()
6941 
    args.read(iprot)
6942 
    iprot.readMessageEnd()
6943 
    result = getOrdersByBillingDate_result()
6944 
    try:
6945 
      result.success = self._handler.getOrdersByBillingDate(args.status, args.start_billing_date, args.end_billing_date, args.warehouse_id)
6946 
    except TransactionServiceException, ex:
6947 
      result.ex = ex
6948 
    oprot.writeMessageBegin("getOrdersByBillingDate", TMessageType.REPLY, seqid)
6949 
    result.write(oprot)
6950 
    oprot.writeMessageEnd()
6951 
    oprot.trans.flush()
6952 
 
3427 chandransh 6953 
  def process_getOrdersByShippingDate(self, seqid, iprot, oprot):
6954 
    args = getOrdersByShippingDate_args()
6955 
    args.read(iprot)
6956 
    iprot.readMessageEnd()
6957 
    result = getOrdersByShippingDate_result()
6958 
    try:
3451 chandransh 6959 
      result.success = self._handler.getOrdersByShippingDate(args.fromShippingDate, args.toShippingDate, args.providerId, args.warehouseId, args.cod)
3427 chandransh 6960 
    except TransactionServiceException, ex:
6961 
      result.ex = ex
6962 
    oprot.writeMessageBegin("getOrdersByShippingDate", TMessageType.REPLY, seqid)
6963 
    result.write(oprot)
6964 
    oprot.writeMessageEnd()
6965 
    oprot.trans.flush()
6966 
 
1382 varun.gupt 6967 
  def process_getReturnableOrdersForCustomer(self, seqid, iprot, oprot):
6968 
    args = getReturnableOrdersForCustomer_args()
6969 
    args.read(iprot)
6970 
    iprot.readMessageEnd()
6971 
    result = getReturnableOrdersForCustomer_result()
6972 
    try:
6973 
      result.success = self._handler.getReturnableOrdersForCustomer(args.customer_id, args.limit)
6974 
    except TransactionServiceException, ex:
6975 
      result.ex = ex
6976 
    oprot.writeMessageBegin("getReturnableOrdersForCustomer", TMessageType.REPLY, seqid)
6977 
    result.write(oprot)
6978 
    oprot.writeMessageEnd()
6979 
    oprot.trans.flush()
6980 
 
6981 
  def process_getCancellableOrdersForCustomer(self, seqid, iprot, oprot):
6982 
    args = getCancellableOrdersForCustomer_args()
6983 
    args.read(iprot)
6984 
    iprot.readMessageEnd()
6985 
    result = getCancellableOrdersForCustomer_result()
6986 
    try:
6987 
      result.success = self._handler.getCancellableOrdersForCustomer(args.customer_id, args.limit)
6988 
    except TransactionServiceException, ex:
6989 
      result.ex = ex
6990 
    oprot.writeMessageBegin("getCancellableOrdersForCustomer", TMessageType.REPLY, seqid)
6991 
    result.write(oprot)
6992 
    oprot.writeMessageEnd()
6993 
    oprot.trans.flush()
6994 
 
483 rajveer 6995 
  def process_changeOrderStatus(self, seqid, iprot, oprot):
6996 
    args = changeOrderStatus_args()
94 ashish 6997 
    args.read(iprot)
6998 
    iprot.readMessageEnd()
483 rajveer 6999 
    result = changeOrderStatus_result()
94 ashish 7000 
    try:
483 rajveer 7001 
      result.success = self._handler.changeOrderStatus(args.orderId, args.status, args.description)
94 ashish 7002 
    except TransactionServiceException, ex:
7003 
      result.ex = ex
483 rajveer 7004 
    oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
94 ashish 7005 
    result.write(oprot)
7006 
    oprot.writeMessageEnd()
7007 
    oprot.trans.flush()
7008 
 
483 rajveer 7009 
  def process_getOrdersForTransaction(self, seqid, iprot, oprot):
7010 
    args = getOrdersForTransaction_args()
94 ashish 7011 
    args.read(iprot)
7012 
    iprot.readMessageEnd()
483 rajveer 7013 
    result = getOrdersForTransaction_result()
94 ashish 7014 
    try:
1528 ankur.sing 7015 
      result.success = self._handler.getOrdersForTransaction(args.transactionId, args.customerId)
94 ashish 7016 
    except TransactionServiceException, ex:
7017 
      result.ex = ex
483 rajveer 7018 
    oprot.writeMessageBegin("getOrdersForTransaction", TMessageType.REPLY, seqid)
94 ashish 7019 
    result.write(oprot)
7020 
    oprot.writeMessageEnd()
7021 
    oprot.trans.flush()
7022 
 
483 rajveer 7023 
  def process_getOrdersForCustomer(self, seqid, iprot, oprot):
7024 
    args = getOrdersForCustomer_args()
94 ashish 7025 
    args.read(iprot)
7026 
    iprot.readMessageEnd()
483 rajveer 7027 
    result = getOrdersForCustomer_result()
94 ashish 7028 
    try:
3014 chandransh 7029 
      result.success = self._handler.getOrdersForCustomer(args.customerId, args.from_date, args.to_date, args.statuses)
94 ashish 7030 
    except TransactionServiceException, ex:
7031 
      result.ex = ex
483 rajveer 7032 
    oprot.writeMessageBegin("getOrdersForCustomer", TMessageType.REPLY, seqid)
94 ashish 7033 
    result.write(oprot)
7034 
    oprot.writeMessageEnd()
7035 
    oprot.trans.flush()
7036 
 
483 rajveer 7037 
  def process_createOrder(self, seqid, iprot, oprot):
7038 
    args = createOrder_args()
94 ashish 7039 
    args.read(iprot)
7040 
    iprot.readMessageEnd()
483 rajveer 7041 
    result = createOrder_result()
94 ashish 7042 
    try:
483 rajveer 7043 
      result.success = self._handler.createOrder(args.order)
94 ashish 7044 
    except TransactionServiceException, ex:
7045 
      result.ex = ex
483 rajveer 7046 
    oprot.writeMessageBegin("createOrder", TMessageType.REPLY, seqid)
94 ashish 7047 
    result.write(oprot)
7048 
    oprot.writeMessageEnd()
7049 
    oprot.trans.flush()
7050 
 
483 rajveer 7051 
  def process_getOrder(self, seqid, iprot, oprot):
7052 
    args = getOrder_args()
94 ashish 7053 
    args.read(iprot)
7054 
    iprot.readMessageEnd()
483 rajveer 7055 
    result = getOrder_result()
94 ashish 7056 
    try:
483 rajveer 7057 
      result.success = self._handler.getOrder(args.id)
94 ashish 7058 
    except TransactionServiceException, ex:
7059 
      result.ex = ex
483 rajveer 7060 
    oprot.writeMessageBegin("getOrder", TMessageType.REPLY, seqid)
94 ashish 7061 
    result.write(oprot)
7062 
    oprot.writeMessageEnd()
7063 
    oprot.trans.flush()
7064 
 
483 rajveer 7065 
  def process_getLineItemsForOrder(self, seqid, iprot, oprot):
7066 
    args = getLineItemsForOrder_args()
94 ashish 7067 
    args.read(iprot)
7068 
    iprot.readMessageEnd()
483 rajveer 7069 
    result = getLineItemsForOrder_result()
94 ashish 7070 
    try:
483 rajveer 7071 
      result.success = self._handler.getLineItemsForOrder(args.orderId)
94 ashish 7072 
    except TransactionServiceException, ex:
7073 
      result.ex = ex
483 rajveer 7074 
    oprot.writeMessageBegin("getLineItemsForOrder", TMessageType.REPLY, seqid)
94 ashish 7075 
    result.write(oprot)
7076 
    oprot.writeMessageEnd()
7077 
    oprot.trans.flush()
7078 
 
4999 phani.kuma 7079 
  def process_getOrderList(self, seqid, iprot, oprot):
7080 
    args = getOrderList_args()
7081 
    args.read(iprot)
7082 
    iprot.readMessageEnd()
7083 
    result = getOrderList_result()
7084 
    result.success = self._handler.getOrderList(args.order_ids)
7085 
    oprot.writeMessageBegin("getOrderList", TMessageType.REPLY, seqid)
7086 
    result.write(oprot)
7087 
    oprot.writeMessageEnd()
7088 
    oprot.trans.flush()
7089 
 
5386 phani.kuma 7090 
  def process_getOrderListForVendor(self, seqid, iprot, oprot):
7091 
    args = getOrderListForVendor_args()
7092 
    args.read(iprot)
7093 
    iprot.readMessageEnd()
7094 
    result = getOrderListForVendor_result()
7095 
    result.success = self._handler.getOrderListForVendor(args.order_ids, args.vendorId)
7096 
    oprot.writeMessageBegin("getOrderListForVendor", TMessageType.REPLY, seqid)
7097 
    result.write(oprot)
7098 
    oprot.writeMessageEnd()
7099 
    oprot.trans.flush()
7100 
 
1528 ankur.sing 7101 
  def process_getOrderForCustomer(self, seqid, iprot, oprot):
7102 
    args = getOrderForCustomer_args()
7103 
    args.read(iprot)
7104 
    iprot.readMessageEnd()
7105 
    result = getOrderForCustomer_result()
7106 
    try:
7107 
      result.success = self._handler.getOrderForCustomer(args.orderId, args.customerId)
7108 
    except TransactionServiceException, ex:
7109 
      result.ex = ex
7110 
    oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
7111 
    result.write(oprot)
7112 
    oprot.writeMessageEnd()
7113 
    oprot.trans.flush()
7114 
 
3064 chandransh 7115 
  def process_getAlerts(self, seqid, iprot, oprot):
7116 
    args = getAlerts_args()
7117 
    args.read(iprot)
7118 
    iprot.readMessageEnd()
7119 
    result = getAlerts_result()
4444 rajveer 7120 
    result.success = self._handler.getAlerts(args.type, args.warehouseId, args.status, args.timestamp)
3064 chandransh 7121 
    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
7122 
    result.write(oprot)
7123 
    oprot.writeMessageEnd()
7124 
    oprot.trans.flush()
7125 
 
4394 rajveer 7126 
  def process_addAlert(self, seqid, iprot, oprot):
7127 
    args = addAlert_args()
3064 chandransh 7128 
    args.read(iprot)
7129 
    iprot.readMessageEnd()
4394 rajveer 7130 
    result = addAlert_result()
4444 rajveer 7131 
    self._handler.addAlert(args.type, args.warehouseId, args.description)
4394 rajveer 7132 
    oprot.writeMessageBegin("addAlert", TMessageType.REPLY, seqid)
3064 chandransh 7133 
    result.write(oprot)
7134 
    oprot.writeMessageEnd()
7135 
    oprot.trans.flush()
7136 
 
4444 rajveer 7137 
  def process_markAlertsAsSeen(self, seqid, iprot, oprot):
7138 
    args = markAlertsAsSeen_args()
7139 
    args.read(iprot)
7140 
    iprot.readMessageEnd()
7141 
    result = markAlertsAsSeen_result()
7142 
    self._handler.markAlertsAsSeen(args.warehouseId)
7143 
    oprot.writeMessageBegin("markAlertsAsSeen", TMessageType.REPLY, seqid)
7144 
    result.write(oprot)
7145 
    oprot.writeMessageEnd()
7146 
    oprot.trans.flush()
7147 
 
3064 chandransh 7148 
  def process_getValidOrderCount(self, seqid, iprot, oprot):
7149 
    args = getValidOrderCount_args()
7150 
    args.read(iprot)
7151 
    iprot.readMessageEnd()
7152 
    result = getValidOrderCount_result()
7153 
    result.success = self._handler.getValidOrderCount()
7154 
    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
7155 
    result.write(oprot)
7156 
    oprot.writeMessageEnd()
7157 
    oprot.trans.flush()
7158 
 
7159 
  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
7160 
    args = getNoOfCustomersWithSuccessfulTransaction_args()
7161 
    args.read(iprot)
7162 
    iprot.readMessageEnd()
7163 
    result = getNoOfCustomersWithSuccessfulTransaction_result()
7164 
    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
7165 
    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
7166 
    result.write(oprot)
7167 
    oprot.writeMessageEnd()
7168 
    oprot.trans.flush()
7169 
 
7170 
  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
7171 
    args = getValidOrdersAmountRange_args()
7172 
    args.read(iprot)
7173 
    iprot.readMessageEnd()
7174 
    result = getValidOrdersAmountRange_result()
7175 
    result.success = self._handler.getValidOrdersAmountRange()
7176 
    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
7177 
    result.write(oprot)
7178 
    oprot.writeMessageEnd()
7179 
    oprot.trans.flush()
7180 
 
7181 
  def process_getValidOrders(self, seqid, iprot, oprot):
7182 
    args = getValidOrders_args()
7183 
    args.read(iprot)
7184 
    iprot.readMessageEnd()
7185 
    result = getValidOrders_result()
5874 rajveer 7186 
    result.success = self._handler.getValidOrders(args.limit, args.onlyStore)
3064 chandransh 7187 
    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
7188 
    result.write(oprot)
7189 
    oprot.writeMessageEnd()
7190 
    oprot.trans.flush()
7191 
 
1220 chandransh 7192 
  def process_batchOrders(self, seqid, iprot, oprot):
7193 
    args = batchOrders_args()
7194 
    args.read(iprot)
7195 
    iprot.readMessageEnd()
7196 
    result = batchOrders_result()
7197 
    try:
7198 
      result.success = self._handler.batchOrders(args.warehouseId)
7199 
    except TransactionServiceException, ex:
7200 
      result.ex = ex
7201 
    oprot.writeMessageBegin("batchOrders", TMessageType.REPLY, seqid)
7202 
    result.write(oprot)
7203 
    oprot.writeMessageEnd()
7204 
    oprot.trans.flush()
7205 
 
1208 chandransh 7206 
  def process_markOrderAsOutOfStock(self, seqid, iprot, oprot):
7207 
    args = markOrderAsOutOfStock_args()
7208 
    args.read(iprot)
7209 
    iprot.readMessageEnd()
7210 
    result = markOrderAsOutOfStock_result()
7211 
    try:
7212 
      result.success = self._handler.markOrderAsOutOfStock(args.orderId)
7213 
    except TransactionServiceException, ex:
7214 
      result.ex = ex
7215 
    oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
7216 
    result.write(oprot)
7217 
    oprot.writeMessageEnd()
7218 
    oprot.trans.flush()
7219 
 
3064 chandransh 7220 
  def process_verifyOrder(self, seqid, iprot, oprot):
7221 
    args = verifyOrder_args()
759 chandransh 7222 
    args.read(iprot)
7223 
    iprot.readMessageEnd()
3064 chandransh 7224 
    result = verifyOrder_result()
759 chandransh 7225 
    try:
3064 chandransh 7226 
      result.success = self._handler.verifyOrder(args.orderId)
759 chandransh 7227 
    except TransactionServiceException, ex:
7228 
      result.ex = ex
3064 chandransh 7229 
    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
759 chandransh 7230 
    result.write(oprot)
7231 
    oprot.writeMessageEnd()
7232 
    oprot.trans.flush()
7233 
 
3064 chandransh 7234 
  def process_acceptOrder(self, seqid, iprot, oprot):
7235 
    args = acceptOrder_args()
1113 chandransh 7236 
    args.read(iprot)
7237 
    iprot.readMessageEnd()
3064 chandransh 7238 
    result = acceptOrder_result()
1113 chandransh 7239 
    try:
3064 chandransh 7240 
      result.success = self._handler.acceptOrder(args.orderId)
1113 chandransh 7241 
    except TransactionServiceException, ex:
7242 
      result.ex = ex
3064 chandransh 7243 
    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
1113 chandransh 7244 
    result.write(oprot)
7245 
    oprot.writeMessageEnd()
7246 
    oprot.trans.flush()
7247 
 
3064 chandransh 7248 
  def process_addBillingDetails(self, seqid, iprot, oprot):
7249 
    args = addBillingDetails_args()
1135 chandransh 7250 
    args.read(iprot)
7251 
    iprot.readMessageEnd()
3064 chandransh 7252 
    result = addBillingDetails_result()
1135 chandransh 7253 
    try:
5110 mandeep.dh 7254 
      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 7255 
    except TransactionServiceException, ex:
7256 
      result.ex = ex
3064 chandransh 7257 
    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
1135 chandransh 7258 
    result.write(oprot)
7259 
    oprot.writeMessageEnd()
7260 
    oprot.trans.flush()
7261 
 
4579 rajveer 7262 
  def process_addInvoiceNumber(self, seqid, iprot, oprot):
7263 
    args = addInvoiceNumber_args()
7264 
    args.read(iprot)
7265 
    iprot.readMessageEnd()
7266 
    result = addInvoiceNumber_result()
7267 
    try:
6756 amar.kumar 7268 
      self._handler.addInvoiceNumber(args.orderId, args.invoiceNumber, args.color, args.serialNumber, args.itemNumber)
4579 rajveer 7269 
    except TransactionServiceException, ex:
7270 
      result.ex = ex
7271 
    oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
7272 
    result.write(oprot)
7273 
    oprot.writeMessageEnd()
7274 
    oprot.trans.flush()
7275 
 
4410 rajveer 7276 
  def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
7277 
    args = markOrdersAsShippedFromWarehouse_args()
7278 
    args.read(iprot)
7279 
    iprot.readMessageEnd()
7280 
    result = markOrdersAsShippedFromWarehouse_result()
7281 
    try:
4789 rajveer 7282 
      result.success = self._handler.markOrdersAsShippedFromWarehouse(args.warehouseId, args.providerId, args.cod, args.orderIds)
4410 rajveer 7283 
    except TransactionServiceException, ex:
7284 
      result.ex = ex
7285 
    oprot.writeMessageBegin("markOrdersAsShippedFromWarehouse", TMessageType.REPLY, seqid)
7286 
    result.write(oprot)
7287 
    oprot.writeMessageEnd()
7288 
    oprot.trans.flush()
7289 
 
5676 rajveer 7290 
  def process_markOrdersAsReturnedFromStore(self, seqid, iprot, oprot):
7291 
    args = markOrdersAsReturnedFromStore_args()
7292 
    args.read(iprot)
7293 
    iprot.readMessageEnd()
7294 
    result = markOrdersAsReturnedFromStore_result()
7295 
    try:
5713 rajveer 7296 
      result.success = self._handler.markOrdersAsReturnedFromStore(args.providerId, args.orderIds, args.awbs)
5676 rajveer 7297 
    except TransactionServiceException, ex:
7298 
      result.ex = ex
7299 
    oprot.writeMessageBegin("markOrdersAsReturnedFromStore", TMessageType.REPLY, seqid)
7300 
    result.write(oprot)
7301 
    oprot.writeMessageEnd()
7302 
    oprot.trans.flush()
7303 
 
3064 chandransh 7304 
  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
7305 
    args = markOrdersAsPickedUp_args()
304 ashish 7306 
    args.read(iprot)
7307 
    iprot.readMessageEnd()
3064 chandransh 7308 
    result = markOrdersAsPickedUp_result()
7309 
    try:
4910 phani.kuma 7310 
      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
3064 chandransh 7311 
    except TransactionServiceException, ex:
7312 
      result.ex = ex
7313 
    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
304 ashish 7314 
    result.write(oprot)
7315 
    oprot.writeMessageEnd()
7316 
    oprot.trans.flush()
94 ashish 7317 
 
4910 phani.kuma 7318 
  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
7319 
    args = getOrdersNotPickedUp_args()
7320 
    args.read(iprot)
7321 
    iprot.readMessageEnd()
7322 
    result = getOrdersNotPickedUp_result()
7323 
    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
7324 
    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
7325 
    result.write(oprot)
7326 
    oprot.writeMessageEnd()
7327 
    oprot.trans.flush()
7328 
 
3064 chandransh 7329 
  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
7330 
    args = markOrdersAsDelivered_args()
304 ashish 7331 
    args.read(iprot)
7332 
    iprot.readMessageEnd()
3064 chandransh 7333 
    result = markOrdersAsDelivered_result()
7334 
    try:
7335 
      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
7336 
    except TransactionServiceException, ex:
7337 
      result.ex = ex
7338 
    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
304 ashish 7339 
    result.write(oprot)
7340 
    oprot.writeMessageEnd()
7341 
    oprot.trans.flush()
7342 
 
4910 phani.kuma 7343 
  def process_markAsRTOrders(self, seqid, iprot, oprot):
7344 
    args = markAsRTOrders_args()
1596 ankur.sing 7345 
    args.read(iprot)
7346 
    iprot.readMessageEnd()
4910 phani.kuma 7347 
    result = markAsRTOrders_result()
3064 chandransh 7348 
    try:
4910 phani.kuma 7349 
      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
3064 chandransh 7350 
    except TransactionServiceException, ex:
7351 
      result.ex = ex
4910 phani.kuma 7352 
    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
1596 ankur.sing 7353 
    result.write(oprot)
7354 
    oprot.writeMessageEnd()
7355 
    oprot.trans.flush()
304 ashish 7356 
 
4910 phani.kuma 7357 
  def process_getRTOrders(self, seqid, iprot, oprot):
7358 
    args = getRTOrders_args()
7359 
    args.read(iprot)
7360 
    iprot.readMessageEnd()
7361 
    result = getRTOrders_result()
7362 
    result.success = self._handler.getRTOrders(args.providerId)
7363 
    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
7364 
    result.write(oprot)
7365 
    oprot.writeMessageEnd()
7366 
    oprot.trans.flush()
7367 
 
3064 chandransh 7368 
  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
7369 
    args = updateNonDeliveryReason_args()
1627 ankur.sing 7370 
    args.read(iprot)
7371 
    iprot.readMessageEnd()
3064 chandransh 7372 
    result = updateNonDeliveryReason_result()
7373 
    try:
4910 phani.kuma 7374 
      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
3064 chandransh 7375 
    except TransactionServiceException, ex:
7376 
      result.ex = ex
7377 
    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
1627 ankur.sing 7378 
    result.write(oprot)
7379 
    oprot.writeMessageEnd()
7380 
    oprot.trans.flush()
1596 ankur.sing 7381 
 
4910 phani.kuma 7382 
  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
7383 
    args = getNonDeliveredOrdersbyCourier_args()
7384 
    args.read(iprot)
7385 
    iprot.readMessageEnd()
7386 
    result = getNonDeliveredOrdersbyCourier_result()
7387 
    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
7388 
    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
7389 
    result.write(oprot)
7390 
    oprot.writeMessageEnd()
7391 
    oprot.trans.flush()
7392 
 
7393 
  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
7394 
    args = markOrdersAsLocalConnected_args()
7395 
    args.read(iprot)
7396 
    iprot.readMessageEnd()
7397 
    result = markOrdersAsLocalConnected_result()
7398 
    try:
7399 
      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
7400 
    except TransactionServiceException, ex:
7401 
      result.ex = ex
7402 
    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
7403 
    result.write(oprot)
7404 
    oprot.writeMessageEnd()
7405 
    oprot.trans.flush()
7406 
 
7407 
  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
7408 
    args = getOrdersNotLocalConnected_args()
7409 
    args.read(iprot)
7410 
    iprot.readMessageEnd()
7411 
    result = getOrdersNotLocalConnected_result()
7412 
    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
7413 
    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
7414 
    result.write(oprot)
7415 
    oprot.writeMessageEnd()
7416 
    oprot.trans.flush()
7417 
 
7418 
  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
7419 
    args = markOrdersAsDestinationCityReached_args()
7420 
    args.read(iprot)
7421 
    iprot.readMessageEnd()
7422 
    result = markOrdersAsDestinationCityReached_result()
7423 
    try:
7424 
      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
7425 
    except TransactionServiceException, ex:
7426 
      result.ex = ex
7427 
    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
7428 
    result.write(oprot)
7429 
    oprot.writeMessageEnd()
7430 
    oprot.trans.flush()
7431 
 
7432 
  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
7433 
    args = markOrdersAsFirstDeliveryAttempted_args()
7434 
    args.read(iprot)
7435 
    iprot.readMessageEnd()
7436 
    result = markOrdersAsFirstDeliveryAttempted_result()
7437 
    try:
7438 
      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
7439 
    except TransactionServiceException, ex:
7440 
      result.ex = ex
7441 
    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
7442 
    result.write(oprot)
7443 
    oprot.writeMessageEnd()
7444 
    oprot.trans.flush()
7445 
 
3064 chandransh 7446 
  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
7447 
    args = getUndeliveredOrders_args()
1627 ankur.sing 7448 
    args.read(iprot)
7449 
    iprot.readMessageEnd()
3064 chandransh 7450 
    result = getUndeliveredOrders_result()
7451 
    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
7452 
    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
1627 ankur.sing 7453 
    result.write(oprot)
7454 
    oprot.writeMessageEnd()
7455 
    oprot.trans.flush()
7456 
 
4783 phani.kuma 7457 
  def process_getUndeliveredOrdersExpectedDeliveryDateNotMet(self, seqid, iprot, oprot):
7458 
    args = getUndeliveredOrdersExpectedDeliveryDateNotMet_args()
7459 
    args.read(iprot)
7460 
    iprot.readMessageEnd()
7461 
    result = getUndeliveredOrdersExpectedDeliveryDateNotMet_result()
7462 
    result.success = self._handler.getUndeliveredOrdersExpectedDeliveryDateNotMet()
7463 
    oprot.writeMessageBegin("getUndeliveredOrdersExpectedDeliveryDateNotMet", TMessageType.REPLY, seqid)
7464 
    result.write(oprot)
7465 
    oprot.writeMessageEnd()
7466 
    oprot.trans.flush()
7467 
 
2536 chandransh 7468 
  def process_toggleDOAFlag(self, seqid, iprot, oprot):
7469 
    args = toggleDOAFlag_args()
7470 
    args.read(iprot)
7471 
    iprot.readMessageEnd()
7472 
    result = toggleDOAFlag_result()
7473 
    try:
7474 
      result.success = self._handler.toggleDOAFlag(args.orderId)
7475 
    except TransactionServiceException, ex:
7476 
      result.ex = ex
7477 
    oprot.writeMessageBegin("toggleDOAFlag", TMessageType.REPLY, seqid)
7478 
    result.write(oprot)
7479 
    oprot.writeMessageEnd()
7480 
    oprot.trans.flush()
1886 ankur.sing 7481 
 
4712 rajveer 7482 
  def process_markOrderAsDelivered(self, seqid, iprot, oprot):
7483 
    args = markOrderAsDelivered_args()
7484 
    args.read(iprot)
7485 
    iprot.readMessageEnd()
7486 
    result = markOrderAsDelivered_result()
7487 
    try:
7488 
      self._handler.markOrderAsDelivered(args.orderId, args.deliveryTimestamp, args.receiver)
7489 
    except TransactionServiceException, ex:
7490 
      result.ex = ex
7491 
    oprot.writeMessageBegin("markOrderAsDelivered", TMessageType.REPLY, seqid)
7492 
    result.write(oprot)
7493 
    oprot.writeMessageEnd()
7494 
    oprot.trans.flush()
7495 
 
5553 rajveer 7496 
  def process_markOrderAsReceivedAtStore(self, seqid, iprot, oprot):
7497 
    args = markOrderAsReceivedAtStore_args()
7498 
    args.read(iprot)
7499 
    iprot.readMessageEnd()
7500 
    result = markOrderAsReceivedAtStore_result()
7501 
    try:
7502 
      self._handler.markOrderAsReceivedAtStore(args.orderId, args.deliveryTimestamp)
7503 
    except TransactionServiceException, ex:
7504 
      result.ex = ex
7505 
    oprot.writeMessageBegin("markOrderAsReceivedAtStore", TMessageType.REPLY, seqid)
7506 
    result.write(oprot)
7507 
    oprot.writeMessageEnd()
7508 
    oprot.trans.flush()
7509 
 
4454 rajveer 7510 
  def process_markOrderDoaRequestReceived(self, seqid, iprot, oprot):
7511 
    args = markOrderDoaRequestReceived_args()
7512 
    args.read(iprot)
7513 
    iprot.readMessageEnd()
7514 
    result = markOrderDoaRequestReceived_result()
7515 
    try:
7516 
      result.success = self._handler.markOrderDoaRequestReceived(args.orderId)
7517 
    except TransactionServiceException, ex:
7518 
      result.ex = ex
7519 
    oprot.writeMessageBegin("markOrderDoaRequestReceived", TMessageType.REPLY, seqid)
7520 
    result.write(oprot)
7521 
    oprot.writeMessageEnd()
7522 
    oprot.trans.flush()
7523 
 
7524 
  def process_markOrderDoaRequestAuthorized(self, seqid, iprot, oprot):
7525 
    args = markOrderDoaRequestAuthorized_args()
7526 
    args.read(iprot)
7527 
    iprot.readMessageEnd()
7528 
    result = markOrderDoaRequestAuthorized_result()
7529 
    try:
7530 
      result.success = self._handler.markOrderDoaRequestAuthorized(args.orderId, args.isAuthorized)
7531 
    except TransactionServiceException, ex:
7532 
      result.ex = ex
7533 
    oprot.writeMessageBegin("markOrderDoaRequestAuthorized", TMessageType.REPLY, seqid)
7534 
    result.write(oprot)
7535 
    oprot.writeMessageEnd()
7536 
    oprot.trans.flush()
7537 
 
4488 rajveer 7538 
  def process_markOrderReturnRequestReceived(self, seqid, iprot, oprot):
7539 
    args = markOrderReturnRequestReceived_args()
7540 
    args.read(iprot)
7541 
    iprot.readMessageEnd()
7542 
    result = markOrderReturnRequestReceived_result()
7543 
    try:
7544 
      result.success = self._handler.markOrderReturnRequestReceived(args.orderId)
7545 
    except TransactionServiceException, ex:
7546 
      result.ex = ex
7547 
    oprot.writeMessageBegin("markOrderReturnRequestReceived", TMessageType.REPLY, seqid)
7548 
    result.write(oprot)
7549 
    oprot.writeMessageEnd()
7550 
    oprot.trans.flush()
7551 
 
7552 
  def process_markOrderReturnRequestAuthorized(self, seqid, iprot, oprot):
7553 
    args = markOrderReturnRequestAuthorized_args()
7554 
    args.read(iprot)
7555 
    iprot.readMessageEnd()
7556 
    result = markOrderReturnRequestAuthorized_result()
7557 
    try:
7558 
      result.success = self._handler.markOrderReturnRequestAuthorized(args.orderId, args.isAuthorized)
7559 
    except TransactionServiceException, ex:
7560 
      result.ex = ex
7561 
    oprot.writeMessageBegin("markOrderReturnRequestAuthorized", TMessageType.REPLY, seqid)
7562 
    result.write(oprot)
7563 
    oprot.writeMessageEnd()
7564 
    oprot.trans.flush()
7565 
 
2536 chandransh 7566 
  def process_requestPickupNumber(self, seqid, iprot, oprot):
7567 
    args = requestPickupNumber_args()
7568 
    args.read(iprot)
7569 
    iprot.readMessageEnd()
7570 
    result = requestPickupNumber_result()
7571 
    try:
4579 rajveer 7572 
      result.success = self._handler.requestPickupNumber(args.orderId, args.providerId)
2536 chandransh 7573 
    except TransactionServiceException, ex:
7574 
      result.ex = ex
7575 
    oprot.writeMessageBegin("requestPickupNumber", TMessageType.REPLY, seqid)
7576 
    result.write(oprot)
7577 
    oprot.writeMessageEnd()
7578 
    oprot.trans.flush()
7579 
 
7580 
  def process_authorizePickup(self, seqid, iprot, oprot):
7581 
    args = authorizePickup_args()
7582 
    args.read(iprot)
7583 
    iprot.readMessageEnd()
7584 
    result = authorizePickup_result()
7585 
    try:
4602 rajveer 7586 
      result.success = self._handler.authorizePickup(args.orderId, args.pickupNumber, args.providerId)
2536 chandransh 7587 
    except TransactionServiceException, ex:
7588 
      result.ex = ex
7589 
    oprot.writeMessageBegin("authorizePickup", TMessageType.REPLY, seqid)
7590 
    result.write(oprot)
7591 
    oprot.writeMessageEnd()
7592 
    oprot.trans.flush()
7593 
 
2764 chandransh 7594 
  def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
7595 
    args = markDoasAsPickedUp_args()
7596 
    args.read(iprot)
7597 
    iprot.readMessageEnd()
7598 
    result = markDoasAsPickedUp_result()
4910 phani.kuma 7599 
    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
2764 chandransh 7600 
    oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
7601 
    result.write(oprot)
7602 
    oprot.writeMessageEnd()
7603 
    oprot.trans.flush()
7604 
 
4910 phani.kuma 7605 
  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
7606 
    args = getDoasNotPickedUp_args()
7607 
    args.read(iprot)
7608 
    iprot.readMessageEnd()
7609 
    result = getDoasNotPickedUp_result()
7610 
    result.success = self._handler.getDoasNotPickedUp(args.providerId)
7611 
    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
7612 
    result.write(oprot)
7613 
    oprot.writeMessageEnd()
7614 
    oprot.trans.flush()
7615 
 
4741 phani.kuma 7616 
  def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
7617 
    args = markReturnOrdersAsPickedUp_args()
7618 
    args.read(iprot)
7619 
    iprot.readMessageEnd()
7620 
    result = markReturnOrdersAsPickedUp_result()
4910 phani.kuma 7621 
    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
4741 phani.kuma 7622 
    oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
7623 
    result.write(oprot)
7624 
    oprot.writeMessageEnd()
7625 
    oprot.trans.flush()
7626 
 
4910 phani.kuma 7627 
  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
7628 
    args = getReturnOrdersNotPickedUp_args()
7629 
    args.read(iprot)
7630 
    iprot.readMessageEnd()
7631 
    result = getReturnOrdersNotPickedUp_result()
7632 
    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
7633 
    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
7634 
    result.write(oprot)
7635 
    oprot.writeMessageEnd()
7636 
    oprot.trans.flush()
7637 
 
2616 chandransh 7638 
  def process_receiveReturn(self, seqid, iprot, oprot):
7639 
    args = receiveReturn_args()
2591 chandransh 7640 
    args.read(iprot)
7641 
    iprot.readMessageEnd()
2616 chandransh 7642 
    result = receiveReturn_result()
2591 chandransh 7643 
    try:
4479 rajveer 7644 
      result.success = self._handler.receiveReturn(args.orderId, args.receiveCondition)
2591 chandransh 7645 
    except TransactionServiceException, ex:
7646 
      result.ex = ex
2616 chandransh 7647 
    oprot.writeMessageBegin("receiveReturn", TMessageType.REPLY, seqid)
2591 chandransh 7648 
    result.write(oprot)
7649 
    oprot.writeMessageEnd()
7650 
    oprot.trans.flush()
2536 chandransh 7651 
 
2591 chandransh 7652 
  def process_validateDoa(self, seqid, iprot, oprot):
7653 
    args = validateDoa_args()
7654 
    args.read(iprot)
7655 
    iprot.readMessageEnd()
7656 
    result = validateDoa_result()
7657 
    try:
7658 
      result.success = self._handler.validateDoa(args.orderId, args.isValid)
7659 
    except TransactionServiceException, ex:
7660 
      result.ex = ex
7661 
    oprot.writeMessageBegin("validateDoa", TMessageType.REPLY, seqid)
7662 
    result.write(oprot)
7663 
    oprot.writeMessageEnd()
7664 
    oprot.trans.flush()
7665 
 
4495 rajveer 7666 
  def process_validateReturnProduct(self, seqid, iprot, oprot):
7667 
    args = validateReturnProduct_args()
7668 
    args.read(iprot)
7669 
    iprot.readMessageEnd()
7670 
    result = validateReturnProduct_result()
7671 
    try:
7672 
      result.success = self._handler.validateReturnProduct(args.orderId, args.isUsable)
7673 
    except TransactionServiceException, ex:
7674 
      result.ex = ex
7675 
    oprot.writeMessageBegin("validateReturnProduct", TMessageType.REPLY, seqid)
7676 
    result.write(oprot)
7677 
    oprot.writeMessageEnd()
7678 
    oprot.trans.flush()
7679 
 
2616 chandransh 7680 
  def process_reshipOrder(self, seqid, iprot, oprot):
7681 
    args = reshipOrder_args()
7682 
    args.read(iprot)
7683 
    iprot.readMessageEnd()
7684 
    result = reshipOrder_result()
7685 
    try:
7686 
      result.success = self._handler.reshipOrder(args.orderId)
7687 
    except TransactionServiceException, ex:
7688 
      result.ex = ex
7689 
    oprot.writeMessageBegin("reshipOrder", TMessageType.REPLY, seqid)
7690 
    result.write(oprot)
7691 
    oprot.writeMessageEnd()
7692 
    oprot.trans.flush()
2591 chandransh 7693 
 
2616 chandransh 7694 
  def process_refundOrder(self, seqid, iprot, oprot):
7695 
    args = refundOrder_args()
7696 
    args.read(iprot)
7697 
    iprot.readMessageEnd()
7698 
    result = refundOrder_result()
7699 
    try:
3226 chandransh 7700 
      result.success = self._handler.refundOrder(args.orderId, args.refundedBy, args.reason)
2616 chandransh 7701 
    except TransactionServiceException, ex:
7702 
      result.ex = ex
7703 
    oprot.writeMessageBegin("refundOrder", TMessageType.REPLY, seqid)
7704 
    result.write(oprot)
7705 
    oprot.writeMessageEnd()
7706 
    oprot.trans.flush()
7707 
 
2690 chandransh 7708 
  def process_getReturnOrders(self, seqid, iprot, oprot):
7709 
    args = getReturnOrders_args()
7710 
    args.read(iprot)
7711 
    iprot.readMessageEnd()
7712 
    result = getReturnOrders_result()
7713 
    result.success = self._handler.getReturnOrders(args.warehouseId, args.fromDate, args.toDate)
7714 
    oprot.writeMessageBegin("getReturnOrders", TMessageType.REPLY, seqid)
7715 
    result.write(oprot)
7716 
    oprot.writeMessageEnd()
7717 
    oprot.trans.flush()
2616 chandransh 7718 
 
5481 phani.kuma 7719 
  def process_getAllReturnOrders(self, seqid, iprot, oprot):
7720 
    args = getAllReturnOrders_args()
7721 
    args.read(iprot)
7722 
    iprot.readMessageEnd()
7723 
    result = getAllReturnOrders_result()
7724 
    result.success = self._handler.getAllReturnOrders(args.onlyNotProcessed, args.fromDate, args.toDate)
7725 
    oprot.writeMessageBegin("getAllReturnOrders", TMessageType.REPLY, seqid)
7726 
    result.write(oprot)
7727 
    oprot.writeMessageEnd()
7728 
    oprot.trans.flush()
7729 
 
2700 chandransh 7730 
  def process_getReturnOrder(self, seqid, iprot, oprot):
7731 
    args = getReturnOrder_args()
7732 
    args.read(iprot)
7733 
    iprot.readMessageEnd()
7734 
    result = getReturnOrder_result()
7735 
    try:
7736 
      result.success = self._handler.getReturnOrder(args.id)
7737 
    except TransactionServiceException, ex:
7738 
      result.ex = ex
7739 
    oprot.writeMessageBegin("getReturnOrder", TMessageType.REPLY, seqid)
7740 
    result.write(oprot)
7741 
    oprot.writeMessageEnd()
7742 
    oprot.trans.flush()
7743 
 
2690 chandransh 7744 
  def process_processReturn(self, seqid, iprot, oprot):
7745 
    args = processReturn_args()
7746 
    args.read(iprot)
7747 
    iprot.readMessageEnd()
7748 
    result = processReturn_result()
7749 
    try:
7750 
      self._handler.processReturn(args.returnOrderId)
7751 
    except TransactionServiceException, ex:
7752 
      result.ex = ex
7753 
    oprot.writeMessageBegin("processReturn", TMessageType.REPLY, seqid)
7754 
    result.write(oprot)
7755 
    oprot.writeMessageEnd()
7756 
    oprot.trans.flush()
7757 
 
3451 chandransh 7758 
  def process_updateWeight(self, seqid, iprot, oprot):
7759 
    args = updateWeight_args()
7760 
    args.read(iprot)
7761 
    iprot.readMessageEnd()
7762 
    result = updateWeight_result()
7763 
    try:
7764 
      result.success = self._handler.updateWeight(args.orderId, args.weight)
7765 
    except TransactionServiceException, ex:
7766 
      result.ex = ex
7767 
    oprot.writeMessageBegin("updateWeight", TMessageType.REPLY, seqid)
7768 
    result.write(oprot)
7769 
    oprot.writeMessageEnd()
7770 
    oprot.trans.flush()
2819 chandransh 7771 
 
3469 chandransh 7772 
  def process_changeItem(self, seqid, iprot, oprot):
7773 
    args = changeItem_args()
7774 
    args.read(iprot)
7775 
    iprot.readMessageEnd()
7776 
    result = changeItem_result()
7777 
    try:
7778 
      result.success = self._handler.changeItem(args.orderId, args.itemId)
7779 
    except TransactionServiceException, ex:
7780 
      result.ex = ex
7781 
    oprot.writeMessageBegin("changeItem", TMessageType.REPLY, seqid)
7782 
    result.write(oprot)
7783 
    oprot.writeMessageEnd()
7784 
    oprot.trans.flush()
3451 chandransh 7785 
 
3469 chandransh 7786 
  def process_shiftToWarehouse(self, seqid, iprot, oprot):
7787 
    args = shiftToWarehouse_args()
7788 
    args.read(iprot)
7789 
    iprot.readMessageEnd()
7790 
    result = shiftToWarehouse_result()
7791 
    try:
7792 
      result.success = self._handler.shiftToWarehouse(args.orderId, args.warehouseId)
7793 
    except TransactionServiceException, ex:
7794 
      result.ex = ex
7795 
    oprot.writeMessageBegin("shiftToWarehouse", TMessageType.REPLY, seqid)
7796 
    result.write(oprot)
7797 
    oprot.writeMessageEnd()
7798 
    oprot.trans.flush()
7799 
 
3553 chandransh 7800 
  def process_addDelayReason(self, seqid, iprot, oprot):
7801 
    args = addDelayReason_args()
7802 
    args.read(iprot)
7803 
    iprot.readMessageEnd()
7804 
    result = addDelayReason_result()
7805 
    try:
4647 rajveer 7806 
      result.success = self._handler.addDelayReason(args.orderId, args.delayReason, args.furtherDelay, args.delayReasonText)
3553 chandransh 7807 
    except TransactionServiceException, ex:
7808 
      result.ex = ex
7809 
    oprot.writeMessageBegin("addDelayReason", TMessageType.REPLY, seqid)
7810 
    result.write(oprot)
7811 
    oprot.writeMessageEnd()
7812 
    oprot.trans.flush()
3469 chandransh 7813 
 
3956 chandransh 7814 
  def process_reconcileCodCollection(self, seqid, iprot, oprot):
7815 
    args = reconcileCodCollection_args()
7816 
    args.read(iprot)
7817 
    iprot.readMessageEnd()
7818 
    result = reconcileCodCollection_result()
7819 
    try:
7820 
      result.success = self._handler.reconcileCodCollection(args.collectedAmountMap, args.xferBy, args.xferTxnId, args.xferDate)
7821 
    except TransactionServiceException, ex:
7822 
      result.ex = ex
7823 
    oprot.writeMessageBegin("reconcileCodCollection", TMessageType.REPLY, seqid)
7824 
    result.write(oprot)
7825 
    oprot.writeMessageEnd()
7826 
    oprot.trans.flush()
3553 chandransh 7827 
 
4008 mandeep.dh 7828 
  def process_getTransactionsRequiringExtraProcessing(self, seqid, iprot, oprot):
7829 
    args = getTransactionsRequiringExtraProcessing_args()
7830 
    args.read(iprot)
7831 
    iprot.readMessageEnd()
7832 
    result = getTransactionsRequiringExtraProcessing_result()
7833 
    result.success = self._handler.getTransactionsRequiringExtraProcessing(args.category)
7834 
    oprot.writeMessageBegin("getTransactionsRequiringExtraProcessing", TMessageType.REPLY, seqid)
7835 
    result.write(oprot)
7836 
    oprot.writeMessageEnd()
7837 
    oprot.trans.flush()
3956 chandransh 7838 
 
4008 mandeep.dh 7839 
  def process_markTransactionAsProcessed(self, seqid, iprot, oprot):
7840 
    args = markTransactionAsProcessed_args()
7841 
    args.read(iprot)
7842 
    iprot.readMessageEnd()
7843 
    result = markTransactionAsProcessed_result()
7844 
    self._handler.markTransactionAsProcessed(args.transactionId, args.category)
7845 
    oprot.writeMessageBegin("markTransactionAsProcessed", TMessageType.REPLY, seqid)
7846 
    result.write(oprot)
7847 
    oprot.writeMessageEnd()
7848 
    oprot.trans.flush()
7849 
 
4018 chandransh 7850 
  def process_getItemWiseRiskyOrdersCount(self, seqid, iprot, oprot):
7851 
    args = getItemWiseRiskyOrdersCount_args()
7852 
    args.read(iprot)
7853 
    iprot.readMessageEnd()
7854 
    result = getItemWiseRiskyOrdersCount_result()
7855 
    result.success = self._handler.getItemWiseRiskyOrdersCount()
7856 
    oprot.writeMessageBegin("getItemWiseRiskyOrdersCount", TMessageType.REPLY, seqid)
7857 
    result.write(oprot)
7858 
    oprot.writeMessageEnd()
7859 
    oprot.trans.flush()
4008 mandeep.dh 7860 
 
4295 varun.gupt 7861 
  def process_getOrdersForItemIds(self, seqid, iprot, oprot):
7862 
    args = getOrdersForItemIds_args()
7863 
    args.read(iprot)
7864 
    iprot.readMessageEnd()
7865 
    result = getOrdersForItemIds_result()
7866 
    result.success = self._handler.getOrdersForItemIds(args.itemIds)
7867 
    oprot.writeMessageBegin("getOrdersForItemIds", TMessageType.REPLY, seqid)
7868 
    result.write(oprot)
7869 
    oprot.writeMessageEnd()
7870 
    oprot.trans.flush()
7871 
 
4247 rajveer 7872 
  def process_markOrderCancellationRequestReceived(self, seqid, iprot, oprot):
7873 
    args = markOrderCancellationRequestReceived_args()
7874 
    args.read(iprot)
7875 
    iprot.readMessageEnd()
7876 
    result = markOrderCancellationRequestReceived_result()
7877 
    try:
7878 
      self._handler.markOrderCancellationRequestReceived(args.orderId)
7879 
    except TransactionServiceException, ex:
7880 
      result.ex = ex
7881 
    oprot.writeMessageBegin("markOrderCancellationRequestReceived", TMessageType.REPLY, seqid)
7882 
    result.write(oprot)
7883 
    oprot.writeMessageEnd()
7884 
    oprot.trans.flush()
4018 chandransh 7885 
 
4247 rajveer 7886 
  def process_markOrderCancellationRequestConfirmed(self, seqid, iprot, oprot):
7887 
    args = markOrderCancellationRequestConfirmed_args()
7888 
    args.read(iprot)
7889 
    iprot.readMessageEnd()
7890 
    result = markOrderCancellationRequestConfirmed_result()
7891 
    try:
7892 
      self._handler.markOrderCancellationRequestConfirmed(args.orderId)
7893 
    except TransactionServiceException, ex:
7894 
      result.ex = ex
7895 
    oprot.writeMessageBegin("markOrderCancellationRequestConfirmed", TMessageType.REPLY, seqid)
7896 
    result.write(oprot)
7897 
    oprot.writeMessageEnd()
7898 
    oprot.trans.flush()
7899 
 
7900 
  def process_markOrderCancellationRequestDenied(self, seqid, iprot, oprot):
7901 
    args = markOrderCancellationRequestDenied_args()
7902 
    args.read(iprot)
7903 
    iprot.readMessageEnd()
7904 
    result = markOrderCancellationRequestDenied_result()
7905 
    try:
7906 
      self._handler.markOrderCancellationRequestDenied(args.orderId)
7907 
    except TransactionServiceException, ex:
7908 
      result.ex = ex
7909 
    oprot.writeMessageBegin("markOrderCancellationRequestDenied", TMessageType.REPLY, seqid)
7910 
    result.write(oprot)
7911 
    oprot.writeMessageEnd()
7912 
    oprot.trans.flush()
7913 
 
4258 rajveer 7914 
  def process_markTransactionAsPaymentFlagRemoved(self, seqid, iprot, oprot):
7915 
    args = markTransactionAsPaymentFlagRemoved_args()
4247 rajveer 7916 
    args.read(iprot)
7917 
    iprot.readMessageEnd()
4258 rajveer 7918 
    result = markTransactionAsPaymentFlagRemoved_result()
4247 rajveer 7919 
    try:
4258 rajveer 7920 
      self._handler.markTransactionAsPaymentFlagRemoved(args.transactionId)
4247 rajveer 7921 
    except TransactionServiceException, ex:
7922 
      result.ex = ex
4258 rajveer 7923 
    oprot.writeMessageBegin("markTransactionAsPaymentFlagRemoved", TMessageType.REPLY, seqid)
4247 rajveer 7924 
    result.write(oprot)
7925 
    oprot.writeMessageEnd()
7926 
    oprot.trans.flush()
7927 
 
4259 anupam.sin 7928 
  def process_refundTransaction(self, seqid, iprot, oprot):
7929 
    args = refundTransaction_args()
7930 
    args.read(iprot)
7931 
    iprot.readMessageEnd()
7932 
    result = refundTransaction_result()
7933 
    try:
7934 
      self._handler.refundTransaction(args.transactionId, args.refundedBy, args.reason)
7935 
    except TransactionServiceException, ex:
7936 
      result.ex = ex
7937 
    oprot.writeMessageBegin("refundTransaction", TMessageType.REPLY, seqid)
7938 
    result.write(oprot)
7939 
    oprot.writeMessageEnd()
7940 
    oprot.trans.flush()
4247 rajveer 7941 
 
4324 mandeep.dh 7942 
  def process_updateShipmentAddress(self, seqid, iprot, oprot):
7943 
    args = updateShipmentAddress_args()
7944 
    args.read(iprot)
7945 
    iprot.readMessageEnd()
7946 
    result = updateShipmentAddress_result()
7947 
    try:
7948 
      self._handler.updateShipmentAddress(args.orderId, args.addressId)
7949 
    except TransactionServiceException, ex:
7950 
      result.ex = ex
7951 
    oprot.writeMessageBegin("updateShipmentAddress", TMessageType.REPLY, seqid)
7952 
    result.write(oprot)
7953 
    oprot.writeMessageEnd()
7954 
    oprot.trans.flush()
7955 
 
4285 rajveer 7956 
  def process_acceptOrdersForItemId(self, seqid, iprot, oprot):
7957 
    args = acceptOrdersForItemId_args()
7958 
    args.read(iprot)
7959 
    iprot.readMessageEnd()
7960 
    result = acceptOrdersForItemId_result()
7961 
    try:
7962 
      result.success = self._handler.acceptOrdersForItemId(args.itemId, args.inventory)
7963 
    except TransactionServiceException, ex:
7964 
      result.ex = ex
7965 
    oprot.writeMessageBegin("acceptOrdersForItemId", TMessageType.REPLY, seqid)
7966 
    result.write(oprot)
7967 
    oprot.writeMessageEnd()
7968 
    oprot.trans.flush()
4259 anupam.sin 7969 
 
4303 rajveer 7970 
  def process_markOrdersAsPORaised(self, seqid, iprot, oprot):
7971 
    args = markOrdersAsPORaised_args()
7972 
    args.read(iprot)
7973 
    iprot.readMessageEnd()
7974 
    result = markOrdersAsPORaised_result()
7975 
    try:
4369 rajveer 7976 
      self._handler.markOrdersAsPORaised(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7977 
    except TransactionServiceException, ex:
7978 
      result.ex = ex
7979 
    oprot.writeMessageBegin("markOrdersAsPORaised", TMessageType.REPLY, seqid)
7980 
    result.write(oprot)
7981 
    oprot.writeMessageEnd()
7982 
    oprot.trans.flush()
4285 rajveer 7983 
 
4303 rajveer 7984 
  def process_markOrdersAsReversalInitiated(self, seqid, iprot, oprot):
7985 
    args = markOrdersAsReversalInitiated_args()
7986 
    args.read(iprot)
7987 
    iprot.readMessageEnd()
7988 
    result = markOrdersAsReversalInitiated_result()
7989 
    try:
4369 rajveer 7990 
      self._handler.markOrdersAsReversalInitiated(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 7991 
    except TransactionServiceException, ex:
7992 
      result.ex = ex
7993 
    oprot.writeMessageBegin("markOrdersAsReversalInitiated", TMessageType.REPLY, seqid)
7994 
    result.write(oprot)
7995 
    oprot.writeMessageEnd()
7996 
    oprot.trans.flush()
7997 
 
7998 
  def process_markOrdersAsNotAvailabke(self, seqid, iprot, oprot):
7999 
    args = markOrdersAsNotAvailabke_args()
8000 
    args.read(iprot)
8001 
    iprot.readMessageEnd()
8002 
    result = markOrdersAsNotAvailabke_result()
8003 
    try:
4369 rajveer 8004 
      self._handler.markOrdersAsNotAvailabke(args.vendorId, args.itemId, args.quantity, args.estimate, args.isReminder)
4303 rajveer 8005 
    except TransactionServiceException, ex:
8006 
      result.ex = ex
8007 
    oprot.writeMessageBegin("markOrdersAsNotAvailabke", TMessageType.REPLY, seqid)
8008 
    result.write(oprot)
8009 
    oprot.writeMessageEnd()
8010 
    oprot.trans.flush()
8011 
 
4369 rajveer 8012 
  def process_markOrdersAsTimeout(self, seqid, iprot, oprot):
8013 
    args = markOrdersAsTimeout_args()
8014 
    args.read(iprot)
8015 
    iprot.readMessageEnd()
8016 
    result = markOrdersAsTimeout_result()
8017 
    try:
8018 
      result.success = self._handler.markOrdersAsTimeout(args.vendorId)
8019 
    except TransactionServiceException, ex:
8020 
      result.ex = ex
8021 
    oprot.writeMessageBegin("markOrdersAsTimeout", TMessageType.REPLY, seqid)
8022 
    result.write(oprot)
8023 
    oprot.writeMessageEnd()
8024 
    oprot.trans.flush()
4303 rajveer 8025 
 
4662 rajveer 8026 
  def process_markOrderAsLostInTransit(self, seqid, iprot, oprot):
8027 
    args = markOrderAsLostInTransit_args()
8028 
    args.read(iprot)
8029 
    iprot.readMessageEnd()
8030 
    result = markOrderAsLostInTransit_result()
8031 
    try:
8032 
      result.success = self._handler.markOrderAsLostInTransit(args.orderId)
8033 
    except TransactionServiceException, ex:
8034 
      result.ex = ex
8035 
    oprot.writeMessageBegin("markOrderAsLostInTransit", TMessageType.REPLY, seqid)
8036 
    result.write(oprot)
8037 
    oprot.writeMessageEnd()
8038 
    oprot.trans.flush()
8039 
 
4386 anupam.sin 8040 
  def process_getOrderForAwb(self, seqid, iprot, oprot):
8041 
    args = getOrderForAwb_args()
8042 
    args.read(iprot)
8043 
    iprot.readMessageEnd()
8044 
    result = getOrderForAwb_result()
8045 
    try:
8046 
      result.success = self._handler.getOrderForAwb(args.awb)
8047 
    except TransactionServiceException, ex:
8048 
      result.ex = ex
8049 
    oprot.writeMessageBegin("getOrderForAwb", TMessageType.REPLY, seqid)
8050 
    result.write(oprot)
8051 
    oprot.writeMessageEnd()
8052 
    oprot.trans.flush()
4369 rajveer 8053 
 
4506 phani.kuma 8054 
  def process_getOrdersForProviderForStatus(self, seqid, iprot, oprot):
8055 
    args = getOrdersForProviderForStatus_args()
8056 
    args.read(iprot)
8057 
    iprot.readMessageEnd()
8058 
    result = getOrdersForProviderForStatus_result()
8059 
    try:
4910 phani.kuma 8060 
      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
4506 phani.kuma 8061 
    except TransactionServiceException, ex:
8062 
      result.ex = ex
8063 
    oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
8064 
    result.write(oprot)
8065 
    oprot.writeMessageEnd()
8066 
    oprot.trans.flush()
4386 anupam.sin 8067 
 
4600 varun.gupt 8068 
  def process_getBilledOrdersForVendor(self, seqid, iprot, oprot):
8069 
    args = getBilledOrdersForVendor_args()
8070 
    args.read(iprot)
8071 
    iprot.readMessageEnd()
8072 
    result = getBilledOrdersForVendor_result()
8073 
    try:
8074 
      result.success = self._handler.getBilledOrdersForVendor(args.vendorId, args.billingDateFrom, args.billingDateTo)
8075 
    except TransactionServiceException, ex:
8076 
      result.ex = ex
8077 
    oprot.writeMessageBegin("getBilledOrdersForVendor", TMessageType.REPLY, seqid)
8078 
    result.write(oprot)
8079 
    oprot.writeMessageEnd()
8080 
    oprot.trans.flush()
4506 phani.kuma 8081 
 
4607 rajveer 8082 
  def process_getSlippedSippingDateOrders(self, seqid, iprot, oprot):
8083 
    args = getSlippedSippingDateOrders_args()
8084 
    args.read(iprot)
8085 
    iprot.readMessageEnd()
8086 
    result = getSlippedSippingDateOrders_result()
8087 
    try:
8088 
      result.success = self._handler.getSlippedSippingDateOrders()
8089 
    except TransactionServiceException, ex:
8090 
      result.ex = ex
8091 
    oprot.writeMessageBegin("getSlippedSippingDateOrders", TMessageType.REPLY, seqid)
8092 
    result.write(oprot)
8093 
    oprot.writeMessageEnd()
8094 
    oprot.trans.flush()
8095 
 
4709 rajveer 8096 
  def process_getCancelledOrders(self, seqid, iprot, oprot):
8097 
    args = getCancelledOrders_args()
8098 
    args.read(iprot)
8099 
    iprot.readMessageEnd()
8100 
    result = getCancelledOrders_result()
8101 
    try:
8102 
      result.success = self._handler.getCancelledOrders(args.cancelDateFrom, args.cancelDateTo)
8103 
    except TransactionServiceException, ex:
8104 
      result.ex = ex
8105 
    oprot.writeMessageBegin("getCancelledOrders", TMessageType.REPLY, seqid)
8106 
    result.write(oprot)
8107 
    oprot.writeMessageEnd()
8108 
    oprot.trans.flush()
8109 
 
4600 varun.gupt 8110 
  def process_saveBluedartSettlements(self, seqid, iprot, oprot):
8111 
    args = saveBluedartSettlements_args()
8112 
    args.read(iprot)
8113 
    iprot.readMessageEnd()
8114 
    result = saveBluedartSettlements_result()
8115 
    try:
8116 
      self._handler.saveBluedartSettlements(args.mapAWBAndAmount)
8117 
    except TransactionServiceException, ex:
8118 
      result.ex = ex
8119 
    oprot.writeMessageBegin("saveBluedartSettlements", TMessageType.REPLY, seqid)
8120 
    result.write(oprot)
8121 
    oprot.writeMessageEnd()
8122 
    oprot.trans.flush()
8123 
 
8124 
  def process_savePaymentSettlements(self, seqid, iprot, oprot):
8125 
    args = savePaymentSettlements_args()
8126 
    args.read(iprot)
8127 
    iprot.readMessageEnd()
8128 
    result = savePaymentSettlements_result()
8129 
    try:
4905 varun.gupt 8130 
      self._handler.savePaymentSettlements(args.settlementDate, args.paymentGatewayId, args.referenceId, args.serviceTax, args.otherCharges, args.netCollection)
4600 varun.gupt 8131 
    except TransactionServiceException, ex:
8132 
      result.ex = ex
8133 
    oprot.writeMessageBegin("savePaymentSettlements", TMessageType.REPLY, seqid)
8134 
    result.write(oprot)
8135 
    oprot.writeMessageEnd()
8136 
    oprot.trans.flush()
8137 
 
8138 
  def process_saveEBSSettlementSummary(self, seqid, iprot, oprot):
8139 
    args = saveEBSSettlementSummary_args()
8140 
    args.read(iprot)
8141 
    iprot.readMessageEnd()
8142 
    result = saveEBSSettlementSummary_result()
8143 
    try:
8144 
      self._handler.saveEBSSettlementSummary(args.settlementId, args.settlementDate, args.transactionDateFrom, args.transactionDateTo, args.amount)
8145 
    except TransactionServiceException, ex:
8146 
      result.ex = ex
8147 
    oprot.writeMessageBegin("saveEBSSettlementSummary", TMessageType.REPLY, seqid)
8148 
    result.write(oprot)
8149 
    oprot.writeMessageEnd()
8150 
    oprot.trans.flush()
8151 
 
5386 phani.kuma 8152 
  def process_getSettlementForPrepaid(self, seqid, iprot, oprot):
8153 
    args = getSettlementForPrepaid_args()
4600 varun.gupt 8154 
    args.read(iprot)
8155 
    iprot.readMessageEnd()
5386 phani.kuma 8156 
    result = getSettlementForPrepaid_result()
4600 varun.gupt 8157 
    try:
5386 phani.kuma 8158 
      result.success = self._handler.getSettlementForPrepaid(args.referenceId, args.isRefund)
4600 varun.gupt 8159 
    except TransactionServiceException, ex:
8160 
      result.ex = ex
5386 phani.kuma 8161 
    oprot.writeMessageBegin("getSettlementForPrepaid", TMessageType.REPLY, seqid)
4600 varun.gupt 8162 
    result.write(oprot)
8163 
    oprot.writeMessageEnd()
8164 
    oprot.trans.flush()
8165 
 
5386 phani.kuma 8166 
  def process_getSettlementForCod(self, seqid, iprot, oprot):
8167 
    args = getSettlementForCod_args()
8168 
    args.read(iprot)
8169 
    iprot.readMessageEnd()
8170 
    result = getSettlementForCod_result()
8171 
    try:
8172 
      result.success = self._handler.getSettlementForCod(args.orderId, args.isRefund)
8173 
    except TransactionServiceException, ex:
8174 
      result.ex = ex
8175 
    oprot.writeMessageBegin("getSettlementForCod", TMessageType.REPLY, seqid)
8176 
    result.write(oprot)
8177 
    oprot.writeMessageEnd()
8178 
    oprot.trans.flush()
8179 
 
4600 varun.gupt 8180 
  def process_getEBSSettlementSummaries(self, seqid, iprot, oprot):
8181 
    args = getEBSSettlementSummaries_args()
8182 
    args.read(iprot)
8183 
    iprot.readMessageEnd()
8184 
    result = getEBSSettlementSummaries_result()
8185 
    try:
8186 
      result.success = self._handler.getEBSSettlementSummaries()
8187 
    except TransactionServiceException, ex:
8188 
      result.ex = ex
8189 
    oprot.writeMessageBegin("getEBSSettlementSummaries", TMessageType.REPLY, seqid)
8190 
    result.write(oprot)
8191 
    oprot.writeMessageEnd()
8192 
    oprot.trans.flush()
8193 
 
8194 
  def process_markEBSSettlementUploaded(self, seqid, iprot, oprot):
8195 
    args = markEBSSettlementUploaded_args()
8196 
    args.read(iprot)
8197 
    iprot.readMessageEnd()
8198 
    result = markEBSSettlementUploaded_result()
8199 
    try:
8200 
      self._handler.markEBSSettlementUploaded(args.settlementId)
8201 
    except TransactionServiceException, ex:
8202 
      result.ex = ex
8203 
    oprot.writeMessageBegin("markEBSSettlementUploaded", TMessageType.REPLY, seqid)
8204 
    result.write(oprot)
8205 
    oprot.writeMessageEnd()
8206 
    oprot.trans.flush()
8207 
 
8208 
  def process_getEBSSettlementDate(self, seqid, iprot, oprot):
8209 
    args = getEBSSettlementDate_args()
8210 
    args.read(iprot)
8211 
    iprot.readMessageEnd()
8212 
    result = getEBSSettlementDate_result()
8213 
    try:
8214 
      result.success = self._handler.getEBSSettlementDate(args.settlementId)
8215 
    except TransactionServiceException, ex:
8216 
      result.ex = ex
8217 
    oprot.writeMessageBegin("getEBSSettlementDate", TMessageType.REPLY, seqid)
8218 
    result.write(oprot)
8219 
    oprot.writeMessageEnd()
8220 
    oprot.trans.flush()
8221 
 
4715 varun.gupt 8222 
  def process_getSettlementsByDate(self, seqid, iprot, oprot):
8223 
    args = getSettlementsByDate_args()
8224 
    args.read(iprot)
8225 
    iprot.readMessageEnd()
8226 
    result = getSettlementsByDate_result()
8227 
    try:
8228 
      result.success = self._handler.getSettlementsByDate(args.settlementDateFrom, args.settlementDateTo, args.isRefund)
8229 
    except TransactionServiceException, ex:
8230 
      result.ex = ex
8231 
    oprot.writeMessageBegin("getSettlementsByDate", TMessageType.REPLY, seqid)
8232 
    result.write(oprot)
8233 
    oprot.writeMessageEnd()
8234 
    oprot.trans.flush()
4600 varun.gupt 8235 
 
4715 varun.gupt 8236 
  def process_getReshippedOrderIds(self, seqid, iprot, oprot):
8237 
    args = getReshippedOrderIds_args()
8238 
    args.read(iprot)
8239 
    iprot.readMessageEnd()
8240 
    result = getReshippedOrderIds_result()
8241 
    try:
8242 
      result.success = self._handler.getReshippedOrderIds(args.orderIds)
8243 
    except TransactionServiceException, ex:
8244 
      result.ex = ex
8245 
    oprot.writeMessageBegin("getReshippedOrderIds", TMessageType.REPLY, seqid)
8246 
    result.write(oprot)
8247 
    oprot.writeMessageEnd()
8248 
    oprot.trans.flush()
8249 
 
5481 phani.kuma 8250 
  def process_getBilledOrders(self, seqid, iprot, oprot):
8251 
    args = getBilledOrders_args()
4875 varun.gupt 8252 
    args.read(iprot)
8253 
    iprot.readMessageEnd()
5481 phani.kuma 8254 
    result = getBilledOrders_result()
4875 varun.gupt 8255 
    try:
5481 phani.kuma 8256 
      result.success = self._handler.getBilledOrders(args.vendorId, args.onlyVendorNotPaid, args.billingDateFrom, args.billingDateTo)
4875 varun.gupt 8257 
    except TransactionServiceException, ex:
8258 
      result.ex = ex
5481 phani.kuma 8259 
    oprot.writeMessageBegin("getBilledOrders", TMessageType.REPLY, seqid)
4875 varun.gupt 8260 
    result.write(oprot)
8261 
    oprot.writeMessageEnd()
8262 
    oprot.trans.flush()
4757 mandeep.dh 8263 
 
5031 varun.gupt 8264 
  def process_getStatusDistributionOfOrders(self, seqid, iprot, oprot):
8265 
    args = getStatusDistributionOfOrders_args()
8266 
    args.read(iprot)
8267 
    iprot.readMessageEnd()
8268 
    result = getStatusDistributionOfOrders_result()
8269 
    try:
8270 
      result.success = self._handler.getStatusDistributionOfOrders(args.startDate, args.endDate)
8271 
    except TransactionServiceException, ex:
8272 
      result.ex = ex
8273 
    oprot.writeMessageBegin("getStatusDistributionOfOrders", TMessageType.REPLY, seqid)
8274 
    result.write(oprot)
8275 
    oprot.writeMessageEnd()
8276 
    oprot.trans.flush()
4875 varun.gupt 8277 
 
5067 varun.gupt 8278 
  def process_getOrderIdsForStatus(self, seqid, iprot, oprot):
8279 
    args = getOrderIdsForStatus_args()
8280 
    args.read(iprot)
8281 
    iprot.readMessageEnd()
8282 
    result = getOrderIdsForStatus_result()
8283 
    try:
8284 
      result.success = self._handler.getOrderIdsForStatus(args.status, args.startDatetime, args.endDatetime)
8285 
    except TransactionServiceException, ex:
8286 
      result.ex = ex
8287 
    oprot.writeMessageBegin("getOrderIdsForStatus", TMessageType.REPLY, seqid)
8288 
    result.write(oprot)
8289 
    oprot.writeMessageEnd()
8290 
    oprot.trans.flush()
5031 varun.gupt 8291 
 
5348 anupam.sin 8292 
  def process_updateCODAgent(self, seqid, iprot, oprot):
8293 
    args = updateCODAgent_args()
8294 
    args.read(iprot)
8295 
    iprot.readMessageEnd()
8296 
    result = updateCODAgent_result()
8297 
    try:
8298 
      self._handler.updateCODAgent(args.agent, args.orderId)
8299 
    except TransactionServiceException, ex:
8300 
      result.ex = ex
8301 
    oprot.writeMessageBegin("updateCODAgent", TMessageType.REPLY, seqid)
8302 
    result.write(oprot)
8303 
    oprot.writeMessageEnd()
8304 
    oprot.trans.flush()
8305 
 
5099 varun.gupt 8306 
  def process_updateOrderAsPaidToVendor(self, seqid, iprot, oprot):
8307 
    args = updateOrderAsPaidToVendor_args()
8308 
    args.read(iprot)
8309 
    iprot.readMessageEnd()
8310 
    result = updateOrderAsPaidToVendor_result()
8311 
    try:
8312 
      self._handler.updateOrderAsPaidToVendor(args.orderId)
8313 
    except TransactionServiceException, ex:
8314 
      result.ex = ex
8315 
    oprot.writeMessageBegin("updateOrderAsPaidToVendor", TMessageType.REPLY, seqid)
8316 
    result.write(oprot)
8317 
    oprot.writeMessageEnd()
8318 
    oprot.trans.flush()
5067 varun.gupt 8319 
 
5386 phani.kuma 8320 
  def process_updateOrderOnlyAsPaidToVendor(self, seqid, iprot, oprot):
8321 
    args = updateOrderOnlyAsPaidToVendor_args()
8322 
    args.read(iprot)
8323 
    iprot.readMessageEnd()
8324 
    result = updateOrderOnlyAsPaidToVendor_result()
8325 
    try:
8326 
      self._handler.updateOrderOnlyAsPaidToVendor(args.orderId)
8327 
    except TransactionServiceException, ex:
8328 
      result.ex = ex
8329 
    oprot.writeMessageBegin("updateOrderOnlyAsPaidToVendor", TMessageType.REPLY, seqid)
8330 
    result.write(oprot)
8331 
    oprot.writeMessageEnd()
8332 
    oprot.trans.flush()
8333 
 
5208 varun.gupt 8334 
  def process_getRefundedOrdersMarkedPaid(self, seqid, iprot, oprot):
8335 
    args = getRefundedOrdersMarkedPaid_args()
8336 
    args.read(iprot)
8337 
    iprot.readMessageEnd()
8338 
    result = getRefundedOrdersMarkedPaid_result()
8339 
    try:
8340 
      result.success = self._handler.getRefundedOrdersMarkedPaid()
8341 
    except TransactionServiceException, ex:
8342 
      result.ex = ex
8343 
    oprot.writeMessageBegin("getRefundedOrdersMarkedPaid", TMessageType.REPLY, seqid)
8344 
    result.write(oprot)
8345 
    oprot.writeMessageEnd()
8346 
    oprot.trans.flush()
5099 varun.gupt 8347 
 
5447 anupam.sin 8348 
  def process_getAllVerificationAgents(self, seqid, iprot, oprot):
8349 
    args = getAllVerificationAgents_args()
8350 
    args.read(iprot)
8351 
    iprot.readMessageEnd()
8352 
    result = getAllVerificationAgents_result()
8353 
    result.success = self._handler.getAllVerificationAgents(args.minOrderId, args.maxOrderId)
8354 
    oprot.writeMessageBegin("getAllVerificationAgents", TMessageType.REPLY, seqid)
8355 
    result.write(oprot)
8356 
    oprot.writeMessageEnd()
8357 
    oprot.trans.flush()
5208 varun.gupt 8358 
 
5527 anupam.sin 8359 
  def process_getAllAttributesForOrderId(self, seqid, iprot, oprot):
8360 
    args = getAllAttributesForOrderId_args()
8361 
    args.read(iprot)
8362 
    iprot.readMessageEnd()
8363 
    result = getAllAttributesForOrderId_result()
8364 
    result.success = self._handler.getAllAttributesForOrderId(args.orderId)
8365 
    oprot.writeMessageBegin("getAllAttributesForOrderId", TMessageType.REPLY, seqid)
8366 
    result.write(oprot)
8367 
    oprot.writeMessageEnd()
8368 
    oprot.trans.flush()
5447 anupam.sin 8369 
 
5676 rajveer 8370 
  def process_setOrderAttributes(self, seqid, iprot, oprot):
8371 
    args = setOrderAttributes_args()
8372 
    args.read(iprot)
8373 
    iprot.readMessageEnd()
8374 
    result = setOrderAttributes_result()
8375 
    self._handler.setOrderAttributes(args.orderId, args.attributes)
8376 
    oprot.writeMessageBegin("setOrderAttributes", TMessageType.REPLY, seqid)
8377 
    result.write(oprot)
8378 
    oprot.writeMessageEnd()
8379 
    oprot.trans.flush()
8380 
 
5527 anupam.sin 8381 
  def process_setOrderAttributeForTransaction(self, seqid, iprot, oprot):
8382 
    args = setOrderAttributeForTransaction_args()
8383 
    args.read(iprot)
8384 
    iprot.readMessageEnd()
8385 
    result = setOrderAttributeForTransaction_result()
8386 
    self._handler.setOrderAttributeForTransaction(args.transactionId, args.attribute)
8387 
    oprot.writeMessageBegin("setOrderAttributeForTransaction", TMessageType.REPLY, seqid)
8388 
    result.write(oprot)
8389 
    oprot.writeMessageEnd()
8390 
    oprot.trans.flush()
8391 
 
5553 rajveer 8392 
  def process_getReceivePendingOrders(self, seqid, iprot, oprot):
8393 
    args = getReceivePendingOrders_args()
8394 
    args.read(iprot)
8395 
    iprot.readMessageEnd()
8396 
    result = getReceivePendingOrders_result()
8397 
    result.success = self._handler.getReceivePendingOrders(args.storeId)
8398 
    oprot.writeMessageBegin("getReceivePendingOrders", TMessageType.REPLY, seqid)
8399 
    result.write(oprot)
8400 
    oprot.writeMessageEnd()
8401 
    oprot.trans.flush()
5527 anupam.sin 8402 
 
5553 rajveer 8403 
  def process_getReceivedAtStoreOrders(self, seqid, iprot, oprot):
8404 
    args = getReceivedAtStoreOrders_args()
8405 
    args.read(iprot)
8406 
    iprot.readMessageEnd()
8407 
    result = getReceivedAtStoreOrders_result()
8408 
    result.success = self._handler.getReceivedAtStoreOrders(args.storeId)
8409 
    oprot.writeMessageBegin("getReceivedAtStoreOrders", TMessageType.REPLY, seqid)
8410 
    result.write(oprot)
8411 
    oprot.writeMessageEnd()
8412 
    oprot.trans.flush()
8413 
 
5713 rajveer 8414 
  def process_getOrdersCollectionAtStore(self, seqid, iprot, oprot):
8415 
    args = getOrdersCollectionAtStore_args()
8416 
    args.read(iprot)
8417 
    iprot.readMessageEnd()
8418 
    result = getOrdersCollectionAtStore_result()
8419 
    result.success = self._handler.getOrdersCollectionAtStore(args.storeId, args.fromDate, args.toDate, args.onlyCod)
8420 
    oprot.writeMessageBegin("getOrdersCollectionAtStore", TMessageType.REPLY, seqid)
8421 
    result.write(oprot)
8422 
    oprot.writeMessageEnd()
8423 
    oprot.trans.flush()
8424 
 
5833 rajveer 8425 
  def process_getOrderAttributeValue(self, seqid, iprot, oprot):
8426 
    args = getOrderAttributeValue_args()
8427 
    args.read(iprot)
8428 
    iprot.readMessageEnd()
8429 
    result = getOrderAttributeValue_result()
8430 
    result.success = self._handler.getOrderAttributeValue(args.orderId, args.attributeName)
8431 
    oprot.writeMessageBegin("getOrderAttributeValue", TMessageType.REPLY, seqid)
8432 
    result.write(oprot)
8433 
    oprot.writeMessageEnd()
8434 
    oprot.trans.flush()
8435 
 
6019 rajveer 8436 
  def process_changeJacketNumber(self, seqid, iprot, oprot):
8437 
    args = changeJacketNumber_args()
8438 
    args.read(iprot)
8439 
    iprot.readMessageEnd()
8440 
    result = changeJacketNumber_result()
8441 
    result.success = self._handler.changeJacketNumber(args.orderId, args.jacketNumber)
8442 
    oprot.writeMessageBegin("changeJacketNumber", TMessageType.REPLY, seqid)
8443 
    result.write(oprot)
8444 
    oprot.writeMessageEnd()
8445 
    oprot.trans.flush()
8446 
 
8447 
  def process_markOrderAsRtoInTransit(self, seqid, iprot, oprot):
8448 
    args = markOrderAsRtoInTransit_args()
8449 
    args.read(iprot)
8450 
    iprot.readMessageEnd()
8451 
    result = markOrderAsRtoInTransit_result()
8452 
    result.success = self._handler.markOrderAsRtoInTransit(args.orderId)
8453 
    oprot.writeMessageBegin("markOrderAsRtoInTransit", TMessageType.REPLY, seqid)
8454 
    result.write(oprot)
8455 
    oprot.writeMessageEnd()
8456 
    oprot.trans.flush()
8457 
 
5593 mandeep.dh 8458 
  def process_acceptOrderForItem(self, seqid, iprot, oprot):
8459 
    args = acceptOrderForItem_args()
8460 
    args.read(iprot)
8461 
    iprot.readMessageEnd()
8462 
    result = acceptOrderForItem_result()
8463 
    self._handler.acceptOrderForItem(args.itemId, args.quantity, args.fulfilmentWarehouseId, args.billingWarehouseId)
8464 
    oprot.writeMessageBegin("acceptOrderForItem", TMessageType.REPLY, seqid)
8465 
    result.write(oprot)
8466 
    oprot.writeMessageEnd()
8467 
    oprot.trans.flush()
5553 rajveer 8468 
 
6000 mandeep.dh 8469 
  def process_createRechargeOrder(self, seqid, iprot, oprot):
8470 
    args = createRechargeOrder_args()
8471 
    args.read(iprot)
8472 
    iprot.readMessageEnd()
8473 
    result = createRechargeOrder_result()
8474 
    try:
8475 
      result.success = self._handler.createRechargeOrder(args.rechargeOrder)
8476 
    except TransactionServiceException, ex:
8477 
      result.ex = ex
8478 
    oprot.writeMessageBegin("createRechargeOrder", TMessageType.REPLY, seqid)
8479 
    result.write(oprot)
8480 
    oprot.writeMessageEnd()
8481 
    oprot.trans.flush()
5593 mandeep.dh 8482 
 
6031 rajveer 8483 
  def process_getRechargeOrder(self, seqid, iprot, oprot):
8484 
    args = getRechargeOrder_args()
8485 
    args.read(iprot)
8486 
    iprot.readMessageEnd()
8487 
    result = getRechargeOrder_result()
8488 
    try:
8489 
      result.success = self._handler.getRechargeOrder(args.rechargeRrderId)
8490 
    except TransactionServiceException, ex:
8491 
      result.ex = ex
8492 
    oprot.writeMessageBegin("getRechargeOrder", TMessageType.REPLY, seqid)
8493 
    result.write(oprot)
8494 
    oprot.writeMessageEnd()
8495 
    oprot.trans.flush()
8496 
 
8497 
  def process_getRechargeOrders(self, seqid, iprot, oprot):
8498 
    args = getRechargeOrders_args()
8499 
    args.read(iprot)
8500 
    iprot.readMessageEnd()
8501 
    result = getRechargeOrders_result()
8502 
    result.success = self._handler.getRechargeOrders(args.userId)
8503 
    oprot.writeMessageBegin("getRechargeOrders", TMessageType.REPLY, seqid)
8504 
    result.write(oprot)
8505 
    oprot.writeMessageEnd()
8506 
    oprot.trans.flush()
8507 
 
6000 mandeep.dh 8508 
  def process_updateRechargeOrderStatus(self, seqid, iprot, oprot):
8509 
    args = updateRechargeOrderStatus_args()
8510 
    args.read(iprot)
8511 
    iprot.readMessageEnd()
8512 
    result = updateRechargeOrderStatus_result()
8513 
    try:
6031 rajveer 8514 
      result.success = self._handler.updateRechargeOrderStatus(args.rechargeOrderId, args.rechargeOrderStatus)
6000 mandeep.dh 8515 
    except TransactionServiceException, ex:
8516 
      result.ex = ex
8517 
    oprot.writeMessageBegin("updateRechargeOrderStatus", TMessageType.REPLY, seqid)
8518 
    result.write(oprot)
8519 
    oprot.writeMessageEnd()
8520 
    oprot.trans.flush()
8521 
 
8522 
  def process_activateRechargeTxn(self, seqid, iprot, oprot):
8523 
    args = activateRechargeTxn_args()
8524 
    args.read(iprot)
8525 
    iprot.readMessageEnd()
8526 
    result = activateRechargeTxn_result()
8527 
    try:
6031 rajveer 8528 
      result.success = self._handler.activateRechargeTxn(args.rechargeOrderId)
6000 mandeep.dh 8529 
    except TransactionServiceException, ex:
8530 
      result.ex = ex
8531 
    oprot.writeMessageBegin("activateRechargeTxn", TMessageType.REPLY, seqid)
8532 
    result.write(oprot)
8533 
    oprot.writeMessageEnd()
8534 
    oprot.trans.flush()
8535 
 
6031 rajveer 8536 
  def process_getUserWallet(self, seqid, iprot, oprot):
8537 
    args = getUserWallet_args()
6000 mandeep.dh 8538 
    args.read(iprot)
8539 
    iprot.readMessageEnd()
6031 rajveer 8540 
    result = getUserWallet_result()
8541 
    result.success = self._handler.getUserWallet(args.userId)
8542 
    oprot.writeMessageBegin("getUserWallet", TMessageType.REPLY, seqid)
6000 mandeep.dh 8543 
    result.write(oprot)
8544 
    oprot.writeMessageEnd()
8545 
    oprot.trans.flush()
8546 
 
6031 rajveer 8547 
  def process_getUserWalletHistory(self, seqid, iprot, oprot):
8548 
    args = getUserWalletHistory_args()
6000 mandeep.dh 8549 
    args.read(iprot)
8550 
    iprot.readMessageEnd()
6031 rajveer 8551 
    result = getUserWalletHistory_result()
8552 
    result.success = self._handler.getUserWalletHistory(args.userId)
8553 
    oprot.writeMessageBegin("getUserWalletHistory", TMessageType.REPLY, seqid)
6000 mandeep.dh 8554 
    result.write(oprot)
8555 
    oprot.writeMessageEnd()
8556 
    oprot.trans.flush()
8557 
 
6050 anupam.sin 8558 
  def process_getRechargeOrdersForTransaction(self, seqid, iprot, oprot):
8559 
    args = getRechargeOrdersForTransaction_args()
8560 
    args.read(iprot)
8561 
    iprot.readMessageEnd()
8562 
    result = getRechargeOrdersForTransaction_result()
8563 
    try:
8564 
      result.success = self._handler.getRechargeOrdersForTransaction(args.txnId)
8565 
    except TransactionServiceException, ex:
8566 
      result.ex = ex
8567 
    oprot.writeMessageBegin("getRechargeOrdersForTransaction", TMessageType.REPLY, seqid)
8568 
    result.write(oprot)
8569 
    oprot.writeMessageEnd()
8570 
    oprot.trans.flush()
8571 
 
6048 rajveer 8572 
  def process_getServiceProviders(self, seqid, iprot, oprot):
8573 
    args = getServiceProviders_args()
8574 
    args.read(iprot)
8575 
    iprot.readMessageEnd()
8576 
    result = getServiceProviders_result()
6206 rajveer 8577 
    result.success = self._handler.getServiceProviders(args.rechargeType, args.onlyActive)
6048 rajveer 8578 
    oprot.writeMessageBegin("getServiceProviders", TMessageType.REPLY, seqid)
8579 
    result.write(oprot)
8580 
    oprot.writeMessageEnd()
8581 
    oprot.trans.flush()
6000 mandeep.dh 8582 
 
6048 rajveer 8583 
  def process_getServiceProviderForDevice(self, seqid, iprot, oprot):
8584 
    args = getServiceProviderForDevice_args()
8585 
    args.read(iprot)
8586 
    iprot.readMessageEnd()
8587 
    result = getServiceProviderForDevice_result()
6049 rajveer 8588 
    result.success = self._handler.getServiceProviderForDevice(args.rechargeType, args.deviceNumber)
6048 rajveer 8589 
    oprot.writeMessageBegin("getServiceProviderForDevice", TMessageType.REPLY, seqid)
8590 
    result.write(oprot)
8591 
    oprot.writeMessageEnd()
8592 
    oprot.trans.flush()
8593 
 
6269 rajveer 8594 
  def process_validateRecharge(self, seqid, iprot, oprot):
8595 
    args = validateRecharge_args()
8596 
    args.read(iprot)
8597 
    iprot.readMessageEnd()
8598 
    result = validateRecharge_result()
6591 anupam.sin 8599 
    result.success = self._handler.validateRecharge(args.rechargeType, args.deviceNumber, args.userSelectedProviderId, args.clientAddress)
6269 rajveer 8600 
    oprot.writeMessageBegin("validateRecharge", TMessageType.REPLY, seqid)
8601 
    result.write(oprot)
8602 
    oprot.writeMessageEnd()
8603 
    oprot.trans.flush()
8604 
 
6094 rajveer 8605 
  def process_getRechargeOrdersForDevice(self, seqid, iprot, oprot):
8606 
    args = getRechargeOrdersForDevice_args()
8607 
    args.read(iprot)
8608 
    iprot.readMessageEnd()
8609 
    result = getRechargeOrdersForDevice_result()
8610 
    result.success = self._handler.getRechargeOrdersForDevice(args.deviceNumber)
8611 
    oprot.writeMessageBegin("getRechargeOrdersForDevice", TMessageType.REPLY, seqid)
8612 
    result.write(oprot)
8613 
    oprot.writeMessageEnd()
8614 
    oprot.trans.flush()
6048 rajveer 8615 
 
6094 rajveer 8616 
  def process_addAmountToWallet(self, seqid, iprot, oprot):
8617 
    args = addAmountToWallet_args()
8618 
    args.read(iprot)
8619 
    iprot.readMessageEnd()
8620 
    result = addAmountToWallet_result()
8621 
    self._handler.addAmountToWallet(args.userId, args.orderId, args.amount)
8622 
    oprot.writeMessageBegin("addAmountToWallet", TMessageType.REPLY, seqid)
8623 
    result.write(oprot)
8624 
    oprot.writeMessageEnd()
8625 
    oprot.trans.flush()
8626 
 
6188 rajveer 8627 
  def process_getRechargeStatistics(self, seqid, iprot, oprot):
8628 
    args = getRechargeStatistics_args()
8629 
    args.read(iprot)
8630 
    iprot.readMessageEnd()
8631 
    result = getRechargeStatistics_result()
8632 
    result.success = self._handler.getRechargeStatistics()
8633 
    oprot.writeMessageBegin("getRechargeStatistics", TMessageType.REPLY, seqid)
8634 
    result.write(oprot)
8635 
    oprot.writeMessageEnd()
8636 
    oprot.trans.flush()
8637 
 
6154 rajveer 8638 
  def process_getRechargeOrdersForStatus(self, seqid, iprot, oprot):
8639 
    args = getRechargeOrdersForStatus_args()
8640 
    args.read(iprot)
8641 
    iprot.readMessageEnd()
8642 
    result = getRechargeOrdersForStatus_result()
8643 
    result.success = self._handler.getRechargeOrdersForStatus(args.status)
8644 
    oprot.writeMessageBegin("getRechargeOrdersForStatus", TMessageType.REPLY, seqid)
8645 
    result.write(oprot)
8646 
    oprot.writeMessageEnd()
8647 
    oprot.trans.flush()
6094 rajveer 8648 
 
6159 rajveer 8649 
  def process_getPlansForOperator(self, seqid, iprot, oprot):
8650 
    args = getPlansForOperator_args()
8651 
    args.read(iprot)
8652 
    iprot.readMessageEnd()
8653 
    result = getPlansForOperator_result()
8654 
    result.success = self._handler.getPlansForOperator(args.operatorId)
8655 
    oprot.writeMessageBegin("getPlansForOperator", TMessageType.REPLY, seqid)
8656 
    result.write(oprot)
8657 
    oprot.writeMessageEnd()
8658 
    oprot.trans.flush()
6154 rajveer 8659 
 
6289 anupam.sin 8660 
  def process_getRechargeDenominations(self, seqid, iprot, oprot):
8661 
    args = getRechargeDenominations_args()
8662 
    args.read(iprot)
8663 
    iprot.readMessageEnd()
8664 
    result = getRechargeDenominations_result()
8665 
    try:
6307 anupam.sin 8666 
      result.success = self._handler.getRechargeDenominations(args.operatorId, args.circleCode, args.denominationType)
6289 anupam.sin 8667 
    except TransactionServiceException, ex:
8668 
      result.ex = ex
8669 
    oprot.writeMessageBegin("getRechargeDenominations", TMessageType.REPLY, seqid)
8670 
    result.write(oprot)
8671 
    oprot.writeMessageEnd()
8672 
    oprot.trans.flush()
6159 rajveer 8673 
 
6371 rajveer 8674 
  def process_updateAvailabilityStatus(self, seqid, iprot, oprot):
8675 
    args = updateAvailabilityStatus_args()
8676 
    args.read(iprot)
8677 
    iprot.readMessageEnd()
8678 
    result = updateAvailabilityStatus_result()
8679 
    self._handler.updateAvailabilityStatus(args.operatorId, args.circleId, args.isAvailable)
8680 
    oprot.writeMessageBegin("updateAvailabilityStatus", TMessageType.REPLY, seqid)
8681 
    result.write(oprot)
8682 
    oprot.writeMessageEnd()
8683 
    oprot.trans.flush()
6289 anupam.sin 8684 
 
6389 rajveer 8685 
  def process_getAvailableEmiSchemes(self, seqid, iprot, oprot):
8686 
    args = getAvailableEmiSchemes_args()
8687 
    args.read(iprot)
8688 
    iprot.readMessageEnd()
8689 
    result = getAvailableEmiSchemes_result()
8690 
    result.success = self._handler.getAvailableEmiSchemes()
8691 
    oprot.writeMessageBegin("getAvailableEmiSchemes", TMessageType.REPLY, seqid)
8692 
    result.write(oprot)
8693 
    oprot.writeMessageEnd()
8694 
    oprot.trans.flush()
6371 rajveer 8695 
 
6389 rajveer 8696 
  def process_getMiscCharges(self, seqid, iprot, oprot):
8697 
    args = getMiscCharges_args()
8698 
    args.read(iprot)
8699 
    iprot.readMessageEnd()
8700 
    result = getMiscCharges_result()
8701 
    result.success = self._handler.getMiscCharges(args.transactionId)
8702 
    oprot.writeMessageBegin("getMiscCharges", TMessageType.REPLY, seqid)
8703 
    result.write(oprot)
8704 
    oprot.writeMessageEnd()
8705 
    oprot.trans.flush()
8706 
 
6507 anupam.sin 8707 
  def process_refundRechargeOrder(self, seqid, iprot, oprot):
8708 
    args = refundRechargeOrder_args()
8709 
    args.read(iprot)
8710 
    iprot.readMessageEnd()
8711 
    result = refundRechargeOrder_result()
8712 
    try:
8713 
      result.success = self._handler.refundRechargeOrder(args.rechargeOrderId)
8714 
    except TransactionServiceException, ex:
8715 
      result.ex = ex
8716 
    oprot.writeMessageBegin("refundRechargeOrder", TMessageType.REPLY, seqid)
8717 
    result.write(oprot)
8718 
    oprot.writeMessageEnd()
8719 
    oprot.trans.flush()
6389 rajveer 8720 
 
6821 amar.kumar 8721 
  def process_getPhysicalOrders(self, seqid, iprot, oprot):
8722 
    args = getPhysicalOrders_args()
8723 
    args.read(iprot)
8724 
    iprot.readMessageEnd()
8725 
    result = getPhysicalOrders_result()
8726 
    result.success = self._handler.getPhysicalOrders(args.fromDate, args.toDate)
8727 
    oprot.writeMessageBegin("getPhysicalOrders", TMessageType.REPLY, seqid)
8728 
    result.write(oprot)
8729 
    oprot.writeMessageEnd()
8730 
    oprot.trans.flush()
6507 anupam.sin 8731 
 
6906 rajveer 8732 
  def process_getDocument(self, seqid, iprot, oprot):
8733 
    args = getDocument_args()
8734 
    args.read(iprot)
8735 
    iprot.readMessageEnd()
8736 
    result = getDocument_result()
8737 
    result.success = self._handler.getDocument(args.docType, args.docSource)
8738 
    oprot.writeMessageBegin("getDocument", TMessageType.REPLY, seqid)
8739 
    result.write(oprot)
8740 
    oprot.writeMessageEnd()
8741 
    oprot.trans.flush()
6821 amar.kumar 8742 
 
6906 rajveer 8743 
 
94 ashish 8744 
# HELPER FUNCTIONS AND STRUCTURES
8745 
 
8746 
class createTransaction_args:
8747 
  """
8748 
  Attributes:
8749 
   - transaction
8750 
  """
8751 
 
8752 
  thrift_spec = (
8753 
    None, # 0
8754 
    (1, TType.STRUCT, 'transaction', (Transaction, Transaction.thrift_spec), None, ), # 1
8755 
  )
8756 
 
8757 
  def __init__(self, transaction=None,):
8758 
    self.transaction = transaction
8759 
 
8760 
  def read(self, iprot):
8761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8763 
      return
8764 
    iprot.readStructBegin()
8765 
    while True:
8766 
      (fname, ftype, fid) = iprot.readFieldBegin()
8767 
      if ftype == TType.STOP:
8768 
        break
8769 
      if fid == 1:
8770 
        if ftype == TType.STRUCT:
8771 
          self.transaction = Transaction()
8772 
          self.transaction.read(iprot)
8773 
        else:
8774 
          iprot.skip(ftype)
8775 
      else:
8776 
        iprot.skip(ftype)
8777 
      iprot.readFieldEnd()
8778 
    iprot.readStructEnd()
8779 
 
8780 
  def write(self, oprot):
8781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8783 
      return
8784 
    oprot.writeStructBegin('createTransaction_args')
3431 rajveer 8785 
    if self.transaction is not None:
94 ashish 8786 
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
8787 
      self.transaction.write(oprot)
8788 
      oprot.writeFieldEnd()
8789 
    oprot.writeFieldStop()
8790 
    oprot.writeStructEnd()
8791 
 
3431 rajveer 8792 
  def validate(self):
8793 
    return
8794 
 
8795 
 
94 ashish 8796 
  def __repr__(self):
8797 
    L = ['%s=%r' % (key, value)
8798 
      for key, value in self.__dict__.iteritems()]
8799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8800 
 
8801 
  def __eq__(self, other):
8802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8803 
 
8804 
  def __ne__(self, other):
8805 
    return not (self == other)
8806 
 
8807 
class createTransaction_result:
8808 
  """
8809 
  Attributes:
132 ashish 8810 
   - success
94 ashish 8811 
   - ex
8812 
  """
8813 
 
8814 
  thrift_spec = (
132 ashish 8815 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 8816 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8817 
  )
8818 
 
132 ashish 8819 
  def __init__(self, success=None, ex=None,):
8820 
    self.success = success
94 ashish 8821 
    self.ex = ex
8822 
 
8823 
  def read(self, iprot):
8824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8826 
      return
8827 
    iprot.readStructBegin()
8828 
    while True:
8829 
      (fname, ftype, fid) = iprot.readFieldBegin()
8830 
      if ftype == TType.STOP:
8831 
        break
132 ashish 8832 
      if fid == 0:
8833 
        if ftype == TType.I64:
8834 
          self.success = iprot.readI64();
8835 
        else:
8836 
          iprot.skip(ftype)
8837 
      elif fid == 1:
94 ashish 8838 
        if ftype == TType.STRUCT:
8839 
          self.ex = TransactionServiceException()
8840 
          self.ex.read(iprot)
8841 
        else:
8842 
          iprot.skip(ftype)
8843 
      else:
8844 
        iprot.skip(ftype)
8845 
      iprot.readFieldEnd()
8846 
    iprot.readStructEnd()
8847 
 
8848 
  def write(self, oprot):
8849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8851 
      return
8852 
    oprot.writeStructBegin('createTransaction_result')
3431 rajveer 8853 
    if self.success is not None:
132 ashish 8854 
      oprot.writeFieldBegin('success', TType.I64, 0)
8855 
      oprot.writeI64(self.success)
8856 
      oprot.writeFieldEnd()
3431 rajveer 8857 
    if self.ex is not None:
94 ashish 8858 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8859 
      self.ex.write(oprot)
8860 
      oprot.writeFieldEnd()
8861 
    oprot.writeFieldStop()
8862 
    oprot.writeStructEnd()
8863 
 
3431 rajveer 8864 
  def validate(self):
8865 
    return
8866 
 
8867 
 
94 ashish 8868 
  def __repr__(self):
8869 
    L = ['%s=%r' % (key, value)
8870 
      for key, value in self.__dict__.iteritems()]
8871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8872 
 
8873 
  def __eq__(self, other):
8874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8875 
 
8876 
  def __ne__(self, other):
8877 
    return not (self == other)
8878 
 
8879 
class getTransaction_args:
8880 
  """
8881 
  Attributes:
8882 
   - id
8883 
  """
8884 
 
8885 
  thrift_spec = (
8886 
    None, # 0
8887 
    (1, TType.I64, 'id', None, None, ), # 1
8888 
  )
8889 
 
8890 
  def __init__(self, id=None,):
8891 
    self.id = id
8892 
 
8893 
  def read(self, iprot):
8894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8896 
      return
8897 
    iprot.readStructBegin()
8898 
    while True:
8899 
      (fname, ftype, fid) = iprot.readFieldBegin()
8900 
      if ftype == TType.STOP:
8901 
        break
8902 
      if fid == 1:
8903 
        if ftype == TType.I64:
8904 
          self.id = iprot.readI64();
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('getTransaction_args')
3431 rajveer 8917 
    if self.id is not None:
94 ashish 8918 
      oprot.writeFieldBegin('id', TType.I64, 1)
8919 
      oprot.writeI64(self.id)
8920 
      oprot.writeFieldEnd()
8921 
    oprot.writeFieldStop()
8922 
    oprot.writeStructEnd()
8923 
 
3431 rajveer 8924 
  def validate(self):
8925 
    return
8926 
 
8927 
 
94 ashish 8928 
  def __repr__(self):
8929 
    L = ['%s=%r' % (key, value)
8930 
      for key, value in self.__dict__.iteritems()]
8931 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8932 
 
8933 
  def __eq__(self, other):
8934 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8935 
 
8936 
  def __ne__(self, other):
8937 
    return not (self == other)
8938 
 
8939 
class getTransaction_result:
8940 
  """
8941 
  Attributes:
8942 
   - success
8943 
   - ex
8944 
  """
8945 
 
8946 
  thrift_spec = (
8947 
    (0, TType.STRUCT, 'success', (Transaction, Transaction.thrift_spec), None, ), # 0
8948 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
8949 
  )
8950 
 
8951 
  def __init__(self, success=None, ex=None,):
8952 
    self.success = success
8953 
    self.ex = ex
8954 
 
8955 
  def read(self, iprot):
8956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8958 
      return
8959 
    iprot.readStructBegin()
8960 
    while True:
8961 
      (fname, ftype, fid) = iprot.readFieldBegin()
8962 
      if ftype == TType.STOP:
8963 
        break
8964 
      if fid == 0:
8965 
        if ftype == TType.STRUCT:
8966 
          self.success = Transaction()
8967 
          self.success.read(iprot)
8968 
        else:
8969 
          iprot.skip(ftype)
8970 
      elif fid == 1:
8971 
        if ftype == TType.STRUCT:
8972 
          self.ex = TransactionServiceException()
8973 
          self.ex.read(iprot)
8974 
        else:
8975 
          iprot.skip(ftype)
8976 
      else:
8977 
        iprot.skip(ftype)
8978 
      iprot.readFieldEnd()
8979 
    iprot.readStructEnd()
8980 
 
8981 
  def write(self, oprot):
8982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8984 
      return
8985 
    oprot.writeStructBegin('getTransaction_result')
3431 rajveer 8986 
    if self.success is not None:
94 ashish 8987 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8988 
      self.success.write(oprot)
8989 
      oprot.writeFieldEnd()
3431 rajveer 8990 
    if self.ex is not None:
94 ashish 8991 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
8992 
      self.ex.write(oprot)
8993 
      oprot.writeFieldEnd()
8994 
    oprot.writeFieldStop()
8995 
    oprot.writeStructEnd()
8996 
 
3431 rajveer 8997 
  def validate(self):
8998 
    return
8999 
 
9000 
 
94 ashish 9001 
  def __repr__(self):
9002 
    L = ['%s=%r' % (key, value)
9003 
      for key, value in self.__dict__.iteritems()]
9004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9005 
 
9006 
  def __eq__(self, other):
9007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9008 
 
9009 
  def __ne__(self, other):
9010 
    return not (self == other)
9011 
 
9012 
class getTransactionsForCustomer_args:
9013 
  """
9014 
  Attributes:
9015 
   - customerId
9016 
   - from_date
9017 
   - to_date
9018 
   - status
9019 
  """
9020 
 
9021 
  thrift_spec = (
9022 
    None, # 0
9023 
    (1, TType.I64, 'customerId', None, None, ), # 1
9024 
    (2, TType.I64, 'from_date', None, None, ), # 2
9025 
    (3, TType.I64, 'to_date', None, None, ), # 3
9026 
    (4, TType.I32, 'status', None, None, ), # 4
9027 
  )
9028 
 
9029 
  def __init__(self, customerId=None, from_date=None, to_date=None, status=None,):
9030 
    self.customerId = customerId
9031 
    self.from_date = from_date
9032 
    self.to_date = to_date
9033 
    self.status = status
9034 
 
9035 
  def read(self, iprot):
9036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9038 
      return
9039 
    iprot.readStructBegin()
9040 
    while True:
9041 
      (fname, ftype, fid) = iprot.readFieldBegin()
9042 
      if ftype == TType.STOP:
9043 
        break
9044 
      if fid == 1:
9045 
        if ftype == TType.I64:
9046 
          self.customerId = iprot.readI64();
9047 
        else:
9048 
          iprot.skip(ftype)
9049 
      elif fid == 2:
9050 
        if ftype == TType.I64:
9051 
          self.from_date = iprot.readI64();
9052 
        else:
9053 
          iprot.skip(ftype)
9054 
      elif fid == 3:
9055 
        if ftype == TType.I64:
9056 
          self.to_date = iprot.readI64();
9057 
        else:
9058 
          iprot.skip(ftype)
9059 
      elif fid == 4:
9060 
        if ftype == TType.I32:
9061 
          self.status = iprot.readI32();
9062 
        else:
9063 
          iprot.skip(ftype)
9064 
      else:
9065 
        iprot.skip(ftype)
9066 
      iprot.readFieldEnd()
9067 
    iprot.readStructEnd()
9068 
 
9069 
  def write(self, oprot):
9070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9072 
      return
9073 
    oprot.writeStructBegin('getTransactionsForCustomer_args')
3431 rajveer 9074 
    if self.customerId is not None:
94 ashish 9075 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
9076 
      oprot.writeI64(self.customerId)
9077 
      oprot.writeFieldEnd()
3431 rajveer 9078 
    if self.from_date is not None:
94 ashish 9079 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9080 
      oprot.writeI64(self.from_date)
9081 
      oprot.writeFieldEnd()
3431 rajveer 9082 
    if self.to_date is not None:
94 ashish 9083 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9084 
      oprot.writeI64(self.to_date)
9085 
      oprot.writeFieldEnd()
3431 rajveer 9086 
    if self.status is not None:
94 ashish 9087 
      oprot.writeFieldBegin('status', TType.I32, 4)
9088 
      oprot.writeI32(self.status)
9089 
      oprot.writeFieldEnd()
9090 
    oprot.writeFieldStop()
9091 
    oprot.writeStructEnd()
9092 
 
3431 rajveer 9093 
  def validate(self):
9094 
    return
9095 
 
9096 
 
94 ashish 9097 
  def __repr__(self):
9098 
    L = ['%s=%r' % (key, value)
9099 
      for key, value in self.__dict__.iteritems()]
9100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9101 
 
9102 
  def __eq__(self, other):
9103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9104 
 
9105 
  def __ne__(self, other):
9106 
    return not (self == other)
9107 
 
9108 
class getTransactionsForCustomer_result:
9109 
  """
9110 
  Attributes:
9111 
   - success
9112 
   - ex
9113 
  """
9114 
 
9115 
  thrift_spec = (
9116 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9117 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9118 
  )
9119 
 
9120 
  def __init__(self, success=None, ex=None,):
9121 
    self.success = success
9122 
    self.ex = ex
9123 
 
9124 
  def read(self, iprot):
9125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9127 
      return
9128 
    iprot.readStructBegin()
9129 
    while True:
9130 
      (fname, ftype, fid) = iprot.readFieldBegin()
9131 
      if ftype == TType.STOP:
9132 
        break
9133 
      if fid == 0:
9134 
        if ftype == TType.LIST:
9135 
          self.success = []
6188 rajveer 9136 
          (_etype109, _size106) = iprot.readListBegin()
9137 
          for _i110 in xrange(_size106):
9138 
            _elem111 = Transaction()
9139 
            _elem111.read(iprot)
9140 
            self.success.append(_elem111)
94 ashish 9141 
          iprot.readListEnd()
9142 
        else:
9143 
          iprot.skip(ftype)
9144 
      elif fid == 1:
9145 
        if ftype == TType.STRUCT:
9146 
          self.ex = TransactionServiceException()
9147 
          self.ex.read(iprot)
9148 
        else:
9149 
          iprot.skip(ftype)
9150 
      else:
9151 
        iprot.skip(ftype)
9152 
      iprot.readFieldEnd()
9153 
    iprot.readStructEnd()
9154 
 
9155 
  def write(self, oprot):
9156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9158 
      return
9159 
    oprot.writeStructBegin('getTransactionsForCustomer_result')
3431 rajveer 9160 
    if self.success is not None:
94 ashish 9161 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9162 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9163 
      for iter112 in self.success:
9164 
        iter112.write(oprot)
94 ashish 9165 
      oprot.writeListEnd()
9166 
      oprot.writeFieldEnd()
3431 rajveer 9167 
    if self.ex is not None:
94 ashish 9168 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9169 
      self.ex.write(oprot)
9170 
      oprot.writeFieldEnd()
9171 
    oprot.writeFieldStop()
9172 
    oprot.writeStructEnd()
9173 
 
3431 rajveer 9174 
  def validate(self):
9175 
    return
9176 
 
9177 
 
94 ashish 9178 
  def __repr__(self):
9179 
    L = ['%s=%r' % (key, value)
9180 
      for key, value in self.__dict__.iteritems()]
9181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9182 
 
9183 
  def __eq__(self, other):
9184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9185 
 
9186 
  def __ne__(self, other):
9187 
    return not (self == other)
9188 
 
132 ashish 9189 
class getTransactionsForShoppingCartId_args:
9190 
  """
9191 
  Attributes:
9192 
   - shoppingCartId
9193 
  """
9194 
 
9195 
  thrift_spec = (
9196 
    None, # 0
9197 
    (1, TType.I64, 'shoppingCartId', None, None, ), # 1
9198 
  )
9199 
 
9200 
  def __init__(self, shoppingCartId=None,):
9201 
    self.shoppingCartId = shoppingCartId
9202 
 
9203 
  def read(self, iprot):
9204 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9205 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9206 
      return
9207 
    iprot.readStructBegin()
9208 
    while True:
9209 
      (fname, ftype, fid) = iprot.readFieldBegin()
9210 
      if ftype == TType.STOP:
9211 
        break
9212 
      if fid == 1:
9213 
        if ftype == TType.I64:
9214 
          self.shoppingCartId = iprot.readI64();
9215 
        else:
9216 
          iprot.skip(ftype)
9217 
      else:
9218 
        iprot.skip(ftype)
9219 
      iprot.readFieldEnd()
9220 
    iprot.readStructEnd()
9221 
 
9222 
  def write(self, oprot):
9223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9225 
      return
9226 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_args')
3431 rajveer 9227 
    if self.shoppingCartId is not None:
132 ashish 9228 
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
9229 
      oprot.writeI64(self.shoppingCartId)
9230 
      oprot.writeFieldEnd()
9231 
    oprot.writeFieldStop()
9232 
    oprot.writeStructEnd()
9233 
 
3431 rajveer 9234 
  def validate(self):
9235 
    return
9236 
 
9237 
 
132 ashish 9238 
  def __repr__(self):
9239 
    L = ['%s=%r' % (key, value)
9240 
      for key, value in self.__dict__.iteritems()]
9241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9242 
 
9243 
  def __eq__(self, other):
9244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9245 
 
9246 
  def __ne__(self, other):
9247 
    return not (self == other)
9248 
 
9249 
class getTransactionsForShoppingCartId_result:
9250 
  """
9251 
  Attributes:
9252 
   - success
9253 
   - ex
9254 
  """
9255 
 
9256 
  thrift_spec = (
9257 
    (0, TType.LIST, 'success', (TType.STRUCT,(Transaction, Transaction.thrift_spec)), None, ), # 0
9258 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9259 
  )
9260 
 
9261 
  def __init__(self, success=None, ex=None,):
9262 
    self.success = success
9263 
    self.ex = ex
9264 
 
9265 
  def read(self, iprot):
9266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9268 
      return
9269 
    iprot.readStructBegin()
9270 
    while True:
9271 
      (fname, ftype, fid) = iprot.readFieldBegin()
9272 
      if ftype == TType.STOP:
9273 
        break
9274 
      if fid == 0:
9275 
        if ftype == TType.LIST:
9276 
          self.success = []
6188 rajveer 9277 
          (_etype116, _size113) = iprot.readListBegin()
9278 
          for _i117 in xrange(_size113):
9279 
            _elem118 = Transaction()
9280 
            _elem118.read(iprot)
9281 
            self.success.append(_elem118)
132 ashish 9282 
          iprot.readListEnd()
9283 
        else:
9284 
          iprot.skip(ftype)
9285 
      elif fid == 1:
9286 
        if ftype == TType.STRUCT:
9287 
          self.ex = TransactionServiceException()
9288 
          self.ex.read(iprot)
9289 
        else:
9290 
          iprot.skip(ftype)
9291 
      else:
9292 
        iprot.skip(ftype)
9293 
      iprot.readFieldEnd()
9294 
    iprot.readStructEnd()
9295 
 
9296 
  def write(self, oprot):
9297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9299 
      return
9300 
    oprot.writeStructBegin('getTransactionsForShoppingCartId_result')
3431 rajveer 9301 
    if self.success is not None:
132 ashish 9302 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9303 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9304 
      for iter119 in self.success:
9305 
        iter119.write(oprot)
132 ashish 9306 
      oprot.writeListEnd()
9307 
      oprot.writeFieldEnd()
3431 rajveer 9308 
    if self.ex is not None:
132 ashish 9309 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9310 
      self.ex.write(oprot)
9311 
      oprot.writeFieldEnd()
9312 
    oprot.writeFieldStop()
9313 
    oprot.writeStructEnd()
9314 
 
3431 rajveer 9315 
  def validate(self):
9316 
    return
9317 
 
9318 
 
132 ashish 9319 
  def __repr__(self):
9320 
    L = ['%s=%r' % (key, value)
9321 
      for key, value in self.__dict__.iteritems()]
9322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9323 
 
9324 
  def __eq__(self, other):
9325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9326 
 
9327 
  def __ne__(self, other):
9328 
    return not (self == other)
9329 
 
94 ashish 9330 
class getTransactionStatus_args:
9331 
  """
9332 
  Attributes:
9333 
   - transactionId
9334 
  """
9335 
 
9336 
  thrift_spec = (
9337 
    None, # 0
9338 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9339 
  )
9340 
 
9341 
  def __init__(self, transactionId=None,):
9342 
    self.transactionId = transactionId
9343 
 
9344 
  def read(self, iprot):
9345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9347 
      return
9348 
    iprot.readStructBegin()
9349 
    while True:
9350 
      (fname, ftype, fid) = iprot.readFieldBegin()
9351 
      if ftype == TType.STOP:
9352 
        break
9353 
      if fid == 1:
9354 
        if ftype == TType.I64:
9355 
          self.transactionId = iprot.readI64();
9356 
        else:
9357 
          iprot.skip(ftype)
9358 
      else:
9359 
        iprot.skip(ftype)
9360 
      iprot.readFieldEnd()
9361 
    iprot.readStructEnd()
9362 
 
9363 
  def write(self, oprot):
9364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9366 
      return
9367 
    oprot.writeStructBegin('getTransactionStatus_args')
3431 rajveer 9368 
    if self.transactionId is not None:
94 ashish 9369 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9370 
      oprot.writeI64(self.transactionId)
9371 
      oprot.writeFieldEnd()
9372 
    oprot.writeFieldStop()
9373 
    oprot.writeStructEnd()
9374 
 
3431 rajveer 9375 
  def validate(self):
9376 
    return
9377 
 
9378 
 
94 ashish 9379 
  def __repr__(self):
9380 
    L = ['%s=%r' % (key, value)
9381 
      for key, value in self.__dict__.iteritems()]
9382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9383 
 
9384 
  def __eq__(self, other):
9385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9386 
 
9387 
  def __ne__(self, other):
9388 
    return not (self == other)
9389 
 
9390 
class getTransactionStatus_result:
9391 
  """
9392 
  Attributes:
9393 
   - success
9394 
   - ex
9395 
  """
9396 
 
9397 
  thrift_spec = (
9398 
    (0, TType.I32, 'success', None, None, ), # 0
9399 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9400 
  )
9401 
 
9402 
  def __init__(self, success=None, ex=None,):
9403 
    self.success = success
9404 
    self.ex = ex
9405 
 
9406 
  def read(self, iprot):
9407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9409 
      return
9410 
    iprot.readStructBegin()
9411 
    while True:
9412 
      (fname, ftype, fid) = iprot.readFieldBegin()
9413 
      if ftype == TType.STOP:
9414 
        break
9415 
      if fid == 0:
9416 
        if ftype == TType.I32:
9417 
          self.success = iprot.readI32();
9418 
        else:
9419 
          iprot.skip(ftype)
9420 
      elif fid == 1:
9421 
        if ftype == TType.STRUCT:
9422 
          self.ex = TransactionServiceException()
9423 
          self.ex.read(iprot)
9424 
        else:
9425 
          iprot.skip(ftype)
9426 
      else:
9427 
        iprot.skip(ftype)
9428 
      iprot.readFieldEnd()
9429 
    iprot.readStructEnd()
9430 
 
9431 
  def write(self, oprot):
9432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9434 
      return
9435 
    oprot.writeStructBegin('getTransactionStatus_result')
3431 rajveer 9436 
    if self.success is not None:
94 ashish 9437 
      oprot.writeFieldBegin('success', TType.I32, 0)
9438 
      oprot.writeI32(self.success)
9439 
      oprot.writeFieldEnd()
3431 rajveer 9440 
    if self.ex is not None:
94 ashish 9441 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9442 
      self.ex.write(oprot)
9443 
      oprot.writeFieldEnd()
9444 
    oprot.writeFieldStop()
9445 
    oprot.writeStructEnd()
9446 
 
3431 rajveer 9447 
  def validate(self):
9448 
    return
9449 
 
9450 
 
94 ashish 9451 
  def __repr__(self):
9452 
    L = ['%s=%r' % (key, value)
9453 
      for key, value in self.__dict__.iteritems()]
9454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9455 
 
9456 
  def __eq__(self, other):
9457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9458 
 
9459 
  def __ne__(self, other):
9460 
    return not (self == other)
9461 
 
9462 
class changeTransactionStatus_args:
9463 
  """
9464 
  Attributes:
9465 
   - transactionId
9466 
   - status
9467 
   - description
5527 anupam.sin 9468 
   - pickUp
9469 
   - orderType
94 ashish 9470 
  """
9471 
 
9472 
  thrift_spec = (
9473 
    None, # 0
9474 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9475 
    (2, TType.I32, 'status', None, None, ), # 2
9476 
    (3, TType.STRING, 'description', None, None, ), # 3
5527 anupam.sin 9477 
    (4, TType.I64, 'pickUp', None, None, ), # 4
9478 
    (5, TType.I32, 'orderType', None, None, ), # 5
94 ashish 9479 
  )
9480 
 
5527 anupam.sin 9481 
  def __init__(self, transactionId=None, status=None, description=None, pickUp=None, orderType=None,):
94 ashish 9482 
    self.transactionId = transactionId
9483 
    self.status = status
9484 
    self.description = description
5527 anupam.sin 9485 
    self.pickUp = pickUp
9486 
    self.orderType = orderType
94 ashish 9487 
 
9488 
  def read(self, iprot):
9489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9491 
      return
9492 
    iprot.readStructBegin()
9493 
    while True:
9494 
      (fname, ftype, fid) = iprot.readFieldBegin()
9495 
      if ftype == TType.STOP:
9496 
        break
9497 
      if fid == 1:
9498 
        if ftype == TType.I64:
9499 
          self.transactionId = iprot.readI64();
9500 
        else:
9501 
          iprot.skip(ftype)
9502 
      elif fid == 2:
9503 
        if ftype == TType.I32:
9504 
          self.status = iprot.readI32();
9505 
        else:
9506 
          iprot.skip(ftype)
9507 
      elif fid == 3:
9508 
        if ftype == TType.STRING:
9509 
          self.description = iprot.readString();
9510 
        else:
9511 
          iprot.skip(ftype)
5387 rajveer 9512 
      elif fid == 4:
5527 anupam.sin 9513 
        if ftype == TType.I64:
9514 
          self.pickUp = iprot.readI64();
5387 rajveer 9515 
        else:
9516 
          iprot.skip(ftype)
5527 anupam.sin 9517 
      elif fid == 5:
9518 
        if ftype == TType.I32:
9519 
          self.orderType = iprot.readI32();
9520 
        else:
9521 
          iprot.skip(ftype)
94 ashish 9522 
      else:
9523 
        iprot.skip(ftype)
9524 
      iprot.readFieldEnd()
9525 
    iprot.readStructEnd()
9526 
 
9527 
  def write(self, oprot):
9528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9530 
      return
9531 
    oprot.writeStructBegin('changeTransactionStatus_args')
3431 rajveer 9532 
    if self.transactionId is not None:
94 ashish 9533 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9534 
      oprot.writeI64(self.transactionId)
9535 
      oprot.writeFieldEnd()
3431 rajveer 9536 
    if self.status is not None:
94 ashish 9537 
      oprot.writeFieldBegin('status', TType.I32, 2)
9538 
      oprot.writeI32(self.status)
9539 
      oprot.writeFieldEnd()
3431 rajveer 9540 
    if self.description is not None:
94 ashish 9541 
      oprot.writeFieldBegin('description', TType.STRING, 3)
9542 
      oprot.writeString(self.description)
9543 
      oprot.writeFieldEnd()
5527 anupam.sin 9544 
    if self.pickUp is not None:
9545 
      oprot.writeFieldBegin('pickUp', TType.I64, 4)
9546 
      oprot.writeI64(self.pickUp)
5387 rajveer 9547 
      oprot.writeFieldEnd()
5527 anupam.sin 9548 
    if self.orderType is not None:
9549 
      oprot.writeFieldBegin('orderType', TType.I32, 5)
9550 
      oprot.writeI32(self.orderType)
9551 
      oprot.writeFieldEnd()
94 ashish 9552 
    oprot.writeFieldStop()
9553 
    oprot.writeStructEnd()
9554 
 
3431 rajveer 9555 
  def validate(self):
9556 
    return
9557 
 
9558 
 
94 ashish 9559 
  def __repr__(self):
9560 
    L = ['%s=%r' % (key, value)
9561 
      for key, value in self.__dict__.iteritems()]
9562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9563 
 
9564 
  def __eq__(self, other):
9565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9566 
 
9567 
  def __ne__(self, other):
9568 
    return not (self == other)
9569 
 
9570 
class changeTransactionStatus_result:
9571 
  """
9572 
  Attributes:
9573 
   - success
9574 
   - ex
9575 
  """
9576 
 
9577 
  thrift_spec = (
9578 
    (0, TType.BOOL, 'success', None, None, ), # 0
9579 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9580 
  )
9581 
 
9582 
  def __init__(self, success=None, ex=None,):
9583 
    self.success = success
9584 
    self.ex = ex
9585 
 
9586 
  def read(self, iprot):
9587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9589 
      return
9590 
    iprot.readStructBegin()
9591 
    while True:
9592 
      (fname, ftype, fid) = iprot.readFieldBegin()
9593 
      if ftype == TType.STOP:
9594 
        break
9595 
      if fid == 0:
9596 
        if ftype == TType.BOOL:
9597 
          self.success = iprot.readBool();
9598 
        else:
9599 
          iprot.skip(ftype)
9600 
      elif fid == 1:
9601 
        if ftype == TType.STRUCT:
9602 
          self.ex = TransactionServiceException()
9603 
          self.ex.read(iprot)
9604 
        else:
9605 
          iprot.skip(ftype)
9606 
      else:
9607 
        iprot.skip(ftype)
9608 
      iprot.readFieldEnd()
9609 
    iprot.readStructEnd()
9610 
 
9611 
  def write(self, oprot):
9612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9614 
      return
9615 
    oprot.writeStructBegin('changeTransactionStatus_result')
3431 rajveer 9616 
    if self.success is not None:
94 ashish 9617 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9618 
      oprot.writeBool(self.success)
9619 
      oprot.writeFieldEnd()
3431 rajveer 9620 
    if self.ex is not None:
94 ashish 9621 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9622 
      self.ex.write(oprot)
9623 
      oprot.writeFieldEnd()
9624 
    oprot.writeFieldStop()
9625 
    oprot.writeStructEnd()
9626 
 
3431 rajveer 9627 
  def validate(self):
9628 
    return
9629 
 
9630 
 
94 ashish 9631 
  def __repr__(self):
9632 
    L = ['%s=%r' % (key, value)
9633 
      for key, value in self.__dict__.iteritems()]
9634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9635 
 
9636 
  def __eq__(self, other):
9637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9638 
 
9639 
  def __ne__(self, other):
9640 
    return not (self == other)
9641 
 
1398 varun.gupt 9642 
class enqueueTransactionInfoEmail_args:
1382 varun.gupt 9643 
  """
9644 
  Attributes:
9645 
   - transactionId
9646 
  """
9647 
 
9648 
  thrift_spec = (
9649 
    None, # 0
9650 
    (1, TType.I64, 'transactionId', None, None, ), # 1
9651 
  )
9652 
 
9653 
  def __init__(self, transactionId=None,):
9654 
    self.transactionId = transactionId
9655 
 
9656 
  def read(self, iprot):
9657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9659 
      return
9660 
    iprot.readStructBegin()
9661 
    while True:
9662 
      (fname, ftype, fid) = iprot.readFieldBegin()
9663 
      if ftype == TType.STOP:
9664 
        break
9665 
      if fid == 1:
9666 
        if ftype == TType.I64:
9667 
          self.transactionId = iprot.readI64();
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
1398 varun.gupt 9679 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_args')
3431 rajveer 9680 
    if self.transactionId is not None:
1382 varun.gupt 9681 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
9682 
      oprot.writeI64(self.transactionId)
9683 
      oprot.writeFieldEnd()
9684 
    oprot.writeFieldStop()
9685 
    oprot.writeStructEnd()
9686 
 
3431 rajveer 9687 
  def validate(self):
9688 
    return
9689 
 
9690 
 
1382 varun.gupt 9691 
  def __repr__(self):
9692 
    L = ['%s=%r' % (key, value)
9693 
      for key, value in self.__dict__.iteritems()]
9694 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9695 
 
9696 
  def __eq__(self, other):
9697 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9698 
 
9699 
  def __ne__(self, other):
9700 
    return not (self == other)
9701 
 
1398 varun.gupt 9702 
class enqueueTransactionInfoEmail_result:
1382 varun.gupt 9703 
  """
9704 
  Attributes:
9705 
   - success
9706 
   - ex
9707 
  """
9708 
 
9709 
  thrift_spec = (
9710 
    (0, TType.BOOL, 'success', None, None, ), # 0
9711 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9712 
  )
9713 
 
9714 
  def __init__(self, success=None, ex=None,):
9715 
    self.success = success
9716 
    self.ex = ex
9717 
 
9718 
  def read(self, iprot):
9719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9721 
      return
9722 
    iprot.readStructBegin()
9723 
    while True:
9724 
      (fname, ftype, fid) = iprot.readFieldBegin()
9725 
      if ftype == TType.STOP:
9726 
        break
9727 
      if fid == 0:
9728 
        if ftype == TType.BOOL:
9729 
          self.success = iprot.readBool();
9730 
        else:
9731 
          iprot.skip(ftype)
9732 
      elif fid == 1:
9733 
        if ftype == TType.STRUCT:
9734 
          self.ex = TransactionServiceException()
9735 
          self.ex.read(iprot)
9736 
        else:
9737 
          iprot.skip(ftype)
9738 
      else:
9739 
        iprot.skip(ftype)
9740 
      iprot.readFieldEnd()
9741 
    iprot.readStructEnd()
9742 
 
9743 
  def write(self, oprot):
9744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9746 
      return
1398 varun.gupt 9747 
    oprot.writeStructBegin('enqueueTransactionInfoEmail_result')
3431 rajveer 9748 
    if self.success is not None:
1382 varun.gupt 9749 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
9750 
      oprot.writeBool(self.success)
9751 
      oprot.writeFieldEnd()
3431 rajveer 9752 
    if self.ex is not None:
1382 varun.gupt 9753 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9754 
      self.ex.write(oprot)
9755 
      oprot.writeFieldEnd()
9756 
    oprot.writeFieldStop()
9757 
    oprot.writeStructEnd()
9758 
 
3431 rajveer 9759 
  def validate(self):
9760 
    return
9761 
 
9762 
 
1382 varun.gupt 9763 
  def __repr__(self):
9764 
    L = ['%s=%r' % (key, value)
9765 
      for key, value in self.__dict__.iteritems()]
9766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9767 
 
9768 
  def __eq__(self, other):
9769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9770 
 
9771 
  def __ne__(self, other):
9772 
    return not (self == other)
9773 
 
483 rajveer 9774 
class getAllOrders_args:
94 ashish 9775 
  """
9776 
  Attributes:
4801 anupam.sin 9777 
   - statuses
483 rajveer 9778 
   - from_date
9779 
   - to_date
9780 
   - warehouse_id
94 ashish 9781 
  """
9782 
 
9783 
  thrift_spec = (
9784 
    None, # 0
4801 anupam.sin 9785 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
483 rajveer 9786 
    (2, TType.I64, 'from_date', None, None, ), # 2
9787 
    (3, TType.I64, 'to_date', None, None, ), # 3
9788 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
94 ashish 9789 
  )
9790 
 
4801 anupam.sin 9791 
  def __init__(self, statuses=None, from_date=None, to_date=None, warehouse_id=None,):
9792 
    self.statuses = statuses
483 rajveer 9793 
    self.from_date = from_date
9794 
    self.to_date = to_date
9795 
    self.warehouse_id = warehouse_id
94 ashish 9796 
 
9797 
  def read(self, iprot):
9798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9800 
      return
9801 
    iprot.readStructBegin()
9802 
    while True:
9803 
      (fname, ftype, fid) = iprot.readFieldBegin()
9804 
      if ftype == TType.STOP:
9805 
        break
9806 
      if fid == 1:
4801 anupam.sin 9807 
        if ftype == TType.LIST:
9808 
          self.statuses = []
6188 rajveer 9809 
          (_etype123, _size120) = iprot.readListBegin()
9810 
          for _i124 in xrange(_size120):
9811 
            _elem125 = iprot.readI32();
9812 
            self.statuses.append(_elem125)
4801 anupam.sin 9813 
          iprot.readListEnd()
94 ashish 9814 
        else:
9815 
          iprot.skip(ftype)
483 rajveer 9816 
      elif fid == 2:
9817 
        if ftype == TType.I64:
9818 
          self.from_date = iprot.readI64();
94 ashish 9819 
        else:
9820 
          iprot.skip(ftype)
483 rajveer 9821 
      elif fid == 3:
9822 
        if ftype == TType.I64:
9823 
          self.to_date = iprot.readI64();
94 ashish 9824 
        else:
9825 
          iprot.skip(ftype)
483 rajveer 9826 
      elif fid == 4:
94 ashish 9827 
        if ftype == TType.I64:
483 rajveer 9828 
          self.warehouse_id = iprot.readI64();
94 ashish 9829 
        else:
9830 
          iprot.skip(ftype)
9831 
      else:
9832 
        iprot.skip(ftype)
9833 
      iprot.readFieldEnd()
9834 
    iprot.readStructEnd()
9835 
 
9836 
  def write(self, oprot):
9837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9839 
      return
483 rajveer 9840 
    oprot.writeStructBegin('getAllOrders_args')
4801 anupam.sin 9841 
    if self.statuses is not None:
9842 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
9843 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 9844 
      for iter126 in self.statuses:
9845 
        oprot.writeI32(iter126)
4801 anupam.sin 9846 
      oprot.writeListEnd()
94 ashish 9847 
      oprot.writeFieldEnd()
3431 rajveer 9848 
    if self.from_date is not None:
483 rajveer 9849 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
9850 
      oprot.writeI64(self.from_date)
94 ashish 9851 
      oprot.writeFieldEnd()
3431 rajveer 9852 
    if self.to_date is not None:
483 rajveer 9853 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
9854 
      oprot.writeI64(self.to_date)
94 ashish 9855 
      oprot.writeFieldEnd()
3431 rajveer 9856 
    if self.warehouse_id is not None:
483 rajveer 9857 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
9858 
      oprot.writeI64(self.warehouse_id)
94 ashish 9859 
      oprot.writeFieldEnd()
9860 
    oprot.writeFieldStop()
9861 
    oprot.writeStructEnd()
9862 
 
3431 rajveer 9863 
  def validate(self):
9864 
    return
9865 
 
9866 
 
94 ashish 9867 
  def __repr__(self):
9868 
    L = ['%s=%r' % (key, value)
9869 
      for key, value in self.__dict__.iteritems()]
9870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9871 
 
9872 
  def __eq__(self, other):
9873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9874 
 
9875 
  def __ne__(self, other):
9876 
    return not (self == other)
9877 
 
483 rajveer 9878 
class getAllOrders_result:
94 ashish 9879 
  """
9880 
  Attributes:
9881 
   - success
9882 
   - ex
9883 
  """
9884 
 
9885 
  thrift_spec = (
483 rajveer 9886 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
94 ashish 9887 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
9888 
  )
9889 
 
9890 
  def __init__(self, success=None, ex=None,):
9891 
    self.success = success
9892 
    self.ex = ex
9893 
 
9894 
  def read(self, iprot):
9895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9897 
      return
9898 
    iprot.readStructBegin()
9899 
    while True:
9900 
      (fname, ftype, fid) = iprot.readFieldBegin()
9901 
      if ftype == TType.STOP:
9902 
        break
9903 
      if fid == 0:
483 rajveer 9904 
        if ftype == TType.LIST:
9905 
          self.success = []
6188 rajveer 9906 
          (_etype130, _size127) = iprot.readListBegin()
9907 
          for _i131 in xrange(_size127):
9908 
            _elem132 = Order()
9909 
            _elem132.read(iprot)
9910 
            self.success.append(_elem132)
483 rajveer 9911 
          iprot.readListEnd()
94 ashish 9912 
        else:
9913 
          iprot.skip(ftype)
9914 
      elif fid == 1:
9915 
        if ftype == TType.STRUCT:
9916 
          self.ex = TransactionServiceException()
9917 
          self.ex.read(iprot)
9918 
        else:
9919 
          iprot.skip(ftype)
9920 
      else:
9921 
        iprot.skip(ftype)
9922 
      iprot.readFieldEnd()
9923 
    iprot.readStructEnd()
9924 
 
9925 
  def write(self, oprot):
9926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9928 
      return
483 rajveer 9929 
    oprot.writeStructBegin('getAllOrders_result')
3431 rajveer 9930 
    if self.success is not None:
483 rajveer 9931 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9932 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 9933 
      for iter133 in self.success:
9934 
        iter133.write(oprot)
483 rajveer 9935 
      oprot.writeListEnd()
94 ashish 9936 
      oprot.writeFieldEnd()
3431 rajveer 9937 
    if self.ex is not None:
94 ashish 9938 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
9939 
      self.ex.write(oprot)
9940 
      oprot.writeFieldEnd()
9941 
    oprot.writeFieldStop()
9942 
    oprot.writeStructEnd()
9943 
 
3431 rajveer 9944 
  def validate(self):
9945 
    return
9946 
 
9947 
 
94 ashish 9948 
  def __repr__(self):
9949 
    L = ['%s=%r' % (key, value)
9950 
      for key, value in self.__dict__.iteritems()]
9951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9952 
 
9953 
  def __eq__(self, other):
9954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9955 
 
9956 
  def __ne__(self, other):
9957 
    return not (self == other)
9958 
 
4133 chandransh 9959 
class getOrdersInBatch_args:
9960 
  """
9961 
  Attributes:
9962 
   - statuses
9963 
   - offset
9964 
   - limit
9965 
   - warehouse_id
9966 
  """
9967 
 
9968 
  thrift_spec = (
9969 
    None, # 0
9970 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
9971 
    (2, TType.I64, 'offset', None, None, ), # 2
9972 
    (3, TType.I64, 'limit', None, None, ), # 3
9973 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
9974 
  )
9975 
 
9976 
  def __init__(self, statuses=None, offset=None, limit=None, warehouse_id=None,):
9977 
    self.statuses = statuses
9978 
    self.offset = offset
9979 
    self.limit = limit
9980 
    self.warehouse_id = warehouse_id
9981 
 
9982 
  def read(self, iprot):
9983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9985 
      return
9986 
    iprot.readStructBegin()
9987 
    while True:
9988 
      (fname, ftype, fid) = iprot.readFieldBegin()
9989 
      if ftype == TType.STOP:
9990 
        break
9991 
      if fid == 1:
9992 
        if ftype == TType.LIST:
9993 
          self.statuses = []
6188 rajveer 9994 
          (_etype137, _size134) = iprot.readListBegin()
9995 
          for _i138 in xrange(_size134):
9996 
            _elem139 = iprot.readI32();
9997 
            self.statuses.append(_elem139)
4133 chandransh 9998 
          iprot.readListEnd()
9999 
        else:
10000 
          iprot.skip(ftype)
10001 
      elif fid == 2:
10002 
        if ftype == TType.I64:
10003 
          self.offset = iprot.readI64();
10004 
        else:
10005 
          iprot.skip(ftype)
10006 
      elif fid == 3:
10007 
        if ftype == TType.I64:
10008 
          self.limit = iprot.readI64();
10009 
        else:
10010 
          iprot.skip(ftype)
10011 
      elif fid == 4:
10012 
        if ftype == TType.I64:
10013 
          self.warehouse_id = iprot.readI64();
10014 
        else:
10015 
          iprot.skip(ftype)
10016 
      else:
10017 
        iprot.skip(ftype)
10018 
      iprot.readFieldEnd()
10019 
    iprot.readStructEnd()
10020 
 
10021 
  def write(self, oprot):
10022 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10023 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10024 
      return
10025 
    oprot.writeStructBegin('getOrdersInBatch_args')
10026 
    if self.statuses is not None:
10027 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10028 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10029 
      for iter140 in self.statuses:
10030 
        oprot.writeI32(iter140)
4133 chandransh 10031 
      oprot.writeListEnd()
10032 
      oprot.writeFieldEnd()
10033 
    if self.offset is not None:
10034 
      oprot.writeFieldBegin('offset', TType.I64, 2)
10035 
      oprot.writeI64(self.offset)
10036 
      oprot.writeFieldEnd()
10037 
    if self.limit is not None:
10038 
      oprot.writeFieldBegin('limit', TType.I64, 3)
10039 
      oprot.writeI64(self.limit)
10040 
      oprot.writeFieldEnd()
10041 
    if self.warehouse_id is not None:
10042 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10043 
      oprot.writeI64(self.warehouse_id)
10044 
      oprot.writeFieldEnd()
10045 
    oprot.writeFieldStop()
10046 
    oprot.writeStructEnd()
10047 
 
10048 
  def validate(self):
10049 
    return
10050 
 
10051 
 
10052 
  def __repr__(self):
10053 
    L = ['%s=%r' % (key, value)
10054 
      for key, value in self.__dict__.iteritems()]
10055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10056 
 
10057 
  def __eq__(self, other):
10058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10059 
 
10060 
  def __ne__(self, other):
10061 
    return not (self == other)
10062 
 
10063 
class getOrdersInBatch_result:
10064 
  """
10065 
  Attributes:
10066 
   - success
10067 
   - ex
10068 
  """
10069 
 
10070 
  thrift_spec = (
10071 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10072 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10073 
  )
10074 
 
10075 
  def __init__(self, success=None, ex=None,):
10076 
    self.success = success
10077 
    self.ex = ex
10078 
 
10079 
  def read(self, iprot):
10080 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10081 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10082 
      return
10083 
    iprot.readStructBegin()
10084 
    while True:
10085 
      (fname, ftype, fid) = iprot.readFieldBegin()
10086 
      if ftype == TType.STOP:
10087 
        break
10088 
      if fid == 0:
10089 
        if ftype == TType.LIST:
10090 
          self.success = []
6188 rajveer 10091 
          (_etype144, _size141) = iprot.readListBegin()
10092 
          for _i145 in xrange(_size141):
10093 
            _elem146 = Order()
10094 
            _elem146.read(iprot)
10095 
            self.success.append(_elem146)
4133 chandransh 10096 
          iprot.readListEnd()
10097 
        else:
10098 
          iprot.skip(ftype)
10099 
      elif fid == 1:
10100 
        if ftype == TType.STRUCT:
10101 
          self.ex = TransactionServiceException()
10102 
          self.ex.read(iprot)
10103 
        else:
10104 
          iprot.skip(ftype)
10105 
      else:
10106 
        iprot.skip(ftype)
10107 
      iprot.readFieldEnd()
10108 
    iprot.readStructEnd()
10109 
 
10110 
  def write(self, oprot):
10111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10113 
      return
10114 
    oprot.writeStructBegin('getOrdersInBatch_result')
10115 
    if self.success is not None:
10116 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10117 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10118 
      for iter147 in self.success:
10119 
        iter147.write(oprot)
4133 chandransh 10120 
      oprot.writeListEnd()
10121 
      oprot.writeFieldEnd()
10122 
    if self.ex is not None:
10123 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10124 
      self.ex.write(oprot)
10125 
      oprot.writeFieldEnd()
10126 
    oprot.writeFieldStop()
10127 
    oprot.writeStructEnd()
10128 
 
10129 
  def validate(self):
10130 
    return
10131 
 
10132 
 
10133 
  def __repr__(self):
10134 
    L = ['%s=%r' % (key, value)
10135 
      for key, value in self.__dict__.iteritems()]
10136 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10137 
 
10138 
  def __eq__(self, other):
10139 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10140 
 
10141 
  def __ne__(self, other):
10142 
    return not (self == other)
10143 
 
10144 
class getOrderCount_args:
10145 
  """
10146 
  Attributes:
10147 
   - statuses
10148 
   - warehouseId
10149 
  """
10150 
 
10151 
  thrift_spec = (
10152 
    None, # 0
10153 
    (1, TType.LIST, 'statuses', (TType.I32,None), None, ), # 1
10154 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
10155 
  )
10156 
 
10157 
  def __init__(self, statuses=None, warehouseId=None,):
10158 
    self.statuses = statuses
10159 
    self.warehouseId = warehouseId
10160 
 
10161 
  def read(self, iprot):
10162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10164 
      return
10165 
    iprot.readStructBegin()
10166 
    while True:
10167 
      (fname, ftype, fid) = iprot.readFieldBegin()
10168 
      if ftype == TType.STOP:
10169 
        break
10170 
      if fid == 1:
10171 
        if ftype == TType.LIST:
10172 
          self.statuses = []
6188 rajveer 10173 
          (_etype151, _size148) = iprot.readListBegin()
10174 
          for _i152 in xrange(_size148):
10175 
            _elem153 = iprot.readI32();
10176 
            self.statuses.append(_elem153)
4133 chandransh 10177 
          iprot.readListEnd()
10178 
        else:
10179 
          iprot.skip(ftype)
10180 
      elif fid == 2:
10181 
        if ftype == TType.I64:
10182 
          self.warehouseId = iprot.readI64();
10183 
        else:
10184 
          iprot.skip(ftype)
10185 
      else:
10186 
        iprot.skip(ftype)
10187 
      iprot.readFieldEnd()
10188 
    iprot.readStructEnd()
10189 
 
10190 
  def write(self, oprot):
10191 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10192 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10193 
      return
10194 
    oprot.writeStructBegin('getOrderCount_args')
10195 
    if self.statuses is not None:
10196 
      oprot.writeFieldBegin('statuses', TType.LIST, 1)
10197 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 10198 
      for iter154 in self.statuses:
10199 
        oprot.writeI32(iter154)
4133 chandransh 10200 
      oprot.writeListEnd()
10201 
      oprot.writeFieldEnd()
10202 
    if self.warehouseId is not None:
10203 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
10204 
      oprot.writeI64(self.warehouseId)
10205 
      oprot.writeFieldEnd()
10206 
    oprot.writeFieldStop()
10207 
    oprot.writeStructEnd()
10208 
 
10209 
  def validate(self):
10210 
    return
10211 
 
10212 
 
10213 
  def __repr__(self):
10214 
    L = ['%s=%r' % (key, value)
10215 
      for key, value in self.__dict__.iteritems()]
10216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10217 
 
10218 
  def __eq__(self, other):
10219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10220 
 
10221 
  def __ne__(self, other):
10222 
    return not (self == other)
10223 
 
10224 
class getOrderCount_result:
10225 
  """
10226 
  Attributes:
10227 
   - success
10228 
   - ex
10229 
  """
10230 
 
10231 
  thrift_spec = (
10232 
    (0, TType.I32, 'success', None, None, ), # 0
10233 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10234 
  )
10235 
 
10236 
  def __init__(self, success=None, ex=None,):
10237 
    self.success = success
10238 
    self.ex = ex
10239 
 
10240 
  def read(self, iprot):
10241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10243 
      return
10244 
    iprot.readStructBegin()
10245 
    while True:
10246 
      (fname, ftype, fid) = iprot.readFieldBegin()
10247 
      if ftype == TType.STOP:
10248 
        break
10249 
      if fid == 0:
10250 
        if ftype == TType.I32:
10251 
          self.success = iprot.readI32();
10252 
        else:
10253 
          iprot.skip(ftype)
10254 
      elif fid == 1:
10255 
        if ftype == TType.STRUCT:
10256 
          self.ex = TransactionServiceException()
10257 
          self.ex.read(iprot)
10258 
        else:
10259 
          iprot.skip(ftype)
10260 
      else:
10261 
        iprot.skip(ftype)
10262 
      iprot.readFieldEnd()
10263 
    iprot.readStructEnd()
10264 
 
10265 
  def write(self, oprot):
10266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10268 
      return
10269 
    oprot.writeStructBegin('getOrderCount_result')
10270 
    if self.success is not None:
10271 
      oprot.writeFieldBegin('success', TType.I32, 0)
10272 
      oprot.writeI32(self.success)
10273 
      oprot.writeFieldEnd()
10274 
    if self.ex is not None:
10275 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10276 
      self.ex.write(oprot)
10277 
      oprot.writeFieldEnd()
10278 
    oprot.writeFieldStop()
10279 
    oprot.writeStructEnd()
10280 
 
10281 
  def validate(self):
10282 
    return
10283 
 
10284 
 
10285 
  def __repr__(self):
10286 
    L = ['%s=%r' % (key, value)
10287 
      for key, value in self.__dict__.iteritems()]
10288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10289 
 
10290 
  def __eq__(self, other):
10291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10292 
 
10293 
  def __ne__(self, other):
10294 
    return not (self == other)
10295 
 
999 varun.gupt 10296 
class getOrdersByBillingDate_args:
10297 
  """
10298 
  Attributes:
10299 
   - status
10300 
   - start_billing_date
10301 
   - end_billing_date
10302 
   - warehouse_id
10303 
  """
10304 
 
10305 
  thrift_spec = (
10306 
    None, # 0
10307 
    (1, TType.I32, 'status', None, None, ), # 1
10308 
    (2, TType.I64, 'start_billing_date', None, None, ), # 2
10309 
    (3, TType.I64, 'end_billing_date', None, None, ), # 3
10310 
    (4, TType.I64, 'warehouse_id', None, None, ), # 4
10311 
  )
10312 
 
10313 
  def __init__(self, status=None, start_billing_date=None, end_billing_date=None, warehouse_id=None,):
10314 
    self.status = status
10315 
    self.start_billing_date = start_billing_date
10316 
    self.end_billing_date = end_billing_date
10317 
    self.warehouse_id = warehouse_id
10318 
 
10319 
  def read(self, iprot):
10320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10322 
      return
10323 
    iprot.readStructBegin()
10324 
    while True:
10325 
      (fname, ftype, fid) = iprot.readFieldBegin()
10326 
      if ftype == TType.STOP:
10327 
        break
10328 
      if fid == 1:
10329 
        if ftype == TType.I32:
10330 
          self.status = iprot.readI32();
10331 
        else:
10332 
          iprot.skip(ftype)
10333 
      elif fid == 2:
10334 
        if ftype == TType.I64:
10335 
          self.start_billing_date = iprot.readI64();
10336 
        else:
10337 
          iprot.skip(ftype)
10338 
      elif fid == 3:
10339 
        if ftype == TType.I64:
10340 
          self.end_billing_date = iprot.readI64();
10341 
        else:
10342 
          iprot.skip(ftype)
10343 
      elif fid == 4:
10344 
        if ftype == TType.I64:
10345 
          self.warehouse_id = iprot.readI64();
10346 
        else:
10347 
          iprot.skip(ftype)
10348 
      else:
10349 
        iprot.skip(ftype)
10350 
      iprot.readFieldEnd()
10351 
    iprot.readStructEnd()
10352 
 
10353 
  def write(self, oprot):
10354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10356 
      return
10357 
    oprot.writeStructBegin('getOrdersByBillingDate_args')
3431 rajveer 10358 
    if self.status is not None:
999 varun.gupt 10359 
      oprot.writeFieldBegin('status', TType.I32, 1)
10360 
      oprot.writeI32(self.status)
10361 
      oprot.writeFieldEnd()
3431 rajveer 10362 
    if self.start_billing_date is not None:
999 varun.gupt 10363 
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
10364 
      oprot.writeI64(self.start_billing_date)
10365 
      oprot.writeFieldEnd()
3431 rajveer 10366 
    if self.end_billing_date is not None:
999 varun.gupt 10367 
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
10368 
      oprot.writeI64(self.end_billing_date)
10369 
      oprot.writeFieldEnd()
3431 rajveer 10370 
    if self.warehouse_id is not None:
999 varun.gupt 10371 
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
10372 
      oprot.writeI64(self.warehouse_id)
10373 
      oprot.writeFieldEnd()
10374 
    oprot.writeFieldStop()
10375 
    oprot.writeStructEnd()
10376 
 
3431 rajveer 10377 
  def validate(self):
10378 
    return
10379 
 
10380 
 
999 varun.gupt 10381 
  def __repr__(self):
10382 
    L = ['%s=%r' % (key, value)
10383 
      for key, value in self.__dict__.iteritems()]
10384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10385 
 
10386 
  def __eq__(self, other):
10387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10388 
 
10389 
  def __ne__(self, other):
10390 
    return not (self == other)
10391 
 
10392 
class getOrdersByBillingDate_result:
10393 
  """
10394 
  Attributes:
10395 
   - success
10396 
   - ex
10397 
  """
10398 
 
10399 
  thrift_spec = (
10400 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10401 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10402 
  )
10403 
 
10404 
  def __init__(self, success=None, ex=None,):
10405 
    self.success = success
10406 
    self.ex = ex
10407 
 
10408 
  def read(self, iprot):
10409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10411 
      return
10412 
    iprot.readStructBegin()
10413 
    while True:
10414 
      (fname, ftype, fid) = iprot.readFieldBegin()
10415 
      if ftype == TType.STOP:
10416 
        break
10417 
      if fid == 0:
10418 
        if ftype == TType.LIST:
10419 
          self.success = []
6188 rajveer 10420 
          (_etype158, _size155) = iprot.readListBegin()
10421 
          for _i159 in xrange(_size155):
10422 
            _elem160 = Order()
10423 
            _elem160.read(iprot)
10424 
            self.success.append(_elem160)
999 varun.gupt 10425 
          iprot.readListEnd()
10426 
        else:
10427 
          iprot.skip(ftype)
10428 
      elif fid == 1:
10429 
        if ftype == TType.STRUCT:
10430 
          self.ex = TransactionServiceException()
10431 
          self.ex.read(iprot)
10432 
        else:
10433 
          iprot.skip(ftype)
10434 
      else:
10435 
        iprot.skip(ftype)
10436 
      iprot.readFieldEnd()
10437 
    iprot.readStructEnd()
10438 
 
10439 
  def write(self, oprot):
10440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10442 
      return
10443 
    oprot.writeStructBegin('getOrdersByBillingDate_result')
3431 rajveer 10444 
    if self.success is not None:
999 varun.gupt 10445 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10446 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10447 
      for iter161 in self.success:
10448 
        iter161.write(oprot)
999 varun.gupt 10449 
      oprot.writeListEnd()
10450 
      oprot.writeFieldEnd()
3431 rajveer 10451 
    if self.ex is not None:
999 varun.gupt 10452 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10453 
      self.ex.write(oprot)
10454 
      oprot.writeFieldEnd()
10455 
    oprot.writeFieldStop()
10456 
    oprot.writeStructEnd()
10457 
 
3431 rajveer 10458 
  def validate(self):
10459 
    return
10460 
 
10461 
 
999 varun.gupt 10462 
  def __repr__(self):
10463 
    L = ['%s=%r' % (key, value)
10464 
      for key, value in self.__dict__.iteritems()]
10465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10466 
 
10467 
  def __eq__(self, other):
10468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10469 
 
10470 
  def __ne__(self, other):
10471 
    return not (self == other)
10472 
 
3427 chandransh 10473 
class getOrdersByShippingDate_args:
10474 
  """
10475 
  Attributes:
10476 
   - fromShippingDate
10477 
   - toShippingDate
10478 
   - providerId
10479 
   - warehouseId
3451 chandransh 10480 
   - cod
3427 chandransh 10481 
  """
10482 
 
10483 
  thrift_spec = (
10484 
    None, # 0
10485 
    (1, TType.I64, 'fromShippingDate', None, None, ), # 1
10486 
    (2, TType.I64, 'toShippingDate', None, None, ), # 2
10487 
    (3, TType.I64, 'providerId', None, None, ), # 3
10488 
    (4, TType.I64, 'warehouseId', None, None, ), # 4
3451 chandransh 10489 
    (5, TType.BOOL, 'cod', None, None, ), # 5
3427 chandransh 10490 
  )
10491 
 
3451 chandransh 10492 
  def __init__(self, fromShippingDate=None, toShippingDate=None, providerId=None, warehouseId=None, cod=None,):
3427 chandransh 10493 
    self.fromShippingDate = fromShippingDate
10494 
    self.toShippingDate = toShippingDate
10495 
    self.providerId = providerId
10496 
    self.warehouseId = warehouseId
3451 chandransh 10497 
    self.cod = cod
3427 chandransh 10498 
 
10499 
  def read(self, iprot):
10500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10502 
      return
10503 
    iprot.readStructBegin()
10504 
    while True:
10505 
      (fname, ftype, fid) = iprot.readFieldBegin()
10506 
      if ftype == TType.STOP:
10507 
        break
10508 
      if fid == 1:
10509 
        if ftype == TType.I64:
10510 
          self.fromShippingDate = iprot.readI64();
10511 
        else:
10512 
          iprot.skip(ftype)
10513 
      elif fid == 2:
10514 
        if ftype == TType.I64:
10515 
          self.toShippingDate = iprot.readI64();
10516 
        else:
10517 
          iprot.skip(ftype)
10518 
      elif fid == 3:
10519 
        if ftype == TType.I64:
10520 
          self.providerId = iprot.readI64();
10521 
        else:
10522 
          iprot.skip(ftype)
10523 
      elif fid == 4:
10524 
        if ftype == TType.I64:
10525 
          self.warehouseId = iprot.readI64();
10526 
        else:
10527 
          iprot.skip(ftype)
3451 chandransh 10528 
      elif fid == 5:
10529 
        if ftype == TType.BOOL:
10530 
          self.cod = iprot.readBool();
10531 
        else:
10532 
          iprot.skip(ftype)
3427 chandransh 10533 
      else:
10534 
        iprot.skip(ftype)
10535 
      iprot.readFieldEnd()
10536 
    iprot.readStructEnd()
10537 
 
10538 
  def write(self, oprot):
10539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10541 
      return
10542 
    oprot.writeStructBegin('getOrdersByShippingDate_args')
3431 rajveer 10543 
    if self.fromShippingDate is not None:
3427 chandransh 10544 
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
10545 
      oprot.writeI64(self.fromShippingDate)
10546 
      oprot.writeFieldEnd()
3431 rajveer 10547 
    if self.toShippingDate is not None:
3427 chandransh 10548 
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
10549 
      oprot.writeI64(self.toShippingDate)
10550 
      oprot.writeFieldEnd()
3431 rajveer 10551 
    if self.providerId is not None:
3427 chandransh 10552 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
10553 
      oprot.writeI64(self.providerId)
10554 
      oprot.writeFieldEnd()
3431 rajveer 10555 
    if self.warehouseId is not None:
3427 chandransh 10556 
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
10557 
      oprot.writeI64(self.warehouseId)
10558 
      oprot.writeFieldEnd()
3451 chandransh 10559 
    if self.cod is not None:
10560 
      oprot.writeFieldBegin('cod', TType.BOOL, 5)
10561 
      oprot.writeBool(self.cod)
10562 
      oprot.writeFieldEnd()
3427 chandransh 10563 
    oprot.writeFieldStop()
10564 
    oprot.writeStructEnd()
10565 
 
3431 rajveer 10566 
  def validate(self):
10567 
    return
10568 
 
10569 
 
3427 chandransh 10570 
  def __repr__(self):
10571 
    L = ['%s=%r' % (key, value)
10572 
      for key, value in self.__dict__.iteritems()]
10573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10574 
 
10575 
  def __eq__(self, other):
10576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10577 
 
10578 
  def __ne__(self, other):
10579 
    return not (self == other)
10580 
 
10581 
class getOrdersByShippingDate_result:
10582 
  """
10583 
  Attributes:
10584 
   - success
10585 
   - ex
10586 
  """
10587 
 
10588 
  thrift_spec = (
10589 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
10590 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10591 
  )
10592 
 
10593 
  def __init__(self, success=None, ex=None,):
10594 
    self.success = success
10595 
    self.ex = ex
10596 
 
10597 
  def read(self, iprot):
10598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10600 
      return
10601 
    iprot.readStructBegin()
10602 
    while True:
10603 
      (fname, ftype, fid) = iprot.readFieldBegin()
10604 
      if ftype == TType.STOP:
10605 
        break
10606 
      if fid == 0:
10607 
        if ftype == TType.LIST:
10608 
          self.success = []
6188 rajveer 10609 
          (_etype165, _size162) = iprot.readListBegin()
10610 
          for _i166 in xrange(_size162):
10611 
            _elem167 = Order()
10612 
            _elem167.read(iprot)
10613 
            self.success.append(_elem167)
3427 chandransh 10614 
          iprot.readListEnd()
10615 
        else:
10616 
          iprot.skip(ftype)
10617 
      elif fid == 1:
10618 
        if ftype == TType.STRUCT:
10619 
          self.ex = TransactionServiceException()
10620 
          self.ex.read(iprot)
10621 
        else:
10622 
          iprot.skip(ftype)
10623 
      else:
10624 
        iprot.skip(ftype)
10625 
      iprot.readFieldEnd()
10626 
    iprot.readStructEnd()
10627 
 
10628 
  def write(self, oprot):
10629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10631 
      return
10632 
    oprot.writeStructBegin('getOrdersByShippingDate_result')
3431 rajveer 10633 
    if self.success is not None:
3427 chandransh 10634 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10635 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 10636 
      for iter168 in self.success:
10637 
        iter168.write(oprot)
3427 chandransh 10638 
      oprot.writeListEnd()
10639 
      oprot.writeFieldEnd()
3431 rajveer 10640 
    if self.ex is not None:
3427 chandransh 10641 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10642 
      self.ex.write(oprot)
10643 
      oprot.writeFieldEnd()
10644 
    oprot.writeFieldStop()
10645 
    oprot.writeStructEnd()
10646 
 
3431 rajveer 10647 
  def validate(self):
10648 
    return
10649 
 
10650 
 
3427 chandransh 10651 
  def __repr__(self):
10652 
    L = ['%s=%r' % (key, value)
10653 
      for key, value in self.__dict__.iteritems()]
10654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10655 
 
10656 
  def __eq__(self, other):
10657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10658 
 
10659 
  def __ne__(self, other):
10660 
    return not (self == other)
10661 
 
1382 varun.gupt 10662 
class getReturnableOrdersForCustomer_args:
10663 
  """
10664 
  Attributes:
10665 
   - customer_id
10666 
   - limit
10667 
  """
10668 
 
10669 
  thrift_spec = (
10670 
    None, # 0
10671 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10672 
    (2, TType.I64, 'limit', None, None, ), # 2
10673 
  )
10674 
 
10675 
  def __init__(self, customer_id=None, limit=None,):
10676 
    self.customer_id = customer_id
10677 
    self.limit = limit
10678 
 
10679 
  def read(self, iprot):
10680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10682 
      return
10683 
    iprot.readStructBegin()
10684 
    while True:
10685 
      (fname, ftype, fid) = iprot.readFieldBegin()
10686 
      if ftype == TType.STOP:
10687 
        break
10688 
      if fid == 1:
10689 
        if ftype == TType.I64:
10690 
          self.customer_id = iprot.readI64();
10691 
        else:
10692 
          iprot.skip(ftype)
10693 
      elif fid == 2:
10694 
        if ftype == TType.I64:
10695 
          self.limit = iprot.readI64();
10696 
        else:
10697 
          iprot.skip(ftype)
10698 
      else:
10699 
        iprot.skip(ftype)
10700 
      iprot.readFieldEnd()
10701 
    iprot.readStructEnd()
10702 
 
10703 
  def write(self, oprot):
10704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10706 
      return
10707 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_args')
3431 rajveer 10708 
    if self.customer_id is not None:
1382 varun.gupt 10709 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10710 
      oprot.writeI64(self.customer_id)
10711 
      oprot.writeFieldEnd()
3431 rajveer 10712 
    if self.limit is not None:
1382 varun.gupt 10713 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10714 
      oprot.writeI64(self.limit)
10715 
      oprot.writeFieldEnd()
10716 
    oprot.writeFieldStop()
10717 
    oprot.writeStructEnd()
10718 
 
3431 rajveer 10719 
  def validate(self):
10720 
    return
10721 
 
10722 
 
1382 varun.gupt 10723 
  def __repr__(self):
10724 
    L = ['%s=%r' % (key, value)
10725 
      for key, value in self.__dict__.iteritems()]
10726 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10727 
 
10728 
  def __eq__(self, other):
10729 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10730 
 
10731 
  def __ne__(self, other):
10732 
    return not (self == other)
10733 
 
10734 
class getReturnableOrdersForCustomer_result:
10735 
  """
10736 
  Attributes:
10737 
   - success
10738 
   - ex
10739 
  """
10740 
 
10741 
  thrift_spec = (
10742 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10743 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10744 
  )
10745 
 
10746 
  def __init__(self, success=None, ex=None,):
10747 
    self.success = success
10748 
    self.ex = ex
10749 
 
10750 
  def read(self, iprot):
10751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10753 
      return
10754 
    iprot.readStructBegin()
10755 
    while True:
10756 
      (fname, ftype, fid) = iprot.readFieldBegin()
10757 
      if ftype == TType.STOP:
10758 
        break
10759 
      if fid == 0:
10760 
        if ftype == TType.LIST:
10761 
          self.success = []
6188 rajveer 10762 
          (_etype172, _size169) = iprot.readListBegin()
10763 
          for _i173 in xrange(_size169):
10764 
            _elem174 = iprot.readI64();
10765 
            self.success.append(_elem174)
1382 varun.gupt 10766 
          iprot.readListEnd()
10767 
        else:
10768 
          iprot.skip(ftype)
10769 
      elif fid == 1:
10770 
        if ftype == TType.STRUCT:
10771 
          self.ex = TransactionServiceException()
10772 
          self.ex.read(iprot)
10773 
        else:
10774 
          iprot.skip(ftype)
10775 
      else:
10776 
        iprot.skip(ftype)
10777 
      iprot.readFieldEnd()
10778 
    iprot.readStructEnd()
10779 
 
10780 
  def write(self, oprot):
10781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10783 
      return
10784 
    oprot.writeStructBegin('getReturnableOrdersForCustomer_result')
3431 rajveer 10785 
    if self.success is not None:
1382 varun.gupt 10786 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10787 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10788 
      for iter175 in self.success:
10789 
        oprot.writeI64(iter175)
1382 varun.gupt 10790 
      oprot.writeListEnd()
10791 
      oprot.writeFieldEnd()
3431 rajveer 10792 
    if self.ex is not None:
1382 varun.gupt 10793 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10794 
      self.ex.write(oprot)
10795 
      oprot.writeFieldEnd()
10796 
    oprot.writeFieldStop()
10797 
    oprot.writeStructEnd()
10798 
 
3431 rajveer 10799 
  def validate(self):
10800 
    return
10801 
 
10802 
 
1382 varun.gupt 10803 
  def __repr__(self):
10804 
    L = ['%s=%r' % (key, value)
10805 
      for key, value in self.__dict__.iteritems()]
10806 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10807 
 
10808 
  def __eq__(self, other):
10809 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10810 
 
10811 
  def __ne__(self, other):
10812 
    return not (self == other)
10813 
 
10814 
class getCancellableOrdersForCustomer_args:
10815 
  """
10816 
  Attributes:
10817 
   - customer_id
10818 
   - limit
10819 
  """
10820 
 
10821 
  thrift_spec = (
10822 
    None, # 0
10823 
    (1, TType.I64, 'customer_id', None, None, ), # 1
10824 
    (2, TType.I64, 'limit', None, None, ), # 2
10825 
  )
10826 
 
10827 
  def __init__(self, customer_id=None, limit=None,):
10828 
    self.customer_id = customer_id
10829 
    self.limit = limit
10830 
 
10831 
  def read(self, iprot):
10832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10834 
      return
10835 
    iprot.readStructBegin()
10836 
    while True:
10837 
      (fname, ftype, fid) = iprot.readFieldBegin()
10838 
      if ftype == TType.STOP:
10839 
        break
10840 
      if fid == 1:
10841 
        if ftype == TType.I64:
10842 
          self.customer_id = iprot.readI64();
10843 
        else:
10844 
          iprot.skip(ftype)
10845 
      elif fid == 2:
10846 
        if ftype == TType.I64:
10847 
          self.limit = iprot.readI64();
10848 
        else:
10849 
          iprot.skip(ftype)
10850 
      else:
10851 
        iprot.skip(ftype)
10852 
      iprot.readFieldEnd()
10853 
    iprot.readStructEnd()
10854 
 
10855 
  def write(self, oprot):
10856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10858 
      return
10859 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_args')
3431 rajveer 10860 
    if self.customer_id is not None:
1382 varun.gupt 10861 
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
10862 
      oprot.writeI64(self.customer_id)
10863 
      oprot.writeFieldEnd()
3431 rajveer 10864 
    if self.limit is not None:
1382 varun.gupt 10865 
      oprot.writeFieldBegin('limit', TType.I64, 2)
10866 
      oprot.writeI64(self.limit)
10867 
      oprot.writeFieldEnd()
10868 
    oprot.writeFieldStop()
10869 
    oprot.writeStructEnd()
10870 
 
3431 rajveer 10871 
  def validate(self):
10872 
    return
10873 
 
10874 
 
1382 varun.gupt 10875 
  def __repr__(self):
10876 
    L = ['%s=%r' % (key, value)
10877 
      for key, value in self.__dict__.iteritems()]
10878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10879 
 
10880 
  def __eq__(self, other):
10881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10882 
 
10883 
  def __ne__(self, other):
10884 
    return not (self == other)
10885 
 
10886 
class getCancellableOrdersForCustomer_result:
10887 
  """
10888 
  Attributes:
10889 
   - success
10890 
   - ex
10891 
  """
10892 
 
10893 
  thrift_spec = (
10894 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
10895 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
10896 
  )
10897 
 
10898 
  def __init__(self, success=None, ex=None,):
10899 
    self.success = success
10900 
    self.ex = ex
10901 
 
10902 
  def read(self, iprot):
10903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10905 
      return
10906 
    iprot.readStructBegin()
10907 
    while True:
10908 
      (fname, ftype, fid) = iprot.readFieldBegin()
10909 
      if ftype == TType.STOP:
10910 
        break
10911 
      if fid == 0:
10912 
        if ftype == TType.LIST:
10913 
          self.success = []
6188 rajveer 10914 
          (_etype179, _size176) = iprot.readListBegin()
10915 
          for _i180 in xrange(_size176):
10916 
            _elem181 = iprot.readI64();
10917 
            self.success.append(_elem181)
1382 varun.gupt 10918 
          iprot.readListEnd()
10919 
        else:
10920 
          iprot.skip(ftype)
10921 
      elif fid == 1:
10922 
        if ftype == TType.STRUCT:
10923 
          self.ex = TransactionServiceException()
10924 
          self.ex.read(iprot)
10925 
        else:
10926 
          iprot.skip(ftype)
10927 
      else:
10928 
        iprot.skip(ftype)
10929 
      iprot.readFieldEnd()
10930 
    iprot.readStructEnd()
10931 
 
10932 
  def write(self, oprot):
10933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10935 
      return
10936 
    oprot.writeStructBegin('getCancellableOrdersForCustomer_result')
3431 rajveer 10937 
    if self.success is not None:
1382 varun.gupt 10938 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10939 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 10940 
      for iter182 in self.success:
10941 
        oprot.writeI64(iter182)
1382 varun.gupt 10942 
      oprot.writeListEnd()
10943 
      oprot.writeFieldEnd()
3431 rajveer 10944 
    if self.ex is not None:
1382 varun.gupt 10945 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
10946 
      self.ex.write(oprot)
10947 
      oprot.writeFieldEnd()
10948 
    oprot.writeFieldStop()
10949 
    oprot.writeStructEnd()
10950 
 
3431 rajveer 10951 
  def validate(self):
10952 
    return
10953 
 
10954 
 
1382 varun.gupt 10955 
  def __repr__(self):
10956 
    L = ['%s=%r' % (key, value)
10957 
      for key, value in self.__dict__.iteritems()]
10958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10959 
 
10960 
  def __eq__(self, other):
10961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10962 
 
10963 
  def __ne__(self, other):
10964 
    return not (self == other)
10965 
 
483 rajveer 10966 
class changeOrderStatus_args:
94 ashish 10967 
  """
10968 
  Attributes:
483 rajveer 10969 
   - orderId
10970 
   - status
10971 
   - description
94 ashish 10972 
  """
10973 
 
10974 
  thrift_spec = (
10975 
    None, # 0
483 rajveer 10976 
    (1, TType.I64, 'orderId', None, None, ), # 1
10977 
    (2, TType.I32, 'status', None, None, ), # 2
10978 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 10979 
  )
10980 
 
483 rajveer 10981 
  def __init__(self, orderId=None, status=None, description=None,):
10982 
    self.orderId = orderId
10983 
    self.status = status
10984 
    self.description = description
94 ashish 10985 
 
10986 
  def read(self, iprot):
10987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10989 
      return
10990 
    iprot.readStructBegin()
10991 
    while True:
10992 
      (fname, ftype, fid) = iprot.readFieldBegin()
10993 
      if ftype == TType.STOP:
10994 
        break
10995 
      if fid == 1:
10996 
        if ftype == TType.I64:
483 rajveer 10997 
          self.orderId = iprot.readI64();
94 ashish 10998 
        else:
10999 
          iprot.skip(ftype)
11000 
      elif fid == 2:
483 rajveer 11001 
        if ftype == TType.I32:
11002 
          self.status = iprot.readI32();
94 ashish 11003 
        else:
11004 
          iprot.skip(ftype)
483 rajveer 11005 
      elif fid == 3:
11006 
        if ftype == TType.STRING:
11007 
          self.description = iprot.readString();
11008 
        else:
11009 
          iprot.skip(ftype)
94 ashish 11010 
      else:
11011 
        iprot.skip(ftype)
11012 
      iprot.readFieldEnd()
11013 
    iprot.readStructEnd()
11014 
 
11015 
  def write(self, oprot):
11016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11018 
      return
483 rajveer 11019 
    oprot.writeStructBegin('changeOrderStatus_args')
3431 rajveer 11020 
    if self.orderId is not None:
483 rajveer 11021 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11022 
      oprot.writeI64(self.orderId)
94 ashish 11023 
      oprot.writeFieldEnd()
3431 rajveer 11024 
    if self.status is not None:
483 rajveer 11025 
      oprot.writeFieldBegin('status', TType.I32, 2)
11026 
      oprot.writeI32(self.status)
94 ashish 11027 
      oprot.writeFieldEnd()
3431 rajveer 11028 
    if self.description is not None:
483 rajveer 11029 
      oprot.writeFieldBegin('description', TType.STRING, 3)
11030 
      oprot.writeString(self.description)
11031 
      oprot.writeFieldEnd()
94 ashish 11032 
    oprot.writeFieldStop()
11033 
    oprot.writeStructEnd()
11034 
 
3431 rajveer 11035 
  def validate(self):
11036 
    return
11037 
 
11038 
 
94 ashish 11039 
  def __repr__(self):
11040 
    L = ['%s=%r' % (key, value)
11041 
      for key, value in self.__dict__.iteritems()]
11042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11043 
 
11044 
  def __eq__(self, other):
11045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11046 
 
11047 
  def __ne__(self, other):
11048 
    return not (self == other)
11049 
 
483 rajveer 11050 
class changeOrderStatus_result:
94 ashish 11051 
  """
11052 
  Attributes:
11053 
   - success
11054 
   - ex
11055 
  """
11056 
 
11057 
  thrift_spec = (
11058 
    (0, TType.BOOL, 'success', None, None, ), # 0
11059 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11060 
  )
11061 
 
11062 
  def __init__(self, success=None, ex=None,):
11063 
    self.success = success
11064 
    self.ex = ex
11065 
 
11066 
  def read(self, iprot):
11067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11069 
      return
11070 
    iprot.readStructBegin()
11071 
    while True:
11072 
      (fname, ftype, fid) = iprot.readFieldBegin()
11073 
      if ftype == TType.STOP:
11074 
        break
11075 
      if fid == 0:
11076 
        if ftype == TType.BOOL:
11077 
          self.success = iprot.readBool();
11078 
        else:
11079 
          iprot.skip(ftype)
11080 
      elif fid == 1:
11081 
        if ftype == TType.STRUCT:
11082 
          self.ex = TransactionServiceException()
11083 
          self.ex.read(iprot)
11084 
        else:
11085 
          iprot.skip(ftype)
11086 
      else:
11087 
        iprot.skip(ftype)
11088 
      iprot.readFieldEnd()
11089 
    iprot.readStructEnd()
11090 
 
11091 
  def write(self, oprot):
11092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11094 
      return
483 rajveer 11095 
    oprot.writeStructBegin('changeOrderStatus_result')
3431 rajveer 11096 
    if self.success is not None:
94 ashish 11097 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11098 
      oprot.writeBool(self.success)
11099 
      oprot.writeFieldEnd()
3431 rajveer 11100 
    if self.ex is not None:
94 ashish 11101 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11102 
      self.ex.write(oprot)
11103 
      oprot.writeFieldEnd()
11104 
    oprot.writeFieldStop()
11105 
    oprot.writeStructEnd()
11106 
 
3431 rajveer 11107 
  def validate(self):
11108 
    return
11109 
 
11110 
 
94 ashish 11111 
  def __repr__(self):
11112 
    L = ['%s=%r' % (key, value)
11113 
      for key, value in self.__dict__.iteritems()]
11114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11115 
 
11116 
  def __eq__(self, other):
11117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11118 
 
11119 
  def __ne__(self, other):
11120 
    return not (self == other)
11121 
 
3064 chandransh 11122 
class getOrdersForTransaction_args:
494 rajveer 11123 
  """
11124 
  Attributes:
3064 chandransh 11125 
   - transactionId
11126 
   - customerId
494 rajveer 11127 
  """
11128 
 
11129 
  thrift_spec = (
11130 
    None, # 0
3064 chandransh 11131 
    (1, TType.I64, 'transactionId', None, None, ), # 1
11132 
    (2, TType.I64, 'customerId', None, None, ), # 2
494 rajveer 11133 
  )
11134 
 
3064 chandransh 11135 
  def __init__(self, transactionId=None, customerId=None,):
11136 
    self.transactionId = transactionId
11137 
    self.customerId = customerId
494 rajveer 11138 
 
11139 
  def read(self, iprot):
11140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11142 
      return
11143 
    iprot.readStructBegin()
11144 
    while True:
11145 
      (fname, ftype, fid) = iprot.readFieldBegin()
11146 
      if ftype == TType.STOP:
11147 
        break
11148 
      if fid == 1:
11149 
        if ftype == TType.I64:
3064 chandransh 11150 
          self.transactionId = iprot.readI64();
494 rajveer 11151 
        else:
11152 
          iprot.skip(ftype)
11153 
      elif fid == 2:
3064 chandransh 11154 
        if ftype == TType.I64:
11155 
          self.customerId = iprot.readI64();
494 rajveer 11156 
        else:
11157 
          iprot.skip(ftype)
11158 
      else:
11159 
        iprot.skip(ftype)
11160 
      iprot.readFieldEnd()
11161 
    iprot.readStructEnd()
11162 
 
11163 
  def write(self, oprot):
11164 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11165 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11166 
      return
3064 chandransh 11167 
    oprot.writeStructBegin('getOrdersForTransaction_args')
3431 rajveer 11168 
    if self.transactionId is not None:
3064 chandransh 11169 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
11170 
      oprot.writeI64(self.transactionId)
494 rajveer 11171 
      oprot.writeFieldEnd()
3431 rajveer 11172 
    if self.customerId is not None:
3064 chandransh 11173 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
11174 
      oprot.writeI64(self.customerId)
494 rajveer 11175 
      oprot.writeFieldEnd()
11176 
    oprot.writeFieldStop()
11177 
    oprot.writeStructEnd()
11178 
 
3431 rajveer 11179 
  def validate(self):
11180 
    return
11181 
 
11182 
 
494 rajveer 11183 
  def __repr__(self):
11184 
    L = ['%s=%r' % (key, value)
11185 
      for key, value in self.__dict__.iteritems()]
11186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11187 
 
11188 
  def __eq__(self, other):
11189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11190 
 
11191 
  def __ne__(self, other):
11192 
    return not (self == other)
11193 
 
3064 chandransh 11194 
class getOrdersForTransaction_result:
494 rajveer 11195 
  """
11196 
  Attributes:
11197 
   - success
11198 
   - ex
11199 
  """
11200 
 
11201 
  thrift_spec = (
3064 chandransh 11202 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
494 rajveer 11203 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11204 
  )
11205 
 
11206 
  def __init__(self, success=None, ex=None,):
11207 
    self.success = success
11208 
    self.ex = ex
11209 
 
11210 
  def read(self, iprot):
11211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11213 
      return
11214 
    iprot.readStructBegin()
11215 
    while True:
11216 
      (fname, ftype, fid) = iprot.readFieldBegin()
11217 
      if ftype == TType.STOP:
11218 
        break
11219 
      if fid == 0:
3064 chandransh 11220 
        if ftype == TType.LIST:
11221 
          self.success = []
6188 rajveer 11222 
          (_etype186, _size183) = iprot.readListBegin()
11223 
          for _i187 in xrange(_size183):
11224 
            _elem188 = Order()
11225 
            _elem188.read(iprot)
11226 
            self.success.append(_elem188)
3064 chandransh 11227 
          iprot.readListEnd()
494 rajveer 11228 
        else:
11229 
          iprot.skip(ftype)
11230 
      elif fid == 1:
11231 
        if ftype == TType.STRUCT:
11232 
          self.ex = TransactionServiceException()
11233 
          self.ex.read(iprot)
11234 
        else:
11235 
          iprot.skip(ftype)
11236 
      else:
11237 
        iprot.skip(ftype)
11238 
      iprot.readFieldEnd()
11239 
    iprot.readStructEnd()
11240 
 
11241 
  def write(self, oprot):
11242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11244 
      return
3064 chandransh 11245 
    oprot.writeStructBegin('getOrdersForTransaction_result')
3431 rajveer 11246 
    if self.success is not None:
3064 chandransh 11247 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11248 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11249 
      for iter189 in self.success:
11250 
        iter189.write(oprot)
3064 chandransh 11251 
      oprot.writeListEnd()
494 rajveer 11252 
      oprot.writeFieldEnd()
3431 rajveer 11253 
    if self.ex is not None:
494 rajveer 11254 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11255 
      self.ex.write(oprot)
11256 
      oprot.writeFieldEnd()
11257 
    oprot.writeFieldStop()
11258 
    oprot.writeStructEnd()
11259 
 
3431 rajveer 11260 
  def validate(self):
11261 
    return
11262 
 
11263 
 
494 rajveer 11264 
  def __repr__(self):
11265 
    L = ['%s=%r' % (key, value)
11266 
      for key, value in self.__dict__.iteritems()]
11267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11268 
 
11269 
  def __eq__(self, other):
11270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11271 
 
11272 
  def __ne__(self, other):
11273 
    return not (self == other)
11274 
 
3064 chandransh 11275 
class getOrdersForCustomer_args:
1149 chandransh 11276 
  """
11277 
  Attributes:
3064 chandransh 11278 
   - customerId
11279 
   - from_date
11280 
   - to_date
11281 
   - statuses
1149 chandransh 11282 
  """
11283 
 
11284 
  thrift_spec = (
11285 
    None, # 0
3064 chandransh 11286 
    (1, TType.I64, 'customerId', None, None, ), # 1
11287 
    (2, TType.I64, 'from_date', None, None, ), # 2
11288 
    (3, TType.I64, 'to_date', None, None, ), # 3
11289 
    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
1149 chandransh 11290 
  )
11291 
 
3064 chandransh 11292 
  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
11293 
    self.customerId = customerId
11294 
    self.from_date = from_date
11295 
    self.to_date = to_date
11296 
    self.statuses = statuses
1149 chandransh 11297 
 
11298 
  def read(self, iprot):
11299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11301 
      return
11302 
    iprot.readStructBegin()
11303 
    while True:
11304 
      (fname, ftype, fid) = iprot.readFieldBegin()
11305 
      if ftype == TType.STOP:
11306 
        break
11307 
      if fid == 1:
11308 
        if ftype == TType.I64:
3064 chandransh 11309 
          self.customerId = iprot.readI64();
1149 chandransh 11310 
        else:
11311 
          iprot.skip(ftype)
11312 
      elif fid == 2:
11313 
        if ftype == TType.I64:
3064 chandransh 11314 
          self.from_date = iprot.readI64();
1149 chandransh 11315 
        else:
11316 
          iprot.skip(ftype)
2783 chandransh 11317 
      elif fid == 3:
11318 
        if ftype == TType.I64:
3064 chandransh 11319 
          self.to_date = iprot.readI64();
2783 chandransh 11320 
        else:
11321 
          iprot.skip(ftype)
11322 
      elif fid == 4:
3064 chandransh 11323 
        if ftype == TType.LIST:
11324 
          self.statuses = []
6188 rajveer 11325 
          (_etype193, _size190) = iprot.readListBegin()
11326 
          for _i194 in xrange(_size190):
11327 
            _elem195 = iprot.readI32();
11328 
            self.statuses.append(_elem195)
3064 chandransh 11329 
          iprot.readListEnd()
2783 chandransh 11330 
        else:
11331 
          iprot.skip(ftype)
1149 chandransh 11332 
      else:
11333 
        iprot.skip(ftype)
11334 
      iprot.readFieldEnd()
11335 
    iprot.readStructEnd()
11336 
 
11337 
  def write(self, oprot):
11338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11340 
      return
3064 chandransh 11341 
    oprot.writeStructBegin('getOrdersForCustomer_args')
3431 rajveer 11342 
    if self.customerId is not None:
3064 chandransh 11343 
      oprot.writeFieldBegin('customerId', TType.I64, 1)
11344 
      oprot.writeI64(self.customerId)
1149 chandransh 11345 
      oprot.writeFieldEnd()
3431 rajveer 11346 
    if self.from_date is not None:
3064 chandransh 11347 
      oprot.writeFieldBegin('from_date', TType.I64, 2)
11348 
      oprot.writeI64(self.from_date)
1149 chandransh 11349 
      oprot.writeFieldEnd()
3431 rajveer 11350 
    if self.to_date is not None:
3064 chandransh 11351 
      oprot.writeFieldBegin('to_date', TType.I64, 3)
11352 
      oprot.writeI64(self.to_date)
2783 chandransh 11353 
      oprot.writeFieldEnd()
3431 rajveer 11354 
    if self.statuses is not None:
3064 chandransh 11355 
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
11356 
      oprot.writeListBegin(TType.I32, len(self.statuses))
6188 rajveer 11357 
      for iter196 in self.statuses:
11358 
        oprot.writeI32(iter196)
3064 chandransh 11359 
      oprot.writeListEnd()
2783 chandransh 11360 
      oprot.writeFieldEnd()
1149 chandransh 11361 
    oprot.writeFieldStop()
11362 
    oprot.writeStructEnd()
11363 
 
3431 rajveer 11364 
  def validate(self):
11365 
    return
11366 
 
11367 
 
1149 chandransh 11368 
  def __repr__(self):
11369 
    L = ['%s=%r' % (key, value)
11370 
      for key, value in self.__dict__.iteritems()]
11371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11372 
 
11373 
  def __eq__(self, other):
11374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11375 
 
11376 
  def __ne__(self, other):
11377 
    return not (self == other)
11378 
 
3064 chandransh 11379 
class getOrdersForCustomer_result:
1149 chandransh 11380 
  """
11381 
  Attributes:
11382 
   - success
11383 
   - ex
11384 
  """
11385 
 
11386 
  thrift_spec = (
3064 chandransh 11387 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1149 chandransh 11388 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11389 
  )
11390 
 
11391 
  def __init__(self, success=None, ex=None,):
11392 
    self.success = success
11393 
    self.ex = ex
11394 
 
11395 
  def read(self, iprot):
11396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11398 
      return
11399 
    iprot.readStructBegin()
11400 
    while True:
11401 
      (fname, ftype, fid) = iprot.readFieldBegin()
11402 
      if ftype == TType.STOP:
11403 
        break
11404 
      if fid == 0:
3064 chandransh 11405 
        if ftype == TType.LIST:
11406 
          self.success = []
6188 rajveer 11407 
          (_etype200, _size197) = iprot.readListBegin()
11408 
          for _i201 in xrange(_size197):
11409 
            _elem202 = Order()
11410 
            _elem202.read(iprot)
11411 
            self.success.append(_elem202)
3064 chandransh 11412 
          iprot.readListEnd()
1149 chandransh 11413 
        else:
11414 
          iprot.skip(ftype)
11415 
      elif fid == 1:
11416 
        if ftype == TType.STRUCT:
11417 
          self.ex = TransactionServiceException()
11418 
          self.ex.read(iprot)
11419 
        else:
11420 
          iprot.skip(ftype)
11421 
      else:
11422 
        iprot.skip(ftype)
11423 
      iprot.readFieldEnd()
11424 
    iprot.readStructEnd()
11425 
 
11426 
  def write(self, oprot):
11427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11429 
      return
3064 chandransh 11430 
    oprot.writeStructBegin('getOrdersForCustomer_result')
3431 rajveer 11431 
    if self.success is not None:
3064 chandransh 11432 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11433 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11434 
      for iter203 in self.success:
11435 
        iter203.write(oprot)
3064 chandransh 11436 
      oprot.writeListEnd()
1149 chandransh 11437 
      oprot.writeFieldEnd()
3431 rajveer 11438 
    if self.ex is not None:
1149 chandransh 11439 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11440 
      self.ex.write(oprot)
11441 
      oprot.writeFieldEnd()
11442 
    oprot.writeFieldStop()
11443 
    oprot.writeStructEnd()
11444 
 
3431 rajveer 11445 
  def validate(self):
11446 
    return
11447 
 
11448 
 
1149 chandransh 11449 
  def __repr__(self):
11450 
    L = ['%s=%r' % (key, value)
11451 
      for key, value in self.__dict__.iteritems()]
11452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11453 
 
11454 
  def __eq__(self, other):
11455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11456 
 
11457 
  def __ne__(self, other):
11458 
    return not (self == other)
11459 
 
3064 chandransh 11460 
class createOrder_args:
921 rajveer 11461 
  """
11462 
  Attributes:
3064 chandransh 11463 
   - order
921 rajveer 11464 
  """
11465 
 
11466 
  thrift_spec = (
11467 
    None, # 0
3064 chandransh 11468 
    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
921 rajveer 11469 
  )
11470 
 
3064 chandransh 11471 
  def __init__(self, order=None,):
11472 
    self.order = order
921 rajveer 11473 
 
11474 
  def read(self, iprot):
11475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11477 
      return
11478 
    iprot.readStructBegin()
11479 
    while True:
11480 
      (fname, ftype, fid) = iprot.readFieldBegin()
11481 
      if ftype == TType.STOP:
11482 
        break
11483 
      if fid == 1:
3064 chandransh 11484 
        if ftype == TType.STRUCT:
11485 
          self.order = Order()
11486 
          self.order.read(iprot)
921 rajveer 11487 
        else:
11488 
          iprot.skip(ftype)
11489 
      else:
11490 
        iprot.skip(ftype)
11491 
      iprot.readFieldEnd()
11492 
    iprot.readStructEnd()
11493 
 
11494 
  def write(self, oprot):
11495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11497 
      return
3064 chandransh 11498 
    oprot.writeStructBegin('createOrder_args')
3431 rajveer 11499 
    if self.order is not None:
3064 chandransh 11500 
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
11501 
      self.order.write(oprot)
921 rajveer 11502 
      oprot.writeFieldEnd()
11503 
    oprot.writeFieldStop()
11504 
    oprot.writeStructEnd()
11505 
 
3431 rajveer 11506 
  def validate(self):
11507 
    return
11508 
 
11509 
 
921 rajveer 11510 
  def __repr__(self):
11511 
    L = ['%s=%r' % (key, value)
11512 
      for key, value in self.__dict__.iteritems()]
11513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11514 
 
11515 
  def __eq__(self, other):
11516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11517 
 
11518 
  def __ne__(self, other):
11519 
    return not (self == other)
11520 
 
3064 chandransh 11521 
class createOrder_result:
921 rajveer 11522 
  """
11523 
  Attributes:
11524 
   - success
11525 
   - ex
11526 
  """
11527 
 
11528 
  thrift_spec = (
3064 chandransh 11529 
    (0, TType.I64, 'success', None, None, ), # 0
921 rajveer 11530 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11531 
  )
11532 
 
11533 
  def __init__(self, success=None, ex=None,):
11534 
    self.success = success
11535 
    self.ex = ex
11536 
 
11537 
  def read(self, iprot):
11538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11540 
      return
11541 
    iprot.readStructBegin()
11542 
    while True:
11543 
      (fname, ftype, fid) = iprot.readFieldBegin()
11544 
      if ftype == TType.STOP:
11545 
        break
11546 
      if fid == 0:
3064 chandransh 11547 
        if ftype == TType.I64:
11548 
          self.success = iprot.readI64();
921 rajveer 11549 
        else:
11550 
          iprot.skip(ftype)
11551 
      elif fid == 1:
11552 
        if ftype == TType.STRUCT:
11553 
          self.ex = TransactionServiceException()
11554 
          self.ex.read(iprot)
11555 
        else:
11556 
          iprot.skip(ftype)
11557 
      else:
11558 
        iprot.skip(ftype)
11559 
      iprot.readFieldEnd()
11560 
    iprot.readStructEnd()
11561 
 
11562 
  def write(self, oprot):
11563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11565 
      return
3064 chandransh 11566 
    oprot.writeStructBegin('createOrder_result')
3431 rajveer 11567 
    if self.success is not None:
3064 chandransh 11568 
      oprot.writeFieldBegin('success', TType.I64, 0)
11569 
      oprot.writeI64(self.success)
921 rajveer 11570 
      oprot.writeFieldEnd()
3431 rajveer 11571 
    if self.ex is not None:
921 rajveer 11572 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11573 
      self.ex.write(oprot)
11574 
      oprot.writeFieldEnd()
11575 
    oprot.writeFieldStop()
11576 
    oprot.writeStructEnd()
11577 
 
3431 rajveer 11578 
  def validate(self):
11579 
    return
11580 
 
11581 
 
921 rajveer 11582 
  def __repr__(self):
11583 
    L = ['%s=%r' % (key, value)
11584 
      for key, value in self.__dict__.iteritems()]
11585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11586 
 
11587 
  def __eq__(self, other):
11588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11589 
 
11590 
  def __ne__(self, other):
11591 
    return not (self == other)
11592 
 
3064 chandransh 11593 
class getOrder_args:
921 rajveer 11594 
  """
11595 
  Attributes:
3064 chandransh 11596 
   - id
921 rajveer 11597 
  """
11598 
 
11599 
  thrift_spec = (
11600 
    None, # 0
3064 chandransh 11601 
    (1, TType.I64, 'id', None, None, ), # 1
921 rajveer 11602 
  )
11603 
 
3064 chandransh 11604 
  def __init__(self, id=None,):
11605 
    self.id = id
921 rajveer 11606 
 
11607 
  def read(self, iprot):
11608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11610 
      return
11611 
    iprot.readStructBegin()
11612 
    while True:
11613 
      (fname, ftype, fid) = iprot.readFieldBegin()
11614 
      if ftype == TType.STOP:
11615 
        break
11616 
      if fid == 1:
11617 
        if ftype == TType.I64:
3064 chandransh 11618 
          self.id = iprot.readI64();
921 rajveer 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('getOrder_args')
3431 rajveer 11631 
    if self.id is not None:
3064 chandransh 11632 
      oprot.writeFieldBegin('id', TType.I64, 1)
11633 
      oprot.writeI64(self.id)
921 rajveer 11634 
      oprot.writeFieldEnd()
11635 
    oprot.writeFieldStop()
11636 
    oprot.writeStructEnd()
11637 
 
3431 rajveer 11638 
  def validate(self):
11639 
    return
11640 
 
11641 
 
921 rajveer 11642 
  def __repr__(self):
11643 
    L = ['%s=%r' % (key, value)
11644 
      for key, value in self.__dict__.iteritems()]
11645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11646 
 
11647 
  def __eq__(self, other):
11648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11649 
 
11650 
  def __ne__(self, other):
11651 
    return not (self == other)
11652 
 
3064 chandransh 11653 
class getOrder_result:
921 rajveer 11654 
  """
11655 
  Attributes:
11656 
   - success
11657 
   - ex
11658 
  """
11659 
 
11660 
  thrift_spec = (
3064 chandransh 11661 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
921 rajveer 11662 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11663 
  )
11664 
 
11665 
  def __init__(self, success=None, ex=None,):
11666 
    self.success = success
11667 
    self.ex = ex
11668 
 
11669 
  def read(self, iprot):
11670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11672 
      return
11673 
    iprot.readStructBegin()
11674 
    while True:
11675 
      (fname, ftype, fid) = iprot.readFieldBegin()
11676 
      if ftype == TType.STOP:
11677 
        break
11678 
      if fid == 0:
3064 chandransh 11679 
        if ftype == TType.STRUCT:
11680 
          self.success = Order()
11681 
          self.success.read(iprot)
921 rajveer 11682 
        else:
11683 
          iprot.skip(ftype)
11684 
      elif fid == 1:
11685 
        if ftype == TType.STRUCT:
11686 
          self.ex = TransactionServiceException()
11687 
          self.ex.read(iprot)
11688 
        else:
11689 
          iprot.skip(ftype)
11690 
      else:
11691 
        iprot.skip(ftype)
11692 
      iprot.readFieldEnd()
11693 
    iprot.readStructEnd()
11694 
 
11695 
  def write(self, oprot):
11696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11698 
      return
3064 chandransh 11699 
    oprot.writeStructBegin('getOrder_result')
3431 rajveer 11700 
    if self.success is not None:
3064 chandransh 11701 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11702 
      self.success.write(oprot)
921 rajveer 11703 
      oprot.writeFieldEnd()
3431 rajveer 11704 
    if self.ex is not None:
921 rajveer 11705 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11706 
      self.ex.write(oprot)
11707 
      oprot.writeFieldEnd()
11708 
    oprot.writeFieldStop()
11709 
    oprot.writeStructEnd()
11710 
 
3431 rajveer 11711 
  def validate(self):
11712 
    return
11713 
 
11714 
 
921 rajveer 11715 
  def __repr__(self):
11716 
    L = ['%s=%r' % (key, value)
11717 
      for key, value in self.__dict__.iteritems()]
11718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11719 
 
11720 
  def __eq__(self, other):
11721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11722 
 
11723 
  def __ne__(self, other):
11724 
    return not (self == other)
11725 
 
3064 chandransh 11726 
class getLineItemsForOrder_args:
94 ashish 11727 
  """
11728 
  Attributes:
3064 chandransh 11729 
   - orderId
94 ashish 11730 
  """
11731 
 
11732 
  thrift_spec = (
11733 
    None, # 0
3064 chandransh 11734 
    (1, TType.I64, 'orderId', None, None, ), # 1
94 ashish 11735 
  )
11736 
 
3064 chandransh 11737 
  def __init__(self, orderId=None,):
11738 
    self.orderId = orderId
94 ashish 11739 
 
11740 
  def read(self, iprot):
11741 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11742 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11743 
      return
11744 
    iprot.readStructBegin()
11745 
    while True:
11746 
      (fname, ftype, fid) = iprot.readFieldBegin()
11747 
      if ftype == TType.STOP:
11748 
        break
11749 
      if fid == 1:
11750 
        if ftype == TType.I64:
3064 chandransh 11751 
          self.orderId = iprot.readI64();
94 ashish 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('getLineItemsForOrder_args')
3431 rajveer 11764 
    if self.orderId is not None:
3064 chandransh 11765 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
11766 
      oprot.writeI64(self.orderId)
94 ashish 11767 
      oprot.writeFieldEnd()
11768 
    oprot.writeFieldStop()
11769 
    oprot.writeStructEnd()
11770 
 
3431 rajveer 11771 
  def validate(self):
11772 
    return
11773 
 
11774 
 
94 ashish 11775 
  def __repr__(self):
11776 
    L = ['%s=%r' % (key, value)
11777 
      for key, value in self.__dict__.iteritems()]
11778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11779 
 
11780 
  def __eq__(self, other):
11781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11782 
 
11783 
  def __ne__(self, other):
11784 
    return not (self == other)
11785 
 
3064 chandransh 11786 
class getLineItemsForOrder_result:
94 ashish 11787 
  """
11788 
  Attributes:
11789 
   - success
11790 
   - ex
11791 
  """
11792 
 
11793 
  thrift_spec = (
3064 chandransh 11794 
    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
94 ashish 11795 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
11796 
  )
11797 
 
11798 
  def __init__(self, success=None, ex=None,):
11799 
    self.success = success
11800 
    self.ex = ex
11801 
 
11802 
  def read(self, iprot):
11803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11805 
      return
11806 
    iprot.readStructBegin()
11807 
    while True:
11808 
      (fname, ftype, fid) = iprot.readFieldBegin()
11809 
      if ftype == TType.STOP:
11810 
        break
11811 
      if fid == 0:
483 rajveer 11812 
        if ftype == TType.LIST:
11813 
          self.success = []
6188 rajveer 11814 
          (_etype207, _size204) = iprot.readListBegin()
11815 
          for _i208 in xrange(_size204):
11816 
            _elem209 = LineItem()
11817 
            _elem209.read(iprot)
11818 
            self.success.append(_elem209)
483 rajveer 11819 
          iprot.readListEnd()
94 ashish 11820 
        else:
11821 
          iprot.skip(ftype)
11822 
      elif fid == 1:
11823 
        if ftype == TType.STRUCT:
11824 
          self.ex = TransactionServiceException()
11825 
          self.ex.read(iprot)
11826 
        else:
11827 
          iprot.skip(ftype)
11828 
      else:
11829 
        iprot.skip(ftype)
11830 
      iprot.readFieldEnd()
11831 
    iprot.readStructEnd()
11832 
 
11833 
  def write(self, oprot):
11834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11836 
      return
3064 chandransh 11837 
    oprot.writeStructBegin('getLineItemsForOrder_result')
3431 rajveer 11838 
    if self.success is not None:
483 rajveer 11839 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11840 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11841 
      for iter210 in self.success:
11842 
        iter210.write(oprot)
483 rajveer 11843 
      oprot.writeListEnd()
94 ashish 11844 
      oprot.writeFieldEnd()
3431 rajveer 11845 
    if self.ex is not None:
94 ashish 11846 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
11847 
      self.ex.write(oprot)
11848 
      oprot.writeFieldEnd()
11849 
    oprot.writeFieldStop()
11850 
    oprot.writeStructEnd()
11851 
 
3431 rajveer 11852 
  def validate(self):
11853 
    return
11854 
 
11855 
 
94 ashish 11856 
  def __repr__(self):
11857 
    L = ['%s=%r' % (key, value)
11858 
      for key, value in self.__dict__.iteritems()]
11859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11860 
 
11861 
  def __eq__(self, other):
11862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11863 
 
11864 
  def __ne__(self, other):
11865 
    return not (self == other)
11866 
 
4999 phani.kuma 11867 
class getOrderList_args:
11868 
  """
11869 
  Attributes:
11870 
   - order_ids
11871 
  """
11872 
 
11873 
  thrift_spec = (
11874 
    None, # 0
11875 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
11876 
  )
11877 
 
11878 
  def __init__(self, order_ids=None,):
11879 
    self.order_ids = order_ids
11880 
 
11881 
  def read(self, iprot):
11882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11884 
      return
11885 
    iprot.readStructBegin()
11886 
    while True:
11887 
      (fname, ftype, fid) = iprot.readFieldBegin()
11888 
      if ftype == TType.STOP:
11889 
        break
11890 
      if fid == 1:
11891 
        if ftype == TType.LIST:
11892 
          self.order_ids = []
6188 rajveer 11893 
          (_etype214, _size211) = iprot.readListBegin()
11894 
          for _i215 in xrange(_size211):
11895 
            _elem216 = iprot.readI64();
11896 
            self.order_ids.append(_elem216)
4999 phani.kuma 11897 
          iprot.readListEnd()
11898 
        else:
11899 
          iprot.skip(ftype)
11900 
      else:
11901 
        iprot.skip(ftype)
11902 
      iprot.readFieldEnd()
11903 
    iprot.readStructEnd()
11904 
 
11905 
  def write(self, oprot):
11906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11908 
      return
11909 
    oprot.writeStructBegin('getOrderList_args')
11910 
    if self.order_ids is not None:
11911 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
11912 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 11913 
      for iter217 in self.order_ids:
11914 
        oprot.writeI64(iter217)
4999 phani.kuma 11915 
      oprot.writeListEnd()
11916 
      oprot.writeFieldEnd()
11917 
    oprot.writeFieldStop()
11918 
    oprot.writeStructEnd()
11919 
 
11920 
  def validate(self):
11921 
    return
11922 
 
11923 
 
11924 
  def __repr__(self):
11925 
    L = ['%s=%r' % (key, value)
11926 
      for key, value in self.__dict__.iteritems()]
11927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11928 
 
11929 
  def __eq__(self, other):
11930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11931 
 
11932 
  def __ne__(self, other):
11933 
    return not (self == other)
11934 
 
11935 
class getOrderList_result:
11936 
  """
11937 
  Attributes:
11938 
   - success
11939 
  """
11940 
 
11941 
  thrift_spec = (
11942 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
11943 
  )
11944 
 
11945 
  def __init__(self, success=None,):
11946 
    self.success = success
11947 
 
11948 
  def read(self, iprot):
11949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11951 
      return
11952 
    iprot.readStructBegin()
11953 
    while True:
11954 
      (fname, ftype, fid) = iprot.readFieldBegin()
11955 
      if ftype == TType.STOP:
11956 
        break
11957 
      if fid == 0:
11958 
        if ftype == TType.LIST:
11959 
          self.success = []
6188 rajveer 11960 
          (_etype221, _size218) = iprot.readListBegin()
11961 
          for _i222 in xrange(_size218):
11962 
            _elem223 = Order()
11963 
            _elem223.read(iprot)
11964 
            self.success.append(_elem223)
4999 phani.kuma 11965 
          iprot.readListEnd()
11966 
        else:
11967 
          iprot.skip(ftype)
11968 
      else:
11969 
        iprot.skip(ftype)
11970 
      iprot.readFieldEnd()
11971 
    iprot.readStructEnd()
11972 
 
11973 
  def write(self, oprot):
11974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11976 
      return
11977 
    oprot.writeStructBegin('getOrderList_result')
11978 
    if self.success is not None:
11979 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11980 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 11981 
      for iter224 in self.success:
11982 
        iter224.write(oprot)
4999 phani.kuma 11983 
      oprot.writeListEnd()
11984 
      oprot.writeFieldEnd()
11985 
    oprot.writeFieldStop()
11986 
    oprot.writeStructEnd()
11987 
 
11988 
  def validate(self):
11989 
    return
11990 
 
11991 
 
11992 
  def __repr__(self):
11993 
    L = ['%s=%r' % (key, value)
11994 
      for key, value in self.__dict__.iteritems()]
11995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11996 
 
11997 
  def __eq__(self, other):
11998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11999 
 
12000 
  def __ne__(self, other):
12001 
    return not (self == other)
12002 
 
5386 phani.kuma 12003 
class getOrderListForVendor_args:
12004 
  """
12005 
  Attributes:
12006 
   - order_ids
12007 
   - vendorId
12008 
  """
12009 
 
12010 
  thrift_spec = (
12011 
    None, # 0
12012 
    (1, TType.LIST, 'order_ids', (TType.I64,None), None, ), # 1
12013 
    (2, TType.I64, 'vendorId', None, None, ), # 2
12014 
  )
12015 
 
12016 
  def __init__(self, order_ids=None, vendorId=None,):
12017 
    self.order_ids = order_ids
12018 
    self.vendorId = vendorId
12019 
 
12020 
  def read(self, iprot):
12021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12023 
      return
12024 
    iprot.readStructBegin()
12025 
    while True:
12026 
      (fname, ftype, fid) = iprot.readFieldBegin()
12027 
      if ftype == TType.STOP:
12028 
        break
12029 
      if fid == 1:
12030 
        if ftype == TType.LIST:
12031 
          self.order_ids = []
6188 rajveer 12032 
          (_etype228, _size225) = iprot.readListBegin()
12033 
          for _i229 in xrange(_size225):
12034 
            _elem230 = iprot.readI64();
12035 
            self.order_ids.append(_elem230)
5386 phani.kuma 12036 
          iprot.readListEnd()
12037 
        else:
12038 
          iprot.skip(ftype)
12039 
      elif fid == 2:
12040 
        if ftype == TType.I64:
12041 
          self.vendorId = iprot.readI64();
12042 
        else:
12043 
          iprot.skip(ftype)
12044 
      else:
12045 
        iprot.skip(ftype)
12046 
      iprot.readFieldEnd()
12047 
    iprot.readStructEnd()
12048 
 
12049 
  def write(self, oprot):
12050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12052 
      return
12053 
    oprot.writeStructBegin('getOrderListForVendor_args')
12054 
    if self.order_ids is not None:
12055 
      oprot.writeFieldBegin('order_ids', TType.LIST, 1)
12056 
      oprot.writeListBegin(TType.I64, len(self.order_ids))
6188 rajveer 12057 
      for iter231 in self.order_ids:
12058 
        oprot.writeI64(iter231)
5386 phani.kuma 12059 
      oprot.writeListEnd()
12060 
      oprot.writeFieldEnd()
12061 
    if self.vendorId is not None:
12062 
      oprot.writeFieldBegin('vendorId', TType.I64, 2)
12063 
      oprot.writeI64(self.vendorId)
12064 
      oprot.writeFieldEnd()
12065 
    oprot.writeFieldStop()
12066 
    oprot.writeStructEnd()
12067 
 
12068 
  def validate(self):
12069 
    return
12070 
 
12071 
 
12072 
  def __repr__(self):
12073 
    L = ['%s=%r' % (key, value)
12074 
      for key, value in self.__dict__.iteritems()]
12075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12076 
 
12077 
  def __eq__(self, other):
12078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12079 
 
12080 
  def __ne__(self, other):
12081 
    return not (self == other)
12082 
 
12083 
class getOrderListForVendor_result:
12084 
  """
12085 
  Attributes:
12086 
   - success
12087 
  """
12088 
 
12089 
  thrift_spec = (
12090 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
12091 
  )
12092 
 
12093 
  def __init__(self, success=None,):
12094 
    self.success = success
12095 
 
12096 
  def read(self, iprot):
12097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12099 
      return
12100 
    iprot.readStructBegin()
12101 
    while True:
12102 
      (fname, ftype, fid) = iprot.readFieldBegin()
12103 
      if ftype == TType.STOP:
12104 
        break
12105 
      if fid == 0:
12106 
        if ftype == TType.LIST:
12107 
          self.success = []
6188 rajveer 12108 
          (_etype235, _size232) = iprot.readListBegin()
12109 
          for _i236 in xrange(_size232):
12110 
            _elem237 = Order()
12111 
            _elem237.read(iprot)
12112 
            self.success.append(_elem237)
5386 phani.kuma 12113 
          iprot.readListEnd()
12114 
        else:
12115 
          iprot.skip(ftype)
12116 
      else:
12117 
        iprot.skip(ftype)
12118 
      iprot.readFieldEnd()
12119 
    iprot.readStructEnd()
12120 
 
12121 
  def write(self, oprot):
12122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12124 
      return
12125 
    oprot.writeStructBegin('getOrderListForVendor_result')
12126 
    if self.success is not None:
12127 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12128 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12129 
      for iter238 in self.success:
12130 
        iter238.write(oprot)
5386 phani.kuma 12131 
      oprot.writeListEnd()
12132 
      oprot.writeFieldEnd()
12133 
    oprot.writeFieldStop()
12134 
    oprot.writeStructEnd()
12135 
 
12136 
  def validate(self):
12137 
    return
12138 
 
12139 
 
12140 
  def __repr__(self):
12141 
    L = ['%s=%r' % (key, value)
12142 
      for key, value in self.__dict__.iteritems()]
12143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12144 
 
12145 
  def __eq__(self, other):
12146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12147 
 
12148 
  def __ne__(self, other):
12149 
    return not (self == other)
12150 
 
3064 chandransh 12151 
class getOrderForCustomer_args:
94 ashish 12152 
  """
12153 
  Attributes:
3064 chandransh 12154 
   - orderId
483 rajveer 12155 
   - customerId
94 ashish 12156 
  """
12157 
 
12158 
  thrift_spec = (
12159 
    None, # 0
3064 chandransh 12160 
    (1, TType.I64, 'orderId', None, None, ), # 1
12161 
    (2, TType.I64, 'customerId', None, None, ), # 2
94 ashish 12162 
  )
12163 
 
3064 chandransh 12164 
  def __init__(self, orderId=None, customerId=None,):
12165 
    self.orderId = orderId
483 rajveer 12166 
    self.customerId = customerId
94 ashish 12167 
 
12168 
  def read(self, iprot):
12169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12171 
      return
12172 
    iprot.readStructBegin()
12173 
    while True:
12174 
      (fname, ftype, fid) = iprot.readFieldBegin()
12175 
      if ftype == TType.STOP:
12176 
        break
12177 
      if fid == 1:
12178 
        if ftype == TType.I64:
3064 chandransh 12179 
          self.orderId = iprot.readI64();
94 ashish 12180 
        else:
12181 
          iprot.skip(ftype)
12182 
      elif fid == 2:
12183 
        if ftype == TType.I64:
3064 chandransh 12184 
          self.customerId = iprot.readI64();
94 ashish 12185 
        else:
12186 
          iprot.skip(ftype)
12187 
      else:
12188 
        iprot.skip(ftype)
12189 
      iprot.readFieldEnd()
12190 
    iprot.readStructEnd()
12191 
 
12192 
  def write(self, oprot):
12193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12195 
      return
3064 chandransh 12196 
    oprot.writeStructBegin('getOrderForCustomer_args')
3431 rajveer 12197 
    if self.orderId is not None:
3064 chandransh 12198 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
12199 
      oprot.writeI64(self.orderId)
12200 
      oprot.writeFieldEnd()
3431 rajveer 12201 
    if self.customerId is not None:
3064 chandransh 12202 
      oprot.writeFieldBegin('customerId', TType.I64, 2)
483 rajveer 12203 
      oprot.writeI64(self.customerId)
94 ashish 12204 
      oprot.writeFieldEnd()
12205 
    oprot.writeFieldStop()
12206 
    oprot.writeStructEnd()
12207 
 
3431 rajveer 12208 
  def validate(self):
12209 
    return
12210 
 
12211 
 
94 ashish 12212 
  def __repr__(self):
12213 
    L = ['%s=%r' % (key, value)
12214 
      for key, value in self.__dict__.iteritems()]
12215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12216 
 
12217 
  def __eq__(self, other):
12218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12219 
 
12220 
  def __ne__(self, other):
12221 
    return not (self == other)
12222 
 
3064 chandransh 12223 
class getOrderForCustomer_result:
94 ashish 12224 
  """
12225 
  Attributes:
12226 
   - success
12227 
   - ex
12228 
  """
12229 
 
12230 
  thrift_spec = (
3064 chandransh 12231 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
94 ashish 12232 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
12233 
  )
12234 
 
12235 
  def __init__(self, success=None, ex=None,):
12236 
    self.success = success
12237 
    self.ex = ex
12238 
 
12239 
  def read(self, iprot):
12240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12242 
      return
12243 
    iprot.readStructBegin()
12244 
    while True:
12245 
      (fname, ftype, fid) = iprot.readFieldBegin()
12246 
      if ftype == TType.STOP:
12247 
        break
12248 
      if fid == 0:
3064 chandransh 12249 
        if ftype == TType.STRUCT:
12250 
          self.success = Order()
12251 
          self.success.read(iprot)
94 ashish 12252 
        else:
12253 
          iprot.skip(ftype)
12254 
      elif fid == 1:
12255 
        if ftype == TType.STRUCT:
12256 
          self.ex = TransactionServiceException()
12257 
          self.ex.read(iprot)
12258 
        else:
12259 
          iprot.skip(ftype)
12260 
      else:
12261 
        iprot.skip(ftype)
12262 
      iprot.readFieldEnd()
12263 
    iprot.readStructEnd()
12264 
 
12265 
  def write(self, oprot):
12266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12268 
      return
3064 chandransh 12269 
    oprot.writeStructBegin('getOrderForCustomer_result')
3431 rajveer 12270 
    if self.success is not None:
3064 chandransh 12271 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12272 
      self.success.write(oprot)
94 ashish 12273 
      oprot.writeFieldEnd()
3431 rajveer 12274 
    if self.ex is not None:
94 ashish 12275 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
12276 
      self.ex.write(oprot)
12277 
      oprot.writeFieldEnd()
12278 
    oprot.writeFieldStop()
12279 
    oprot.writeStructEnd()
12280 
 
3431 rajveer 12281 
  def validate(self):
12282 
    return
12283 
 
12284 
 
94 ashish 12285 
  def __repr__(self):
12286 
    L = ['%s=%r' % (key, value)
12287 
      for key, value in self.__dict__.iteritems()]
12288 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12289 
 
12290 
  def __eq__(self, other):
12291 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12292 
 
12293 
  def __ne__(self, other):
12294 
    return not (self == other)
12295 
 
3064 chandransh 12296 
class getAlerts_args:
94 ashish 12297 
  """
12298 
  Attributes:
4394 rajveer 12299 
   - type
4444 rajveer 12300 
   - warehouseId
4394 rajveer 12301 
   - status
12302 
   - timestamp
94 ashish 12303 
  """
12304 
 
12305 
  thrift_spec = (
12306 
    None, # 0
4394 rajveer 12307 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12308 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12309 
    (3, TType.I64, 'status', None, None, ), # 3
12310 
    (4, TType.I64, 'timestamp', None, None, ), # 4
94 ashish 12311 
  )
12312 
 
4444 rajveer 12313 
  def __init__(self, type=None, warehouseId=None, status=None, timestamp=None,):
4394 rajveer 12314 
    self.type = type
4444 rajveer 12315 
    self.warehouseId = warehouseId
4394 rajveer 12316 
    self.status = status
12317 
    self.timestamp = timestamp
94 ashish 12318 
 
12319 
  def read(self, iprot):
12320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12322 
      return
12323 
    iprot.readStructBegin()
12324 
    while True:
12325 
      (fname, ftype, fid) = iprot.readFieldBegin()
12326 
      if ftype == TType.STOP:
12327 
        break
12328 
      if fid == 1:
3064 chandransh 12329 
        if ftype == TType.I64:
4394 rajveer 12330 
          self.type = iprot.readI64();
94 ashish 12331 
        else:
12332 
          iprot.skip(ftype)
3064 chandransh 12333 
      elif fid == 2:
4394 rajveer 12334 
        if ftype == TType.I64:
4444 rajveer 12335 
          self.warehouseId = iprot.readI64();
3064 chandransh 12336 
        else:
12337 
          iprot.skip(ftype)
4394 rajveer 12338 
      elif fid == 3:
12339 
        if ftype == TType.I64:
4444 rajveer 12340 
          self.status = iprot.readI64();
12341 
        else:
12342 
          iprot.skip(ftype)
12343 
      elif fid == 4:
12344 
        if ftype == TType.I64:
4394 rajveer 12345 
          self.timestamp = iprot.readI64();
12346 
        else:
12347 
          iprot.skip(ftype)
94 ashish 12348 
      else:
12349 
        iprot.skip(ftype)
12350 
      iprot.readFieldEnd()
12351 
    iprot.readStructEnd()
12352 
 
12353 
  def write(self, oprot):
12354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12356 
      return
3064 chandransh 12357 
    oprot.writeStructBegin('getAlerts_args')
4394 rajveer 12358 
    if self.type is not None:
12359 
      oprot.writeFieldBegin('type', TType.I64, 1)
12360 
      oprot.writeI64(self.type)
94 ashish 12361 
      oprot.writeFieldEnd()
4444 rajveer 12362 
    if self.warehouseId is not None:
12363 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12364 
      oprot.writeI64(self.warehouseId)
12365 
      oprot.writeFieldEnd()
4394 rajveer 12366 
    if self.status is not None:
4444 rajveer 12367 
      oprot.writeFieldBegin('status', TType.I64, 3)
4394 rajveer 12368 
      oprot.writeI64(self.status)
3064 chandransh 12369 
      oprot.writeFieldEnd()
4394 rajveer 12370 
    if self.timestamp is not None:
4444 rajveer 12371 
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
4394 rajveer 12372 
      oprot.writeI64(self.timestamp)
12373 
      oprot.writeFieldEnd()
94 ashish 12374 
    oprot.writeFieldStop()
12375 
    oprot.writeStructEnd()
12376 
 
3431 rajveer 12377 
  def validate(self):
12378 
    return
12379 
 
12380 
 
94 ashish 12381 
  def __repr__(self):
12382 
    L = ['%s=%r' % (key, value)
12383 
      for key, value in self.__dict__.iteritems()]
12384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12385 
 
12386 
  def __eq__(self, other):
12387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12388 
 
12389 
  def __ne__(self, other):
12390 
    return not (self == other)
12391 
 
3064 chandransh 12392 
class getAlerts_result:
94 ashish 12393 
  """
12394 
  Attributes:
12395 
   - success
12396 
  """
12397 
 
12398 
  thrift_spec = (
3064 chandransh 12399 
    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
94 ashish 12400 
  )
12401 
 
3064 chandransh 12402 
  def __init__(self, success=None,):
94 ashish 12403 
    self.success = success
12404 
 
12405 
  def read(self, iprot):
12406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12408 
      return
12409 
    iprot.readStructBegin()
12410 
    while True:
12411 
      (fname, ftype, fid) = iprot.readFieldBegin()
12412 
      if ftype == TType.STOP:
12413 
        break
12414 
      if fid == 0:
3064 chandransh 12415 
        if ftype == TType.LIST:
12416 
          self.success = []
6188 rajveer 12417 
          (_etype242, _size239) = iprot.readListBegin()
12418 
          for _i243 in xrange(_size239):
12419 
            _elem244 = Alert()
12420 
            _elem244.read(iprot)
12421 
            self.success.append(_elem244)
3064 chandransh 12422 
          iprot.readListEnd()
94 ashish 12423 
        else:
12424 
          iprot.skip(ftype)
12425 
      else:
12426 
        iprot.skip(ftype)
12427 
      iprot.readFieldEnd()
12428 
    iprot.readStructEnd()
12429 
 
12430 
  def write(self, oprot):
12431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12433 
      return
3064 chandransh 12434 
    oprot.writeStructBegin('getAlerts_result')
3431 rajveer 12435 
    if self.success is not None:
3064 chandransh 12436 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12437 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 12438 
      for iter245 in self.success:
12439 
        iter245.write(oprot)
3064 chandransh 12440 
      oprot.writeListEnd()
94 ashish 12441 
      oprot.writeFieldEnd()
12442 
    oprot.writeFieldStop()
12443 
    oprot.writeStructEnd()
12444 
 
3431 rajveer 12445 
  def validate(self):
12446 
    return
12447 
 
12448 
 
94 ashish 12449 
  def __repr__(self):
12450 
    L = ['%s=%r' % (key, value)
12451 
      for key, value in self.__dict__.iteritems()]
12452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12453 
 
12454 
  def __eq__(self, other):
12455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12456 
 
12457 
  def __ne__(self, other):
12458 
    return not (self == other)
12459 
 
4394 rajveer 12460 
class addAlert_args:
94 ashish 12461 
  """
12462 
  Attributes:
3064 chandransh 12463 
   - type
4444 rajveer 12464 
   - warehouseId
4394 rajveer 12465 
   - description
94 ashish 12466 
  """
12467 
 
12468 
  thrift_spec = (
12469 
    None, # 0
4394 rajveer 12470 
    (1, TType.I64, 'type', None, None, ), # 1
4444 rajveer 12471 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
12472 
    (3, TType.STRING, 'description', None, None, ), # 3
94 ashish 12473 
  )
12474 
 
4444 rajveer 12475 
  def __init__(self, type=None, warehouseId=None, description=None,):
3064 chandransh 12476 
    self.type = type
4444 rajveer 12477 
    self.warehouseId = warehouseId
4394 rajveer 12478 
    self.description = description
94 ashish 12479 
 
12480 
  def read(self, iprot):
12481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12483 
      return
12484 
    iprot.readStructBegin()
12485 
    while True:
12486 
      (fname, ftype, fid) = iprot.readFieldBegin()
12487 
      if ftype == TType.STOP:
12488 
        break
12489 
      if fid == 1:
12490 
        if ftype == TType.I64:
4394 rajveer 12491 
          self.type = iprot.readI64();
94 ashish 12492 
        else:
12493 
          iprot.skip(ftype)
3064 chandransh 12494 
      elif fid == 2:
4444 rajveer 12495 
        if ftype == TType.I64:
12496 
          self.warehouseId = iprot.readI64();
12497 
        else:
12498 
          iprot.skip(ftype)
12499 
      elif fid == 3:
3064 chandransh 12500 
        if ftype == TType.STRING:
4394 rajveer 12501 
          self.description = iprot.readString();
3064 chandransh 12502 
        else:
12503 
          iprot.skip(ftype)
94 ashish 12504 
      else:
12505 
        iprot.skip(ftype)
12506 
      iprot.readFieldEnd()
12507 
    iprot.readStructEnd()
12508 
 
12509 
  def write(self, oprot):
12510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12512 
      return
4394 rajveer 12513 
    oprot.writeStructBegin('addAlert_args')
3431 rajveer 12514 
    if self.type is not None:
4394 rajveer 12515 
      oprot.writeFieldBegin('type', TType.I64, 1)
3064 chandransh 12516 
      oprot.writeI64(self.type)
12517 
      oprot.writeFieldEnd()
4444 rajveer 12518 
    if self.warehouseId is not None:
12519 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
12520 
      oprot.writeI64(self.warehouseId)
12521 
      oprot.writeFieldEnd()
4394 rajveer 12522 
    if self.description is not None:
4444 rajveer 12523 
      oprot.writeFieldBegin('description', TType.STRING, 3)
4394 rajveer 12524 
      oprot.writeString(self.description)
3064 chandransh 12525 
      oprot.writeFieldEnd()
94 ashish 12526 
    oprot.writeFieldStop()
12527 
    oprot.writeStructEnd()
12528 
 
3431 rajveer 12529 
  def validate(self):
12530 
    return
12531 
 
12532 
 
94 ashish 12533 
  def __repr__(self):
12534 
    L = ['%s=%r' % (key, value)
12535 
      for key, value in self.__dict__.iteritems()]
12536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12537 
 
12538 
  def __eq__(self, other):
12539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12540 
 
12541 
  def __ne__(self, other):
12542 
    return not (self == other)
12543 
 
4394 rajveer 12544 
class addAlert_result:
3064 chandransh 12545 
 
12546 
  thrift_spec = (
12547 
  )
12548 
 
12549 
  def read(self, iprot):
12550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12552 
      return
12553 
    iprot.readStructBegin()
12554 
    while True:
12555 
      (fname, ftype, fid) = iprot.readFieldBegin()
12556 
      if ftype == TType.STOP:
12557 
        break
12558 
      else:
12559 
        iprot.skip(ftype)
12560 
      iprot.readFieldEnd()
12561 
    iprot.readStructEnd()
12562 
 
12563 
  def write(self, oprot):
12564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12566 
      return
4394 rajveer 12567 
    oprot.writeStructBegin('addAlert_result')
3064 chandransh 12568 
    oprot.writeFieldStop()
12569 
    oprot.writeStructEnd()
12570 
 
3431 rajveer 12571 
  def validate(self):
12572 
    return
12573 
 
12574 
 
3064 chandransh 12575 
  def __repr__(self):
12576 
    L = ['%s=%r' % (key, value)
12577 
      for key, value in self.__dict__.iteritems()]
12578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12579 
 
12580 
  def __eq__(self, other):
12581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12582 
 
12583 
  def __ne__(self, other):
12584 
    return not (self == other)
12585 
 
4444 rajveer 12586 
class markAlertsAsSeen_args:
12587 
  """
12588 
  Attributes:
12589 
   - warehouseId
12590 
  """
12591 
 
12592 
  thrift_spec = (
12593 
    None, # 0
12594 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
12595 
  )
12596 
 
12597 
  def __init__(self, warehouseId=None,):
12598 
    self.warehouseId = warehouseId
12599 
 
12600 
  def read(self, iprot):
12601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12603 
      return
12604 
    iprot.readStructBegin()
12605 
    while True:
12606 
      (fname, ftype, fid) = iprot.readFieldBegin()
12607 
      if ftype == TType.STOP:
12608 
        break
12609 
      if fid == 1:
12610 
        if ftype == TType.I64:
12611 
          self.warehouseId = iprot.readI64();
12612 
        else:
12613 
          iprot.skip(ftype)
12614 
      else:
12615 
        iprot.skip(ftype)
12616 
      iprot.readFieldEnd()
12617 
    iprot.readStructEnd()
12618 
 
12619 
  def write(self, oprot):
12620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12622 
      return
12623 
    oprot.writeStructBegin('markAlertsAsSeen_args')
12624 
    if self.warehouseId is not None:
12625 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
12626 
      oprot.writeI64(self.warehouseId)
12627 
      oprot.writeFieldEnd()
12628 
    oprot.writeFieldStop()
12629 
    oprot.writeStructEnd()
12630 
 
12631 
  def validate(self):
12632 
    return
12633 
 
12634 
 
12635 
  def __repr__(self):
12636 
    L = ['%s=%r' % (key, value)
12637 
      for key, value in self.__dict__.iteritems()]
12638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12639 
 
12640 
  def __eq__(self, other):
12641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12642 
 
12643 
  def __ne__(self, other):
12644 
    return not (self == other)
12645 
 
12646 
class markAlertsAsSeen_result:
12647 
 
12648 
  thrift_spec = (
12649 
  )
12650 
 
12651 
  def read(self, iprot):
12652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12654 
      return
12655 
    iprot.readStructBegin()
12656 
    while True:
12657 
      (fname, ftype, fid) = iprot.readFieldBegin()
12658 
      if ftype == TType.STOP:
12659 
        break
12660 
      else:
12661 
        iprot.skip(ftype)
12662 
      iprot.readFieldEnd()
12663 
    iprot.readStructEnd()
12664 
 
12665 
  def write(self, oprot):
12666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12668 
      return
12669 
    oprot.writeStructBegin('markAlertsAsSeen_result')
12670 
    oprot.writeFieldStop()
12671 
    oprot.writeStructEnd()
12672 
 
12673 
  def validate(self):
12674 
    return
12675 
 
12676 
 
12677 
  def __repr__(self):
12678 
    L = ['%s=%r' % (key, value)
12679 
      for key, value in self.__dict__.iteritems()]
12680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12681 
 
12682 
  def __eq__(self, other):
12683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12684 
 
12685 
  def __ne__(self, other):
12686 
    return not (self == other)
12687 
 
3064 chandransh 12688 
class getValidOrderCount_args:
12689 
 
12690 
  thrift_spec = (
12691 
  )
12692 
 
12693 
  def read(self, iprot):
12694 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12695 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12696 
      return
12697 
    iprot.readStructBegin()
12698 
    while True:
12699 
      (fname, ftype, fid) = iprot.readFieldBegin()
12700 
      if ftype == TType.STOP:
12701 
        break
12702 
      else:
12703 
        iprot.skip(ftype)
12704 
      iprot.readFieldEnd()
12705 
    iprot.readStructEnd()
12706 
 
12707 
  def write(self, oprot):
12708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12710 
      return
12711 
    oprot.writeStructBegin('getValidOrderCount_args')
12712 
    oprot.writeFieldStop()
12713 
    oprot.writeStructEnd()
12714 
 
3431 rajveer 12715 
  def validate(self):
12716 
    return
12717 
 
12718 
 
3064 chandransh 12719 
  def __repr__(self):
12720 
    L = ['%s=%r' % (key, value)
12721 
      for key, value in self.__dict__.iteritems()]
12722 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12723 
 
12724 
  def __eq__(self, other):
12725 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12726 
 
12727 
  def __ne__(self, other):
12728 
    return not (self == other)
12729 
 
12730 
class getValidOrderCount_result:
94 ashish 12731 
  """
12732 
  Attributes:
12733 
   - success
12734 
  """
12735 
 
12736 
  thrift_spec = (
3064 chandransh 12737 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12738 
  )
12739 
 
3064 chandransh 12740 
  def __init__(self, success=None,):
94 ashish 12741 
    self.success = success
12742 
 
12743 
  def read(self, iprot):
12744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12746 
      return
12747 
    iprot.readStructBegin()
12748 
    while True:
12749 
      (fname, ftype, fid) = iprot.readFieldBegin()
12750 
      if ftype == TType.STOP:
12751 
        break
12752 
      if fid == 0:
3064 chandransh 12753 
        if ftype == TType.I64:
12754 
          self.success = iprot.readI64();
94 ashish 12755 
        else:
12756 
          iprot.skip(ftype)
12757 
      else:
12758 
        iprot.skip(ftype)
12759 
      iprot.readFieldEnd()
12760 
    iprot.readStructEnd()
12761 
 
12762 
  def write(self, oprot):
12763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12765 
      return
3064 chandransh 12766 
    oprot.writeStructBegin('getValidOrderCount_result')
3431 rajveer 12767 
    if self.success is not None:
3064 chandransh 12768 
      oprot.writeFieldBegin('success', TType.I64, 0)
12769 
      oprot.writeI64(self.success)
94 ashish 12770 
      oprot.writeFieldEnd()
12771 
    oprot.writeFieldStop()
12772 
    oprot.writeStructEnd()
12773 
 
3431 rajveer 12774 
  def validate(self):
12775 
    return
12776 
 
12777 
 
94 ashish 12778 
  def __repr__(self):
12779 
    L = ['%s=%r' % (key, value)
12780 
      for key, value in self.__dict__.iteritems()]
12781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12782 
 
12783 
  def __eq__(self, other):
12784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12785 
 
12786 
  def __ne__(self, other):
12787 
    return not (self == other)
12788 
 
3064 chandransh 12789 
class getNoOfCustomersWithSuccessfulTransaction_args:
12790 
 
12791 
  thrift_spec = (
12792 
  )
12793 
 
12794 
  def read(self, iprot):
12795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12797 
      return
12798 
    iprot.readStructBegin()
12799 
    while True:
12800 
      (fname, ftype, fid) = iprot.readFieldBegin()
12801 
      if ftype == TType.STOP:
12802 
        break
12803 
      else:
12804 
        iprot.skip(ftype)
12805 
      iprot.readFieldEnd()
12806 
    iprot.readStructEnd()
12807 
 
12808 
  def write(self, oprot):
12809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12811 
      return
12812 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
12813 
    oprot.writeFieldStop()
12814 
    oprot.writeStructEnd()
12815 
 
3431 rajveer 12816 
  def validate(self):
12817 
    return
12818 
 
12819 
 
3064 chandransh 12820 
  def __repr__(self):
12821 
    L = ['%s=%r' % (key, value)
12822 
      for key, value in self.__dict__.iteritems()]
12823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12824 
 
12825 
  def __eq__(self, other):
12826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12827 
 
12828 
  def __ne__(self, other):
12829 
    return not (self == other)
12830 
 
12831 
class getNoOfCustomersWithSuccessfulTransaction_result:
94 ashish 12832 
  """
12833 
  Attributes:
3064 chandransh 12834 
   - success
94 ashish 12835 
  """
12836 
 
12837 
  thrift_spec = (
3064 chandransh 12838 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 12839 
  )
12840 
 
3064 chandransh 12841 
  def __init__(self, success=None,):
12842 
    self.success = success
94 ashish 12843 
 
12844 
  def read(self, iprot):
12845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12847 
      return
12848 
    iprot.readStructBegin()
12849 
    while True:
12850 
      (fname, ftype, fid) = iprot.readFieldBegin()
12851 
      if ftype == TType.STOP:
12852 
        break
3064 chandransh 12853 
      if fid == 0:
94 ashish 12854 
        if ftype == TType.I64:
3064 chandransh 12855 
          self.success = iprot.readI64();
94 ashish 12856 
        else:
12857 
          iprot.skip(ftype)
12858 
      else:
12859 
        iprot.skip(ftype)
12860 
      iprot.readFieldEnd()
12861 
    iprot.readStructEnd()
12862 
 
12863 
  def write(self, oprot):
12864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12866 
      return
3064 chandransh 12867 
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
3431 rajveer 12868 
    if self.success is not None:
3064 chandransh 12869 
      oprot.writeFieldBegin('success', TType.I64, 0)
12870 
      oprot.writeI64(self.success)
94 ashish 12871 
      oprot.writeFieldEnd()
12872 
    oprot.writeFieldStop()
12873 
    oprot.writeStructEnd()
12874 
 
3431 rajveer 12875 
  def validate(self):
12876 
    return
12877 
 
12878 
 
94 ashish 12879 
  def __repr__(self):
12880 
    L = ['%s=%r' % (key, value)
12881 
      for key, value in self.__dict__.iteritems()]
12882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12883 
 
12884 
  def __eq__(self, other):
12885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12886 
 
12887 
  def __ne__(self, other):
12888 
    return not (self == other)
12889 
 
3064 chandransh 12890 
class getValidOrdersAmountRange_args:
12891 
 
12892 
  thrift_spec = (
12893 
  )
12894 
 
12895 
  def read(self, iprot):
12896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12898 
      return
12899 
    iprot.readStructBegin()
12900 
    while True:
12901 
      (fname, ftype, fid) = iprot.readFieldBegin()
12902 
      if ftype == TType.STOP:
12903 
        break
12904 
      else:
12905 
        iprot.skip(ftype)
12906 
      iprot.readFieldEnd()
12907 
    iprot.readStructEnd()
12908 
 
12909 
  def write(self, oprot):
12910 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12911 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12912 
      return
12913 
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
12914 
    oprot.writeFieldStop()
12915 
    oprot.writeStructEnd()
12916 
 
3431 rajveer 12917 
  def validate(self):
12918 
    return
12919 
 
12920 
 
3064 chandransh 12921 
  def __repr__(self):
12922 
    L = ['%s=%r' % (key, value)
12923 
      for key, value in self.__dict__.iteritems()]
12924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12925 
 
12926 
  def __eq__(self, other):
12927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12928 
 
12929 
  def __ne__(self, other):
12930 
    return not (self == other)
12931 
 
12932 
class getValidOrdersAmountRange_result:
94 ashish 12933 
  """
12934 
  Attributes:
12935 
   - success
12936 
  """
12937 
 
12938 
  thrift_spec = (
3064 chandransh 12939 
    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
94 ashish 12940 
  )
12941 
 
3064 chandransh 12942 
  def __init__(self, success=None,):
94 ashish 12943 
    self.success = success
12944 
 
12945 
  def read(self, iprot):
12946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12948 
      return
12949 
    iprot.readStructBegin()
12950 
    while True:
12951 
      (fname, ftype, fid) = iprot.readFieldBegin()
12952 
      if ftype == TType.STOP:
12953 
        break
12954 
      if fid == 0:
483 rajveer 12955 
        if ftype == TType.LIST:
12956 
          self.success = []
6188 rajveer 12957 
          (_etype249, _size246) = iprot.readListBegin()
12958 
          for _i250 in xrange(_size246):
12959 
            _elem251 = iprot.readDouble();
12960 
            self.success.append(_elem251)
483 rajveer 12961 
          iprot.readListEnd()
94 ashish 12962 
        else:
12963 
          iprot.skip(ftype)
12964 
      else:
12965 
        iprot.skip(ftype)
12966 
      iprot.readFieldEnd()
12967 
    iprot.readStructEnd()
12968 
 
12969 
  def write(self, oprot):
12970 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12971 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12972 
      return
3064 chandransh 12973 
    oprot.writeStructBegin('getValidOrdersAmountRange_result')
3431 rajveer 12974 
    if self.success is not None:
483 rajveer 12975 
      oprot.writeFieldBegin('success', TType.LIST, 0)
3064 chandransh 12976 
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
6188 rajveer 12977 
      for iter252 in self.success:
12978 
        oprot.writeDouble(iter252)
483 rajveer 12979 
      oprot.writeListEnd()
94 ashish 12980 
      oprot.writeFieldEnd()
12981 
    oprot.writeFieldStop()
12982 
    oprot.writeStructEnd()
12983 
 
3431 rajveer 12984 
  def validate(self):
12985 
    return
12986 
 
12987 
 
94 ashish 12988 
  def __repr__(self):
12989 
    L = ['%s=%r' % (key, value)
12990 
      for key, value in self.__dict__.iteritems()]
12991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12992 
 
12993 
  def __eq__(self, other):
12994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12995 
 
12996 
  def __ne__(self, other):
12997 
    return not (self == other)
12998 
 
3064 chandransh 12999 
class getValidOrders_args:
1528 ankur.sing 13000 
  """
13001 
  Attributes:
3064 chandransh 13002 
   - limit
5874 rajveer 13003 
   - onlyStore
1528 ankur.sing 13004 
  """
13005 
 
13006 
  thrift_spec = (
13007 
    None, # 0
3064 chandransh 13008 
    (1, TType.I64, 'limit', None, None, ), # 1
5874 rajveer 13009 
    (2, TType.BOOL, 'onlyStore', None, None, ), # 2
1528 ankur.sing 13010 
  )
13011 
 
5874 rajveer 13012 
  def __init__(self, limit=None, onlyStore=None,):
3064 chandransh 13013 
    self.limit = limit
5874 rajveer 13014 
    self.onlyStore = onlyStore
1528 ankur.sing 13015 
 
13016 
  def read(self, iprot):
13017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13019 
      return
13020 
    iprot.readStructBegin()
13021 
    while True:
13022 
      (fname, ftype, fid) = iprot.readFieldBegin()
13023 
      if ftype == TType.STOP:
13024 
        break
13025 
      if fid == 1:
13026 
        if ftype == TType.I64:
3064 chandransh 13027 
          self.limit = iprot.readI64();
1528 ankur.sing 13028 
        else:
13029 
          iprot.skip(ftype)
5874 rajveer 13030 
      elif fid == 2:
13031 
        if ftype == TType.BOOL:
13032 
          self.onlyStore = iprot.readBool();
13033 
        else:
13034 
          iprot.skip(ftype)
1528 ankur.sing 13035 
      else:
13036 
        iprot.skip(ftype)
13037 
      iprot.readFieldEnd()
13038 
    iprot.readStructEnd()
13039 
 
13040 
  def write(self, oprot):
13041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13043 
      return
3064 chandransh 13044 
    oprot.writeStructBegin('getValidOrders_args')
3431 rajveer 13045 
    if self.limit is not None:
3064 chandransh 13046 
      oprot.writeFieldBegin('limit', TType.I64, 1)
13047 
      oprot.writeI64(self.limit)
1528 ankur.sing 13048 
      oprot.writeFieldEnd()
5874 rajveer 13049 
    if self.onlyStore is not None:
13050 
      oprot.writeFieldBegin('onlyStore', TType.BOOL, 2)
13051 
      oprot.writeBool(self.onlyStore)
13052 
      oprot.writeFieldEnd()
1528 ankur.sing 13053 
    oprot.writeFieldStop()
13054 
    oprot.writeStructEnd()
13055 
 
3431 rajveer 13056 
  def validate(self):
13057 
    return
13058 
 
13059 
 
1528 ankur.sing 13060 
  def __repr__(self):
13061 
    L = ['%s=%r' % (key, value)
13062 
      for key, value in self.__dict__.iteritems()]
13063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13064 
 
13065 
  def __eq__(self, other):
13066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13067 
 
13068 
  def __ne__(self, other):
13069 
    return not (self == other)
13070 
 
3064 chandransh 13071 
class getValidOrders_result:
1528 ankur.sing 13072 
  """
13073 
  Attributes:
13074 
   - success
13075 
  """
13076 
 
13077 
  thrift_spec = (
3064 chandransh 13078 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
1528 ankur.sing 13079 
  )
13080 
 
3064 chandransh 13081 
  def __init__(self, success=None,):
1528 ankur.sing 13082 
    self.success = success
13083 
 
13084 
  def read(self, iprot):
13085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13087 
      return
13088 
    iprot.readStructBegin()
13089 
    while True:
13090 
      (fname, ftype, fid) = iprot.readFieldBegin()
13091 
      if ftype == TType.STOP:
13092 
        break
13093 
      if fid == 0:
3064 chandransh 13094 
        if ftype == TType.LIST:
13095 
          self.success = []
6188 rajveer 13096 
          (_etype256, _size253) = iprot.readListBegin()
13097 
          for _i257 in xrange(_size253):
13098 
            _elem258 = Order()
13099 
            _elem258.read(iprot)
13100 
            self.success.append(_elem258)
3064 chandransh 13101 
          iprot.readListEnd()
1528 ankur.sing 13102 
        else:
13103 
          iprot.skip(ftype)
13104 
      else:
13105 
        iprot.skip(ftype)
13106 
      iprot.readFieldEnd()
13107 
    iprot.readStructEnd()
13108 
 
13109 
  def write(self, oprot):
13110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13112 
      return
3064 chandransh 13113 
    oprot.writeStructBegin('getValidOrders_result')
3431 rajveer 13114 
    if self.success is not None:
3064 chandransh 13115 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13116 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13117 
      for iter259 in self.success:
13118 
        iter259.write(oprot)
3064 chandransh 13119 
      oprot.writeListEnd()
1528 ankur.sing 13120 
      oprot.writeFieldEnd()
13121 
    oprot.writeFieldStop()
13122 
    oprot.writeStructEnd()
13123 
 
3431 rajveer 13124 
  def validate(self):
13125 
    return
13126 
 
13127 
 
1528 ankur.sing 13128 
  def __repr__(self):
13129 
    L = ['%s=%r' % (key, value)
13130 
      for key, value in self.__dict__.iteritems()]
13131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13132 
 
13133 
  def __eq__(self, other):
13134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13135 
 
13136 
  def __ne__(self, other):
13137 
    return not (self == other)
13138 
 
1220 chandransh 13139 
class batchOrders_args:
13140 
  """
13141 
  Attributes:
13142 
   - warehouseId
13143 
  """
13144 
 
13145 
  thrift_spec = (
13146 
    None, # 0
13147 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
13148 
  )
13149 
 
13150 
  def __init__(self, warehouseId=None,):
13151 
    self.warehouseId = warehouseId
13152 
 
13153 
  def read(self, iprot):
13154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13156 
      return
13157 
    iprot.readStructBegin()
13158 
    while True:
13159 
      (fname, ftype, fid) = iprot.readFieldBegin()
13160 
      if ftype == TType.STOP:
13161 
        break
13162 
      if fid == 1:
13163 
        if ftype == TType.I64:
13164 
          self.warehouseId = iprot.readI64();
13165 
        else:
13166 
          iprot.skip(ftype)
13167 
      else:
13168 
        iprot.skip(ftype)
13169 
      iprot.readFieldEnd()
13170 
    iprot.readStructEnd()
13171 
 
13172 
  def write(self, oprot):
13173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13175 
      return
13176 
    oprot.writeStructBegin('batchOrders_args')
3431 rajveer 13177 
    if self.warehouseId is not None:
1220 chandransh 13178 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
13179 
      oprot.writeI64(self.warehouseId)
13180 
      oprot.writeFieldEnd()
13181 
    oprot.writeFieldStop()
13182 
    oprot.writeStructEnd()
13183 
 
3431 rajveer 13184 
  def validate(self):
13185 
    return
13186 
 
13187 
 
1220 chandransh 13188 
  def __repr__(self):
13189 
    L = ['%s=%r' % (key, value)
13190 
      for key, value in self.__dict__.iteritems()]
13191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13192 
 
13193 
  def __eq__(self, other):
13194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13195 
 
13196 
  def __ne__(self, other):
13197 
    return not (self == other)
13198 
 
13199 
class batchOrders_result:
13200 
  """
13201 
  Attributes:
13202 
   - success
13203 
   - ex
13204 
  """
13205 
 
13206 
  thrift_spec = (
13207 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
13208 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13209 
  )
13210 
 
13211 
  def __init__(self, success=None, ex=None,):
13212 
    self.success = success
13213 
    self.ex = ex
13214 
 
13215 
  def read(self, iprot):
13216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13218 
      return
13219 
    iprot.readStructBegin()
13220 
    while True:
13221 
      (fname, ftype, fid) = iprot.readFieldBegin()
13222 
      if ftype == TType.STOP:
13223 
        break
13224 
      if fid == 0:
13225 
        if ftype == TType.LIST:
13226 
          self.success = []
6188 rajveer 13227 
          (_etype263, _size260) = iprot.readListBegin()
13228 
          for _i264 in xrange(_size260):
13229 
            _elem265 = Order()
13230 
            _elem265.read(iprot)
13231 
            self.success.append(_elem265)
1220 chandransh 13232 
          iprot.readListEnd()
13233 
        else:
13234 
          iprot.skip(ftype)
13235 
      elif fid == 1:
13236 
        if ftype == TType.STRUCT:
13237 
          self.ex = TransactionServiceException()
13238 
          self.ex.read(iprot)
13239 
        else:
13240 
          iprot.skip(ftype)
13241 
      else:
13242 
        iprot.skip(ftype)
13243 
      iprot.readFieldEnd()
13244 
    iprot.readStructEnd()
13245 
 
13246 
  def write(self, oprot):
13247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13249 
      return
13250 
    oprot.writeStructBegin('batchOrders_result')
3431 rajveer 13251 
    if self.success is not None:
1220 chandransh 13252 
      oprot.writeFieldBegin('success', TType.LIST, 0)
13253 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 13254 
      for iter266 in self.success:
13255 
        iter266.write(oprot)
1220 chandransh 13256 
      oprot.writeListEnd()
13257 
      oprot.writeFieldEnd()
3431 rajveer 13258 
    if self.ex is not None:
1220 chandransh 13259 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13260 
      self.ex.write(oprot)
13261 
      oprot.writeFieldEnd()
13262 
    oprot.writeFieldStop()
13263 
    oprot.writeStructEnd()
13264 
 
3431 rajveer 13265 
  def validate(self):
13266 
    return
13267 
 
13268 
 
1220 chandransh 13269 
  def __repr__(self):
13270 
    L = ['%s=%r' % (key, value)
13271 
      for key, value in self.__dict__.iteritems()]
13272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13273 
 
13274 
  def __eq__(self, other):
13275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13276 
 
13277 
  def __ne__(self, other):
13278 
    return not (self == other)
13279 
 
1208 chandransh 13280 
class markOrderAsOutOfStock_args:
13281 
  """
13282 
  Attributes:
13283 
   - orderId
13284 
  """
13285 
 
13286 
  thrift_spec = (
13287 
    None, # 0
13288 
    (1, TType.I64, 'orderId', None, None, ), # 1
13289 
  )
13290 
 
13291 
  def __init__(self, orderId=None,):
13292 
    self.orderId = orderId
13293 
 
13294 
  def read(self, iprot):
13295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13297 
      return
13298 
    iprot.readStructBegin()
13299 
    while True:
13300 
      (fname, ftype, fid) = iprot.readFieldBegin()
13301 
      if ftype == TType.STOP:
13302 
        break
13303 
      if fid == 1:
13304 
        if ftype == TType.I64:
13305 
          self.orderId = iprot.readI64();
13306 
        else:
13307 
          iprot.skip(ftype)
13308 
      else:
13309 
        iprot.skip(ftype)
13310 
      iprot.readFieldEnd()
13311 
    iprot.readStructEnd()
13312 
 
13313 
  def write(self, oprot):
13314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13316 
      return
13317 
    oprot.writeStructBegin('markOrderAsOutOfStock_args')
3431 rajveer 13318 
    if self.orderId is not None:
1208 chandransh 13319 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13320 
      oprot.writeI64(self.orderId)
13321 
      oprot.writeFieldEnd()
13322 
    oprot.writeFieldStop()
13323 
    oprot.writeStructEnd()
13324 
 
3431 rajveer 13325 
  def validate(self):
13326 
    return
13327 
 
13328 
 
1208 chandransh 13329 
  def __repr__(self):
13330 
    L = ['%s=%r' % (key, value)
13331 
      for key, value in self.__dict__.iteritems()]
13332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13333 
 
13334 
  def __eq__(self, other):
13335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13336 
 
13337 
  def __ne__(self, other):
13338 
    return not (self == other)
13339 
 
13340 
class markOrderAsOutOfStock_result:
13341 
  """
13342 
  Attributes:
13343 
   - success
13344 
   - ex
13345 
  """
13346 
 
13347 
  thrift_spec = (
13348 
    (0, TType.BOOL, 'success', None, None, ), # 0
13349 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13350 
  )
13351 
 
13352 
  def __init__(self, success=None, ex=None,):
13353 
    self.success = success
13354 
    self.ex = ex
13355 
 
13356 
  def read(self, iprot):
13357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13359 
      return
13360 
    iprot.readStructBegin()
13361 
    while True:
13362 
      (fname, ftype, fid) = iprot.readFieldBegin()
13363 
      if ftype == TType.STOP:
13364 
        break
13365 
      if fid == 0:
13366 
        if ftype == TType.BOOL:
13367 
          self.success = iprot.readBool();
13368 
        else:
13369 
          iprot.skip(ftype)
13370 
      elif fid == 1:
13371 
        if ftype == TType.STRUCT:
13372 
          self.ex = TransactionServiceException()
13373 
          self.ex.read(iprot)
13374 
        else:
13375 
          iprot.skip(ftype)
13376 
      else:
13377 
        iprot.skip(ftype)
13378 
      iprot.readFieldEnd()
13379 
    iprot.readStructEnd()
13380 
 
13381 
  def write(self, oprot):
13382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13384 
      return
13385 
    oprot.writeStructBegin('markOrderAsOutOfStock_result')
3431 rajveer 13386 
    if self.success is not None:
1208 chandransh 13387 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13388 
      oprot.writeBool(self.success)
13389 
      oprot.writeFieldEnd()
3431 rajveer 13390 
    if self.ex is not None:
1208 chandransh 13391 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13392 
      self.ex.write(oprot)
13393 
      oprot.writeFieldEnd()
13394 
    oprot.writeFieldStop()
13395 
    oprot.writeStructEnd()
13396 
 
3431 rajveer 13397 
  def validate(self):
13398 
    return
13399 
 
13400 
 
1208 chandransh 13401 
  def __repr__(self):
13402 
    L = ['%s=%r' % (key, value)
13403 
      for key, value in self.__dict__.iteritems()]
13404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13405 
 
13406 
  def __eq__(self, other):
13407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13408 
 
13409 
  def __ne__(self, other):
13410 
    return not (self == other)
13411 
 
3064 chandransh 13412 
class verifyOrder_args:
759 chandransh 13413 
  """
13414 
  Attributes:
3064 chandransh 13415 
   - orderId
759 chandransh 13416 
  """
13417 
 
13418 
  thrift_spec = (
13419 
    None, # 0
3064 chandransh 13420 
    (1, TType.I64, 'orderId', None, None, ), # 1
759 chandransh 13421 
  )
13422 
 
3064 chandransh 13423 
  def __init__(self, orderId=None,):
13424 
    self.orderId = orderId
759 chandransh 13425 
 
13426 
  def read(self, iprot):
13427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13429 
      return
13430 
    iprot.readStructBegin()
13431 
    while True:
13432 
      (fname, ftype, fid) = iprot.readFieldBegin()
13433 
      if ftype == TType.STOP:
13434 
        break
13435 
      if fid == 1:
13436 
        if ftype == TType.I64:
3064 chandransh 13437 
          self.orderId = iprot.readI64();
759 chandransh 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
3064 chandransh 13449 
    oprot.writeStructBegin('verifyOrder_args')
3431 rajveer 13450 
    if self.orderId is not None:
3064 chandransh 13451 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13452 
      oprot.writeI64(self.orderId)
759 chandransh 13453 
      oprot.writeFieldEnd()
13454 
    oprot.writeFieldStop()
13455 
    oprot.writeStructEnd()
13456 
 
3431 rajveer 13457 
  def validate(self):
13458 
    return
13459 
 
13460 
 
759 chandransh 13461 
  def __repr__(self):
13462 
    L = ['%s=%r' % (key, value)
13463 
      for key, value in self.__dict__.iteritems()]
13464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13465 
 
13466 
  def __eq__(self, other):
13467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13468 
 
13469 
  def __ne__(self, other):
13470 
    return not (self == other)
13471 
 
3064 chandransh 13472 
class verifyOrder_result:
759 chandransh 13473 
  """
13474 
  Attributes:
13475 
   - success
13476 
   - ex
13477 
  """
13478 
 
13479 
  thrift_spec = (
13480 
    (0, TType.BOOL, 'success', None, None, ), # 0
13481 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13482 
  )
13483 
 
13484 
  def __init__(self, success=None, ex=None,):
13485 
    self.success = success
13486 
    self.ex = ex
13487 
 
13488 
  def read(self, iprot):
13489 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13490 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13491 
      return
13492 
    iprot.readStructBegin()
13493 
    while True:
13494 
      (fname, ftype, fid) = iprot.readFieldBegin()
13495 
      if ftype == TType.STOP:
13496 
        break
13497 
      if fid == 0:
13498 
        if ftype == TType.BOOL:
13499 
          self.success = iprot.readBool();
13500 
        else:
13501 
          iprot.skip(ftype)
13502 
      elif fid == 1:
13503 
        if ftype == TType.STRUCT:
13504 
          self.ex = TransactionServiceException()
13505 
          self.ex.read(iprot)
13506 
        else:
13507 
          iprot.skip(ftype)
13508 
      else:
13509 
        iprot.skip(ftype)
13510 
      iprot.readFieldEnd()
13511 
    iprot.readStructEnd()
13512 
 
13513 
  def write(self, oprot):
13514 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13515 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13516 
      return
3064 chandransh 13517 
    oprot.writeStructBegin('verifyOrder_result')
3431 rajveer 13518 
    if self.success is not None:
759 chandransh 13519 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13520 
      oprot.writeBool(self.success)
13521 
      oprot.writeFieldEnd()
3431 rajveer 13522 
    if self.ex is not None:
759 chandransh 13523 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13524 
      self.ex.write(oprot)
13525 
      oprot.writeFieldEnd()
13526 
    oprot.writeFieldStop()
13527 
    oprot.writeStructEnd()
13528 
 
3431 rajveer 13529 
  def validate(self):
13530 
    return
13531 
 
13532 
 
759 chandransh 13533 
  def __repr__(self):
13534 
    L = ['%s=%r' % (key, value)
13535 
      for key, value in self.__dict__.iteritems()]
13536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13537 
 
13538 
  def __eq__(self, other):
13539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13540 
 
13541 
  def __ne__(self, other):
13542 
    return not (self == other)
13543 
 
3064 chandransh 13544 
class acceptOrder_args:
1113 chandransh 13545 
  """
13546 
  Attributes:
3064 chandransh 13547 
   - orderId
1113 chandransh 13548 
  """
13549 
 
13550 
  thrift_spec = (
13551 
    None, # 0
3064 chandransh 13552 
    (1, TType.I64, 'orderId', None, None, ), # 1
1113 chandransh 13553 
  )
13554 
 
3064 chandransh 13555 
  def __init__(self, orderId=None,):
13556 
    self.orderId = orderId
1113 chandransh 13557 
 
13558 
  def read(self, iprot):
13559 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13560 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13561 
      return
13562 
    iprot.readStructBegin()
13563 
    while True:
13564 
      (fname, ftype, fid) = iprot.readFieldBegin()
13565 
      if ftype == TType.STOP:
13566 
        break
13567 
      if fid == 1:
13568 
        if ftype == TType.I64:
3064 chandransh 13569 
          self.orderId = iprot.readI64();
1113 chandransh 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('acceptOrder_args')
3431 rajveer 13582 
    if self.orderId is not None:
3064 chandransh 13583 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13584 
      oprot.writeI64(self.orderId)
1113 chandransh 13585 
      oprot.writeFieldEnd()
13586 
    oprot.writeFieldStop()
13587 
    oprot.writeStructEnd()
13588 
 
3431 rajveer 13589 
  def validate(self):
13590 
    return
13591 
 
13592 
 
1113 chandransh 13593 
  def __repr__(self):
13594 
    L = ['%s=%r' % (key, value)
13595 
      for key, value in self.__dict__.iteritems()]
13596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13597 
 
13598 
  def __eq__(self, other):
13599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13600 
 
13601 
  def __ne__(self, other):
13602 
    return not (self == other)
13603 
 
3064 chandransh 13604 
class acceptOrder_result:
1113 chandransh 13605 
  """
13606 
  Attributes:
13607 
   - success
13608 
   - ex
13609 
  """
13610 
 
13611 
  thrift_spec = (
3064 chandransh 13612 
    (0, TType.BOOL, 'success', None, None, ), # 0
1113 chandransh 13613 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13614 
  )
13615 
 
13616 
  def __init__(self, success=None, ex=None,):
13617 
    self.success = success
13618 
    self.ex = ex
13619 
 
13620 
  def read(self, iprot):
13621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13623 
      return
13624 
    iprot.readStructBegin()
13625 
    while True:
13626 
      (fname, ftype, fid) = iprot.readFieldBegin()
13627 
      if ftype == TType.STOP:
13628 
        break
13629 
      if fid == 0:
3064 chandransh 13630 
        if ftype == TType.BOOL:
13631 
          self.success = iprot.readBool();
1113 chandransh 13632 
        else:
13633 
          iprot.skip(ftype)
13634 
      elif fid == 1:
13635 
        if ftype == TType.STRUCT:
13636 
          self.ex = TransactionServiceException()
13637 
          self.ex.read(iprot)
13638 
        else:
13639 
          iprot.skip(ftype)
13640 
      else:
13641 
        iprot.skip(ftype)
13642 
      iprot.readFieldEnd()
13643 
    iprot.readStructEnd()
13644 
 
13645 
  def write(self, oprot):
13646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13648 
      return
3064 chandransh 13649 
    oprot.writeStructBegin('acceptOrder_result')
3431 rajveer 13650 
    if self.success is not None:
3064 chandransh 13651 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13652 
      oprot.writeBool(self.success)
1113 chandransh 13653 
      oprot.writeFieldEnd()
3431 rajveer 13654 
    if self.ex is not None:
1113 chandransh 13655 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13656 
      self.ex.write(oprot)
13657 
      oprot.writeFieldEnd()
13658 
    oprot.writeFieldStop()
13659 
    oprot.writeStructEnd()
13660 
 
3431 rajveer 13661 
  def validate(self):
13662 
    return
13663 
 
13664 
 
1113 chandransh 13665 
  def __repr__(self):
13666 
    L = ['%s=%r' % (key, value)
13667 
      for key, value in self.__dict__.iteritems()]
13668 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13669 
 
13670 
  def __eq__(self, other):
13671 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13672 
 
13673 
  def __ne__(self, other):
13674 
    return not (self == other)
13675 
 
3064 chandransh 13676 
class addBillingDetails_args:
1135 chandransh 13677 
  """
13678 
  Attributes:
3064 chandransh 13679 
   - orderId
13680 
   - invoice_number
4658 mandeep.dh 13681 
   - serialNumber
4283 anupam.sin 13682 
   - itemNumber
3064 chandransh 13683 
   - billed_by
4264 rajveer 13684 
   - jacketNumber
4283 anupam.sin 13685 
   - billingType
5110 mandeep.dh 13686 
   - fulfilmentWarehouseId
4763 rajveer 13687 
   - authorize
1135 chandransh 13688 
  """
13689 
 
13690 
  thrift_spec = (
13691 
    None, # 0
3064 chandransh 13692 
    (1, TType.I64, 'orderId', None, None, ), # 1
13693 
    (2, TType.STRING, 'invoice_number', None, None, ), # 2
5411 rajveer 13694 
    (3, TType.LIST, 'serialNumber', (TType.STRING,None), None, ), # 3
13695 
    (4, TType.LIST, 'itemNumber', (TType.STRING,None), None, ), # 4
4283 anupam.sin 13696 
    (5, TType.STRING, 'billed_by', None, None, ), # 5
13697 
    (6, TType.I64, 'jacketNumber', None, None, ), # 6
13698 
    (7, TType.I64, 'billingType', None, None, ), # 7
5110 mandeep.dh 13699 
    (8, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 8
4763 rajveer 13700 
    (9, TType.BOOL, 'authorize', None, None, ), # 9
1135 chandransh 13701 
  )
13702 
 
5110 mandeep.dh 13703 
  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 13704 
    self.orderId = orderId
13705 
    self.invoice_number = invoice_number
4658 mandeep.dh 13706 
    self.serialNumber = serialNumber
4283 anupam.sin 13707 
    self.itemNumber = itemNumber
3064 chandransh 13708 
    self.billed_by = billed_by
4264 rajveer 13709 
    self.jacketNumber = jacketNumber
4283 anupam.sin 13710 
    self.billingType = billingType
5110 mandeep.dh 13711 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
4763 rajveer 13712 
    self.authorize = authorize
1135 chandransh 13713 
 
13714 
  def read(self, iprot):
13715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13717 
      return
13718 
    iprot.readStructBegin()
13719 
    while True:
13720 
      (fname, ftype, fid) = iprot.readFieldBegin()
13721 
      if ftype == TType.STOP:
13722 
        break
13723 
      if fid == 1:
13724 
        if ftype == TType.I64:
3064 chandransh 13725 
          self.orderId = iprot.readI64();
1135 chandransh 13726 
        else:
13727 
          iprot.skip(ftype)
13728 
      elif fid == 2:
3064 chandransh 13729 
        if ftype == TType.STRING:
13730 
          self.invoice_number = iprot.readString();
1135 chandransh 13731 
        else:
13732 
          iprot.skip(ftype)
3064 chandransh 13733 
      elif fid == 3:
5411 rajveer 13734 
        if ftype == TType.LIST:
13735 
          self.serialNumber = []
6188 rajveer 13736 
          (_etype270, _size267) = iprot.readListBegin()
13737 
          for _i271 in xrange(_size267):
13738 
            _elem272 = iprot.readString();
13739 
            self.serialNumber.append(_elem272)
5411 rajveer 13740 
          iprot.readListEnd()
3064 chandransh 13741 
        else:
13742 
          iprot.skip(ftype)
13743 
      elif fid == 4:
5411 rajveer 13744 
        if ftype == TType.LIST:
13745 
          self.itemNumber = []
6188 rajveer 13746 
          (_etype276, _size273) = iprot.readListBegin()
13747 
          for _i277 in xrange(_size273):
13748 
            _elem278 = iprot.readString();
13749 
            self.itemNumber.append(_elem278)
5411 rajveer 13750 
          iprot.readListEnd()
3064 chandransh 13751 
        else:
13752 
          iprot.skip(ftype)
13753 
      elif fid == 5:
13754 
        if ftype == TType.STRING:
4283 anupam.sin 13755 
          self.billed_by = iprot.readString();
3064 chandransh 13756 
        else:
13757 
          iprot.skip(ftype)
13758 
      elif fid == 6:
13759 
        if ftype == TType.I64:
4283 anupam.sin 13760 
          self.jacketNumber = iprot.readI64();
13761 
        else:
13762 
          iprot.skip(ftype)
13763 
      elif fid == 7:
13764 
        if ftype == TType.I64:
3064 chandransh 13765 
          self.billingType = iprot.readI64();
13766 
        else:
13767 
          iprot.skip(ftype)
4283 anupam.sin 13768 
      elif fid == 8:
13769 
        if ftype == TType.I64:
5110 mandeep.dh 13770 
          self.fulfilmentWarehouseId = iprot.readI64();
4283 anupam.sin 13771 
        else:
13772 
          iprot.skip(ftype)
4763 rajveer 13773 
      elif fid == 9:
13774 
        if ftype == TType.BOOL:
13775 
          self.authorize = iprot.readBool();
13776 
        else:
13777 
          iprot.skip(ftype)
1246 chandransh 13778 
      else:
13779 
        iprot.skip(ftype)
13780 
      iprot.readFieldEnd()
13781 
    iprot.readStructEnd()
13782 
 
13783 
  def write(self, oprot):
13784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13786 
      return
4283 anupam.sin 13787 
    oprot.writeStructBegin('addBillingDetails_args')
3431 rajveer 13788 
    if self.orderId is not None:
3064 chandransh 13789 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13790 
      oprot.writeI64(self.orderId)
1246 chandransh 13791 
      oprot.writeFieldEnd()
4283 anupam.sin 13792 
    if self.invoice_number is not None:
13793 
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
13794 
      oprot.writeString(self.invoice_number)
1246 chandransh 13795 
      oprot.writeFieldEnd()
4658 mandeep.dh 13796 
    if self.serialNumber is not None:
5411 rajveer 13797 
      oprot.writeFieldBegin('serialNumber', TType.LIST, 3)
13798 
      oprot.writeListBegin(TType.STRING, len(self.serialNumber))
6188 rajveer 13799 
      for iter279 in self.serialNumber:
13800 
        oprot.writeString(iter279)
5411 rajveer 13801 
      oprot.writeListEnd()
3064 chandransh 13802 
      oprot.writeFieldEnd()
3431 rajveer 13803 
    if self.itemNumber is not None:
5411 rajveer 13804 
      oprot.writeFieldBegin('itemNumber', TType.LIST, 4)
13805 
      oprot.writeListBegin(TType.STRING, len(self.itemNumber))
6188 rajveer 13806 
      for iter280 in self.itemNumber:
13807 
        oprot.writeString(iter280)
5411 rajveer 13808 
      oprot.writeListEnd()
3064 chandransh 13809 
      oprot.writeFieldEnd()
4283 anupam.sin 13810 
    if self.billed_by is not None:
13811 
      oprot.writeFieldBegin('billed_by', TType.STRING, 5)
13812 
      oprot.writeString(self.billed_by)
3064 chandransh 13813 
      oprot.writeFieldEnd()
4283 anupam.sin 13814 
    if self.jacketNumber is not None:
13815 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 6)
13816 
      oprot.writeI64(self.jacketNumber)
13817 
      oprot.writeFieldEnd()
3431 rajveer 13818 
    if self.billingType is not None:
4283 anupam.sin 13819 
      oprot.writeFieldBegin('billingType', TType.I64, 7)
3064 chandransh 13820 
      oprot.writeI64(self.billingType)
13821 
      oprot.writeFieldEnd()
5110 mandeep.dh 13822 
    if self.fulfilmentWarehouseId is not None:
13823 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 8)
13824 
      oprot.writeI64(self.fulfilmentWarehouseId)
4283 anupam.sin 13825 
      oprot.writeFieldEnd()
4763 rajveer 13826 
    if self.authorize is not None:
13827 
      oprot.writeFieldBegin('authorize', TType.BOOL, 9)
13828 
      oprot.writeBool(self.authorize)
13829 
      oprot.writeFieldEnd()
1246 chandransh 13830 
    oprot.writeFieldStop()
13831 
    oprot.writeStructEnd()
13832 
 
3431 rajveer 13833 
  def validate(self):
13834 
    return
13835 
 
13836 
 
1246 chandransh 13837 
  def __repr__(self):
13838 
    L = ['%s=%r' % (key, value)
13839 
      for key, value in self.__dict__.iteritems()]
13840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13841 
 
13842 
  def __eq__(self, other):
13843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13844 
 
13845 
  def __ne__(self, other):
13846 
    return not (self == other)
13847 
 
4283 anupam.sin 13848 
class addBillingDetails_result:
1246 chandransh 13849 
  """
13850 
  Attributes:
3064 chandransh 13851 
   - success
1246 chandransh 13852 
   - ex
13853 
  """
13854 
 
13855 
  thrift_spec = (
3064 chandransh 13856 
    (0, TType.BOOL, 'success', None, None, ), # 0
1246 chandransh 13857 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
13858 
  )
13859 
 
3064 chandransh 13860 
  def __init__(self, success=None, ex=None,):
13861 
    self.success = success
1246 chandransh 13862 
    self.ex = ex
13863 
 
13864 
  def read(self, iprot):
13865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13867 
      return
13868 
    iprot.readStructBegin()
13869 
    while True:
13870 
      (fname, ftype, fid) = iprot.readFieldBegin()
13871 
      if ftype == TType.STOP:
13872 
        break
3064 chandransh 13873 
      if fid == 0:
13874 
        if ftype == TType.BOOL:
13875 
          self.success = iprot.readBool();
13876 
        else:
13877 
          iprot.skip(ftype)
13878 
      elif fid == 1:
1246 chandransh 13879 
        if ftype == TType.STRUCT:
13880 
          self.ex = TransactionServiceException()
13881 
          self.ex.read(iprot)
13882 
        else:
13883 
          iprot.skip(ftype)
13884 
      else:
13885 
        iprot.skip(ftype)
13886 
      iprot.readFieldEnd()
13887 
    iprot.readStructEnd()
13888 
 
13889 
  def write(self, oprot):
13890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13892 
      return
4283 anupam.sin 13893 
    oprot.writeStructBegin('addBillingDetails_result')
3431 rajveer 13894 
    if self.success is not None:
3064 chandransh 13895 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
13896 
      oprot.writeBool(self.success)
13897 
      oprot.writeFieldEnd()
3431 rajveer 13898 
    if self.ex is not None:
1246 chandransh 13899 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
13900 
      self.ex.write(oprot)
13901 
      oprot.writeFieldEnd()
13902 
    oprot.writeFieldStop()
13903 
    oprot.writeStructEnd()
13904 
 
3431 rajveer 13905 
  def validate(self):
13906 
    return
13907 
 
13908 
 
1246 chandransh 13909 
  def __repr__(self):
13910 
    L = ['%s=%r' % (key, value)
13911 
      for key, value in self.__dict__.iteritems()]
13912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
13913 
 
13914 
  def __eq__(self, other):
13915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
13916 
 
13917 
  def __ne__(self, other):
13918 
    return not (self == other)
13919 
 
4579 rajveer 13920 
class addInvoiceNumber_args:
13921 
  """
13922 
  Attributes:
13923 
   - orderId
13924 
   - invoiceNumber
4763 rajveer 13925 
   - color
6756 amar.kumar 13926 
   - serialNumber
13927 
   - itemNumber
4579 rajveer 13928 
  """
13929 
 
13930 
  thrift_spec = (
13931 
    None, # 0
13932 
    (1, TType.I64, 'orderId', None, None, ), # 1
13933 
    (2, TType.STRING, 'invoiceNumber', None, None, ), # 2
4763 rajveer 13934 
    (3, TType.STRING, 'color', None, None, ), # 3
6756 amar.kumar 13935 
    (4, TType.STRING, 'serialNumber', None, None, ), # 4
13936 
    (5, TType.STRING, 'itemNumber', None, None, ), # 5
4579 rajveer 13937 
  )
13938 
 
6756 amar.kumar 13939 
  def __init__(self, orderId=None, invoiceNumber=None, color=None, serialNumber=None, itemNumber=None,):
4579 rajveer 13940 
    self.orderId = orderId
13941 
    self.invoiceNumber = invoiceNumber
4763 rajveer 13942 
    self.color = color
6756 amar.kumar 13943 
    self.serialNumber = serialNumber
13944 
    self.itemNumber = itemNumber
4579 rajveer 13945 
 
13946 
  def read(self, iprot):
13947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
13948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
13949 
      return
13950 
    iprot.readStructBegin()
13951 
    while True:
13952 
      (fname, ftype, fid) = iprot.readFieldBegin()
13953 
      if ftype == TType.STOP:
13954 
        break
13955 
      if fid == 1:
13956 
        if ftype == TType.I64:
13957 
          self.orderId = iprot.readI64();
13958 
        else:
13959 
          iprot.skip(ftype)
13960 
      elif fid == 2:
13961 
        if ftype == TType.STRING:
13962 
          self.invoiceNumber = iprot.readString();
13963 
        else:
13964 
          iprot.skip(ftype)
4763 rajveer 13965 
      elif fid == 3:
13966 
        if ftype == TType.STRING:
13967 
          self.color = iprot.readString();
13968 
        else:
13969 
          iprot.skip(ftype)
6756 amar.kumar 13970 
      elif fid == 4:
13971 
        if ftype == TType.STRING:
13972 
          self.serialNumber = iprot.readString();
13973 
        else:
13974 
          iprot.skip(ftype)
13975 
      elif fid == 5:
13976 
        if ftype == TType.STRING:
13977 
          self.itemNumber = iprot.readString();
13978 
        else:
13979 
          iprot.skip(ftype)
4579 rajveer 13980 
      else:
13981 
        iprot.skip(ftype)
13982 
      iprot.readFieldEnd()
13983 
    iprot.readStructEnd()
13984 
 
13985 
  def write(self, oprot):
13986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
13987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
13988 
      return
13989 
    oprot.writeStructBegin('addInvoiceNumber_args')
13990 
    if self.orderId is not None:
13991 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
13992 
      oprot.writeI64(self.orderId)
13993 
      oprot.writeFieldEnd()
13994 
    if self.invoiceNumber is not None:
13995 
      oprot.writeFieldBegin('invoiceNumber', TType.STRING, 2)
13996 
      oprot.writeString(self.invoiceNumber)
13997 
      oprot.writeFieldEnd()
4763 rajveer 13998 
    if self.color is not None:
13999 
      oprot.writeFieldBegin('color', TType.STRING, 3)
14000 
      oprot.writeString(self.color)
14001 
      oprot.writeFieldEnd()
6756 amar.kumar 14002 
    if self.serialNumber is not None:
14003 
      oprot.writeFieldBegin('serialNumber', TType.STRING, 4)
14004 
      oprot.writeString(self.serialNumber)
14005 
      oprot.writeFieldEnd()
14006 
    if self.itemNumber is not None:
14007 
      oprot.writeFieldBegin('itemNumber', TType.STRING, 5)
14008 
      oprot.writeString(self.itemNumber)
14009 
      oprot.writeFieldEnd()
4579 rajveer 14010 
    oprot.writeFieldStop()
14011 
    oprot.writeStructEnd()
14012 
 
14013 
  def validate(self):
14014 
    return
14015 
 
14016 
 
14017 
  def __repr__(self):
14018 
    L = ['%s=%r' % (key, value)
14019 
      for key, value in self.__dict__.iteritems()]
14020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14021 
 
14022 
  def __eq__(self, other):
14023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14024 
 
14025 
  def __ne__(self, other):
14026 
    return not (self == other)
14027 
 
14028 
class addInvoiceNumber_result:
14029 
  """
14030 
  Attributes:
14031 
   - ex
14032 
  """
14033 
 
14034 
  thrift_spec = (
14035 
    None, # 0
14036 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14037 
  )
14038 
 
14039 
  def __init__(self, ex=None,):
14040 
    self.ex = ex
14041 
 
14042 
  def read(self, iprot):
14043 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14044 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14045 
      return
14046 
    iprot.readStructBegin()
14047 
    while True:
14048 
      (fname, ftype, fid) = iprot.readFieldBegin()
14049 
      if ftype == TType.STOP:
14050 
        break
14051 
      if fid == 1:
14052 
        if ftype == TType.STRUCT:
14053 
          self.ex = TransactionServiceException()
14054 
          self.ex.read(iprot)
14055 
        else:
14056 
          iprot.skip(ftype)
14057 
      else:
14058 
        iprot.skip(ftype)
14059 
      iprot.readFieldEnd()
14060 
    iprot.readStructEnd()
14061 
 
14062 
  def write(self, oprot):
14063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14065 
      return
14066 
    oprot.writeStructBegin('addInvoiceNumber_result')
14067 
    if self.ex is not None:
14068 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14069 
      self.ex.write(oprot)
14070 
      oprot.writeFieldEnd()
14071 
    oprot.writeFieldStop()
14072 
    oprot.writeStructEnd()
14073 
 
14074 
  def validate(self):
14075 
    return
14076 
 
14077 
 
14078 
  def __repr__(self):
14079 
    L = ['%s=%r' % (key, value)
14080 
      for key, value in self.__dict__.iteritems()]
14081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14082 
 
14083 
  def __eq__(self, other):
14084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14085 
 
14086 
  def __ne__(self, other):
14087 
    return not (self == other)
14088 
 
4910 phani.kuma 14089 
class markOrdersAsShippedFromWarehouse_args:
1408 ankur.sing 14090 
  """
14091 
  Attributes:
3064 chandransh 14092 
   - warehouseId
1408 ankur.sing 14093 
   - providerId
3064 chandransh 14094 
   - cod
4910 phani.kuma 14095 
   - orderIds
1408 ankur.sing 14096 
  """
14097 
 
14098 
  thrift_spec = (
14099 
    None, # 0
3064 chandransh 14100 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
14101 
    (2, TType.I64, 'providerId', None, None, ), # 2
14102 
    (3, TType.BOOL, 'cod', None, None, ), # 3
4910 phani.kuma 14103 
    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
1408 ankur.sing 14104 
  )
14105 
 
4910 phani.kuma 14106 
  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
3064 chandransh 14107 
    self.warehouseId = warehouseId
1408 ankur.sing 14108 
    self.providerId = providerId
3064 chandransh 14109 
    self.cod = cod
4910 phani.kuma 14110 
    self.orderIds = orderIds
1408 ankur.sing 14111 
 
14112 
  def read(self, iprot):
14113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14115 
      return
14116 
    iprot.readStructBegin()
14117 
    while True:
14118 
      (fname, ftype, fid) = iprot.readFieldBegin()
14119 
      if ftype == TType.STOP:
14120 
        break
14121 
      if fid == 1:
14122 
        if ftype == TType.I64:
3064 chandransh 14123 
          self.warehouseId = iprot.readI64();
1408 ankur.sing 14124 
        else:
14125 
          iprot.skip(ftype)
14126 
      elif fid == 2:
14127 
        if ftype == TType.I64:
3064 chandransh 14128 
          self.providerId = iprot.readI64();
1408 ankur.sing 14129 
        else:
14130 
          iprot.skip(ftype)
3064 chandransh 14131 
      elif fid == 3:
14132 
        if ftype == TType.BOOL:
14133 
          self.cod = iprot.readBool();
14134 
        else:
14135 
          iprot.skip(ftype)
4910 phani.kuma 14136 
      elif fid == 4:
14137 
        if ftype == TType.LIST:
14138 
          self.orderIds = []
6188 rajveer 14139 
          (_etype284, _size281) = iprot.readListBegin()
14140 
          for _i285 in xrange(_size281):
14141 
            _elem286 = iprot.readI64();
14142 
            self.orderIds.append(_elem286)
4910 phani.kuma 14143 
          iprot.readListEnd()
14144 
        else:
14145 
          iprot.skip(ftype)
1408 ankur.sing 14146 
      else:
14147 
        iprot.skip(ftype)
14148 
      iprot.readFieldEnd()
14149 
    iprot.readStructEnd()
14150 
 
14151 
  def write(self, oprot):
14152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14154 
      return
4910 phani.kuma 14155 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
3431 rajveer 14156 
    if self.warehouseId is not None:
3064 chandransh 14157 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
14158 
      oprot.writeI64(self.warehouseId)
14159 
      oprot.writeFieldEnd()
3431 rajveer 14160 
    if self.providerId is not None:
3064 chandransh 14161 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
1408 ankur.sing 14162 
      oprot.writeI64(self.providerId)
14163 
      oprot.writeFieldEnd()
3431 rajveer 14164 
    if self.cod is not None:
3064 chandransh 14165 
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
14166 
      oprot.writeBool(self.cod)
1408 ankur.sing 14167 
      oprot.writeFieldEnd()
4910 phani.kuma 14168 
    if self.orderIds is not None:
14169 
      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
14170 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14171 
      for iter287 in self.orderIds:
14172 
        oprot.writeI64(iter287)
4910 phani.kuma 14173 
      oprot.writeListEnd()
14174 
      oprot.writeFieldEnd()
1408 ankur.sing 14175 
    oprot.writeFieldStop()
14176 
    oprot.writeStructEnd()
14177 
 
3431 rajveer 14178 
  def validate(self):
14179 
    return
14180 
 
14181 
 
1408 ankur.sing 14182 
  def __repr__(self):
14183 
    L = ['%s=%r' % (key, value)
14184 
      for key, value in self.__dict__.iteritems()]
14185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14186 
 
14187 
  def __eq__(self, other):
14188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14189 
 
14190 
  def __ne__(self, other):
14191 
    return not (self == other)
14192 
 
4910 phani.kuma 14193 
class markOrdersAsShippedFromWarehouse_result:
1408 ankur.sing 14194 
  """
14195 
  Attributes:
14196 
   - success
3064 chandransh 14197 
   - ex
1408 ankur.sing 14198 
  """
14199 
 
14200 
  thrift_spec = (
3064 chandransh 14201 
    (0, TType.BOOL, 'success', None, None, ), # 0
14202 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1408 ankur.sing 14203 
  )
14204 
 
3064 chandransh 14205 
  def __init__(self, success=None, ex=None,):
1408 ankur.sing 14206 
    self.success = success
3064 chandransh 14207 
    self.ex = ex
1408 ankur.sing 14208 
 
14209 
  def read(self, iprot):
14210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14212 
      return
14213 
    iprot.readStructBegin()
14214 
    while True:
14215 
      (fname, ftype, fid) = iprot.readFieldBegin()
14216 
      if ftype == TType.STOP:
14217 
        break
14218 
      if fid == 0:
3064 chandransh 14219 
        if ftype == TType.BOOL:
14220 
          self.success = iprot.readBool();
1408 ankur.sing 14221 
        else:
14222 
          iprot.skip(ftype)
3064 chandransh 14223 
      elif fid == 1:
14224 
        if ftype == TType.STRUCT:
14225 
          self.ex = TransactionServiceException()
14226 
          self.ex.read(iprot)
14227 
        else:
14228 
          iprot.skip(ftype)
1408 ankur.sing 14229 
      else:
14230 
        iprot.skip(ftype)
14231 
      iprot.readFieldEnd()
14232 
    iprot.readStructEnd()
14233 
 
14234 
  def write(self, oprot):
14235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14237 
      return
4910 phani.kuma 14238 
    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
3431 rajveer 14239 
    if self.success is not None:
3064 chandransh 14240 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14241 
      oprot.writeBool(self.success)
1408 ankur.sing 14242 
      oprot.writeFieldEnd()
3431 rajveer 14243 
    if self.ex is not None:
3064 chandransh 14244 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14245 
      self.ex.write(oprot)
14246 
      oprot.writeFieldEnd()
1408 ankur.sing 14247 
    oprot.writeFieldStop()
14248 
    oprot.writeStructEnd()
14249 
 
3431 rajveer 14250 
  def validate(self):
14251 
    return
14252 
 
14253 
 
1408 ankur.sing 14254 
  def __repr__(self):
14255 
    L = ['%s=%r' % (key, value)
14256 
      for key, value in self.__dict__.iteritems()]
14257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14258 
 
14259 
  def __eq__(self, other):
14260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14261 
 
14262 
  def __ne__(self, other):
14263 
    return not (self == other)
14264 
 
5676 rajveer 14265 
class markOrdersAsReturnedFromStore_args:
14266 
  """
14267 
  Attributes:
14268 
   - providerId
14269 
   - orderIds
5713 rajveer 14270 
   - awbs
5676 rajveer 14271 
  """
14272 
 
14273 
  thrift_spec = (
14274 
    None, # 0
14275 
    (1, TType.I64, 'providerId', None, None, ), # 1
14276 
    (2, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 2
5713 rajveer 14277 
    (3, TType.LIST, 'awbs', (TType.STRING,None), None, ), # 3
5676 rajveer 14278 
  )
14279 
 
5713 rajveer 14280 
  def __init__(self, providerId=None, orderIds=None, awbs=None,):
5676 rajveer 14281 
    self.providerId = providerId
14282 
    self.orderIds = orderIds
5713 rajveer 14283 
    self.awbs = awbs
5676 rajveer 14284 
 
14285 
  def read(self, iprot):
14286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14288 
      return
14289 
    iprot.readStructBegin()
14290 
    while True:
14291 
      (fname, ftype, fid) = iprot.readFieldBegin()
14292 
      if ftype == TType.STOP:
14293 
        break
14294 
      if fid == 1:
14295 
        if ftype == TType.I64:
14296 
          self.providerId = iprot.readI64();
14297 
        else:
14298 
          iprot.skip(ftype)
14299 
      elif fid == 2:
14300 
        if ftype == TType.LIST:
14301 
          self.orderIds = []
6188 rajveer 14302 
          (_etype291, _size288) = iprot.readListBegin()
14303 
          for _i292 in xrange(_size288):
14304 
            _elem293 = iprot.readI64();
14305 
            self.orderIds.append(_elem293)
5676 rajveer 14306 
          iprot.readListEnd()
14307 
        else:
14308 
          iprot.skip(ftype)
5713 rajveer 14309 
      elif fid == 3:
14310 
        if ftype == TType.LIST:
14311 
          self.awbs = []
6188 rajveer 14312 
          (_etype297, _size294) = iprot.readListBegin()
14313 
          for _i298 in xrange(_size294):
14314 
            _elem299 = iprot.readString();
14315 
            self.awbs.append(_elem299)
5713 rajveer 14316 
          iprot.readListEnd()
14317 
        else:
14318 
          iprot.skip(ftype)
5676 rajveer 14319 
      else:
14320 
        iprot.skip(ftype)
14321 
      iprot.readFieldEnd()
14322 
    iprot.readStructEnd()
14323 
 
14324 
  def write(self, oprot):
14325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14327 
      return
14328 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_args')
14329 
    if self.providerId is not None:
14330 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14331 
      oprot.writeI64(self.providerId)
14332 
      oprot.writeFieldEnd()
14333 
    if self.orderIds is not None:
14334 
      oprot.writeFieldBegin('orderIds', TType.LIST, 2)
14335 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 14336 
      for iter300 in self.orderIds:
14337 
        oprot.writeI64(iter300)
5676 rajveer 14338 
      oprot.writeListEnd()
14339 
      oprot.writeFieldEnd()
5713 rajveer 14340 
    if self.awbs is not None:
14341 
      oprot.writeFieldBegin('awbs', TType.LIST, 3)
14342 
      oprot.writeListBegin(TType.STRING, len(self.awbs))
6188 rajveer 14343 
      for iter301 in self.awbs:
14344 
        oprot.writeString(iter301)
5713 rajveer 14345 
      oprot.writeListEnd()
14346 
      oprot.writeFieldEnd()
5676 rajveer 14347 
    oprot.writeFieldStop()
14348 
    oprot.writeStructEnd()
14349 
 
14350 
  def validate(self):
14351 
    return
14352 
 
14353 
 
14354 
  def __repr__(self):
14355 
    L = ['%s=%r' % (key, value)
14356 
      for key, value in self.__dict__.iteritems()]
14357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14358 
 
14359 
  def __eq__(self, other):
14360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14361 
 
14362 
  def __ne__(self, other):
14363 
    return not (self == other)
14364 
 
14365 
class markOrdersAsReturnedFromStore_result:
14366 
  """
14367 
  Attributes:
14368 
   - success
14369 
   - ex
14370 
  """
14371 
 
14372 
  thrift_spec = (
14373 
    (0, TType.BOOL, 'success', None, None, ), # 0
14374 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14375 
  )
14376 
 
14377 
  def __init__(self, success=None, ex=None,):
14378 
    self.success = success
14379 
    self.ex = ex
14380 
 
14381 
  def read(self, iprot):
14382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14384 
      return
14385 
    iprot.readStructBegin()
14386 
    while True:
14387 
      (fname, ftype, fid) = iprot.readFieldBegin()
14388 
      if ftype == TType.STOP:
14389 
        break
14390 
      if fid == 0:
14391 
        if ftype == TType.BOOL:
14392 
          self.success = iprot.readBool();
14393 
        else:
14394 
          iprot.skip(ftype)
14395 
      elif fid == 1:
14396 
        if ftype == TType.STRUCT:
14397 
          self.ex = TransactionServiceException()
14398 
          self.ex.read(iprot)
14399 
        else:
14400 
          iprot.skip(ftype)
14401 
      else:
14402 
        iprot.skip(ftype)
14403 
      iprot.readFieldEnd()
14404 
    iprot.readStructEnd()
14405 
 
14406 
  def write(self, oprot):
14407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14409 
      return
14410 
    oprot.writeStructBegin('markOrdersAsReturnedFromStore_result')
14411 
    if self.success is not None:
14412 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
14413 
      oprot.writeBool(self.success)
14414 
      oprot.writeFieldEnd()
14415 
    if self.ex is not None:
14416 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14417 
      self.ex.write(oprot)
14418 
      oprot.writeFieldEnd()
14419 
    oprot.writeFieldStop()
14420 
    oprot.writeStructEnd()
14421 
 
14422 
  def validate(self):
14423 
    return
14424 
 
14425 
 
14426 
  def __repr__(self):
14427 
    L = ['%s=%r' % (key, value)
14428 
      for key, value in self.__dict__.iteritems()]
14429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14430 
 
14431 
  def __eq__(self, other):
14432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14433 
 
14434 
  def __ne__(self, other):
14435 
    return not (self == other)
14436 
 
4910 phani.kuma 14437 
class markOrdersAsPickedUp_args:
4410 rajveer 14438 
  """
14439 
  Attributes:
14440 
   - providerId
4910 phani.kuma 14441 
   - pickupDetails
4410 rajveer 14442 
  """
14443 
 
14444 
  thrift_spec = (
14445 
    None, # 0
4910 phani.kuma 14446 
    (1, TType.I64, 'providerId', None, None, ), # 1
14447 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
4410 rajveer 14448 
  )
14449 
 
4910 phani.kuma 14450 
  def __init__(self, providerId=None, pickupDetails=None,):
4410 rajveer 14451 
    self.providerId = providerId
4910 phani.kuma 14452 
    self.pickupDetails = pickupDetails
4410 rajveer 14453 
 
14454 
  def read(self, iprot):
14455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14457 
      return
14458 
    iprot.readStructBegin()
14459 
    while True:
14460 
      (fname, ftype, fid) = iprot.readFieldBegin()
14461 
      if ftype == TType.STOP:
14462 
        break
14463 
      if fid == 1:
14464 
        if ftype == TType.I64:
4910 phani.kuma 14465 
          self.providerId = iprot.readI64();
4410 rajveer 14466 
        else:
14467 
          iprot.skip(ftype)
14468 
      elif fid == 2:
4910 phani.kuma 14469 
        if ftype == TType.MAP:
14470 
          self.pickupDetails = {}
6188 rajveer 14471 
          (_ktype303, _vtype304, _size302 ) = iprot.readMapBegin()
14472 
          for _i306 in xrange(_size302):
14473 
            _key307 = iprot.readString();
14474 
            _val308 = iprot.readString();
14475 
            self.pickupDetails[_key307] = _val308
4910 phani.kuma 14476 
          iprot.readMapEnd()
4410 rajveer 14477 
        else:
14478 
          iprot.skip(ftype)
14479 
      else:
14480 
        iprot.skip(ftype)
14481 
      iprot.readFieldEnd()
14482 
    iprot.readStructEnd()
14483 
 
14484 
  def write(self, oprot):
14485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14487 
      return
4910 phani.kuma 14488 
    oprot.writeStructBegin('markOrdersAsPickedUp_args')
4410 rajveer 14489 
    if self.providerId is not None:
4910 phani.kuma 14490 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
4410 rajveer 14491 
      oprot.writeI64(self.providerId)
14492 
      oprot.writeFieldEnd()
4910 phani.kuma 14493 
    if self.pickupDetails is not None:
14494 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
14495 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 14496 
      for kiter309,viter310 in self.pickupDetails.items():
14497 
        oprot.writeString(kiter309)
14498 
        oprot.writeString(viter310)
4910 phani.kuma 14499 
      oprot.writeMapEnd()
4410 rajveer 14500 
      oprot.writeFieldEnd()
14501 
    oprot.writeFieldStop()
14502 
    oprot.writeStructEnd()
14503 
 
14504 
  def validate(self):
14505 
    return
14506 
 
14507 
 
14508 
  def __repr__(self):
14509 
    L = ['%s=%r' % (key, value)
14510 
      for key, value in self.__dict__.iteritems()]
14511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14512 
 
14513 
  def __eq__(self, other):
14514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14515 
 
14516 
  def __ne__(self, other):
14517 
    return not (self == other)
14518 
 
4910 phani.kuma 14519 
class markOrdersAsPickedUp_result:
4410 rajveer 14520 
  """
14521 
  Attributes:
14522 
   - ex
14523 
  """
14524 
 
14525 
  thrift_spec = (
4910 phani.kuma 14526 
    None, # 0
4410 rajveer 14527 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
14528 
  )
14529 
 
4910 phani.kuma 14530 
  def __init__(self, ex=None,):
4410 rajveer 14531 
    self.ex = ex
14532 
 
14533 
  def read(self, iprot):
14534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14536 
      return
14537 
    iprot.readStructBegin()
14538 
    while True:
14539 
      (fname, ftype, fid) = iprot.readFieldBegin()
14540 
      if ftype == TType.STOP:
14541 
        break
4910 phani.kuma 14542 
      if fid == 1:
4410 rajveer 14543 
        if ftype == TType.STRUCT:
14544 
          self.ex = TransactionServiceException()
14545 
          self.ex.read(iprot)
14546 
        else:
14547 
          iprot.skip(ftype)
14548 
      else:
14549 
        iprot.skip(ftype)
14550 
      iprot.readFieldEnd()
14551 
    iprot.readStructEnd()
14552 
 
14553 
  def write(self, oprot):
14554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14556 
      return
4910 phani.kuma 14557 
    oprot.writeStructBegin('markOrdersAsPickedUp_result')
4410 rajveer 14558 
    if self.ex is not None:
14559 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14560 
      self.ex.write(oprot)
14561 
      oprot.writeFieldEnd()
14562 
    oprot.writeFieldStop()
14563 
    oprot.writeStructEnd()
14564 
 
14565 
  def validate(self):
14566 
    return
14567 
 
14568 
 
14569 
  def __repr__(self):
14570 
    L = ['%s=%r' % (key, value)
14571 
      for key, value in self.__dict__.iteritems()]
14572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14573 
 
14574 
  def __eq__(self, other):
14575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14576 
 
14577 
  def __ne__(self, other):
14578 
    return not (self == other)
14579 
 
4910 phani.kuma 14580 
class getOrdersNotPickedUp_args:
304 ashish 14581 
  """
14582 
  Attributes:
3064 chandransh 14583 
   - providerId
304 ashish 14584 
  """
94 ashish 14585 
 
304 ashish 14586 
  thrift_spec = (
14587 
    None, # 0
3064 chandransh 14588 
    (1, TType.I64, 'providerId', None, None, ), # 1
304 ashish 14589 
  )
14590 
 
4910 phani.kuma 14591 
  def __init__(self, providerId=None,):
3064 chandransh 14592 
    self.providerId = providerId
304 ashish 14593 
 
14594 
  def read(self, iprot):
14595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14597 
      return
14598 
    iprot.readStructBegin()
14599 
    while True:
14600 
      (fname, ftype, fid) = iprot.readFieldBegin()
14601 
      if ftype == TType.STOP:
14602 
        break
14603 
      if fid == 1:
14604 
        if ftype == TType.I64:
3064 chandransh 14605 
          self.providerId = iprot.readI64();
304 ashish 14606 
        else:
14607 
          iprot.skip(ftype)
14608 
      else:
14609 
        iprot.skip(ftype)
14610 
      iprot.readFieldEnd()
14611 
    iprot.readStructEnd()
14612 
 
14613 
  def write(self, oprot):
14614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14616 
      return
4910 phani.kuma 14617 
    oprot.writeStructBegin('getOrdersNotPickedUp_args')
3431 rajveer 14618 
    if self.providerId is not None:
3064 chandransh 14619 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14620 
      oprot.writeI64(self.providerId)
304 ashish 14621 
      oprot.writeFieldEnd()
14622 
    oprot.writeFieldStop()
14623 
    oprot.writeStructEnd()
14624 
 
3431 rajveer 14625 
  def validate(self):
14626 
    return
14627 
 
14628 
 
304 ashish 14629 
  def __repr__(self):
14630 
    L = ['%s=%r' % (key, value)
14631 
      for key, value in self.__dict__.iteritems()]
14632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14633 
 
14634 
  def __eq__(self, other):
14635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14636 
 
14637 
  def __ne__(self, other):
14638 
    return not (self == other)
14639 
 
4910 phani.kuma 14640 
class getOrdersNotPickedUp_result:
304 ashish 14641 
  """
14642 
  Attributes:
14643 
   - success
14644 
  """
14645 
 
14646 
  thrift_spec = (
3064 chandransh 14647 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
304 ashish 14648 
  )
14649 
 
4910 phani.kuma 14650 
  def __init__(self, success=None,):
304 ashish 14651 
    self.success = success
14652 
 
14653 
  def read(self, iprot):
14654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14656 
      return
14657 
    iprot.readStructBegin()
14658 
    while True:
14659 
      (fname, ftype, fid) = iprot.readFieldBegin()
14660 
      if ftype == TType.STOP:
14661 
        break
14662 
      if fid == 0:
14663 
        if ftype == TType.LIST:
14664 
          self.success = []
6188 rajveer 14665 
          (_etype314, _size311) = iprot.readListBegin()
14666 
          for _i315 in xrange(_size311):
14667 
            _elem316 = Order()
14668 
            _elem316.read(iprot)
14669 
            self.success.append(_elem316)
304 ashish 14670 
          iprot.readListEnd()
14671 
        else:
14672 
          iprot.skip(ftype)
14673 
      else:
14674 
        iprot.skip(ftype)
14675 
      iprot.readFieldEnd()
14676 
    iprot.readStructEnd()
14677 
 
14678 
  def write(self, oprot):
14679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14681 
      return
4910 phani.kuma 14682 
    oprot.writeStructBegin('getOrdersNotPickedUp_result')
3431 rajveer 14683 
    if self.success is not None:
304 ashish 14684 
      oprot.writeFieldBegin('success', TType.LIST, 0)
14685 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 14686 
      for iter317 in self.success:
14687 
        iter317.write(oprot)
304 ashish 14688 
      oprot.writeListEnd()
14689 
      oprot.writeFieldEnd()
14690 
    oprot.writeFieldStop()
14691 
    oprot.writeStructEnd()
14692 
 
3431 rajveer 14693 
  def validate(self):
14694 
    return
14695 
 
14696 
 
304 ashish 14697 
  def __repr__(self):
14698 
    L = ['%s=%r' % (key, value)
14699 
      for key, value in self.__dict__.iteritems()]
14700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14701 
 
14702 
  def __eq__(self, other):
14703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14704 
 
14705 
  def __ne__(self, other):
14706 
    return not (self == other)
14707 
 
3064 chandransh 14708 
class markOrdersAsDelivered_args:
304 ashish 14709 
  """
14710 
  Attributes:
3064 chandransh 14711 
   - providerId
14712 
   - deliveredOrders
304 ashish 14713 
  """
14714 
 
14715 
  thrift_spec = (
14716 
    None, # 0
3064 chandransh 14717 
    (1, TType.I64, 'providerId', None, None, ), # 1
14718 
    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
304 ashish 14719 
  )
14720 
 
3064 chandransh 14721 
  def __init__(self, providerId=None, deliveredOrders=None,):
14722 
    self.providerId = providerId
14723 
    self.deliveredOrders = deliveredOrders
304 ashish 14724 
 
14725 
  def read(self, iprot):
14726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14728 
      return
14729 
    iprot.readStructBegin()
14730 
    while True:
14731 
      (fname, ftype, fid) = iprot.readFieldBegin()
14732 
      if ftype == TType.STOP:
14733 
        break
14734 
      if fid == 1:
14735 
        if ftype == TType.I64:
3064 chandransh 14736 
          self.providerId = iprot.readI64();
304 ashish 14737 
        else:
14738 
          iprot.skip(ftype)
14739 
      elif fid == 2:
3064 chandransh 14740 
        if ftype == TType.MAP:
14741 
          self.deliveredOrders = {}
6188 rajveer 14742 
          (_ktype319, _vtype320, _size318 ) = iprot.readMapBegin()
14743 
          for _i322 in xrange(_size318):
14744 
            _key323 = iprot.readString();
14745 
            _val324 = iprot.readString();
14746 
            self.deliveredOrders[_key323] = _val324
3064 chandransh 14747 
          iprot.readMapEnd()
304 ashish 14748 
        else:
14749 
          iprot.skip(ftype)
14750 
      else:
14751 
        iprot.skip(ftype)
14752 
      iprot.readFieldEnd()
14753 
    iprot.readStructEnd()
14754 
 
14755 
  def write(self, oprot):
14756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14758 
      return
3064 chandransh 14759 
    oprot.writeStructBegin('markOrdersAsDelivered_args')
3431 rajveer 14760 
    if self.providerId is not None:
3064 chandransh 14761 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14762 
      oprot.writeI64(self.providerId)
304 ashish 14763 
      oprot.writeFieldEnd()
3431 rajveer 14764 
    if self.deliveredOrders is not None:
3064 chandransh 14765 
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
14766 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
6188 rajveer 14767 
      for kiter325,viter326 in self.deliveredOrders.items():
14768 
        oprot.writeString(kiter325)
14769 
        oprot.writeString(viter326)
3064 chandransh 14770 
      oprot.writeMapEnd()
304 ashish 14771 
      oprot.writeFieldEnd()
14772 
    oprot.writeFieldStop()
14773 
    oprot.writeStructEnd()
14774 
 
3431 rajveer 14775 
  def validate(self):
14776 
    return
14777 
 
14778 
 
304 ashish 14779 
  def __repr__(self):
14780 
    L = ['%s=%r' % (key, value)
14781 
      for key, value in self.__dict__.iteritems()]
14782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14783 
 
14784 
  def __eq__(self, other):
14785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14786 
 
14787 
  def __ne__(self, other):
14788 
    return not (self == other)
14789 
 
3064 chandransh 14790 
class markOrdersAsDelivered_result:
14791 
  """
14792 
  Attributes:
14793 
   - ex
14794 
  """
304 ashish 14795 
 
14796 
  thrift_spec = (
3064 chandransh 14797 
    None, # 0
14798 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
304 ashish 14799 
  )
14800 
 
3064 chandransh 14801 
  def __init__(self, ex=None,):
14802 
    self.ex = ex
304 ashish 14803 
 
1596 ankur.sing 14804 
  def read(self, iprot):
14805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14807 
      return
14808 
    iprot.readStructBegin()
14809 
    while True:
14810 
      (fname, ftype, fid) = iprot.readFieldBegin()
14811 
      if ftype == TType.STOP:
14812 
        break
3064 chandransh 14813 
      if fid == 1:
14814 
        if ftype == TType.STRUCT:
14815 
          self.ex = TransactionServiceException()
14816 
          self.ex.read(iprot)
14817 
        else:
14818 
          iprot.skip(ftype)
1596 ankur.sing 14819 
      else:
14820 
        iprot.skip(ftype)
14821 
      iprot.readFieldEnd()
14822 
    iprot.readStructEnd()
14823 
 
14824 
  def write(self, oprot):
14825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14827 
      return
3064 chandransh 14828 
    oprot.writeStructBegin('markOrdersAsDelivered_result')
3431 rajveer 14829 
    if self.ex is not None:
3064 chandransh 14830 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14831 
      self.ex.write(oprot)
14832 
      oprot.writeFieldEnd()
1596 ankur.sing 14833 
    oprot.writeFieldStop()
14834 
    oprot.writeStructEnd()
14835 
 
3431 rajveer 14836 
  def validate(self):
14837 
    return
14838 
 
14839 
 
1596 ankur.sing 14840 
  def __repr__(self):
14841 
    L = ['%s=%r' % (key, value)
14842 
      for key, value in self.__dict__.iteritems()]
14843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14844 
 
14845 
  def __eq__(self, other):
14846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14847 
 
14848 
  def __ne__(self, other):
14849 
    return not (self == other)
14850 
 
4910 phani.kuma 14851 
class markAsRTOrders_args:
1596 ankur.sing 14852 
  """
14853 
  Attributes:
3064 chandransh 14854 
   - providerId
14855 
   - returnedOrders
1596 ankur.sing 14856 
  """
14857 
 
14858 
  thrift_spec = (
3064 chandransh 14859 
    None, # 0
14860 
    (1, TType.I64, 'providerId', None, None, ), # 1
14861 
    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1596 ankur.sing 14862 
  )
14863 
 
3064 chandransh 14864 
  def __init__(self, providerId=None, returnedOrders=None,):
14865 
    self.providerId = providerId
14866 
    self.returnedOrders = returnedOrders
1596 ankur.sing 14867 
 
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:
1596 ankur.sing 14878 
        if ftype == TType.I64:
3064 chandransh 14879 
          self.providerId = iprot.readI64();
1596 ankur.sing 14880 
        else:
14881 
          iprot.skip(ftype)
3064 chandransh 14882 
      elif fid == 2:
14883 
        if ftype == TType.MAP:
14884 
          self.returnedOrders = {}
6188 rajveer 14885 
          (_ktype328, _vtype329, _size327 ) = iprot.readMapBegin()
14886 
          for _i331 in xrange(_size327):
14887 
            _key332 = iprot.readString();
14888 
            _val333 = iprot.readString();
14889 
            self.returnedOrders[_key332] = _val333
3064 chandransh 14890 
          iprot.readMapEnd()
14891 
        else:
14892 
          iprot.skip(ftype)
1596 ankur.sing 14893 
      else:
14894 
        iprot.skip(ftype)
14895 
      iprot.readFieldEnd()
14896 
    iprot.readStructEnd()
14897 
 
14898 
  def write(self, oprot):
14899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14901 
      return
4910 phani.kuma 14902 
    oprot.writeStructBegin('markAsRTOrders_args')
3431 rajveer 14903 
    if self.providerId is not None:
3064 chandransh 14904 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
14905 
      oprot.writeI64(self.providerId)
1596 ankur.sing 14906 
      oprot.writeFieldEnd()
3431 rajveer 14907 
    if self.returnedOrders is not None:
3064 chandransh 14908 
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
14909 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
6188 rajveer 14910 
      for kiter334,viter335 in self.returnedOrders.items():
14911 
        oprot.writeString(kiter334)
14912 
        oprot.writeString(viter335)
3064 chandransh 14913 
      oprot.writeMapEnd()
14914 
      oprot.writeFieldEnd()
1596 ankur.sing 14915 
    oprot.writeFieldStop()
14916 
    oprot.writeStructEnd()
14917 
 
3431 rajveer 14918 
  def validate(self):
14919 
    return
14920 
 
14921 
 
1596 ankur.sing 14922 
  def __repr__(self):
14923 
    L = ['%s=%r' % (key, value)
14924 
      for key, value in self.__dict__.iteritems()]
14925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14926 
 
14927 
  def __eq__(self, other):
14928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14929 
 
14930 
  def __ne__(self, other):
14931 
    return not (self == other)
14932 
 
4910 phani.kuma 14933 
class markAsRTOrders_result:
3064 chandransh 14934 
  """
14935 
  Attributes:
14936 
   - ex
14937 
  """
1596 ankur.sing 14938 
 
1627 ankur.sing 14939 
  thrift_spec = (
3064 chandransh 14940 
    None, # 0
14941 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 14942 
  )
14943 
 
3064 chandransh 14944 
  def __init__(self, ex=None,):
14945 
    self.ex = ex
14946 
 
1627 ankur.sing 14947 
  def read(self, iprot):
14948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
14949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
14950 
      return
14951 
    iprot.readStructBegin()
14952 
    while True:
14953 
      (fname, ftype, fid) = iprot.readFieldBegin()
14954 
      if ftype == TType.STOP:
14955 
        break
3064 chandransh 14956 
      if fid == 1:
14957 
        if ftype == TType.STRUCT:
14958 
          self.ex = TransactionServiceException()
14959 
          self.ex.read(iprot)
14960 
        else:
14961 
          iprot.skip(ftype)
1627 ankur.sing 14962 
      else:
14963 
        iprot.skip(ftype)
14964 
      iprot.readFieldEnd()
14965 
    iprot.readStructEnd()
14966 
 
14967 
  def write(self, oprot):
14968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
14969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
14970 
      return
4910 phani.kuma 14971 
    oprot.writeStructBegin('markAsRTOrders_result')
3431 rajveer 14972 
    if self.ex is not None:
3064 chandransh 14973 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
14974 
      self.ex.write(oprot)
14975 
      oprot.writeFieldEnd()
1627 ankur.sing 14976 
    oprot.writeFieldStop()
14977 
    oprot.writeStructEnd()
14978 
 
3431 rajveer 14979 
  def validate(self):
14980 
    return
14981 
 
14982 
 
1627 ankur.sing 14983 
  def __repr__(self):
14984 
    L = ['%s=%r' % (key, value)
14985 
      for key, value in self.__dict__.iteritems()]
14986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
14987 
 
14988 
  def __eq__(self, other):
14989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
14990 
 
14991 
  def __ne__(self, other):
14992 
    return not (self == other)
14993 
 
4910 phani.kuma 14994 
class getRTOrders_args:
14995 
  """
14996 
  Attributes:
14997 
   - providerId
14998 
  """
14999 
 
15000 
  thrift_spec = (
15001 
    None, # 0
15002 
    (1, TType.I64, 'providerId', None, None, ), # 1
15003 
  )
15004 
 
15005 
  def __init__(self, providerId=None,):
15006 
    self.providerId = providerId
15007 
 
15008 
  def read(self, iprot):
15009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15011 
      return
15012 
    iprot.readStructBegin()
15013 
    while True:
15014 
      (fname, ftype, fid) = iprot.readFieldBegin()
15015 
      if ftype == TType.STOP:
15016 
        break
15017 
      if fid == 1:
15018 
        if ftype == TType.I64:
15019 
          self.providerId = iprot.readI64();
15020 
        else:
15021 
          iprot.skip(ftype)
15022 
      else:
15023 
        iprot.skip(ftype)
15024 
      iprot.readFieldEnd()
15025 
    iprot.readStructEnd()
15026 
 
15027 
  def write(self, oprot):
15028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15030 
      return
15031 
    oprot.writeStructBegin('getRTOrders_args')
15032 
    if self.providerId is not None:
15033 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15034 
      oprot.writeI64(self.providerId)
15035 
      oprot.writeFieldEnd()
15036 
    oprot.writeFieldStop()
15037 
    oprot.writeStructEnd()
15038 
 
15039 
  def validate(self):
15040 
    return
15041 
 
15042 
 
15043 
  def __repr__(self):
15044 
    L = ['%s=%r' % (key, value)
15045 
      for key, value in self.__dict__.iteritems()]
15046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15047 
 
15048 
  def __eq__(self, other):
15049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15050 
 
15051 
  def __ne__(self, other):
15052 
    return not (self == other)
15053 
 
15054 
class getRTOrders_result:
15055 
  """
15056 
  Attributes:
15057 
   - success
15058 
  """
15059 
 
15060 
  thrift_spec = (
15061 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15062 
  )
15063 
 
15064 
  def __init__(self, success=None,):
15065 
    self.success = success
15066 
 
15067 
  def read(self, iprot):
15068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15070 
      return
15071 
    iprot.readStructBegin()
15072 
    while True:
15073 
      (fname, ftype, fid) = iprot.readFieldBegin()
15074 
      if ftype == TType.STOP:
15075 
        break
15076 
      if fid == 0:
15077 
        if ftype == TType.LIST:
15078 
          self.success = []
6188 rajveer 15079 
          (_etype339, _size336) = iprot.readListBegin()
15080 
          for _i340 in xrange(_size336):
15081 
            _elem341 = Order()
15082 
            _elem341.read(iprot)
15083 
            self.success.append(_elem341)
4910 phani.kuma 15084 
          iprot.readListEnd()
15085 
        else:
15086 
          iprot.skip(ftype)
15087 
      else:
15088 
        iprot.skip(ftype)
15089 
      iprot.readFieldEnd()
15090 
    iprot.readStructEnd()
15091 
 
15092 
  def write(self, oprot):
15093 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15094 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15095 
      return
15096 
    oprot.writeStructBegin('getRTOrders_result')
15097 
    if self.success is not None:
15098 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15099 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15100 
      for iter342 in self.success:
15101 
        iter342.write(oprot)
4910 phani.kuma 15102 
      oprot.writeListEnd()
15103 
      oprot.writeFieldEnd()
15104 
    oprot.writeFieldStop()
15105 
    oprot.writeStructEnd()
15106 
 
15107 
  def validate(self):
15108 
    return
15109 
 
15110 
 
15111 
  def __repr__(self):
15112 
    L = ['%s=%r' % (key, value)
15113 
      for key, value in self.__dict__.iteritems()]
15114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15115 
 
15116 
  def __eq__(self, other):
15117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15118 
 
15119 
  def __ne__(self, other):
15120 
    return not (self == other)
15121 
 
3064 chandransh 15122 
class updateNonDeliveryReason_args:
1627 ankur.sing 15123 
  """
15124 
  Attributes:
3064 chandransh 15125 
   - providerId
15126 
   - undeliveredOrders
1627 ankur.sing 15127 
  """
15128 
 
15129 
  thrift_spec = (
3064 chandransh 15130 
    None, # 0
15131 
    (1, TType.I64, 'providerId', None, None, ), # 1
15132 
    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
1627 ankur.sing 15133 
  )
15134 
 
3064 chandransh 15135 
  def __init__(self, providerId=None, undeliveredOrders=None,):
15136 
    self.providerId = providerId
15137 
    self.undeliveredOrders = undeliveredOrders
1627 ankur.sing 15138 
 
15139 
  def read(self, iprot):
15140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15142 
      return
15143 
    iprot.readStructBegin()
15144 
    while True:
15145 
      (fname, ftype, fid) = iprot.readFieldBegin()
15146 
      if ftype == TType.STOP:
15147 
        break
3064 chandransh 15148 
      if fid == 1:
1627 ankur.sing 15149 
        if ftype == TType.I64:
3064 chandransh 15150 
          self.providerId = iprot.readI64();
1627 ankur.sing 15151 
        else:
15152 
          iprot.skip(ftype)
3064 chandransh 15153 
      elif fid == 2:
15154 
        if ftype == TType.MAP:
15155 
          self.undeliveredOrders = {}
6188 rajveer 15156 
          (_ktype344, _vtype345, _size343 ) = iprot.readMapBegin()
15157 
          for _i347 in xrange(_size343):
15158 
            _key348 = iprot.readString();
15159 
            _val349 = iprot.readString();
15160 
            self.undeliveredOrders[_key348] = _val349
3064 chandransh 15161 
          iprot.readMapEnd()
15162 
        else:
15163 
          iprot.skip(ftype)
1627 ankur.sing 15164 
      else:
15165 
        iprot.skip(ftype)
15166 
      iprot.readFieldEnd()
15167 
    iprot.readStructEnd()
15168 
 
15169 
  def write(self, oprot):
15170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15172 
      return
3064 chandransh 15173 
    oprot.writeStructBegin('updateNonDeliveryReason_args')
3431 rajveer 15174 
    if self.providerId is not None:
3064 chandransh 15175 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15176 
      oprot.writeI64(self.providerId)
1627 ankur.sing 15177 
      oprot.writeFieldEnd()
3431 rajveer 15178 
    if self.undeliveredOrders is not None:
3064 chandransh 15179 
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
15180 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
6188 rajveer 15181 
      for kiter350,viter351 in self.undeliveredOrders.items():
15182 
        oprot.writeString(kiter350)
15183 
        oprot.writeString(viter351)
3064 chandransh 15184 
      oprot.writeMapEnd()
15185 
      oprot.writeFieldEnd()
1627 ankur.sing 15186 
    oprot.writeFieldStop()
15187 
    oprot.writeStructEnd()
15188 
 
3431 rajveer 15189 
  def validate(self):
15190 
    return
15191 
 
15192 
 
1627 ankur.sing 15193 
  def __repr__(self):
15194 
    L = ['%s=%r' % (key, value)
15195 
      for key, value in self.__dict__.iteritems()]
15196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15197 
 
15198 
  def __eq__(self, other):
15199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15200 
 
15201 
  def __ne__(self, other):
15202 
    return not (self == other)
15203 
 
3064 chandransh 15204 
class updateNonDeliveryReason_result:
1627 ankur.sing 15205 
  """
15206 
  Attributes:
3064 chandransh 15207 
   - ex
1627 ankur.sing 15208 
  """
15209 
 
15210 
  thrift_spec = (
4910 phani.kuma 15211 
    None, # 0
3064 chandransh 15212 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
1627 ankur.sing 15213 
  )
15214 
 
4910 phani.kuma 15215 
  def __init__(self, ex=None,):
3064 chandransh 15216 
    self.ex = ex
1627 ankur.sing 15217 
 
15218 
  def read(self, iprot):
15219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15221 
      return
15222 
    iprot.readStructBegin()
15223 
    while True:
15224 
      (fname, ftype, fid) = iprot.readFieldBegin()
15225 
      if ftype == TType.STOP:
15226 
        break
4910 phani.kuma 15227 
      if fid == 1:
15228 
        if ftype == TType.STRUCT:
15229 
          self.ex = TransactionServiceException()
15230 
          self.ex.read(iprot)
15231 
        else:
15232 
          iprot.skip(ftype)
15233 
      else:
15234 
        iprot.skip(ftype)
15235 
      iprot.readFieldEnd()
15236 
    iprot.readStructEnd()
15237 
 
15238 
  def write(self, oprot):
15239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15241 
      return
15242 
    oprot.writeStructBegin('updateNonDeliveryReason_result')
15243 
    if self.ex is not None:
15244 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15245 
      self.ex.write(oprot)
15246 
      oprot.writeFieldEnd()
15247 
    oprot.writeFieldStop()
15248 
    oprot.writeStructEnd()
15249 
 
15250 
  def validate(self):
15251 
    return
15252 
 
15253 
 
15254 
  def __repr__(self):
15255 
    L = ['%s=%r' % (key, value)
15256 
      for key, value in self.__dict__.iteritems()]
15257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15258 
 
15259 
  def __eq__(self, other):
15260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15261 
 
15262 
  def __ne__(self, other):
15263 
    return not (self == other)
15264 
 
15265 
class getNonDeliveredOrdersbyCourier_args:
15266 
  """
15267 
  Attributes:
15268 
   - providerId
15269 
  """
15270 
 
15271 
  thrift_spec = (
15272 
    None, # 0
15273 
    (1, TType.I64, 'providerId', None, None, ), # 1
15274 
  )
15275 
 
15276 
  def __init__(self, providerId=None,):
15277 
    self.providerId = providerId
15278 
 
15279 
  def read(self, iprot):
15280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15282 
      return
15283 
    iprot.readStructBegin()
15284 
    while True:
15285 
      (fname, ftype, fid) = iprot.readFieldBegin()
15286 
      if ftype == TType.STOP:
15287 
        break
15288 
      if fid == 1:
15289 
        if ftype == TType.I64:
15290 
          self.providerId = iprot.readI64();
15291 
        else:
15292 
          iprot.skip(ftype)
15293 
      else:
15294 
        iprot.skip(ftype)
15295 
      iprot.readFieldEnd()
15296 
    iprot.readStructEnd()
15297 
 
15298 
  def write(self, oprot):
15299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15301 
      return
15302 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
15303 
    if self.providerId is not None:
15304 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15305 
      oprot.writeI64(self.providerId)
15306 
      oprot.writeFieldEnd()
15307 
    oprot.writeFieldStop()
15308 
    oprot.writeStructEnd()
15309 
 
15310 
  def validate(self):
15311 
    return
15312 
 
15313 
 
15314 
  def __repr__(self):
15315 
    L = ['%s=%r' % (key, value)
15316 
      for key, value in self.__dict__.iteritems()]
15317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15318 
 
15319 
  def __eq__(self, other):
15320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15321 
 
15322 
  def __ne__(self, other):
15323 
    return not (self == other)
15324 
 
15325 
class getNonDeliveredOrdersbyCourier_result:
15326 
  """
15327 
  Attributes:
15328 
   - success
15329 
  """
15330 
 
15331 
  thrift_spec = (
15332 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15333 
  )
15334 
 
15335 
  def __init__(self, success=None,):
15336 
    self.success = success
15337 
 
15338 
  def read(self, iprot):
15339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15341 
      return
15342 
    iprot.readStructBegin()
15343 
    while True:
15344 
      (fname, ftype, fid) = iprot.readFieldBegin()
15345 
      if ftype == TType.STOP:
15346 
        break
4581 phani.kuma 15347 
      if fid == 0:
15348 
        if ftype == TType.LIST:
15349 
          self.success = []
6188 rajveer 15350 
          (_etype355, _size352) = iprot.readListBegin()
15351 
          for _i356 in xrange(_size352):
15352 
            _elem357 = Order()
15353 
            _elem357.read(iprot)
15354 
            self.success.append(_elem357)
4581 phani.kuma 15355 
          iprot.readListEnd()
15356 
        else:
15357 
          iprot.skip(ftype)
4910 phani.kuma 15358 
      else:
15359 
        iprot.skip(ftype)
15360 
      iprot.readFieldEnd()
15361 
    iprot.readStructEnd()
15362 
 
15363 
  def write(self, oprot):
15364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15366 
      return
15367 
    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
15368 
    if self.success is not None:
15369 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15370 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15371 
      for iter358 in self.success:
15372 
        iter358.write(oprot)
4910 phani.kuma 15373 
      oprot.writeListEnd()
15374 
      oprot.writeFieldEnd()
15375 
    oprot.writeFieldStop()
15376 
    oprot.writeStructEnd()
15377 
 
15378 
  def validate(self):
15379 
    return
15380 
 
15381 
 
15382 
  def __repr__(self):
15383 
    L = ['%s=%r' % (key, value)
15384 
      for key, value in self.__dict__.iteritems()]
15385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15386 
 
15387 
  def __eq__(self, other):
15388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15389 
 
15390 
  def __ne__(self, other):
15391 
    return not (self == other)
15392 
 
15393 
class markOrdersAsLocalConnected_args:
15394 
  """
15395 
  Attributes:
15396 
   - providerId
15397 
   - local_connected_orders
15398 
  """
15399 
 
15400 
  thrift_spec = (
15401 
    None, # 0
15402 
    (1, TType.I64, 'providerId', None, None, ), # 1
15403 
    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15404 
  )
15405 
 
15406 
  def __init__(self, providerId=None, local_connected_orders=None,):
15407 
    self.providerId = providerId
15408 
    self.local_connected_orders = local_connected_orders
15409 
 
15410 
  def read(self, iprot):
15411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15413 
      return
15414 
    iprot.readStructBegin()
15415 
    while True:
15416 
      (fname, ftype, fid) = iprot.readFieldBegin()
15417 
      if ftype == TType.STOP:
15418 
        break
15419 
      if fid == 1:
15420 
        if ftype == TType.I64:
15421 
          self.providerId = iprot.readI64();
15422 
        else:
15423 
          iprot.skip(ftype)
15424 
      elif fid == 2:
15425 
        if ftype == TType.MAP:
15426 
          self.local_connected_orders = {}
6188 rajveer 15427 
          (_ktype360, _vtype361, _size359 ) = iprot.readMapBegin()
15428 
          for _i363 in xrange(_size359):
15429 
            _key364 = iprot.readString();
15430 
            _val365 = iprot.readString();
15431 
            self.local_connected_orders[_key364] = _val365
4910 phani.kuma 15432 
          iprot.readMapEnd()
15433 
        else:
15434 
          iprot.skip(ftype)
15435 
      else:
15436 
        iprot.skip(ftype)
15437 
      iprot.readFieldEnd()
15438 
    iprot.readStructEnd()
15439 
 
15440 
  def write(self, oprot):
15441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15443 
      return
15444 
    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
15445 
    if self.providerId is not None:
15446 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15447 
      oprot.writeI64(self.providerId)
15448 
      oprot.writeFieldEnd()
15449 
    if self.local_connected_orders is not None:
15450 
      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
15451 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
6188 rajveer 15452 
      for kiter366,viter367 in self.local_connected_orders.items():
15453 
        oprot.writeString(kiter366)
15454 
        oprot.writeString(viter367)
4910 phani.kuma 15455 
      oprot.writeMapEnd()
15456 
      oprot.writeFieldEnd()
15457 
    oprot.writeFieldStop()
15458 
    oprot.writeStructEnd()
15459 
 
15460 
  def validate(self):
15461 
    return
15462 
 
15463 
 
15464 
  def __repr__(self):
15465 
    L = ['%s=%r' % (key, value)
15466 
      for key, value in self.__dict__.iteritems()]
15467 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15468 
 
15469 
  def __eq__(self, other):
15470 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15471 
 
15472 
  def __ne__(self, other):
15473 
    return not (self == other)
15474 
 
15475 
class markOrdersAsLocalConnected_result:
15476 
  """
15477 
  Attributes:
15478 
   - ex
15479 
  """
15480 
 
15481 
  thrift_spec = (
15482 
    None, # 0
15483 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15484 
  )
15485 
 
15486 
  def __init__(self, ex=None,):
15487 
    self.ex = ex
15488 
 
15489 
  def read(self, iprot):
15490 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15491 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15492 
      return
15493 
    iprot.readStructBegin()
15494 
    while True:
15495 
      (fname, ftype, fid) = iprot.readFieldBegin()
15496 
      if ftype == TType.STOP:
15497 
        break
15498 
      if fid == 1:
3064 chandransh 15499 
        if ftype == TType.STRUCT:
15500 
          self.ex = TransactionServiceException()
15501 
          self.ex.read(iprot)
1627 ankur.sing 15502 
        else:
15503 
          iprot.skip(ftype)
15504 
      else:
15505 
        iprot.skip(ftype)
15506 
      iprot.readFieldEnd()
15507 
    iprot.readStructEnd()
15508 
 
15509 
  def write(self, oprot):
15510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15512 
      return
4910 phani.kuma 15513 
    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
15514 
    if self.ex is not None:
15515 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15516 
      self.ex.write(oprot)
15517 
      oprot.writeFieldEnd()
15518 
    oprot.writeFieldStop()
15519 
    oprot.writeStructEnd()
15520 
 
15521 
  def validate(self):
15522 
    return
15523 
 
15524 
 
15525 
  def __repr__(self):
15526 
    L = ['%s=%r' % (key, value)
15527 
      for key, value in self.__dict__.iteritems()]
15528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15529 
 
15530 
  def __eq__(self, other):
15531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15532 
 
15533 
  def __ne__(self, other):
15534 
    return not (self == other)
15535 
 
15536 
class getOrdersNotLocalConnected_args:
15537 
  """
15538 
  Attributes:
15539 
   - providerId
15540 
  """
15541 
 
15542 
  thrift_spec = (
15543 
    None, # 0
15544 
    (1, TType.I64, 'providerId', None, None, ), # 1
15545 
  )
15546 
 
15547 
  def __init__(self, providerId=None,):
15548 
    self.providerId = providerId
15549 
 
15550 
  def read(self, iprot):
15551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15553 
      return
15554 
    iprot.readStructBegin()
15555 
    while True:
15556 
      (fname, ftype, fid) = iprot.readFieldBegin()
15557 
      if ftype == TType.STOP:
15558 
        break
15559 
      if fid == 1:
15560 
        if ftype == TType.I64:
15561 
          self.providerId = iprot.readI64();
15562 
        else:
15563 
          iprot.skip(ftype)
15564 
      else:
15565 
        iprot.skip(ftype)
15566 
      iprot.readFieldEnd()
15567 
    iprot.readStructEnd()
15568 
 
15569 
  def write(self, oprot):
15570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15572 
      return
15573 
    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
15574 
    if self.providerId is not None:
15575 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15576 
      oprot.writeI64(self.providerId)
15577 
      oprot.writeFieldEnd()
15578 
    oprot.writeFieldStop()
15579 
    oprot.writeStructEnd()
15580 
 
15581 
  def validate(self):
15582 
    return
15583 
 
15584 
 
15585 
  def __repr__(self):
15586 
    L = ['%s=%r' % (key, value)
15587 
      for key, value in self.__dict__.iteritems()]
15588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15589 
 
15590 
  def __eq__(self, other):
15591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15592 
 
15593 
  def __ne__(self, other):
15594 
    return not (self == other)
15595 
 
15596 
class getOrdersNotLocalConnected_result:
15597 
  """
15598 
  Attributes:
15599 
   - success
15600 
  """
15601 
 
15602 
  thrift_spec = (
15603 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
15604 
  )
15605 
 
15606 
  def __init__(self, success=None,):
15607 
    self.success = success
15608 
 
15609 
  def read(self, iprot):
15610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15612 
      return
15613 
    iprot.readStructBegin()
15614 
    while True:
15615 
      (fname, ftype, fid) = iprot.readFieldBegin()
15616 
      if ftype == TType.STOP:
15617 
        break
15618 
      if fid == 0:
15619 
        if ftype == TType.LIST:
15620 
          self.success = []
6188 rajveer 15621 
          (_etype371, _size368) = iprot.readListBegin()
15622 
          for _i372 in xrange(_size368):
15623 
            _elem373 = Order()
15624 
            _elem373.read(iprot)
15625 
            self.success.append(_elem373)
4910 phani.kuma 15626 
          iprot.readListEnd()
15627 
        else:
15628 
          iprot.skip(ftype)
15629 
      else:
15630 
        iprot.skip(ftype)
15631 
      iprot.readFieldEnd()
15632 
    iprot.readStructEnd()
15633 
 
15634 
  def write(self, oprot):
15635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15637 
      return
15638 
    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
4581 phani.kuma 15639 
    if self.success is not None:
15640 
      oprot.writeFieldBegin('success', TType.LIST, 0)
15641 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 15642 
      for iter374 in self.success:
15643 
        iter374.write(oprot)
4581 phani.kuma 15644 
      oprot.writeListEnd()
15645 
      oprot.writeFieldEnd()
4910 phani.kuma 15646 
    oprot.writeFieldStop()
15647 
    oprot.writeStructEnd()
15648 
 
15649 
  def validate(self):
15650 
    return
15651 
 
15652 
 
15653 
  def __repr__(self):
15654 
    L = ['%s=%r' % (key, value)
15655 
      for key, value in self.__dict__.iteritems()]
15656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15657 
 
15658 
  def __eq__(self, other):
15659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15660 
 
15661 
  def __ne__(self, other):
15662 
    return not (self == other)
15663 
 
15664 
class markOrdersAsDestinationCityReached_args:
15665 
  """
15666 
  Attributes:
15667 
   - providerId
15668 
   - destination_city_reached_orders
15669 
  """
15670 
 
15671 
  thrift_spec = (
15672 
    None, # 0
15673 
    (1, TType.I64, 'providerId', None, None, ), # 1
15674 
    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15675 
  )
15676 
 
15677 
  def __init__(self, providerId=None, destination_city_reached_orders=None,):
15678 
    self.providerId = providerId
15679 
    self.destination_city_reached_orders = destination_city_reached_orders
15680 
 
15681 
  def read(self, iprot):
15682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15684 
      return
15685 
    iprot.readStructBegin()
15686 
    while True:
15687 
      (fname, ftype, fid) = iprot.readFieldBegin()
15688 
      if ftype == TType.STOP:
15689 
        break
15690 
      if fid == 1:
15691 
        if ftype == TType.I64:
15692 
          self.providerId = iprot.readI64();
15693 
        else:
15694 
          iprot.skip(ftype)
15695 
      elif fid == 2:
15696 
        if ftype == TType.MAP:
15697 
          self.destination_city_reached_orders = {}
6188 rajveer 15698 
          (_ktype376, _vtype377, _size375 ) = iprot.readMapBegin()
15699 
          for _i379 in xrange(_size375):
15700 
            _key380 = iprot.readString();
15701 
            _val381 = iprot.readString();
15702 
            self.destination_city_reached_orders[_key380] = _val381
4910 phani.kuma 15703 
          iprot.readMapEnd()
15704 
        else:
15705 
          iprot.skip(ftype)
15706 
      else:
15707 
        iprot.skip(ftype)
15708 
      iprot.readFieldEnd()
15709 
    iprot.readStructEnd()
15710 
 
15711 
  def write(self, oprot):
15712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15714 
      return
15715 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
15716 
    if self.providerId is not None:
15717 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15718 
      oprot.writeI64(self.providerId)
15719 
      oprot.writeFieldEnd()
15720 
    if self.destination_city_reached_orders is not None:
15721 
      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
15722 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
6188 rajveer 15723 
      for kiter382,viter383 in self.destination_city_reached_orders.items():
15724 
        oprot.writeString(kiter382)
15725 
        oprot.writeString(viter383)
4910 phani.kuma 15726 
      oprot.writeMapEnd()
15727 
      oprot.writeFieldEnd()
15728 
    oprot.writeFieldStop()
15729 
    oprot.writeStructEnd()
15730 
 
15731 
  def validate(self):
15732 
    return
15733 
 
15734 
 
15735 
  def __repr__(self):
15736 
    L = ['%s=%r' % (key, value)
15737 
      for key, value in self.__dict__.iteritems()]
15738 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15739 
 
15740 
  def __eq__(self, other):
15741 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15742 
 
15743 
  def __ne__(self, other):
15744 
    return not (self == other)
15745 
 
15746 
class markOrdersAsDestinationCityReached_result:
15747 
  """
15748 
  Attributes:
15749 
   - ex
15750 
  """
15751 
 
15752 
  thrift_spec = (
15753 
    None, # 0
15754 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15755 
  )
15756 
 
15757 
  def __init__(self, ex=None,):
15758 
    self.ex = ex
15759 
 
15760 
  def read(self, iprot):
15761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15763 
      return
15764 
    iprot.readStructBegin()
15765 
    while True:
15766 
      (fname, ftype, fid) = iprot.readFieldBegin()
15767 
      if ftype == TType.STOP:
15768 
        break
15769 
      if fid == 1:
15770 
        if ftype == TType.STRUCT:
15771 
          self.ex = TransactionServiceException()
15772 
          self.ex.read(iprot)
15773 
        else:
15774 
          iprot.skip(ftype)
15775 
      else:
15776 
        iprot.skip(ftype)
15777 
      iprot.readFieldEnd()
15778 
    iprot.readStructEnd()
15779 
 
15780 
  def write(self, oprot):
15781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15783 
      return
15784 
    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
3431 rajveer 15785 
    if self.ex is not None:
3064 chandransh 15786 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15787 
      self.ex.write(oprot)
1627 ankur.sing 15788 
      oprot.writeFieldEnd()
15789 
    oprot.writeFieldStop()
15790 
    oprot.writeStructEnd()
15791 
 
3431 rajveer 15792 
  def validate(self):
15793 
    return
15794 
 
15795 
 
1627 ankur.sing 15796 
  def __repr__(self):
15797 
    L = ['%s=%r' % (key, value)
15798 
      for key, value in self.__dict__.iteritems()]
15799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15800 
 
15801 
  def __eq__(self, other):
15802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15803 
 
15804 
  def __ne__(self, other):
15805 
    return not (self == other)
15806 
 
4910 phani.kuma 15807 
class markOrdersAsFirstDeliveryAttempted_args:
15808 
  """
15809 
  Attributes:
15810 
   - providerId
15811 
   - first_atdl_orders
15812 
  """
15813 
 
15814 
  thrift_spec = (
15815 
    None, # 0
15816 
    (1, TType.I64, 'providerId', None, None, ), # 1
15817 
    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
15818 
  )
15819 
 
15820 
  def __init__(self, providerId=None, first_atdl_orders=None,):
15821 
    self.providerId = providerId
15822 
    self.first_atdl_orders = first_atdl_orders
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.I64:
15835 
          self.providerId = iprot.readI64();
15836 
        else:
15837 
          iprot.skip(ftype)
15838 
      elif fid == 2:
15839 
        if ftype == TType.MAP:
15840 
          self.first_atdl_orders = {}
6188 rajveer 15841 
          (_ktype385, _vtype386, _size384 ) = iprot.readMapBegin()
15842 
          for _i388 in xrange(_size384):
15843 
            _key389 = iprot.readString();
15844 
            _val390 = iprot.readString();
15845 
            self.first_atdl_orders[_key389] = _val390
4910 phani.kuma 15846 
          iprot.readMapEnd()
15847 
        else:
15848 
          iprot.skip(ftype)
15849 
      else:
15850 
        iprot.skip(ftype)
15851 
      iprot.readFieldEnd()
15852 
    iprot.readStructEnd()
15853 
 
15854 
  def write(self, oprot):
15855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15857 
      return
15858 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
15859 
    if self.providerId is not None:
15860 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15861 
      oprot.writeI64(self.providerId)
15862 
      oprot.writeFieldEnd()
15863 
    if self.first_atdl_orders is not None:
15864 
      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
15865 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
6188 rajveer 15866 
      for kiter391,viter392 in self.first_atdl_orders.items():
15867 
        oprot.writeString(kiter391)
15868 
        oprot.writeString(viter392)
4910 phani.kuma 15869 
      oprot.writeMapEnd()
15870 
      oprot.writeFieldEnd()
15871 
    oprot.writeFieldStop()
15872 
    oprot.writeStructEnd()
15873 
 
15874 
  def validate(self):
15875 
    return
15876 
 
15877 
 
15878 
  def __repr__(self):
15879 
    L = ['%s=%r' % (key, value)
15880 
      for key, value in self.__dict__.iteritems()]
15881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15882 
 
15883 
  def __eq__(self, other):
15884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15885 
 
15886 
  def __ne__(self, other):
15887 
    return not (self == other)
15888 
 
15889 
class markOrdersAsFirstDeliveryAttempted_result:
15890 
  """
15891 
  Attributes:
15892 
   - ex
15893 
  """
15894 
 
15895 
  thrift_spec = (
15896 
    None, # 0
15897 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
15898 
  )
15899 
 
15900 
  def __init__(self, ex=None,):
15901 
    self.ex = ex
15902 
 
15903 
  def read(self, iprot):
15904 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15905 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15906 
      return
15907 
    iprot.readStructBegin()
15908 
    while True:
15909 
      (fname, ftype, fid) = iprot.readFieldBegin()
15910 
      if ftype == TType.STOP:
15911 
        break
15912 
      if fid == 1:
15913 
        if ftype == TType.STRUCT:
15914 
          self.ex = TransactionServiceException()
15915 
          self.ex.read(iprot)
15916 
        else:
15917 
          iprot.skip(ftype)
15918 
      else:
15919 
        iprot.skip(ftype)
15920 
      iprot.readFieldEnd()
15921 
    iprot.readStructEnd()
15922 
 
15923 
  def write(self, oprot):
15924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15926 
      return
15927 
    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
15928 
    if self.ex is not None:
15929 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
15930 
      self.ex.write(oprot)
15931 
      oprot.writeFieldEnd()
15932 
    oprot.writeFieldStop()
15933 
    oprot.writeStructEnd()
15934 
 
15935 
  def validate(self):
15936 
    return
15937 
 
15938 
 
15939 
  def __repr__(self):
15940 
    L = ['%s=%r' % (key, value)
15941 
      for key, value in self.__dict__.iteritems()]
15942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
15943 
 
15944 
  def __eq__(self, other):
15945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
15946 
 
15947 
  def __ne__(self, other):
15948 
    return not (self == other)
15949 
 
3064 chandransh 15950 
class getUndeliveredOrders_args:
1886 ankur.sing 15951 
  """
15952 
  Attributes:
3064 chandransh 15953 
   - providerId
15954 
   - warehouseId
1886 ankur.sing 15955 
  """
1627 ankur.sing 15956 
 
1886 ankur.sing 15957 
  thrift_spec = (
15958 
    None, # 0
3064 chandransh 15959 
    (1, TType.I64, 'providerId', None, None, ), # 1
15960 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
1886 ankur.sing 15961 
  )
15962 
 
3064 chandransh 15963 
  def __init__(self, providerId=None, warehouseId=None,):
15964 
    self.providerId = providerId
15965 
    self.warehouseId = warehouseId
1886 ankur.sing 15966 
 
15967 
  def read(self, iprot):
15968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
15969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
15970 
      return
15971 
    iprot.readStructBegin()
15972 
    while True:
15973 
      (fname, ftype, fid) = iprot.readFieldBegin()
15974 
      if ftype == TType.STOP:
15975 
        break
15976 
      if fid == 1:
15977 
        if ftype == TType.I64:
3064 chandransh 15978 
          self.providerId = iprot.readI64();
1886 ankur.sing 15979 
        else:
15980 
          iprot.skip(ftype)
3064 chandransh 15981 
      elif fid == 2:
15982 
        if ftype == TType.I64:
15983 
          self.warehouseId = iprot.readI64();
15984 
        else:
15985 
          iprot.skip(ftype)
1886 ankur.sing 15986 
      else:
15987 
        iprot.skip(ftype)
15988 
      iprot.readFieldEnd()
15989 
    iprot.readStructEnd()
15990 
 
15991 
  def write(self, oprot):
15992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
15993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
15994 
      return
3064 chandransh 15995 
    oprot.writeStructBegin('getUndeliveredOrders_args')
3431 rajveer 15996 
    if self.providerId is not None:
3064 chandransh 15997 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
15998 
      oprot.writeI64(self.providerId)
1886 ankur.sing 15999 
      oprot.writeFieldEnd()
3431 rajveer 16000 
    if self.warehouseId is not None:
3064 chandransh 16001 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
16002 
      oprot.writeI64(self.warehouseId)
16003 
      oprot.writeFieldEnd()
1886 ankur.sing 16004 
    oprot.writeFieldStop()
16005 
    oprot.writeStructEnd()
16006 
 
3431 rajveer 16007 
  def validate(self):
16008 
    return
16009 
 
16010 
 
1886 ankur.sing 16011 
  def __repr__(self):
16012 
    L = ['%s=%r' % (key, value)
16013 
      for key, value in self.__dict__.iteritems()]
16014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16015 
 
16016 
  def __eq__(self, other):
16017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16018 
 
16019 
  def __ne__(self, other):
16020 
    return not (self == other)
16021 
 
3064 chandransh 16022 
class getUndeliveredOrders_result:
1886 ankur.sing 16023 
  """
16024 
  Attributes:
16025 
   - success
16026 
  """
16027 
 
16028 
  thrift_spec = (
16029 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16030 
  )
16031 
 
16032 
  def __init__(self, success=None,):
16033 
    self.success = success
16034 
 
16035 
  def read(self, iprot):
16036 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16037 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16038 
      return
16039 
    iprot.readStructBegin()
16040 
    while True:
16041 
      (fname, ftype, fid) = iprot.readFieldBegin()
16042 
      if ftype == TType.STOP:
16043 
        break
16044 
      if fid == 0:
16045 
        if ftype == TType.LIST:
16046 
          self.success = []
6188 rajveer 16047 
          (_etype396, _size393) = iprot.readListBegin()
16048 
          for _i397 in xrange(_size393):
16049 
            _elem398 = Order()
16050 
            _elem398.read(iprot)
16051 
            self.success.append(_elem398)
1886 ankur.sing 16052 
          iprot.readListEnd()
16053 
        else:
16054 
          iprot.skip(ftype)
16055 
      else:
16056 
        iprot.skip(ftype)
16057 
      iprot.readFieldEnd()
16058 
    iprot.readStructEnd()
16059 
 
16060 
  def write(self, oprot):
16061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16063 
      return
3064 chandransh 16064 
    oprot.writeStructBegin('getUndeliveredOrders_result')
3431 rajveer 16065 
    if self.success is not None:
1886 ankur.sing 16066 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16067 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16068 
      for iter399 in self.success:
16069 
        iter399.write(oprot)
1886 ankur.sing 16070 
      oprot.writeListEnd()
16071 
      oprot.writeFieldEnd()
16072 
    oprot.writeFieldStop()
16073 
    oprot.writeStructEnd()
16074 
 
3431 rajveer 16075 
  def validate(self):
16076 
    return
16077 
 
16078 
 
1886 ankur.sing 16079 
  def __repr__(self):
16080 
    L = ['%s=%r' % (key, value)
16081 
      for key, value in self.__dict__.iteritems()]
16082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16083 
 
16084 
  def __eq__(self, other):
16085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16086 
 
16087 
  def __ne__(self, other):
16088 
    return not (self == other)
16089 
 
4783 phani.kuma 16090 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_args:
16091 
 
16092 
  thrift_spec = (
16093 
  )
16094 
 
16095 
  def read(self, iprot):
16096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16098 
      return
16099 
    iprot.readStructBegin()
16100 
    while True:
16101 
      (fname, ftype, fid) = iprot.readFieldBegin()
16102 
      if ftype == TType.STOP:
16103 
        break
16104 
      else:
16105 
        iprot.skip(ftype)
16106 
      iprot.readFieldEnd()
16107 
    iprot.readStructEnd()
16108 
 
16109 
  def write(self, oprot):
16110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16112 
      return
16113 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_args')
16114 
    oprot.writeFieldStop()
16115 
    oprot.writeStructEnd()
16116 
 
16117 
  def validate(self):
16118 
    return
16119 
 
16120 
 
16121 
  def __repr__(self):
16122 
    L = ['%s=%r' % (key, value)
16123 
      for key, value in self.__dict__.iteritems()]
16124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16125 
 
16126 
  def __eq__(self, other):
16127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16128 
 
16129 
  def __ne__(self, other):
16130 
    return not (self == other)
16131 
 
16132 
class getUndeliveredOrdersExpectedDeliveryDateNotMet_result:
16133 
  """
16134 
  Attributes:
16135 
   - success
16136 
  """
16137 
 
16138 
  thrift_spec = (
16139 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
16140 
  )
16141 
 
16142 
  def __init__(self, success=None,):
16143 
    self.success = success
16144 
 
16145 
  def read(self, iprot):
16146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16148 
      return
16149 
    iprot.readStructBegin()
16150 
    while True:
16151 
      (fname, ftype, fid) = iprot.readFieldBegin()
16152 
      if ftype == TType.STOP:
16153 
        break
16154 
      if fid == 0:
16155 
        if ftype == TType.LIST:
16156 
          self.success = []
6188 rajveer 16157 
          (_etype403, _size400) = iprot.readListBegin()
16158 
          for _i404 in xrange(_size400):
16159 
            _elem405 = Order()
16160 
            _elem405.read(iprot)
16161 
            self.success.append(_elem405)
4783 phani.kuma 16162 
          iprot.readListEnd()
16163 
        else:
16164 
          iprot.skip(ftype)
16165 
      else:
16166 
        iprot.skip(ftype)
16167 
      iprot.readFieldEnd()
16168 
    iprot.readStructEnd()
16169 
 
16170 
  def write(self, oprot):
16171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16173 
      return
16174 
    oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
16175 
    if self.success is not None:
16176 
      oprot.writeFieldBegin('success', TType.LIST, 0)
16177 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 16178 
      for iter406 in self.success:
16179 
        iter406.write(oprot)
4783 phani.kuma 16180 
      oprot.writeListEnd()
16181 
      oprot.writeFieldEnd()
16182 
    oprot.writeFieldStop()
16183 
    oprot.writeStructEnd()
16184 
 
16185 
  def validate(self):
16186 
    return
16187 
 
16188 
 
16189 
  def __repr__(self):
16190 
    L = ['%s=%r' % (key, value)
16191 
      for key, value in self.__dict__.iteritems()]
16192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16193 
 
16194 
  def __eq__(self, other):
16195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16196 
 
16197 
  def __ne__(self, other):
16198 
    return not (self == other)
16199 
 
2536 chandransh 16200 
class toggleDOAFlag_args:
16201 
  """
16202 
  Attributes:
16203 
   - orderId
16204 
  """
1886 ankur.sing 16205 
 
2536 chandransh 16206 
  thrift_spec = (
16207 
    None, # 0
16208 
    (1, TType.I64, 'orderId', None, None, ), # 1
16209 
  )
16210 
 
16211 
  def __init__(self, orderId=None,):
16212 
    self.orderId = orderId
16213 
 
16214 
  def read(self, iprot):
16215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16217 
      return
16218 
    iprot.readStructBegin()
16219 
    while True:
16220 
      (fname, ftype, fid) = iprot.readFieldBegin()
16221 
      if ftype == TType.STOP:
16222 
        break
16223 
      if fid == 1:
16224 
        if ftype == TType.I64:
16225 
          self.orderId = iprot.readI64();
16226 
        else:
16227 
          iprot.skip(ftype)
16228 
      else:
16229 
        iprot.skip(ftype)
16230 
      iprot.readFieldEnd()
16231 
    iprot.readStructEnd()
16232 
 
16233 
  def write(self, oprot):
16234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16236 
      return
16237 
    oprot.writeStructBegin('toggleDOAFlag_args')
3431 rajveer 16238 
    if self.orderId is not None:
2536 chandransh 16239 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16240 
      oprot.writeI64(self.orderId)
16241 
      oprot.writeFieldEnd()
16242 
    oprot.writeFieldStop()
16243 
    oprot.writeStructEnd()
16244 
 
3431 rajveer 16245 
  def validate(self):
16246 
    return
16247 
 
16248 
 
2536 chandransh 16249 
  def __repr__(self):
16250 
    L = ['%s=%r' % (key, value)
16251 
      for key, value in self.__dict__.iteritems()]
16252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16253 
 
16254 
  def __eq__(self, other):
16255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16256 
 
16257 
  def __ne__(self, other):
16258 
    return not (self == other)
16259 
 
16260 
class toggleDOAFlag_result:
16261 
  """
16262 
  Attributes:
16263 
   - success
16264 
   - ex
16265 
  """
16266 
 
16267 
  thrift_spec = (
16268 
    (0, TType.BOOL, 'success', None, None, ), # 0
16269 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16270 
  )
16271 
 
16272 
  def __init__(self, success=None, ex=None,):
16273 
    self.success = success
16274 
    self.ex = ex
16275 
 
16276 
  def read(self, iprot):
16277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16279 
      return
16280 
    iprot.readStructBegin()
16281 
    while True:
16282 
      (fname, ftype, fid) = iprot.readFieldBegin()
16283 
      if ftype == TType.STOP:
16284 
        break
16285 
      if fid == 0:
16286 
        if ftype == TType.BOOL:
16287 
          self.success = iprot.readBool();
16288 
        else:
16289 
          iprot.skip(ftype)
16290 
      elif fid == 1:
16291 
        if ftype == TType.STRUCT:
16292 
          self.ex = TransactionServiceException()
16293 
          self.ex.read(iprot)
16294 
        else:
16295 
          iprot.skip(ftype)
16296 
      else:
16297 
        iprot.skip(ftype)
16298 
      iprot.readFieldEnd()
16299 
    iprot.readStructEnd()
16300 
 
16301 
  def write(self, oprot):
16302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16304 
      return
16305 
    oprot.writeStructBegin('toggleDOAFlag_result')
3431 rajveer 16306 
    if self.success is not None:
2536 chandransh 16307 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16308 
      oprot.writeBool(self.success)
16309 
      oprot.writeFieldEnd()
3431 rajveer 16310 
    if self.ex is not None:
2536 chandransh 16311 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16312 
      self.ex.write(oprot)
16313 
      oprot.writeFieldEnd()
16314 
    oprot.writeFieldStop()
16315 
    oprot.writeStructEnd()
16316 
 
3431 rajveer 16317 
  def validate(self):
16318 
    return
16319 
 
16320 
 
2536 chandransh 16321 
  def __repr__(self):
16322 
    L = ['%s=%r' % (key, value)
16323 
      for key, value in self.__dict__.iteritems()]
16324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16325 
 
16326 
  def __eq__(self, other):
16327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16328 
 
16329 
  def __ne__(self, other):
16330 
    return not (self == other)
16331 
 
4712 rajveer 16332 
class markOrderAsDelivered_args:
16333 
  """
16334 
  Attributes:
16335 
   - orderId
16336 
   - deliveryTimestamp
16337 
   - receiver
16338 
  """
16339 
 
16340 
  thrift_spec = None
16341 
  def __init__(self, orderId=None, deliveryTimestamp=None, receiver=None,):
16342 
    self.orderId = orderId
16343 
    self.deliveryTimestamp = deliveryTimestamp
16344 
    self.receiver = receiver
16345 
 
16346 
  def read(self, iprot):
16347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16349 
      return
16350 
    iprot.readStructBegin()
16351 
    while True:
16352 
      (fname, ftype, fid) = iprot.readFieldBegin()
16353 
      if ftype == TType.STOP:
16354 
        break
16355 
      if fid == 1:
16356 
        if ftype == TType.I64:
16357 
          self.orderId = iprot.readI64();
16358 
        else:
16359 
          iprot.skip(ftype)
16360 
      elif fid == 2:
16361 
        if ftype == TType.I64:
16362 
          self.deliveryTimestamp = iprot.readI64();
16363 
        else:
16364 
          iprot.skip(ftype)
16365 
      elif fid == -1:
16366 
        if ftype == TType.STRING:
16367 
          self.receiver = iprot.readString();
16368 
        else:
16369 
          iprot.skip(ftype)
16370 
      else:
16371 
        iprot.skip(ftype)
16372 
      iprot.readFieldEnd()
16373 
    iprot.readStructEnd()
16374 
 
16375 
  def write(self, oprot):
16376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16378 
      return
16379 
    oprot.writeStructBegin('markOrderAsDelivered_args')
16380 
    if self.receiver is not None:
16381 
      oprot.writeFieldBegin('receiver', TType.STRING, -1)
16382 
      oprot.writeString(self.receiver)
16383 
      oprot.writeFieldEnd()
16384 
    if self.orderId is not None:
16385 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16386 
      oprot.writeI64(self.orderId)
16387 
      oprot.writeFieldEnd()
16388 
    if self.deliveryTimestamp is not None:
16389 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16390 
      oprot.writeI64(self.deliveryTimestamp)
16391 
      oprot.writeFieldEnd()
16392 
    oprot.writeFieldStop()
16393 
    oprot.writeStructEnd()
16394 
 
16395 
  def validate(self):
16396 
    return
16397 
 
16398 
 
16399 
  def __repr__(self):
16400 
    L = ['%s=%r' % (key, value)
16401 
      for key, value in self.__dict__.iteritems()]
16402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16403 
 
16404 
  def __eq__(self, other):
16405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16406 
 
16407 
  def __ne__(self, other):
16408 
    return not (self == other)
16409 
 
16410 
class markOrderAsDelivered_result:
16411 
  """
16412 
  Attributes:
16413 
   - ex
16414 
  """
16415 
 
16416 
  thrift_spec = (
16417 
    None, # 0
16418 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16419 
  )
16420 
 
16421 
  def __init__(self, ex=None,):
16422 
    self.ex = ex
16423 
 
16424 
  def read(self, iprot):
16425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16427 
      return
16428 
    iprot.readStructBegin()
16429 
    while True:
16430 
      (fname, ftype, fid) = iprot.readFieldBegin()
16431 
      if ftype == TType.STOP:
16432 
        break
16433 
      if fid == 1:
16434 
        if ftype == TType.STRUCT:
16435 
          self.ex = TransactionServiceException()
16436 
          self.ex.read(iprot)
16437 
        else:
16438 
          iprot.skip(ftype)
16439 
      else:
16440 
        iprot.skip(ftype)
16441 
      iprot.readFieldEnd()
16442 
    iprot.readStructEnd()
16443 
 
16444 
  def write(self, oprot):
16445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16447 
      return
16448 
    oprot.writeStructBegin('markOrderAsDelivered_result')
16449 
    if self.ex is not None:
16450 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16451 
      self.ex.write(oprot)
16452 
      oprot.writeFieldEnd()
16453 
    oprot.writeFieldStop()
16454 
    oprot.writeStructEnd()
16455 
 
16456 
  def validate(self):
16457 
    return
16458 
 
16459 
 
16460 
  def __repr__(self):
16461 
    L = ['%s=%r' % (key, value)
16462 
      for key, value in self.__dict__.iteritems()]
16463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16464 
 
16465 
  def __eq__(self, other):
16466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16467 
 
16468 
  def __ne__(self, other):
16469 
    return not (self == other)
16470 
 
5553 rajveer 16471 
class markOrderAsReceivedAtStore_args:
16472 
  """
16473 
  Attributes:
16474 
   - orderId
16475 
   - deliveryTimestamp
16476 
  """
16477 
 
16478 
  thrift_spec = (
16479 
    None, # 0
16480 
    (1, TType.I64, 'orderId', None, None, ), # 1
16481 
    (2, TType.I64, 'deliveryTimestamp', None, None, ), # 2
16482 
  )
16483 
 
16484 
  def __init__(self, orderId=None, deliveryTimestamp=None,):
16485 
    self.orderId = orderId
16486 
    self.deliveryTimestamp = deliveryTimestamp
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.I64:
16499 
          self.orderId = iprot.readI64();
16500 
        else:
16501 
          iprot.skip(ftype)
16502 
      elif fid == 2:
16503 
        if ftype == TType.I64:
16504 
          self.deliveryTimestamp = iprot.readI64();
16505 
        else:
16506 
          iprot.skip(ftype)
16507 
      else:
16508 
        iprot.skip(ftype)
16509 
      iprot.readFieldEnd()
16510 
    iprot.readStructEnd()
16511 
 
16512 
  def write(self, oprot):
16513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16515 
      return
16516 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_args')
16517 
    if self.orderId is not None:
16518 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16519 
      oprot.writeI64(self.orderId)
16520 
      oprot.writeFieldEnd()
16521 
    if self.deliveryTimestamp is not None:
16522 
      oprot.writeFieldBegin('deliveryTimestamp', TType.I64, 2)
16523 
      oprot.writeI64(self.deliveryTimestamp)
16524 
      oprot.writeFieldEnd()
16525 
    oprot.writeFieldStop()
16526 
    oprot.writeStructEnd()
16527 
 
16528 
  def validate(self):
16529 
    return
16530 
 
16531 
 
16532 
  def __repr__(self):
16533 
    L = ['%s=%r' % (key, value)
16534 
      for key, value in self.__dict__.iteritems()]
16535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16536 
 
16537 
  def __eq__(self, other):
16538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16539 
 
16540 
  def __ne__(self, other):
16541 
    return not (self == other)
16542 
 
16543 
class markOrderAsReceivedAtStore_result:
16544 
  """
16545 
  Attributes:
16546 
   - ex
16547 
  """
16548 
 
16549 
  thrift_spec = (
16550 
    None, # 0
16551 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16552 
  )
16553 
 
16554 
  def __init__(self, ex=None,):
16555 
    self.ex = ex
16556 
 
16557 
  def read(self, iprot):
16558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16560 
      return
16561 
    iprot.readStructBegin()
16562 
    while True:
16563 
      (fname, ftype, fid) = iprot.readFieldBegin()
16564 
      if ftype == TType.STOP:
16565 
        break
16566 
      if fid == 1:
16567 
        if ftype == TType.STRUCT:
16568 
          self.ex = TransactionServiceException()
16569 
          self.ex.read(iprot)
16570 
        else:
16571 
          iprot.skip(ftype)
16572 
      else:
16573 
        iprot.skip(ftype)
16574 
      iprot.readFieldEnd()
16575 
    iprot.readStructEnd()
16576 
 
16577 
  def write(self, oprot):
16578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16580 
      return
16581 
    oprot.writeStructBegin('markOrderAsReceivedAtStore_result')
16582 
    if self.ex is not None:
16583 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16584 
      self.ex.write(oprot)
16585 
      oprot.writeFieldEnd()
16586 
    oprot.writeFieldStop()
16587 
    oprot.writeStructEnd()
16588 
 
16589 
  def validate(self):
16590 
    return
16591 
 
16592 
 
16593 
  def __repr__(self):
16594 
    L = ['%s=%r' % (key, value)
16595 
      for key, value in self.__dict__.iteritems()]
16596 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16597 
 
16598 
  def __eq__(self, other):
16599 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16600 
 
16601 
  def __ne__(self, other):
16602 
    return not (self == other)
16603 
 
4454 rajveer 16604 
class markOrderDoaRequestReceived_args:
16605 
  """
16606 
  Attributes:
16607 
   - orderId
16608 
  """
16609 
 
16610 
  thrift_spec = (
16611 
    None, # 0
16612 
    (1, TType.I64, 'orderId', None, None, ), # 1
16613 
  )
16614 
 
16615 
  def __init__(self, orderId=None,):
16616 
    self.orderId = orderId
16617 
 
16618 
  def read(self, iprot):
16619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16621 
      return
16622 
    iprot.readStructBegin()
16623 
    while True:
16624 
      (fname, ftype, fid) = iprot.readFieldBegin()
16625 
      if ftype == TType.STOP:
16626 
        break
16627 
      if fid == 1:
16628 
        if ftype == TType.I64:
16629 
          self.orderId = iprot.readI64();
16630 
        else:
16631 
          iprot.skip(ftype)
16632 
      else:
16633 
        iprot.skip(ftype)
16634 
      iprot.readFieldEnd()
16635 
    iprot.readStructEnd()
16636 
 
16637 
  def write(self, oprot):
16638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16640 
      return
16641 
    oprot.writeStructBegin('markOrderDoaRequestReceived_args')
16642 
    if self.orderId is not None:
16643 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16644 
      oprot.writeI64(self.orderId)
16645 
      oprot.writeFieldEnd()
16646 
    oprot.writeFieldStop()
16647 
    oprot.writeStructEnd()
16648 
 
16649 
  def validate(self):
16650 
    return
16651 
 
16652 
 
16653 
  def __repr__(self):
16654 
    L = ['%s=%r' % (key, value)
16655 
      for key, value in self.__dict__.iteritems()]
16656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16657 
 
16658 
  def __eq__(self, other):
16659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16660 
 
16661 
  def __ne__(self, other):
16662 
    return not (self == other)
16663 
 
16664 
class markOrderDoaRequestReceived_result:
16665 
  """
16666 
  Attributes:
16667 
   - success
16668 
   - ex
16669 
  """
16670 
 
16671 
  thrift_spec = (
16672 
    (0, TType.BOOL, 'success', None, None, ), # 0
16673 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16674 
  )
16675 
 
16676 
  def __init__(self, success=None, ex=None,):
16677 
    self.success = success
16678 
    self.ex = ex
16679 
 
16680 
  def read(self, iprot):
16681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16683 
      return
16684 
    iprot.readStructBegin()
16685 
    while True:
16686 
      (fname, ftype, fid) = iprot.readFieldBegin()
16687 
      if ftype == TType.STOP:
16688 
        break
16689 
      if fid == 0:
16690 
        if ftype == TType.BOOL:
16691 
          self.success = iprot.readBool();
16692 
        else:
16693 
          iprot.skip(ftype)
16694 
      elif fid == 1:
16695 
        if ftype == TType.STRUCT:
16696 
          self.ex = TransactionServiceException()
16697 
          self.ex.read(iprot)
16698 
        else:
16699 
          iprot.skip(ftype)
16700 
      else:
16701 
        iprot.skip(ftype)
16702 
      iprot.readFieldEnd()
16703 
    iprot.readStructEnd()
16704 
 
16705 
  def write(self, oprot):
16706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16708 
      return
16709 
    oprot.writeStructBegin('markOrderDoaRequestReceived_result')
16710 
    if self.success is not None:
16711 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16712 
      oprot.writeBool(self.success)
16713 
      oprot.writeFieldEnd()
16714 
    if self.ex is not None:
16715 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16716 
      self.ex.write(oprot)
16717 
      oprot.writeFieldEnd()
16718 
    oprot.writeFieldStop()
16719 
    oprot.writeStructEnd()
16720 
 
16721 
  def validate(self):
16722 
    return
16723 
 
16724 
 
16725 
  def __repr__(self):
16726 
    L = ['%s=%r' % (key, value)
16727 
      for key, value in self.__dict__.iteritems()]
16728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16729 
 
16730 
  def __eq__(self, other):
16731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16732 
 
16733 
  def __ne__(self, other):
16734 
    return not (self == other)
16735 
 
16736 
class markOrderDoaRequestAuthorized_args:
16737 
  """
16738 
  Attributes:
16739 
   - orderId
16740 
   - isAuthorized
16741 
  """
16742 
 
16743 
  thrift_spec = (
16744 
    None, # 0
16745 
    (1, TType.I64, 'orderId', None, None, ), # 1
16746 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
16747 
  )
16748 
 
16749 
  def __init__(self, orderId=None, isAuthorized=None,):
16750 
    self.orderId = orderId
16751 
    self.isAuthorized = isAuthorized
16752 
 
16753 
  def read(self, iprot):
16754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16756 
      return
16757 
    iprot.readStructBegin()
16758 
    while True:
16759 
      (fname, ftype, fid) = iprot.readFieldBegin()
16760 
      if ftype == TType.STOP:
16761 
        break
16762 
      if fid == 1:
16763 
        if ftype == TType.I64:
16764 
          self.orderId = iprot.readI64();
16765 
        else:
16766 
          iprot.skip(ftype)
16767 
      elif fid == 2:
16768 
        if ftype == TType.BOOL:
16769 
          self.isAuthorized = iprot.readBool();
16770 
        else:
16771 
          iprot.skip(ftype)
16772 
      else:
16773 
        iprot.skip(ftype)
16774 
      iprot.readFieldEnd()
16775 
    iprot.readStructEnd()
16776 
 
16777 
  def write(self, oprot):
16778 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16779 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16780 
      return
16781 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_args')
16782 
    if self.orderId is not None:
16783 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16784 
      oprot.writeI64(self.orderId)
16785 
      oprot.writeFieldEnd()
16786 
    if self.isAuthorized is not None:
16787 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
16788 
      oprot.writeBool(self.isAuthorized)
16789 
      oprot.writeFieldEnd()
16790 
    oprot.writeFieldStop()
16791 
    oprot.writeStructEnd()
16792 
 
16793 
  def validate(self):
16794 
    return
16795 
 
16796 
 
16797 
  def __repr__(self):
16798 
    L = ['%s=%r' % (key, value)
16799 
      for key, value in self.__dict__.iteritems()]
16800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16801 
 
16802 
  def __eq__(self, other):
16803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16804 
 
16805 
  def __ne__(self, other):
16806 
    return not (self == other)
16807 
 
16808 
class markOrderDoaRequestAuthorized_result:
16809 
  """
16810 
  Attributes:
16811 
   - success
16812 
   - ex
16813 
  """
16814 
 
16815 
  thrift_spec = (
16816 
    (0, TType.BOOL, 'success', None, None, ), # 0
16817 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16818 
  )
16819 
 
16820 
  def __init__(self, success=None, ex=None,):
16821 
    self.success = success
16822 
    self.ex = ex
16823 
 
16824 
  def read(self, iprot):
16825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16827 
      return
16828 
    iprot.readStructBegin()
16829 
    while True:
16830 
      (fname, ftype, fid) = iprot.readFieldBegin()
16831 
      if ftype == TType.STOP:
16832 
        break
16833 
      if fid == 0:
16834 
        if ftype == TType.BOOL:
16835 
          self.success = iprot.readBool();
16836 
        else:
16837 
          iprot.skip(ftype)
16838 
      elif fid == 1:
16839 
        if ftype == TType.STRUCT:
16840 
          self.ex = TransactionServiceException()
16841 
          self.ex.read(iprot)
16842 
        else:
16843 
          iprot.skip(ftype)
16844 
      else:
16845 
        iprot.skip(ftype)
16846 
      iprot.readFieldEnd()
16847 
    iprot.readStructEnd()
16848 
 
16849 
  def write(self, oprot):
16850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16852 
      return
16853 
    oprot.writeStructBegin('markOrderDoaRequestAuthorized_result')
16854 
    if self.success is not None:
16855 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16856 
      oprot.writeBool(self.success)
16857 
      oprot.writeFieldEnd()
16858 
    if self.ex is not None:
16859 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16860 
      self.ex.write(oprot)
16861 
      oprot.writeFieldEnd()
16862 
    oprot.writeFieldStop()
16863 
    oprot.writeStructEnd()
16864 
 
16865 
  def validate(self):
16866 
    return
16867 
 
16868 
 
16869 
  def __repr__(self):
16870 
    L = ['%s=%r' % (key, value)
16871 
      for key, value in self.__dict__.iteritems()]
16872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16873 
 
16874 
  def __eq__(self, other):
16875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16876 
 
16877 
  def __ne__(self, other):
16878 
    return not (self == other)
16879 
 
4488 rajveer 16880 
class markOrderReturnRequestReceived_args:
16881 
  """
16882 
  Attributes:
16883 
   - orderId
16884 
  """
16885 
 
16886 
  thrift_spec = (
16887 
    None, # 0
16888 
    (1, TType.I64, 'orderId', None, None, ), # 1
16889 
  )
16890 
 
16891 
  def __init__(self, orderId=None,):
16892 
    self.orderId = orderId
16893 
 
16894 
  def read(self, iprot):
16895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16897 
      return
16898 
    iprot.readStructBegin()
16899 
    while True:
16900 
      (fname, ftype, fid) = iprot.readFieldBegin()
16901 
      if ftype == TType.STOP:
16902 
        break
16903 
      if fid == 1:
16904 
        if ftype == TType.I64:
16905 
          self.orderId = iprot.readI64();
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('markOrderReturnRequestReceived_args')
16918 
    if self.orderId is not None:
16919 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
16920 
      oprot.writeI64(self.orderId)
16921 
      oprot.writeFieldEnd()
16922 
    oprot.writeFieldStop()
16923 
    oprot.writeStructEnd()
16924 
 
16925 
  def validate(self):
16926 
    return
16927 
 
16928 
 
16929 
  def __repr__(self):
16930 
    L = ['%s=%r' % (key, value)
16931 
      for key, value in self.__dict__.iteritems()]
16932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
16933 
 
16934 
  def __eq__(self, other):
16935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
16936 
 
16937 
  def __ne__(self, other):
16938 
    return not (self == other)
16939 
 
16940 
class markOrderReturnRequestReceived_result:
16941 
  """
16942 
  Attributes:
16943 
   - success
16944 
   - ex
16945 
  """
16946 
 
16947 
  thrift_spec = (
16948 
    (0, TType.BOOL, 'success', None, None, ), # 0
16949 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
16950 
  )
16951 
 
16952 
  def __init__(self, success=None, ex=None,):
16953 
    self.success = success
16954 
    self.ex = ex
16955 
 
16956 
  def read(self, iprot):
16957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
16958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
16959 
      return
16960 
    iprot.readStructBegin()
16961 
    while True:
16962 
      (fname, ftype, fid) = iprot.readFieldBegin()
16963 
      if ftype == TType.STOP:
16964 
        break
16965 
      if fid == 0:
16966 
        if ftype == TType.BOOL:
16967 
          self.success = iprot.readBool();
16968 
        else:
16969 
          iprot.skip(ftype)
16970 
      elif fid == 1:
16971 
        if ftype == TType.STRUCT:
16972 
          self.ex = TransactionServiceException()
16973 
          self.ex.read(iprot)
16974 
        else:
16975 
          iprot.skip(ftype)
16976 
      else:
16977 
        iprot.skip(ftype)
16978 
      iprot.readFieldEnd()
16979 
    iprot.readStructEnd()
16980 
 
16981 
  def write(self, oprot):
16982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
16983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
16984 
      return
16985 
    oprot.writeStructBegin('markOrderReturnRequestReceived_result')
16986 
    if self.success is not None:
16987 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
16988 
      oprot.writeBool(self.success)
16989 
      oprot.writeFieldEnd()
16990 
    if self.ex is not None:
16991 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
16992 
      self.ex.write(oprot)
16993 
      oprot.writeFieldEnd()
16994 
    oprot.writeFieldStop()
16995 
    oprot.writeStructEnd()
16996 
 
16997 
  def validate(self):
16998 
    return
16999 
 
17000 
 
17001 
  def __repr__(self):
17002 
    L = ['%s=%r' % (key, value)
17003 
      for key, value in self.__dict__.iteritems()]
17004 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17005 
 
17006 
  def __eq__(self, other):
17007 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17008 
 
17009 
  def __ne__(self, other):
17010 
    return not (self == other)
17011 
 
17012 
class markOrderReturnRequestAuthorized_args:
17013 
  """
17014 
  Attributes:
17015 
   - orderId
17016 
   - isAuthorized
17017 
  """
17018 
 
17019 
  thrift_spec = (
17020 
    None, # 0
17021 
    (1, TType.I64, 'orderId', None, None, ), # 1
17022 
    (2, TType.BOOL, 'isAuthorized', None, None, ), # 2
17023 
  )
17024 
 
17025 
  def __init__(self, orderId=None, isAuthorized=None,):
17026 
    self.orderId = orderId
17027 
    self.isAuthorized = isAuthorized
17028 
 
17029 
  def read(self, iprot):
17030 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17031 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17032 
      return
17033 
    iprot.readStructBegin()
17034 
    while True:
17035 
      (fname, ftype, fid) = iprot.readFieldBegin()
17036 
      if ftype == TType.STOP:
17037 
        break
17038 
      if fid == 1:
17039 
        if ftype == TType.I64:
17040 
          self.orderId = iprot.readI64();
17041 
        else:
17042 
          iprot.skip(ftype)
17043 
      elif fid == 2:
17044 
        if ftype == TType.BOOL:
17045 
          self.isAuthorized = iprot.readBool();
17046 
        else:
17047 
          iprot.skip(ftype)
17048 
      else:
17049 
        iprot.skip(ftype)
17050 
      iprot.readFieldEnd()
17051 
    iprot.readStructEnd()
17052 
 
17053 
  def write(self, oprot):
17054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17056 
      return
17057 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_args')
17058 
    if self.orderId is not None:
17059 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17060 
      oprot.writeI64(self.orderId)
17061 
      oprot.writeFieldEnd()
17062 
    if self.isAuthorized is not None:
17063 
      oprot.writeFieldBegin('isAuthorized', TType.BOOL, 2)
17064 
      oprot.writeBool(self.isAuthorized)
17065 
      oprot.writeFieldEnd()
17066 
    oprot.writeFieldStop()
17067 
    oprot.writeStructEnd()
17068 
 
17069 
  def validate(self):
17070 
    return
17071 
 
17072 
 
17073 
  def __repr__(self):
17074 
    L = ['%s=%r' % (key, value)
17075 
      for key, value in self.__dict__.iteritems()]
17076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17077 
 
17078 
  def __eq__(self, other):
17079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17080 
 
17081 
  def __ne__(self, other):
17082 
    return not (self == other)
17083 
 
17084 
class markOrderReturnRequestAuthorized_result:
17085 
  """
17086 
  Attributes:
17087 
   - success
17088 
   - ex
17089 
  """
17090 
 
17091 
  thrift_spec = (
17092 
    (0, TType.BOOL, 'success', None, None, ), # 0
17093 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17094 
  )
17095 
 
17096 
  def __init__(self, success=None, ex=None,):
17097 
    self.success = success
17098 
    self.ex = ex
17099 
 
17100 
  def read(self, iprot):
17101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17103 
      return
17104 
    iprot.readStructBegin()
17105 
    while True:
17106 
      (fname, ftype, fid) = iprot.readFieldBegin()
17107 
      if ftype == TType.STOP:
17108 
        break
17109 
      if fid == 0:
17110 
        if ftype == TType.BOOL:
17111 
          self.success = iprot.readBool();
17112 
        else:
17113 
          iprot.skip(ftype)
17114 
      elif fid == 1:
17115 
        if ftype == TType.STRUCT:
17116 
          self.ex = TransactionServiceException()
17117 
          self.ex.read(iprot)
17118 
        else:
17119 
          iprot.skip(ftype)
17120 
      else:
17121 
        iprot.skip(ftype)
17122 
      iprot.readFieldEnd()
17123 
    iprot.readStructEnd()
17124 
 
17125 
  def write(self, oprot):
17126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17128 
      return
17129 
    oprot.writeStructBegin('markOrderReturnRequestAuthorized_result')
17130 
    if self.success is not None:
17131 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17132 
      oprot.writeBool(self.success)
17133 
      oprot.writeFieldEnd()
17134 
    if self.ex is not None:
17135 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17136 
      self.ex.write(oprot)
17137 
      oprot.writeFieldEnd()
17138 
    oprot.writeFieldStop()
17139 
    oprot.writeStructEnd()
17140 
 
17141 
  def validate(self):
17142 
    return
17143 
 
17144 
 
17145 
  def __repr__(self):
17146 
    L = ['%s=%r' % (key, value)
17147 
      for key, value in self.__dict__.iteritems()]
17148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17149 
 
17150 
  def __eq__(self, other):
17151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17152 
 
17153 
  def __ne__(self, other):
17154 
    return not (self == other)
17155 
 
2536 chandransh 17156 
class requestPickupNumber_args:
17157 
  """
17158 
  Attributes:
17159 
   - orderId
4579 rajveer 17160 
   - providerId
2536 chandransh 17161 
  """
17162 
 
17163 
  thrift_spec = (
17164 
    None, # 0
17165 
    (1, TType.I64, 'orderId', None, None, ), # 1
4579 rajveer 17166 
    (2, TType.I64, 'providerId', None, None, ), # 2
2536 chandransh 17167 
  )
17168 
 
4579 rajveer 17169 
  def __init__(self, orderId=None, providerId=None,):
2536 chandransh 17170 
    self.orderId = orderId
4579 rajveer 17171 
    self.providerId = providerId
2536 chandransh 17172 
 
17173 
  def read(self, iprot):
17174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17176 
      return
17177 
    iprot.readStructBegin()
17178 
    while True:
17179 
      (fname, ftype, fid) = iprot.readFieldBegin()
17180 
      if ftype == TType.STOP:
17181 
        break
17182 
      if fid == 1:
17183 
        if ftype == TType.I64:
17184 
          self.orderId = iprot.readI64();
17185 
        else:
17186 
          iprot.skip(ftype)
4579 rajveer 17187 
      elif fid == 2:
17188 
        if ftype == TType.I64:
17189 
          self.providerId = iprot.readI64();
17190 
        else:
17191 
          iprot.skip(ftype)
2536 chandransh 17192 
      else:
17193 
        iprot.skip(ftype)
17194 
      iprot.readFieldEnd()
17195 
    iprot.readStructEnd()
17196 
 
17197 
  def write(self, oprot):
17198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17200 
      return
17201 
    oprot.writeStructBegin('requestPickupNumber_args')
3431 rajveer 17202 
    if self.orderId is not None:
2536 chandransh 17203 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17204 
      oprot.writeI64(self.orderId)
17205 
      oprot.writeFieldEnd()
4579 rajveer 17206 
    if self.providerId is not None:
17207 
      oprot.writeFieldBegin('providerId', TType.I64, 2)
17208 
      oprot.writeI64(self.providerId)
17209 
      oprot.writeFieldEnd()
2536 chandransh 17210 
    oprot.writeFieldStop()
17211 
    oprot.writeStructEnd()
17212 
 
3431 rajveer 17213 
  def validate(self):
17214 
    return
17215 
 
17216 
 
2536 chandransh 17217 
  def __repr__(self):
17218 
    L = ['%s=%r' % (key, value)
17219 
      for key, value in self.__dict__.iteritems()]
17220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17221 
 
17222 
  def __eq__(self, other):
17223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17224 
 
17225 
  def __ne__(self, other):
17226 
    return not (self == other)
17227 
 
17228 
class requestPickupNumber_result:
17229 
  """
17230 
  Attributes:
17231 
   - success
17232 
   - ex
17233 
  """
17234 
 
17235 
  thrift_spec = (
17236 
    (0, TType.BOOL, 'success', None, None, ), # 0
17237 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17238 
  )
17239 
 
17240 
  def __init__(self, success=None, ex=None,):
17241 
    self.success = success
17242 
    self.ex = ex
17243 
 
17244 
  def read(self, iprot):
17245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17247 
      return
17248 
    iprot.readStructBegin()
17249 
    while True:
17250 
      (fname, ftype, fid) = iprot.readFieldBegin()
17251 
      if ftype == TType.STOP:
17252 
        break
17253 
      if fid == 0:
17254 
        if ftype == TType.BOOL:
17255 
          self.success = iprot.readBool();
17256 
        else:
17257 
          iprot.skip(ftype)
17258 
      elif fid == 1:
17259 
        if ftype == TType.STRUCT:
17260 
          self.ex = TransactionServiceException()
17261 
          self.ex.read(iprot)
17262 
        else:
17263 
          iprot.skip(ftype)
17264 
      else:
17265 
        iprot.skip(ftype)
17266 
      iprot.readFieldEnd()
17267 
    iprot.readStructEnd()
17268 
 
17269 
  def write(self, oprot):
17270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17272 
      return
17273 
    oprot.writeStructBegin('requestPickupNumber_result')
3431 rajveer 17274 
    if self.success is not None:
2536 chandransh 17275 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17276 
      oprot.writeBool(self.success)
17277 
      oprot.writeFieldEnd()
3431 rajveer 17278 
    if self.ex is not None:
2536 chandransh 17279 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17280 
      self.ex.write(oprot)
17281 
      oprot.writeFieldEnd()
17282 
    oprot.writeFieldStop()
17283 
    oprot.writeStructEnd()
17284 
 
3431 rajveer 17285 
  def validate(self):
17286 
    return
17287 
 
17288 
 
2536 chandransh 17289 
  def __repr__(self):
17290 
    L = ['%s=%r' % (key, value)
17291 
      for key, value in self.__dict__.iteritems()]
17292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17293 
 
17294 
  def __eq__(self, other):
17295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17296 
 
17297 
  def __ne__(self, other):
17298 
    return not (self == other)
17299 
 
17300 
class authorizePickup_args:
17301 
  """
17302 
  Attributes:
17303 
   - orderId
17304 
   - pickupNumber
4602 rajveer 17305 
   - providerId
2536 chandransh 17306 
  """
17307 
 
17308 
  thrift_spec = (
17309 
    None, # 0
17310 
    (1, TType.I64, 'orderId', None, None, ), # 1
17311 
    (2, TType.STRING, 'pickupNumber', None, None, ), # 2
4602 rajveer 17312 
    (3, TType.I64, 'providerId', None, None, ), # 3
2536 chandransh 17313 
  )
17314 
 
4602 rajveer 17315 
  def __init__(self, orderId=None, pickupNumber=None, providerId=None,):
2536 chandransh 17316 
    self.orderId = orderId
17317 
    self.pickupNumber = pickupNumber
4602 rajveer 17318 
    self.providerId = providerId
2536 chandransh 17319 
 
17320 
  def read(self, iprot):
17321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17323 
      return
17324 
    iprot.readStructBegin()
17325 
    while True:
17326 
      (fname, ftype, fid) = iprot.readFieldBegin()
17327 
      if ftype == TType.STOP:
17328 
        break
17329 
      if fid == 1:
17330 
        if ftype == TType.I64:
17331 
          self.orderId = iprot.readI64();
17332 
        else:
17333 
          iprot.skip(ftype)
17334 
      elif fid == 2:
17335 
        if ftype == TType.STRING:
17336 
          self.pickupNumber = iprot.readString();
17337 
        else:
17338 
          iprot.skip(ftype)
4602 rajveer 17339 
      elif fid == 3:
17340 
        if ftype == TType.I64:
17341 
          self.providerId = iprot.readI64();
17342 
        else:
17343 
          iprot.skip(ftype)
2536 chandransh 17344 
      else:
17345 
        iprot.skip(ftype)
17346 
      iprot.readFieldEnd()
17347 
    iprot.readStructEnd()
17348 
 
17349 
  def write(self, oprot):
17350 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17351 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17352 
      return
17353 
    oprot.writeStructBegin('authorizePickup_args')
3431 rajveer 17354 
    if self.orderId is not None:
2536 chandransh 17355 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
17356 
      oprot.writeI64(self.orderId)
17357 
      oprot.writeFieldEnd()
3431 rajveer 17358 
    if self.pickupNumber is not None:
2536 chandransh 17359 
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
17360 
      oprot.writeString(self.pickupNumber)
17361 
      oprot.writeFieldEnd()
4602 rajveer 17362 
    if self.providerId is not None:
17363 
      oprot.writeFieldBegin('providerId', TType.I64, 3)
17364 
      oprot.writeI64(self.providerId)
17365 
      oprot.writeFieldEnd()
2536 chandransh 17366 
    oprot.writeFieldStop()
17367 
    oprot.writeStructEnd()
17368 
 
3431 rajveer 17369 
  def validate(self):
17370 
    return
17371 
 
17372 
 
2536 chandransh 17373 
  def __repr__(self):
17374 
    L = ['%s=%r' % (key, value)
17375 
      for key, value in self.__dict__.iteritems()]
17376 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17377 
 
17378 
  def __eq__(self, other):
17379 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17380 
 
17381 
  def __ne__(self, other):
17382 
    return not (self == other)
17383 
 
17384 
class authorizePickup_result:
17385 
  """
17386 
  Attributes:
17387 
   - success
17388 
   - ex
17389 
  """
17390 
 
17391 
  thrift_spec = (
17392 
    (0, TType.BOOL, 'success', None, None, ), # 0
17393 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
17394 
  )
17395 
 
17396 
  def __init__(self, success=None, ex=None,):
17397 
    self.success = success
17398 
    self.ex = ex
17399 
 
17400 
  def read(self, iprot):
17401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17403 
      return
17404 
    iprot.readStructBegin()
17405 
    while True:
17406 
      (fname, ftype, fid) = iprot.readFieldBegin()
17407 
      if ftype == TType.STOP:
17408 
        break
17409 
      if fid == 0:
17410 
        if ftype == TType.BOOL:
17411 
          self.success = iprot.readBool();
17412 
        else:
17413 
          iprot.skip(ftype)
17414 
      elif fid == 1:
17415 
        if ftype == TType.STRUCT:
17416 
          self.ex = TransactionServiceException()
17417 
          self.ex.read(iprot)
17418 
        else:
17419 
          iprot.skip(ftype)
17420 
      else:
17421 
        iprot.skip(ftype)
17422 
      iprot.readFieldEnd()
17423 
    iprot.readStructEnd()
17424 
 
17425 
  def write(self, oprot):
17426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17428 
      return
17429 
    oprot.writeStructBegin('authorizePickup_result')
3431 rajveer 17430 
    if self.success is not None:
2536 chandransh 17431 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
17432 
      oprot.writeBool(self.success)
17433 
      oprot.writeFieldEnd()
3431 rajveer 17434 
    if self.ex is not None:
2536 chandransh 17435 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
17436 
      self.ex.write(oprot)
17437 
      oprot.writeFieldEnd()
17438 
    oprot.writeFieldStop()
17439 
    oprot.writeStructEnd()
17440 
 
3431 rajveer 17441 
  def validate(self):
17442 
    return
17443 
 
17444 
 
2536 chandransh 17445 
  def __repr__(self):
17446 
    L = ['%s=%r' % (key, value)
17447 
      for key, value in self.__dict__.iteritems()]
17448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17449 
 
17450 
  def __eq__(self, other):
17451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17452 
 
17453 
  def __ne__(self, other):
17454 
    return not (self == other)
17455 
 
2764 chandransh 17456 
class markDoasAsPickedUp_args:
17457 
  """
17458 
  Attributes:
17459 
   - providerId
17460 
   - pickupDetails
17461 
  """
17462 
 
17463 
  thrift_spec = (
17464 
    None, # 0
17465 
    (1, TType.I64, 'providerId', None, None, ), # 1
17466 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17467 
  )
17468 
 
17469 
  def __init__(self, providerId=None, pickupDetails=None,):
17470 
    self.providerId = providerId
17471 
    self.pickupDetails = pickupDetails
17472 
 
17473 
  def read(self, iprot):
17474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17476 
      return
17477 
    iprot.readStructBegin()
17478 
    while True:
17479 
      (fname, ftype, fid) = iprot.readFieldBegin()
17480 
      if ftype == TType.STOP:
17481 
        break
17482 
      if fid == 1:
17483 
        if ftype == TType.I64:
17484 
          self.providerId = iprot.readI64();
17485 
        else:
17486 
          iprot.skip(ftype)
17487 
      elif fid == 2:
17488 
        if ftype == TType.MAP:
17489 
          self.pickupDetails = {}
6188 rajveer 17490 
          (_ktype408, _vtype409, _size407 ) = iprot.readMapBegin()
17491 
          for _i411 in xrange(_size407):
17492 
            _key412 = iprot.readString();
17493 
            _val413 = iprot.readString();
17494 
            self.pickupDetails[_key412] = _val413
2764 chandransh 17495 
          iprot.readMapEnd()
17496 
        else:
17497 
          iprot.skip(ftype)
17498 
      else:
17499 
        iprot.skip(ftype)
17500 
      iprot.readFieldEnd()
17501 
    iprot.readStructEnd()
17502 
 
17503 
  def write(self, oprot):
17504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17506 
      return
17507 
    oprot.writeStructBegin('markDoasAsPickedUp_args')
3431 rajveer 17508 
    if self.providerId is not None:
2764 chandransh 17509 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17510 
      oprot.writeI64(self.providerId)
17511 
      oprot.writeFieldEnd()
3431 rajveer 17512 
    if self.pickupDetails is not None:
2764 chandransh 17513 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17514 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17515 
      for kiter414,viter415 in self.pickupDetails.items():
17516 
        oprot.writeString(kiter414)
17517 
        oprot.writeString(viter415)
2764 chandransh 17518 
      oprot.writeMapEnd()
17519 
      oprot.writeFieldEnd()
17520 
    oprot.writeFieldStop()
17521 
    oprot.writeStructEnd()
17522 
 
3431 rajveer 17523 
  def validate(self):
17524 
    return
17525 
 
17526 
 
2764 chandransh 17527 
  def __repr__(self):
17528 
    L = ['%s=%r' % (key, value)
17529 
      for key, value in self.__dict__.iteritems()]
17530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17531 
 
17532 
  def __eq__(self, other):
17533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17534 
 
17535 
  def __ne__(self, other):
17536 
    return not (self == other)
17537 
 
17538 
class markDoasAsPickedUp_result:
4910 phani.kuma 17539 
 
17540 
  thrift_spec = (
17541 
  )
17542 
 
17543 
  def read(self, iprot):
17544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17546 
      return
17547 
    iprot.readStructBegin()
17548 
    while True:
17549 
      (fname, ftype, fid) = iprot.readFieldBegin()
17550 
      if ftype == TType.STOP:
17551 
        break
17552 
      else:
17553 
        iprot.skip(ftype)
17554 
      iprot.readFieldEnd()
17555 
    iprot.readStructEnd()
17556 
 
17557 
  def write(self, oprot):
17558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17560 
      return
17561 
    oprot.writeStructBegin('markDoasAsPickedUp_result')
17562 
    oprot.writeFieldStop()
17563 
    oprot.writeStructEnd()
17564 
 
17565 
  def validate(self):
17566 
    return
17567 
 
17568 
 
17569 
  def __repr__(self):
17570 
    L = ['%s=%r' % (key, value)
17571 
      for key, value in self.__dict__.iteritems()]
17572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17573 
 
17574 
  def __eq__(self, other):
17575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17576 
 
17577 
  def __ne__(self, other):
17578 
    return not (self == other)
17579 
 
17580 
class getDoasNotPickedUp_args:
2764 chandransh 17581 
  """
17582 
  Attributes:
4910 phani.kuma 17583 
   - providerId
17584 
  """
17585 
 
17586 
  thrift_spec = (
17587 
    None, # 0
17588 
    (1, TType.I64, 'providerId', None, None, ), # 1
17589 
  )
17590 
 
17591 
  def __init__(self, providerId=None,):
17592 
    self.providerId = providerId
17593 
 
17594 
  def read(self, iprot):
17595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17597 
      return
17598 
    iprot.readStructBegin()
17599 
    while True:
17600 
      (fname, ftype, fid) = iprot.readFieldBegin()
17601 
      if ftype == TType.STOP:
17602 
        break
17603 
      if fid == 1:
17604 
        if ftype == TType.I64:
17605 
          self.providerId = iprot.readI64();
17606 
        else:
17607 
          iprot.skip(ftype)
17608 
      else:
17609 
        iprot.skip(ftype)
17610 
      iprot.readFieldEnd()
17611 
    iprot.readStructEnd()
17612 
 
17613 
  def write(self, oprot):
17614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17616 
      return
17617 
    oprot.writeStructBegin('getDoasNotPickedUp_args')
17618 
    if self.providerId is not None:
17619 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17620 
      oprot.writeI64(self.providerId)
17621 
      oprot.writeFieldEnd()
17622 
    oprot.writeFieldStop()
17623 
    oprot.writeStructEnd()
17624 
 
17625 
  def validate(self):
17626 
    return
17627 
 
17628 
 
17629 
  def __repr__(self):
17630 
    L = ['%s=%r' % (key, value)
17631 
      for key, value in self.__dict__.iteritems()]
17632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17633 
 
17634 
  def __eq__(self, other):
17635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17636 
 
17637 
  def __ne__(self, other):
17638 
    return not (self == other)
17639 
 
17640 
class getDoasNotPickedUp_result:
17641 
  """
17642 
  Attributes:
2764 chandransh 17643 
   - success
17644 
  """
17645 
 
17646 
  thrift_spec = (
17647 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17648 
  )
17649 
 
17650 
  def __init__(self, success=None,):
17651 
    self.success = success
17652 
 
17653 
  def read(self, iprot):
17654 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17655 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17656 
      return
17657 
    iprot.readStructBegin()
17658 
    while True:
17659 
      (fname, ftype, fid) = iprot.readFieldBegin()
17660 
      if ftype == TType.STOP:
17661 
        break
17662 
      if fid == 0:
17663 
        if ftype == TType.LIST:
17664 
          self.success = []
6188 rajveer 17665 
          (_etype419, _size416) = iprot.readListBegin()
17666 
          for _i420 in xrange(_size416):
17667 
            _elem421 = Order()
17668 
            _elem421.read(iprot)
17669 
            self.success.append(_elem421)
2764 chandransh 17670 
          iprot.readListEnd()
17671 
        else:
17672 
          iprot.skip(ftype)
17673 
      else:
17674 
        iprot.skip(ftype)
17675 
      iprot.readFieldEnd()
17676 
    iprot.readStructEnd()
17677 
 
17678 
  def write(self, oprot):
17679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17681 
      return
4910 phani.kuma 17682 
    oprot.writeStructBegin('getDoasNotPickedUp_result')
3431 rajveer 17683 
    if self.success is not None:
2764 chandransh 17684 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17685 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17686 
      for iter422 in self.success:
17687 
        iter422.write(oprot)
2764 chandransh 17688 
      oprot.writeListEnd()
17689 
      oprot.writeFieldEnd()
17690 
    oprot.writeFieldStop()
17691 
    oprot.writeStructEnd()
17692 
 
3431 rajveer 17693 
  def validate(self):
17694 
    return
17695 
 
17696 
 
2764 chandransh 17697 
  def __repr__(self):
17698 
    L = ['%s=%r' % (key, value)
17699 
      for key, value in self.__dict__.iteritems()]
17700 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17701 
 
17702 
  def __eq__(self, other):
17703 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17704 
 
17705 
  def __ne__(self, other):
17706 
    return not (self == other)
17707 
 
4741 phani.kuma 17708 
class markReturnOrdersAsPickedUp_args:
17709 
  """
17710 
  Attributes:
17711 
   - providerId
17712 
   - pickupDetails
17713 
  """
17714 
 
17715 
  thrift_spec = (
17716 
    None, # 0
17717 
    (1, TType.I64, 'providerId', None, None, ), # 1
17718 
    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
17719 
  )
17720 
 
17721 
  def __init__(self, providerId=None, pickupDetails=None,):
17722 
    self.providerId = providerId
17723 
    self.pickupDetails = pickupDetails
17724 
 
17725 
  def read(self, iprot):
17726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17728 
      return
17729 
    iprot.readStructBegin()
17730 
    while True:
17731 
      (fname, ftype, fid) = iprot.readFieldBegin()
17732 
      if ftype == TType.STOP:
17733 
        break
17734 
      if fid == 1:
17735 
        if ftype == TType.I64:
17736 
          self.providerId = iprot.readI64();
17737 
        else:
17738 
          iprot.skip(ftype)
17739 
      elif fid == 2:
17740 
        if ftype == TType.MAP:
17741 
          self.pickupDetails = {}
6188 rajveer 17742 
          (_ktype424, _vtype425, _size423 ) = iprot.readMapBegin()
17743 
          for _i427 in xrange(_size423):
17744 
            _key428 = iprot.readString();
17745 
            _val429 = iprot.readString();
17746 
            self.pickupDetails[_key428] = _val429
4741 phani.kuma 17747 
          iprot.readMapEnd()
17748 
        else:
17749 
          iprot.skip(ftype)
17750 
      else:
17751 
        iprot.skip(ftype)
17752 
      iprot.readFieldEnd()
17753 
    iprot.readStructEnd()
17754 
 
17755 
  def write(self, oprot):
17756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17758 
      return
17759 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_args')
17760 
    if self.providerId is not None:
17761 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17762 
      oprot.writeI64(self.providerId)
17763 
      oprot.writeFieldEnd()
17764 
    if self.pickupDetails is not None:
17765 
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
17766 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
6188 rajveer 17767 
      for kiter430,viter431 in self.pickupDetails.items():
17768 
        oprot.writeString(kiter430)
17769 
        oprot.writeString(viter431)
4741 phani.kuma 17770 
      oprot.writeMapEnd()
17771 
      oprot.writeFieldEnd()
17772 
    oprot.writeFieldStop()
17773 
    oprot.writeStructEnd()
17774 
 
17775 
  def validate(self):
17776 
    return
17777 
 
17778 
 
17779 
  def __repr__(self):
17780 
    L = ['%s=%r' % (key, value)
17781 
      for key, value in self.__dict__.iteritems()]
17782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17783 
 
17784 
  def __eq__(self, other):
17785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17786 
 
17787 
  def __ne__(self, other):
17788 
    return not (self == other)
17789 
 
17790 
class markReturnOrdersAsPickedUp_result:
4910 phani.kuma 17791 
 
17792 
  thrift_spec = (
17793 
  )
17794 
 
17795 
  def read(self, iprot):
17796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17798 
      return
17799 
    iprot.readStructBegin()
17800 
    while True:
17801 
      (fname, ftype, fid) = iprot.readFieldBegin()
17802 
      if ftype == TType.STOP:
17803 
        break
17804 
      else:
17805 
        iprot.skip(ftype)
17806 
      iprot.readFieldEnd()
17807 
    iprot.readStructEnd()
17808 
 
17809 
  def write(self, oprot):
17810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17812 
      return
17813 
    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
17814 
    oprot.writeFieldStop()
17815 
    oprot.writeStructEnd()
17816 
 
17817 
  def validate(self):
17818 
    return
17819 
 
17820 
 
17821 
  def __repr__(self):
17822 
    L = ['%s=%r' % (key, value)
17823 
      for key, value in self.__dict__.iteritems()]
17824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17825 
 
17826 
  def __eq__(self, other):
17827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17828 
 
17829 
  def __ne__(self, other):
17830 
    return not (self == other)
17831 
 
17832 
class getReturnOrdersNotPickedUp_args:
4741 phani.kuma 17833 
  """
17834 
  Attributes:
4910 phani.kuma 17835 
   - providerId
17836 
  """
17837 
 
17838 
  thrift_spec = (
17839 
    None, # 0
17840 
    (1, TType.I64, 'providerId', None, None, ), # 1
17841 
  )
17842 
 
17843 
  def __init__(self, providerId=None,):
17844 
    self.providerId = providerId
17845 
 
17846 
  def read(self, iprot):
17847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17849 
      return
17850 
    iprot.readStructBegin()
17851 
    while True:
17852 
      (fname, ftype, fid) = iprot.readFieldBegin()
17853 
      if ftype == TType.STOP:
17854 
        break
17855 
      if fid == 1:
17856 
        if ftype == TType.I64:
17857 
          self.providerId = iprot.readI64();
17858 
        else:
17859 
          iprot.skip(ftype)
17860 
      else:
17861 
        iprot.skip(ftype)
17862 
      iprot.readFieldEnd()
17863 
    iprot.readStructEnd()
17864 
 
17865 
  def write(self, oprot):
17866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17868 
      return
17869 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
17870 
    if self.providerId is not None:
17871 
      oprot.writeFieldBegin('providerId', TType.I64, 1)
17872 
      oprot.writeI64(self.providerId)
17873 
      oprot.writeFieldEnd()
17874 
    oprot.writeFieldStop()
17875 
    oprot.writeStructEnd()
17876 
 
17877 
  def validate(self):
17878 
    return
17879 
 
17880 
 
17881 
  def __repr__(self):
17882 
    L = ['%s=%r' % (key, value)
17883 
      for key, value in self.__dict__.iteritems()]
17884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17885 
 
17886 
  def __eq__(self, other):
17887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17888 
 
17889 
  def __ne__(self, other):
17890 
    return not (self == other)
17891 
 
17892 
class getReturnOrdersNotPickedUp_result:
17893 
  """
17894 
  Attributes:
4741 phani.kuma 17895 
   - success
17896 
  """
17897 
 
17898 
  thrift_spec = (
17899 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
17900 
  )
17901 
 
17902 
  def __init__(self, success=None,):
17903 
    self.success = success
17904 
 
17905 
  def read(self, iprot):
17906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17908 
      return
17909 
    iprot.readStructBegin()
17910 
    while True:
17911 
      (fname, ftype, fid) = iprot.readFieldBegin()
17912 
      if ftype == TType.STOP:
17913 
        break
17914 
      if fid == 0:
17915 
        if ftype == TType.LIST:
17916 
          self.success = []
6188 rajveer 17917 
          (_etype435, _size432) = iprot.readListBegin()
17918 
          for _i436 in xrange(_size432):
17919 
            _elem437 = Order()
17920 
            _elem437.read(iprot)
17921 
            self.success.append(_elem437)
4741 phani.kuma 17922 
          iprot.readListEnd()
17923 
        else:
17924 
          iprot.skip(ftype)
17925 
      else:
17926 
        iprot.skip(ftype)
17927 
      iprot.readFieldEnd()
17928 
    iprot.readStructEnd()
17929 
 
17930 
  def write(self, oprot):
17931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
17932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
17933 
      return
4910 phani.kuma 17934 
    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
4741 phani.kuma 17935 
    if self.success is not None:
17936 
      oprot.writeFieldBegin('success', TType.LIST, 0)
17937 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 17938 
      for iter438 in self.success:
17939 
        iter438.write(oprot)
4741 phani.kuma 17940 
      oprot.writeListEnd()
17941 
      oprot.writeFieldEnd()
17942 
    oprot.writeFieldStop()
17943 
    oprot.writeStructEnd()
17944 
 
17945 
  def validate(self):
17946 
    return
17947 
 
17948 
 
17949 
  def __repr__(self):
17950 
    L = ['%s=%r' % (key, value)
17951 
      for key, value in self.__dict__.iteritems()]
17952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
17953 
 
17954 
  def __eq__(self, other):
17955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
17956 
 
17957 
  def __ne__(self, other):
17958 
    return not (self == other)
17959 
 
2616 chandransh 17960 
class receiveReturn_args:
2591 chandransh 17961 
  """
17962 
  Attributes:
17963 
   - orderId
4479 rajveer 17964 
   - receiveCondition
2591 chandransh 17965 
  """
2536 chandransh 17966 
 
2591 chandransh 17967 
  thrift_spec = (
17968 
    None, # 0
17969 
    (1, TType.I64, 'orderId', None, None, ), # 1
4479 rajveer 17970 
    (2, TType.I64, 'receiveCondition', None, None, ), # 2
2591 chandransh 17971 
  )
17972 
 
4479 rajveer 17973 
  def __init__(self, orderId=None, receiveCondition=None,):
2591 chandransh 17974 
    self.orderId = orderId
4479 rajveer 17975 
    self.receiveCondition = receiveCondition
2591 chandransh 17976 
 
17977 
  def read(self, iprot):
17978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
17979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
17980 
      return
17981 
    iprot.readStructBegin()
17982 
    while True:
17983 
      (fname, ftype, fid) = iprot.readFieldBegin()
17984 
      if ftype == TType.STOP:
17985 
        break
17986 
      if fid == 1:
17987 
        if ftype == TType.I64:
17988 
          self.orderId = iprot.readI64();
17989 
        else:
17990 
          iprot.skip(ftype)
4479 rajveer 17991 
      elif fid == 2:
17992 
        if ftype == TType.I64:
17993 
          self.receiveCondition = iprot.readI64();
17994 
        else:
17995 
          iprot.skip(ftype)
2591 chandransh 17996 
      else:
17997 
        iprot.skip(ftype)
17998 
      iprot.readFieldEnd()
17999 
    iprot.readStructEnd()
18000 
 
18001 
  def write(self, oprot):
18002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18004 
      return
2616 chandransh 18005 
    oprot.writeStructBegin('receiveReturn_args')
3431 rajveer 18006 
    if self.orderId is not None:
2591 chandransh 18007 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18008 
      oprot.writeI64(self.orderId)
18009 
      oprot.writeFieldEnd()
4479 rajveer 18010 
    if self.receiveCondition is not None:
18011 
      oprot.writeFieldBegin('receiveCondition', TType.I64, 2)
18012 
      oprot.writeI64(self.receiveCondition)
18013 
      oprot.writeFieldEnd()
2591 chandransh 18014 
    oprot.writeFieldStop()
18015 
    oprot.writeStructEnd()
18016 
 
3431 rajveer 18017 
  def validate(self):
18018 
    return
18019 
 
18020 
 
2591 chandransh 18021 
  def __repr__(self):
18022 
    L = ['%s=%r' % (key, value)
18023 
      for key, value in self.__dict__.iteritems()]
18024 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18025 
 
18026 
  def __eq__(self, other):
18027 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18028 
 
18029 
  def __ne__(self, other):
18030 
    return not (self == other)
18031 
 
2616 chandransh 18032 
class receiveReturn_result:
2591 chandransh 18033 
  """
18034 
  Attributes:
18035 
   - success
18036 
   - ex
18037 
  """
18038 
 
18039 
  thrift_spec = (
18040 
    (0, TType.BOOL, 'success', None, None, ), # 0
18041 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18042 
  )
18043 
 
18044 
  def __init__(self, success=None, ex=None,):
18045 
    self.success = success
18046 
    self.ex = ex
18047 
 
18048 
  def read(self, iprot):
18049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18051 
      return
18052 
    iprot.readStructBegin()
18053 
    while True:
18054 
      (fname, ftype, fid) = iprot.readFieldBegin()
18055 
      if ftype == TType.STOP:
18056 
        break
18057 
      if fid == 0:
18058 
        if ftype == TType.BOOL:
18059 
          self.success = iprot.readBool();
18060 
        else:
18061 
          iprot.skip(ftype)
18062 
      elif fid == 1:
18063 
        if ftype == TType.STRUCT:
18064 
          self.ex = TransactionServiceException()
18065 
          self.ex.read(iprot)
18066 
        else:
18067 
          iprot.skip(ftype)
18068 
      else:
18069 
        iprot.skip(ftype)
18070 
      iprot.readFieldEnd()
18071 
    iprot.readStructEnd()
18072 
 
18073 
  def write(self, oprot):
18074 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18075 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18076 
      return
2616 chandransh 18077 
    oprot.writeStructBegin('receiveReturn_result')
3431 rajveer 18078 
    if self.success is not None:
2591 chandransh 18079 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18080 
      oprot.writeBool(self.success)
18081 
      oprot.writeFieldEnd()
3431 rajveer 18082 
    if self.ex is not None:
2591 chandransh 18083 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18084 
      self.ex.write(oprot)
18085 
      oprot.writeFieldEnd()
18086 
    oprot.writeFieldStop()
18087 
    oprot.writeStructEnd()
18088 
 
3431 rajveer 18089 
  def validate(self):
18090 
    return
18091 
 
18092 
 
2591 chandransh 18093 
  def __repr__(self):
18094 
    L = ['%s=%r' % (key, value)
18095 
      for key, value in self.__dict__.iteritems()]
18096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18097 
 
18098 
  def __eq__(self, other):
18099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18100 
 
18101 
  def __ne__(self, other):
18102 
    return not (self == other)
18103 
 
18104 
class validateDoa_args:
18105 
  """
18106 
  Attributes:
18107 
   - orderId
18108 
   - isValid
18109 
  """
18110 
 
18111 
  thrift_spec = (
18112 
    None, # 0
18113 
    (1, TType.I64, 'orderId', None, None, ), # 1
18114 
    (2, TType.BOOL, 'isValid', None, None, ), # 2
18115 
  )
18116 
 
18117 
  def __init__(self, orderId=None, isValid=None,):
18118 
    self.orderId = orderId
18119 
    self.isValid = isValid
18120 
 
18121 
  def read(self, iprot):
18122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18124 
      return
18125 
    iprot.readStructBegin()
18126 
    while True:
18127 
      (fname, ftype, fid) = iprot.readFieldBegin()
18128 
      if ftype == TType.STOP:
18129 
        break
18130 
      if fid == 1:
18131 
        if ftype == TType.I64:
18132 
          self.orderId = iprot.readI64();
18133 
        else:
18134 
          iprot.skip(ftype)
18135 
      elif fid == 2:
18136 
        if ftype == TType.BOOL:
18137 
          self.isValid = iprot.readBool();
18138 
        else:
18139 
          iprot.skip(ftype)
18140 
      else:
18141 
        iprot.skip(ftype)
18142 
      iprot.readFieldEnd()
18143 
    iprot.readStructEnd()
18144 
 
18145 
  def write(self, oprot):
18146 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18147 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18148 
      return
18149 
    oprot.writeStructBegin('validateDoa_args')
3431 rajveer 18150 
    if self.orderId is not None:
2591 chandransh 18151 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18152 
      oprot.writeI64(self.orderId)
18153 
      oprot.writeFieldEnd()
3431 rajveer 18154 
    if self.isValid is not None:
2591 chandransh 18155 
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
18156 
      oprot.writeBool(self.isValid)
18157 
      oprot.writeFieldEnd()
18158 
    oprot.writeFieldStop()
18159 
    oprot.writeStructEnd()
18160 
 
3431 rajveer 18161 
  def validate(self):
18162 
    return
18163 
 
18164 
 
2591 chandransh 18165 
  def __repr__(self):
18166 
    L = ['%s=%r' % (key, value)
18167 
      for key, value in self.__dict__.iteritems()]
18168 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18169 
 
18170 
  def __eq__(self, other):
18171 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18172 
 
18173 
  def __ne__(self, other):
18174 
    return not (self == other)
18175 
 
18176 
class validateDoa_result:
18177 
  """
18178 
  Attributes:
18179 
   - success
18180 
   - ex
18181 
  """
18182 
 
18183 
  thrift_spec = (
18184 
    (0, TType.BOOL, 'success', None, None, ), # 0
18185 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18186 
  )
18187 
 
18188 
  def __init__(self, success=None, ex=None,):
18189 
    self.success = success
18190 
    self.ex = ex
18191 
 
18192 
  def read(self, iprot):
18193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18195 
      return
18196 
    iprot.readStructBegin()
18197 
    while True:
18198 
      (fname, ftype, fid) = iprot.readFieldBegin()
18199 
      if ftype == TType.STOP:
18200 
        break
18201 
      if fid == 0:
18202 
        if ftype == TType.BOOL:
18203 
          self.success = iprot.readBool();
18204 
        else:
18205 
          iprot.skip(ftype)
18206 
      elif fid == 1:
18207 
        if ftype == TType.STRUCT:
18208 
          self.ex = TransactionServiceException()
18209 
          self.ex.read(iprot)
18210 
        else:
18211 
          iprot.skip(ftype)
18212 
      else:
18213 
        iprot.skip(ftype)
18214 
      iprot.readFieldEnd()
18215 
    iprot.readStructEnd()
18216 
 
18217 
  def write(self, oprot):
18218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18220 
      return
18221 
    oprot.writeStructBegin('validateDoa_result')
3431 rajveer 18222 
    if self.success is not None:
2591 chandransh 18223 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18224 
      oprot.writeBool(self.success)
18225 
      oprot.writeFieldEnd()
3431 rajveer 18226 
    if self.ex is not None:
2591 chandransh 18227 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18228 
      self.ex.write(oprot)
18229 
      oprot.writeFieldEnd()
18230 
    oprot.writeFieldStop()
18231 
    oprot.writeStructEnd()
18232 
 
3431 rajveer 18233 
  def validate(self):
18234 
    return
18235 
 
18236 
 
2591 chandransh 18237 
  def __repr__(self):
18238 
    L = ['%s=%r' % (key, value)
18239 
      for key, value in self.__dict__.iteritems()]
18240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18241 
 
18242 
  def __eq__(self, other):
18243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18244 
 
18245 
  def __ne__(self, other):
18246 
    return not (self == other)
18247 
 
4495 rajveer 18248 
class validateReturnProduct_args:
18249 
  """
18250 
  Attributes:
18251 
   - orderId
18252 
   - isUsable
18253 
  """
18254 
 
18255 
  thrift_spec = (
18256 
    None, # 0
18257 
    (1, TType.I64, 'orderId', None, None, ), # 1
18258 
    (2, TType.BOOL, 'isUsable', None, None, ), # 2
18259 
  )
18260 
 
18261 
  def __init__(self, orderId=None, isUsable=None,):
18262 
    self.orderId = orderId
18263 
    self.isUsable = isUsable
18264 
 
18265 
  def read(self, iprot):
18266 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18267 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18268 
      return
18269 
    iprot.readStructBegin()
18270 
    while True:
18271 
      (fname, ftype, fid) = iprot.readFieldBegin()
18272 
      if ftype == TType.STOP:
18273 
        break
18274 
      if fid == 1:
18275 
        if ftype == TType.I64:
18276 
          self.orderId = iprot.readI64();
18277 
        else:
18278 
          iprot.skip(ftype)
18279 
      elif fid == 2:
18280 
        if ftype == TType.BOOL:
18281 
          self.isUsable = iprot.readBool();
18282 
        else:
18283 
          iprot.skip(ftype)
18284 
      else:
18285 
        iprot.skip(ftype)
18286 
      iprot.readFieldEnd()
18287 
    iprot.readStructEnd()
18288 
 
18289 
  def write(self, oprot):
18290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18292 
      return
18293 
    oprot.writeStructBegin('validateReturnProduct_args')
18294 
    if self.orderId is not None:
18295 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18296 
      oprot.writeI64(self.orderId)
18297 
      oprot.writeFieldEnd()
18298 
    if self.isUsable is not None:
18299 
      oprot.writeFieldBegin('isUsable', TType.BOOL, 2)
18300 
      oprot.writeBool(self.isUsable)
18301 
      oprot.writeFieldEnd()
18302 
    oprot.writeFieldStop()
18303 
    oprot.writeStructEnd()
18304 
 
18305 
  def validate(self):
18306 
    return
18307 
 
18308 
 
18309 
  def __repr__(self):
18310 
    L = ['%s=%r' % (key, value)
18311 
      for key, value in self.__dict__.iteritems()]
18312 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18313 
 
18314 
  def __eq__(self, other):
18315 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18316 
 
18317 
  def __ne__(self, other):
18318 
    return not (self == other)
18319 
 
18320 
class validateReturnProduct_result:
18321 
  """
18322 
  Attributes:
18323 
   - success
18324 
   - ex
18325 
  """
18326 
 
18327 
  thrift_spec = (
18328 
    (0, TType.BOOL, 'success', None, None, ), # 0
18329 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18330 
  )
18331 
 
18332 
  def __init__(self, success=None, ex=None,):
18333 
    self.success = success
18334 
    self.ex = ex
18335 
 
18336 
  def read(self, iprot):
18337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18339 
      return
18340 
    iprot.readStructBegin()
18341 
    while True:
18342 
      (fname, ftype, fid) = iprot.readFieldBegin()
18343 
      if ftype == TType.STOP:
18344 
        break
18345 
      if fid == 0:
18346 
        if ftype == TType.BOOL:
18347 
          self.success = iprot.readBool();
18348 
        else:
18349 
          iprot.skip(ftype)
18350 
      elif fid == 1:
18351 
        if ftype == TType.STRUCT:
18352 
          self.ex = TransactionServiceException()
18353 
          self.ex.read(iprot)
18354 
        else:
18355 
          iprot.skip(ftype)
18356 
      else:
18357 
        iprot.skip(ftype)
18358 
      iprot.readFieldEnd()
18359 
    iprot.readStructEnd()
18360 
 
18361 
  def write(self, oprot):
18362 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18363 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18364 
      return
18365 
    oprot.writeStructBegin('validateReturnProduct_result')
18366 
    if self.success is not None:
18367 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18368 
      oprot.writeBool(self.success)
18369 
      oprot.writeFieldEnd()
18370 
    if self.ex is not None:
18371 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18372 
      self.ex.write(oprot)
18373 
      oprot.writeFieldEnd()
18374 
    oprot.writeFieldStop()
18375 
    oprot.writeStructEnd()
18376 
 
18377 
  def validate(self):
18378 
    return
18379 
 
18380 
 
18381 
  def __repr__(self):
18382 
    L = ['%s=%r' % (key, value)
18383 
      for key, value in self.__dict__.iteritems()]
18384 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18385 
 
18386 
  def __eq__(self, other):
18387 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18388 
 
18389 
  def __ne__(self, other):
18390 
    return not (self == other)
18391 
 
2616 chandransh 18392 
class reshipOrder_args:
18393 
  """
18394 
  Attributes:
18395 
   - orderId
18396 
  """
2591 chandransh 18397 
 
2616 chandransh 18398 
  thrift_spec = (
18399 
    None, # 0
18400 
    (1, TType.I64, 'orderId', None, None, ), # 1
18401 
  )
18402 
 
18403 
  def __init__(self, orderId=None,):
18404 
    self.orderId = orderId
18405 
 
18406 
  def read(self, iprot):
18407 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18408 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18409 
      return
18410 
    iprot.readStructBegin()
18411 
    while True:
18412 
      (fname, ftype, fid) = iprot.readFieldBegin()
18413 
      if ftype == TType.STOP:
18414 
        break
18415 
      if fid == 1:
18416 
        if ftype == TType.I64:
18417 
          self.orderId = iprot.readI64();
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('reshipOrder_args')
3431 rajveer 18430 
    if self.orderId is not None:
2616 chandransh 18431 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18432 
      oprot.writeI64(self.orderId)
18433 
      oprot.writeFieldEnd()
18434 
    oprot.writeFieldStop()
18435 
    oprot.writeStructEnd()
18436 
 
3431 rajveer 18437 
  def validate(self):
18438 
    return
18439 
 
18440 
 
2616 chandransh 18441 
  def __repr__(self):
18442 
    L = ['%s=%r' % (key, value)
18443 
      for key, value in self.__dict__.iteritems()]
18444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18445 
 
18446 
  def __eq__(self, other):
18447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18448 
 
18449 
  def __ne__(self, other):
18450 
    return not (self == other)
18451 
 
18452 
class reshipOrder_result:
18453 
  """
18454 
  Attributes:
18455 
   - success
18456 
   - ex
18457 
  """
18458 
 
18459 
  thrift_spec = (
18460 
    (0, TType.I64, 'success', None, None, ), # 0
18461 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18462 
  )
18463 
 
18464 
  def __init__(self, success=None, ex=None,):
18465 
    self.success = success
18466 
    self.ex = ex
18467 
 
18468 
  def read(self, iprot):
18469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18471 
      return
18472 
    iprot.readStructBegin()
18473 
    while True:
18474 
      (fname, ftype, fid) = iprot.readFieldBegin()
18475 
      if ftype == TType.STOP:
18476 
        break
18477 
      if fid == 0:
18478 
        if ftype == TType.I64:
18479 
          self.success = iprot.readI64();
18480 
        else:
18481 
          iprot.skip(ftype)
18482 
      elif fid == 1:
18483 
        if ftype == TType.STRUCT:
18484 
          self.ex = TransactionServiceException()
18485 
          self.ex.read(iprot)
18486 
        else:
18487 
          iprot.skip(ftype)
18488 
      else:
18489 
        iprot.skip(ftype)
18490 
      iprot.readFieldEnd()
18491 
    iprot.readStructEnd()
18492 
 
18493 
  def write(self, oprot):
18494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18496 
      return
18497 
    oprot.writeStructBegin('reshipOrder_result')
3431 rajveer 18498 
    if self.success is not None:
2616 chandransh 18499 
      oprot.writeFieldBegin('success', TType.I64, 0)
18500 
      oprot.writeI64(self.success)
18501 
      oprot.writeFieldEnd()
3431 rajveer 18502 
    if self.ex is not None:
2616 chandransh 18503 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18504 
      self.ex.write(oprot)
18505 
      oprot.writeFieldEnd()
18506 
    oprot.writeFieldStop()
18507 
    oprot.writeStructEnd()
18508 
 
3431 rajveer 18509 
  def validate(self):
18510 
    return
18511 
 
18512 
 
2616 chandransh 18513 
  def __repr__(self):
18514 
    L = ['%s=%r' % (key, value)
18515 
      for key, value in self.__dict__.iteritems()]
18516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18517 
 
18518 
  def __eq__(self, other):
18519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18520 
 
18521 
  def __ne__(self, other):
18522 
    return not (self == other)
18523 
 
18524 
class refundOrder_args:
18525 
  """
18526 
  Attributes:
18527 
   - orderId
3226 chandransh 18528 
   - refundedBy
18529 
   - reason
2616 chandransh 18530 
  """
18531 
 
18532 
  thrift_spec = (
18533 
    None, # 0
18534 
    (1, TType.I64, 'orderId', None, None, ), # 1
3226 chandransh 18535 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
18536 
    (3, TType.STRING, 'reason', None, None, ), # 3
2616 chandransh 18537 
  )
18538 
 
3226 chandransh 18539 
  def __init__(self, orderId=None, refundedBy=None, reason=None,):
2616 chandransh 18540 
    self.orderId = orderId
3226 chandransh 18541 
    self.refundedBy = refundedBy
18542 
    self.reason = reason
2616 chandransh 18543 
 
18544 
  def read(self, iprot):
18545 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18546 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18547 
      return
18548 
    iprot.readStructBegin()
18549 
    while True:
18550 
      (fname, ftype, fid) = iprot.readFieldBegin()
18551 
      if ftype == TType.STOP:
18552 
        break
18553 
      if fid == 1:
18554 
        if ftype == TType.I64:
18555 
          self.orderId = iprot.readI64();
18556 
        else:
18557 
          iprot.skip(ftype)
3226 chandransh 18558 
      elif fid == 2:
18559 
        if ftype == TType.STRING:
18560 
          self.refundedBy = iprot.readString();
18561 
        else:
18562 
          iprot.skip(ftype)
18563 
      elif fid == 3:
18564 
        if ftype == TType.STRING:
18565 
          self.reason = iprot.readString();
18566 
        else:
18567 
          iprot.skip(ftype)
2616 chandransh 18568 
      else:
18569 
        iprot.skip(ftype)
18570 
      iprot.readFieldEnd()
18571 
    iprot.readStructEnd()
18572 
 
18573 
  def write(self, oprot):
18574 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18575 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18576 
      return
18577 
    oprot.writeStructBegin('refundOrder_args')
3431 rajveer 18578 
    if self.orderId is not None:
2616 chandransh 18579 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
18580 
      oprot.writeI64(self.orderId)
18581 
      oprot.writeFieldEnd()
3431 rajveer 18582 
    if self.refundedBy is not None:
3226 chandransh 18583 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
18584 
      oprot.writeString(self.refundedBy)
18585 
      oprot.writeFieldEnd()
3431 rajveer 18586 
    if self.reason is not None:
3226 chandransh 18587 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
18588 
      oprot.writeString(self.reason)
18589 
      oprot.writeFieldEnd()
2616 chandransh 18590 
    oprot.writeFieldStop()
18591 
    oprot.writeStructEnd()
18592 
 
3431 rajveer 18593 
  def validate(self):
18594 
    return
18595 
 
18596 
 
2616 chandransh 18597 
  def __repr__(self):
18598 
    L = ['%s=%r' % (key, value)
18599 
      for key, value in self.__dict__.iteritems()]
18600 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18601 
 
18602 
  def __eq__(self, other):
18603 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18604 
 
18605 
  def __ne__(self, other):
18606 
    return not (self == other)
18607 
 
18608 
class refundOrder_result:
18609 
  """
18610 
  Attributes:
18611 
   - success
18612 
   - ex
18613 
  """
18614 
 
18615 
  thrift_spec = (
18616 
    (0, TType.BOOL, 'success', None, None, ), # 0
18617 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
18618 
  )
18619 
 
18620 
  def __init__(self, success=None, ex=None,):
18621 
    self.success = success
18622 
    self.ex = ex
18623 
 
18624 
  def read(self, iprot):
18625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18627 
      return
18628 
    iprot.readStructBegin()
18629 
    while True:
18630 
      (fname, ftype, fid) = iprot.readFieldBegin()
18631 
      if ftype == TType.STOP:
18632 
        break
18633 
      if fid == 0:
18634 
        if ftype == TType.BOOL:
18635 
          self.success = iprot.readBool();
18636 
        else:
18637 
          iprot.skip(ftype)
18638 
      elif fid == 1:
18639 
        if ftype == TType.STRUCT:
18640 
          self.ex = TransactionServiceException()
18641 
          self.ex.read(iprot)
18642 
        else:
18643 
          iprot.skip(ftype)
18644 
      else:
18645 
        iprot.skip(ftype)
18646 
      iprot.readFieldEnd()
18647 
    iprot.readStructEnd()
18648 
 
18649 
  def write(self, oprot):
18650 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18651 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18652 
      return
18653 
    oprot.writeStructBegin('refundOrder_result')
3431 rajveer 18654 
    if self.success is not None:
2616 chandransh 18655 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
18656 
      oprot.writeBool(self.success)
18657 
      oprot.writeFieldEnd()
3431 rajveer 18658 
    if self.ex is not None:
2616 chandransh 18659 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
18660 
      self.ex.write(oprot)
18661 
      oprot.writeFieldEnd()
18662 
    oprot.writeFieldStop()
18663 
    oprot.writeStructEnd()
18664 
 
3431 rajveer 18665 
  def validate(self):
18666 
    return
18667 
 
18668 
 
2616 chandransh 18669 
  def __repr__(self):
18670 
    L = ['%s=%r' % (key, value)
18671 
      for key, value in self.__dict__.iteritems()]
18672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18673 
 
18674 
  def __eq__(self, other):
18675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18676 
 
18677 
  def __ne__(self, other):
18678 
    return not (self == other)
18679 
 
2690 chandransh 18680 
class getReturnOrders_args:
18681 
  """
18682 
  Attributes:
18683 
   - warehouseId
18684 
   - fromDate
18685 
   - toDate
18686 
  """
2616 chandransh 18687 
 
2690 chandransh 18688 
  thrift_spec = (
18689 
    None, # 0
18690 
    (1, TType.I64, 'warehouseId', None, None, ), # 1
18691 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18692 
    (3, TType.I64, 'toDate', None, None, ), # 3
18693 
  )
18694 
 
18695 
  def __init__(self, warehouseId=None, fromDate=None, toDate=None,):
18696 
    self.warehouseId = warehouseId
18697 
    self.fromDate = fromDate
18698 
    self.toDate = toDate
18699 
 
18700 
  def read(self, iprot):
18701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18703 
      return
18704 
    iprot.readStructBegin()
18705 
    while True:
18706 
      (fname, ftype, fid) = iprot.readFieldBegin()
18707 
      if ftype == TType.STOP:
18708 
        break
18709 
      if fid == 1:
18710 
        if ftype == TType.I64:
18711 
          self.warehouseId = iprot.readI64();
18712 
        else:
18713 
          iprot.skip(ftype)
18714 
      elif fid == 2:
18715 
        if ftype == TType.I64:
18716 
          self.fromDate = iprot.readI64();
18717 
        else:
18718 
          iprot.skip(ftype)
18719 
      elif fid == 3:
18720 
        if ftype == TType.I64:
18721 
          self.toDate = iprot.readI64();
18722 
        else:
18723 
          iprot.skip(ftype)
18724 
      else:
18725 
        iprot.skip(ftype)
18726 
      iprot.readFieldEnd()
18727 
    iprot.readStructEnd()
18728 
 
18729 
  def write(self, oprot):
18730 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18731 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18732 
      return
18733 
    oprot.writeStructBegin('getReturnOrders_args')
3431 rajveer 18734 
    if self.warehouseId is not None:
2690 chandransh 18735 
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
18736 
      oprot.writeI64(self.warehouseId)
18737 
      oprot.writeFieldEnd()
3431 rajveer 18738 
    if self.fromDate is not None:
2690 chandransh 18739 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18740 
      oprot.writeI64(self.fromDate)
18741 
      oprot.writeFieldEnd()
3431 rajveer 18742 
    if self.toDate is not None:
2690 chandransh 18743 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18744 
      oprot.writeI64(self.toDate)
18745 
      oprot.writeFieldEnd()
18746 
    oprot.writeFieldStop()
18747 
    oprot.writeStructEnd()
18748 
 
3431 rajveer 18749 
  def validate(self):
18750 
    return
18751 
 
18752 
 
2690 chandransh 18753 
  def __repr__(self):
18754 
    L = ['%s=%r' % (key, value)
18755 
      for key, value in self.__dict__.iteritems()]
18756 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18757 
 
18758 
  def __eq__(self, other):
18759 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18760 
 
18761 
  def __ne__(self, other):
18762 
    return not (self == other)
18763 
 
18764 
class getReturnOrders_result:
18765 
  """
18766 
  Attributes:
18767 
   - success
18768 
  """
18769 
 
18770 
  thrift_spec = (
18771 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18772 
  )
18773 
 
18774 
  def __init__(self, success=None,):
18775 
    self.success = success
18776 
 
18777 
  def read(self, iprot):
18778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18780 
      return
18781 
    iprot.readStructBegin()
18782 
    while True:
18783 
      (fname, ftype, fid) = iprot.readFieldBegin()
18784 
      if ftype == TType.STOP:
18785 
        break
18786 
      if fid == 0:
18787 
        if ftype == TType.LIST:
18788 
          self.success = []
6188 rajveer 18789 
          (_etype442, _size439) = iprot.readListBegin()
18790 
          for _i443 in xrange(_size439):
18791 
            _elem444 = ReturnOrder()
18792 
            _elem444.read(iprot)
18793 
            self.success.append(_elem444)
2690 chandransh 18794 
          iprot.readListEnd()
18795 
        else:
18796 
          iprot.skip(ftype)
18797 
      else:
18798 
        iprot.skip(ftype)
18799 
      iprot.readFieldEnd()
18800 
    iprot.readStructEnd()
18801 
 
18802 
  def write(self, oprot):
18803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18805 
      return
18806 
    oprot.writeStructBegin('getReturnOrders_result')
3431 rajveer 18807 
    if self.success is not None:
2690 chandransh 18808 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18809 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18810 
      for iter445 in self.success:
18811 
        iter445.write(oprot)
2690 chandransh 18812 
      oprot.writeListEnd()
18813 
      oprot.writeFieldEnd()
18814 
    oprot.writeFieldStop()
18815 
    oprot.writeStructEnd()
18816 
 
3431 rajveer 18817 
  def validate(self):
18818 
    return
18819 
 
18820 
 
2690 chandransh 18821 
  def __repr__(self):
18822 
    L = ['%s=%r' % (key, value)
18823 
      for key, value in self.__dict__.iteritems()]
18824 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18825 
 
18826 
  def __eq__(self, other):
18827 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18828 
 
18829 
  def __ne__(self, other):
18830 
    return not (self == other)
18831 
 
5481 phani.kuma 18832 
class getAllReturnOrders_args:
18833 
  """
18834 
  Attributes:
18835 
   - onlyNotProcessed
18836 
   - fromDate
18837 
   - toDate
18838 
  """
18839 
 
18840 
  thrift_spec = (
18841 
    None, # 0
18842 
    (1, TType.BOOL, 'onlyNotProcessed', None, None, ), # 1
18843 
    (2, TType.I64, 'fromDate', None, None, ), # 2
18844 
    (3, TType.I64, 'toDate', None, None, ), # 3
18845 
  )
18846 
 
18847 
  def __init__(self, onlyNotProcessed=None, fromDate=None, toDate=None,):
18848 
    self.onlyNotProcessed = onlyNotProcessed
18849 
    self.fromDate = fromDate
18850 
    self.toDate = toDate
18851 
 
18852 
  def read(self, iprot):
18853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18855 
      return
18856 
    iprot.readStructBegin()
18857 
    while True:
18858 
      (fname, ftype, fid) = iprot.readFieldBegin()
18859 
      if ftype == TType.STOP:
18860 
        break
18861 
      if fid == 1:
18862 
        if ftype == TType.BOOL:
18863 
          self.onlyNotProcessed = iprot.readBool();
18864 
        else:
18865 
          iprot.skip(ftype)
18866 
      elif fid == 2:
18867 
        if ftype == TType.I64:
18868 
          self.fromDate = iprot.readI64();
18869 
        else:
18870 
          iprot.skip(ftype)
18871 
      elif fid == 3:
18872 
        if ftype == TType.I64:
18873 
          self.toDate = iprot.readI64();
18874 
        else:
18875 
          iprot.skip(ftype)
18876 
      else:
18877 
        iprot.skip(ftype)
18878 
      iprot.readFieldEnd()
18879 
    iprot.readStructEnd()
18880 
 
18881 
  def write(self, oprot):
18882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18884 
      return
18885 
    oprot.writeStructBegin('getAllReturnOrders_args')
18886 
    if self.onlyNotProcessed is not None:
18887 
      oprot.writeFieldBegin('onlyNotProcessed', TType.BOOL, 1)
18888 
      oprot.writeBool(self.onlyNotProcessed)
18889 
      oprot.writeFieldEnd()
18890 
    if self.fromDate is not None:
18891 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
18892 
      oprot.writeI64(self.fromDate)
18893 
      oprot.writeFieldEnd()
18894 
    if self.toDate is not None:
18895 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
18896 
      oprot.writeI64(self.toDate)
18897 
      oprot.writeFieldEnd()
18898 
    oprot.writeFieldStop()
18899 
    oprot.writeStructEnd()
18900 
 
18901 
  def validate(self):
18902 
    return
18903 
 
18904 
 
18905 
  def __repr__(self):
18906 
    L = ['%s=%r' % (key, value)
18907 
      for key, value in self.__dict__.iteritems()]
18908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18909 
 
18910 
  def __eq__(self, other):
18911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18912 
 
18913 
  def __ne__(self, other):
18914 
    return not (self == other)
18915 
 
18916 
class getAllReturnOrders_result:
18917 
  """
18918 
  Attributes:
18919 
   - success
18920 
  """
18921 
 
18922 
  thrift_spec = (
18923 
    (0, TType.LIST, 'success', (TType.STRUCT,(ReturnOrder, ReturnOrder.thrift_spec)), None, ), # 0
18924 
  )
18925 
 
18926 
  def __init__(self, success=None,):
18927 
    self.success = success
18928 
 
18929 
  def read(self, iprot):
18930 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
18931 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
18932 
      return
18933 
    iprot.readStructBegin()
18934 
    while True:
18935 
      (fname, ftype, fid) = iprot.readFieldBegin()
18936 
      if ftype == TType.STOP:
18937 
        break
18938 
      if fid == 0:
18939 
        if ftype == TType.LIST:
18940 
          self.success = []
6188 rajveer 18941 
          (_etype449, _size446) = iprot.readListBegin()
18942 
          for _i450 in xrange(_size446):
18943 
            _elem451 = ReturnOrder()
18944 
            _elem451.read(iprot)
18945 
            self.success.append(_elem451)
5481 phani.kuma 18946 
          iprot.readListEnd()
18947 
        else:
18948 
          iprot.skip(ftype)
18949 
      else:
18950 
        iprot.skip(ftype)
18951 
      iprot.readFieldEnd()
18952 
    iprot.readStructEnd()
18953 
 
18954 
  def write(self, oprot):
18955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
18956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
18957 
      return
18958 
    oprot.writeStructBegin('getAllReturnOrders_result')
18959 
    if self.success is not None:
18960 
      oprot.writeFieldBegin('success', TType.LIST, 0)
18961 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 18962 
      for iter452 in self.success:
18963 
        iter452.write(oprot)
5481 phani.kuma 18964 
      oprot.writeListEnd()
18965 
      oprot.writeFieldEnd()
18966 
    oprot.writeFieldStop()
18967 
    oprot.writeStructEnd()
18968 
 
18969 
  def validate(self):
18970 
    return
18971 
 
18972 
 
18973 
  def __repr__(self):
18974 
    L = ['%s=%r' % (key, value)
18975 
      for key, value in self.__dict__.iteritems()]
18976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
18977 
 
18978 
  def __eq__(self, other):
18979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
18980 
 
18981 
  def __ne__(self, other):
18982 
    return not (self == other)
18983 
 
2700 chandransh 18984 
class getReturnOrder_args:
18985 
  """
18986 
  Attributes:
18987 
   - id
18988 
  """
18989 
 
18990 
  thrift_spec = (
18991 
    None, # 0
18992 
    (1, TType.I64, 'id', None, None, ), # 1
18993 
  )
18994 
 
18995 
  def __init__(self, id=None,):
18996 
    self.id = id
18997 
 
18998 
  def read(self, iprot):
18999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19001 
      return
19002 
    iprot.readStructBegin()
19003 
    while True:
19004 
      (fname, ftype, fid) = iprot.readFieldBegin()
19005 
      if ftype == TType.STOP:
19006 
        break
19007 
      if fid == 1:
19008 
        if ftype == TType.I64:
19009 
          self.id = iprot.readI64();
19010 
        else:
19011 
          iprot.skip(ftype)
19012 
      else:
19013 
        iprot.skip(ftype)
19014 
      iprot.readFieldEnd()
19015 
    iprot.readStructEnd()
19016 
 
19017 
  def write(self, oprot):
19018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19020 
      return
19021 
    oprot.writeStructBegin('getReturnOrder_args')
3431 rajveer 19022 
    if self.id is not None:
2700 chandransh 19023 
      oprot.writeFieldBegin('id', TType.I64, 1)
19024 
      oprot.writeI64(self.id)
19025 
      oprot.writeFieldEnd()
19026 
    oprot.writeFieldStop()
19027 
    oprot.writeStructEnd()
19028 
 
3431 rajveer 19029 
  def validate(self):
19030 
    return
19031 
 
19032 
 
2700 chandransh 19033 
  def __repr__(self):
19034 
    L = ['%s=%r' % (key, value)
19035 
      for key, value in self.__dict__.iteritems()]
19036 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19037 
 
19038 
  def __eq__(self, other):
19039 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19040 
 
19041 
  def __ne__(self, other):
19042 
    return not (self == other)
19043 
 
19044 
class getReturnOrder_result:
19045 
  """
19046 
  Attributes:
19047 
   - success
19048 
   - ex
19049 
  """
19050 
 
19051 
  thrift_spec = (
19052 
    (0, TType.STRUCT, 'success', (ReturnOrder, ReturnOrder.thrift_spec), None, ), # 0
19053 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19054 
  )
19055 
 
19056 
  def __init__(self, success=None, ex=None,):
19057 
    self.success = success
19058 
    self.ex = ex
19059 
 
19060 
  def read(self, iprot):
19061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19063 
      return
19064 
    iprot.readStructBegin()
19065 
    while True:
19066 
      (fname, ftype, fid) = iprot.readFieldBegin()
19067 
      if ftype == TType.STOP:
19068 
        break
19069 
      if fid == 0:
19070 
        if ftype == TType.STRUCT:
19071 
          self.success = ReturnOrder()
19072 
          self.success.read(iprot)
19073 
        else:
19074 
          iprot.skip(ftype)
19075 
      elif fid == 1:
19076 
        if ftype == TType.STRUCT:
19077 
          self.ex = TransactionServiceException()
19078 
          self.ex.read(iprot)
19079 
        else:
19080 
          iprot.skip(ftype)
19081 
      else:
19082 
        iprot.skip(ftype)
19083 
      iprot.readFieldEnd()
19084 
    iprot.readStructEnd()
19085 
 
19086 
  def write(self, oprot):
19087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19089 
      return
19090 
    oprot.writeStructBegin('getReturnOrder_result')
3431 rajveer 19091 
    if self.success is not None:
2700 chandransh 19092 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19093 
      self.success.write(oprot)
19094 
      oprot.writeFieldEnd()
3431 rajveer 19095 
    if self.ex is not None:
2700 chandransh 19096 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19097 
      self.ex.write(oprot)
19098 
      oprot.writeFieldEnd()
19099 
    oprot.writeFieldStop()
19100 
    oprot.writeStructEnd()
19101 
 
3431 rajveer 19102 
  def validate(self):
19103 
    return
19104 
 
19105 
 
2700 chandransh 19106 
  def __repr__(self):
19107 
    L = ['%s=%r' % (key, value)
19108 
      for key, value in self.__dict__.iteritems()]
19109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19110 
 
19111 
  def __eq__(self, other):
19112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19113 
 
19114 
  def __ne__(self, other):
19115 
    return not (self == other)
19116 
 
2690 chandransh 19117 
class processReturn_args:
19118 
  """
19119 
  Attributes:
19120 
   - returnOrderId
19121 
  """
19122 
 
19123 
  thrift_spec = (
19124 
    None, # 0
19125 
    (1, TType.I64, 'returnOrderId', None, None, ), # 1
19126 
  )
19127 
 
19128 
  def __init__(self, returnOrderId=None,):
19129 
    self.returnOrderId = returnOrderId
19130 
 
19131 
  def read(self, iprot):
19132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19134 
      return
19135 
    iprot.readStructBegin()
19136 
    while True:
19137 
      (fname, ftype, fid) = iprot.readFieldBegin()
19138 
      if ftype == TType.STOP:
19139 
        break
19140 
      if fid == 1:
19141 
        if ftype == TType.I64:
19142 
          self.returnOrderId = iprot.readI64();
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('processReturn_args')
3431 rajveer 19155 
    if self.returnOrderId is not None:
2690 chandransh 19156 
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
19157 
      oprot.writeI64(self.returnOrderId)
19158 
      oprot.writeFieldEnd()
19159 
    oprot.writeFieldStop()
19160 
    oprot.writeStructEnd()
19161 
 
3431 rajveer 19162 
  def validate(self):
19163 
    return
19164 
 
19165 
 
2690 chandransh 19166 
  def __repr__(self):
19167 
    L = ['%s=%r' % (key, value)
19168 
      for key, value in self.__dict__.iteritems()]
19169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19170 
 
19171 
  def __eq__(self, other):
19172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19173 
 
19174 
  def __ne__(self, other):
19175 
    return not (self == other)
19176 
 
19177 
class processReturn_result:
19178 
  """
19179 
  Attributes:
19180 
   - ex
19181 
  """
19182 
 
19183 
  thrift_spec = (
19184 
    None, # 0
19185 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19186 
  )
19187 
 
19188 
  def __init__(self, ex=None,):
19189 
    self.ex = ex
19190 
 
19191 
  def read(self, iprot):
19192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19194 
      return
19195 
    iprot.readStructBegin()
19196 
    while True:
19197 
      (fname, ftype, fid) = iprot.readFieldBegin()
19198 
      if ftype == TType.STOP:
19199 
        break
19200 
      if fid == 1:
19201 
        if ftype == TType.STRUCT:
19202 
          self.ex = TransactionServiceException()
19203 
          self.ex.read(iprot)
19204 
        else:
19205 
          iprot.skip(ftype)
19206 
      else:
19207 
        iprot.skip(ftype)
19208 
      iprot.readFieldEnd()
19209 
    iprot.readStructEnd()
19210 
 
19211 
  def write(self, oprot):
19212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19214 
      return
19215 
    oprot.writeStructBegin('processReturn_result')
3431 rajveer 19216 
    if self.ex is not None:
2690 chandransh 19217 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19218 
      self.ex.write(oprot)
19219 
      oprot.writeFieldEnd()
19220 
    oprot.writeFieldStop()
19221 
    oprot.writeStructEnd()
19222 
 
3431 rajveer 19223 
  def validate(self):
19224 
    return
19225 
 
19226 
 
2690 chandransh 19227 
  def __repr__(self):
19228 
    L = ['%s=%r' % (key, value)
19229 
      for key, value in self.__dict__.iteritems()]
19230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19231 
 
19232 
  def __eq__(self, other):
19233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19234 
 
19235 
  def __ne__(self, other):
19236 
    return not (self == other)
19237 
 
3451 chandransh 19238 
class updateWeight_args:
19239 
  """
19240 
  Attributes:
19241 
   - orderId
19242 
   - weight
19243 
  """
19244 
 
19245 
  thrift_spec = (
19246 
    None, # 0
19247 
    (1, TType.I64, 'orderId', None, None, ), # 1
19248 
    (2, TType.DOUBLE, 'weight', None, None, ), # 2
19249 
  )
19250 
 
19251 
  def __init__(self, orderId=None, weight=None,):
19252 
    self.orderId = orderId
19253 
    self.weight = weight
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.I64:
19266 
          self.orderId = iprot.readI64();
19267 
        else:
19268 
          iprot.skip(ftype)
19269 
      elif fid == 2:
19270 
        if ftype == TType.DOUBLE:
19271 
          self.weight = iprot.readDouble();
19272 
        else:
19273 
          iprot.skip(ftype)
19274 
      else:
19275 
        iprot.skip(ftype)
19276 
      iprot.readFieldEnd()
19277 
    iprot.readStructEnd()
19278 
 
19279 
  def write(self, oprot):
19280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19282 
      return
19283 
    oprot.writeStructBegin('updateWeight_args')
19284 
    if self.orderId is not None:
19285 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19286 
      oprot.writeI64(self.orderId)
19287 
      oprot.writeFieldEnd()
19288 
    if self.weight is not None:
19289 
      oprot.writeFieldBegin('weight', TType.DOUBLE, 2)
19290 
      oprot.writeDouble(self.weight)
19291 
      oprot.writeFieldEnd()
19292 
    oprot.writeFieldStop()
19293 
    oprot.writeStructEnd()
19294 
 
19295 
  def validate(self):
19296 
    return
19297 
 
19298 
 
19299 
  def __repr__(self):
19300 
    L = ['%s=%r' % (key, value)
19301 
      for key, value in self.__dict__.iteritems()]
19302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19303 
 
19304 
  def __eq__(self, other):
19305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19306 
 
19307 
  def __ne__(self, other):
19308 
    return not (self == other)
19309 
 
19310 
class updateWeight_result:
19311 
  """
19312 
  Attributes:
19313 
   - success
19314 
   - ex
19315 
  """
19316 
 
19317 
  thrift_spec = (
19318 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19319 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19320 
  )
19321 
 
19322 
  def __init__(self, success=None, ex=None,):
19323 
    self.success = success
19324 
    self.ex = ex
19325 
 
19326 
  def read(self, iprot):
19327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19329 
      return
19330 
    iprot.readStructBegin()
19331 
    while True:
19332 
      (fname, ftype, fid) = iprot.readFieldBegin()
19333 
      if ftype == TType.STOP:
19334 
        break
19335 
      if fid == 0:
19336 
        if ftype == TType.STRUCT:
19337 
          self.success = Order()
19338 
          self.success.read(iprot)
19339 
        else:
19340 
          iprot.skip(ftype)
19341 
      elif fid == 1:
19342 
        if ftype == TType.STRUCT:
19343 
          self.ex = TransactionServiceException()
19344 
          self.ex.read(iprot)
19345 
        else:
19346 
          iprot.skip(ftype)
19347 
      else:
19348 
        iprot.skip(ftype)
19349 
      iprot.readFieldEnd()
19350 
    iprot.readStructEnd()
19351 
 
19352 
  def write(self, oprot):
19353 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19354 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19355 
      return
19356 
    oprot.writeStructBegin('updateWeight_result')
19357 
    if self.success is not None:
19358 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19359 
      self.success.write(oprot)
19360 
      oprot.writeFieldEnd()
19361 
    if self.ex is not None:
19362 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19363 
      self.ex.write(oprot)
19364 
      oprot.writeFieldEnd()
19365 
    oprot.writeFieldStop()
19366 
    oprot.writeStructEnd()
19367 
 
19368 
  def validate(self):
19369 
    return
19370 
 
19371 
 
19372 
  def __repr__(self):
19373 
    L = ['%s=%r' % (key, value)
19374 
      for key, value in self.__dict__.iteritems()]
19375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19376 
 
19377 
  def __eq__(self, other):
19378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19379 
 
19380 
  def __ne__(self, other):
19381 
    return not (self == other)
3469 chandransh 19382 
 
19383 
class changeItem_args:
19384 
  """
19385 
  Attributes:
19386 
   - orderId
19387 
   - itemId
19388 
  """
19389 
 
19390 
  thrift_spec = (
19391 
    None, # 0
19392 
    (1, TType.I64, 'orderId', None, None, ), # 1
19393 
    (2, TType.I64, 'itemId', None, None, ), # 2
19394 
  )
19395 
 
19396 
  def __init__(self, orderId=None, itemId=None,):
19397 
    self.orderId = orderId
19398 
    self.itemId = itemId
19399 
 
19400 
  def read(self, iprot):
19401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19403 
      return
19404 
    iprot.readStructBegin()
19405 
    while True:
19406 
      (fname, ftype, fid) = iprot.readFieldBegin()
19407 
      if ftype == TType.STOP:
19408 
        break
19409 
      if fid == 1:
19410 
        if ftype == TType.I64:
19411 
          self.orderId = iprot.readI64();
19412 
        else:
19413 
          iprot.skip(ftype)
19414 
      elif fid == 2:
19415 
        if ftype == TType.I64:
19416 
          self.itemId = iprot.readI64();
19417 
        else:
19418 
          iprot.skip(ftype)
19419 
      else:
19420 
        iprot.skip(ftype)
19421 
      iprot.readFieldEnd()
19422 
    iprot.readStructEnd()
19423 
 
19424 
  def write(self, oprot):
19425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19427 
      return
19428 
    oprot.writeStructBegin('changeItem_args')
19429 
    if self.orderId is not None:
19430 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19431 
      oprot.writeI64(self.orderId)
19432 
      oprot.writeFieldEnd()
19433 
    if self.itemId is not None:
19434 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
19435 
      oprot.writeI64(self.itemId)
19436 
      oprot.writeFieldEnd()
19437 
    oprot.writeFieldStop()
19438 
    oprot.writeStructEnd()
19439 
 
19440 
  def validate(self):
19441 
    return
19442 
 
19443 
 
19444 
  def __repr__(self):
19445 
    L = ['%s=%r' % (key, value)
19446 
      for key, value in self.__dict__.iteritems()]
19447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19448 
 
19449 
  def __eq__(self, other):
19450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19451 
 
19452 
  def __ne__(self, other):
19453 
    return not (self == other)
19454 
 
19455 
class changeItem_result:
19456 
  """
19457 
  Attributes:
19458 
   - success
19459 
   - ex
19460 
  """
19461 
 
19462 
  thrift_spec = (
19463 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19464 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19465 
  )
19466 
 
19467 
  def __init__(self, success=None, ex=None,):
19468 
    self.success = success
19469 
    self.ex = ex
19470 
 
19471 
  def read(self, iprot):
19472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19474 
      return
19475 
    iprot.readStructBegin()
19476 
    while True:
19477 
      (fname, ftype, fid) = iprot.readFieldBegin()
19478 
      if ftype == TType.STOP:
19479 
        break
19480 
      if fid == 0:
19481 
        if ftype == TType.STRUCT:
19482 
          self.success = Order()
19483 
          self.success.read(iprot)
19484 
        else:
19485 
          iprot.skip(ftype)
19486 
      elif fid == 1:
19487 
        if ftype == TType.STRUCT:
19488 
          self.ex = TransactionServiceException()
19489 
          self.ex.read(iprot)
19490 
        else:
19491 
          iprot.skip(ftype)
19492 
      else:
19493 
        iprot.skip(ftype)
19494 
      iprot.readFieldEnd()
19495 
    iprot.readStructEnd()
19496 
 
19497 
  def write(self, oprot):
19498 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19499 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19500 
      return
19501 
    oprot.writeStructBegin('changeItem_result')
19502 
    if self.success is not None:
19503 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19504 
      self.success.write(oprot)
19505 
      oprot.writeFieldEnd()
19506 
    if self.ex is not None:
19507 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19508 
      self.ex.write(oprot)
19509 
      oprot.writeFieldEnd()
19510 
    oprot.writeFieldStop()
19511 
    oprot.writeStructEnd()
19512 
 
19513 
  def validate(self):
19514 
    return
19515 
 
19516 
 
19517 
  def __repr__(self):
19518 
    L = ['%s=%r' % (key, value)
19519 
      for key, value in self.__dict__.iteritems()]
19520 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19521 
 
19522 
  def __eq__(self, other):
19523 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19524 
 
19525 
  def __ne__(self, other):
19526 
    return not (self == other)
19527 
 
19528 
class shiftToWarehouse_args:
19529 
  """
19530 
  Attributes:
19531 
   - orderId
19532 
   - warehouseId
19533 
  """
19534 
 
19535 
  thrift_spec = (
19536 
    None, # 0
19537 
    (1, TType.I64, 'orderId', None, None, ), # 1
19538 
    (2, TType.I64, 'warehouseId', None, None, ), # 2
19539 
  )
19540 
 
19541 
  def __init__(self, orderId=None, warehouseId=None,):
19542 
    self.orderId = orderId
19543 
    self.warehouseId = warehouseId
19544 
 
19545 
  def read(self, iprot):
19546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19548 
      return
19549 
    iprot.readStructBegin()
19550 
    while True:
19551 
      (fname, ftype, fid) = iprot.readFieldBegin()
19552 
      if ftype == TType.STOP:
19553 
        break
19554 
      if fid == 1:
19555 
        if ftype == TType.I64:
19556 
          self.orderId = iprot.readI64();
19557 
        else:
19558 
          iprot.skip(ftype)
19559 
      elif fid == 2:
19560 
        if ftype == TType.I64:
19561 
          self.warehouseId = iprot.readI64();
19562 
        else:
19563 
          iprot.skip(ftype)
19564 
      else:
19565 
        iprot.skip(ftype)
19566 
      iprot.readFieldEnd()
19567 
    iprot.readStructEnd()
19568 
 
19569 
  def write(self, oprot):
19570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19572 
      return
19573 
    oprot.writeStructBegin('shiftToWarehouse_args')
19574 
    if self.orderId is not None:
19575 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19576 
      oprot.writeI64(self.orderId)
19577 
      oprot.writeFieldEnd()
19578 
    if self.warehouseId is not None:
19579 
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
19580 
      oprot.writeI64(self.warehouseId)
19581 
      oprot.writeFieldEnd()
19582 
    oprot.writeFieldStop()
19583 
    oprot.writeStructEnd()
19584 
 
19585 
  def validate(self):
19586 
    return
19587 
 
19588 
 
19589 
  def __repr__(self):
19590 
    L = ['%s=%r' % (key, value)
19591 
      for key, value in self.__dict__.iteritems()]
19592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19593 
 
19594 
  def __eq__(self, other):
19595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19596 
 
19597 
  def __ne__(self, other):
19598 
    return not (self == other)
19599 
 
19600 
class shiftToWarehouse_result:
19601 
  """
19602 
  Attributes:
19603 
   - success
19604 
   - ex
19605 
  """
19606 
 
19607 
  thrift_spec = (
19608 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
19609 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19610 
  )
19611 
 
19612 
  def __init__(self, success=None, ex=None,):
19613 
    self.success = success
19614 
    self.ex = ex
19615 
 
19616 
  def read(self, iprot):
19617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19619 
      return
19620 
    iprot.readStructBegin()
19621 
    while True:
19622 
      (fname, ftype, fid) = iprot.readFieldBegin()
19623 
      if ftype == TType.STOP:
19624 
        break
19625 
      if fid == 0:
19626 
        if ftype == TType.STRUCT:
19627 
          self.success = Order()
19628 
          self.success.read(iprot)
19629 
        else:
19630 
          iprot.skip(ftype)
19631 
      elif fid == 1:
19632 
        if ftype == TType.STRUCT:
19633 
          self.ex = TransactionServiceException()
19634 
          self.ex.read(iprot)
19635 
        else:
19636 
          iprot.skip(ftype)
19637 
      else:
19638 
        iprot.skip(ftype)
19639 
      iprot.readFieldEnd()
19640 
    iprot.readStructEnd()
19641 
 
19642 
  def write(self, oprot):
19643 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19644 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19645 
      return
19646 
    oprot.writeStructBegin('shiftToWarehouse_result')
19647 
    if self.success is not None:
19648 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
19649 
      self.success.write(oprot)
19650 
      oprot.writeFieldEnd()
19651 
    if self.ex is not None:
19652 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19653 
      self.ex.write(oprot)
19654 
      oprot.writeFieldEnd()
19655 
    oprot.writeFieldStop()
19656 
    oprot.writeStructEnd()
19657 
 
19658 
  def validate(self):
19659 
    return
19660 
 
19661 
 
19662 
  def __repr__(self):
19663 
    L = ['%s=%r' % (key, value)
19664 
      for key, value in self.__dict__.iteritems()]
19665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19666 
 
19667 
  def __eq__(self, other):
19668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19669 
 
19670 
  def __ne__(self, other):
19671 
    return not (self == other)
3553 chandransh 19672 
 
19673 
class addDelayReason_args:
19674 
  """
19675 
  Attributes:
19676 
   - orderId
19677 
   - delayReason
3986 chandransh 19678 
   - furtherDelay
4647 rajveer 19679 
   - delayReasonText
3553 chandransh 19680 
  """
19681 
 
19682 
  thrift_spec = (
19683 
    None, # 0
19684 
    (1, TType.I64, 'orderId', None, None, ), # 1
19685 
    (2, TType.I32, 'delayReason', None, None, ), # 2
3986 chandransh 19686 
    (3, TType.I64, 'furtherDelay', None, None, ), # 3
4647 rajveer 19687 
    (4, TType.STRING, 'delayReasonText', None, None, ), # 4
3553 chandransh 19688 
  )
19689 
 
4647 rajveer 19690 
  def __init__(self, orderId=None, delayReason=None, furtherDelay=None, delayReasonText=None,):
3553 chandransh 19691 
    self.orderId = orderId
19692 
    self.delayReason = delayReason
3986 chandransh 19693 
    self.furtherDelay = furtherDelay
4647 rajveer 19694 
    self.delayReasonText = delayReasonText
3553 chandransh 19695 
 
19696 
  def read(self, iprot):
19697 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19698 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19699 
      return
19700 
    iprot.readStructBegin()
19701 
    while True:
19702 
      (fname, ftype, fid) = iprot.readFieldBegin()
19703 
      if ftype == TType.STOP:
19704 
        break
19705 
      if fid == 1:
19706 
        if ftype == TType.I64:
19707 
          self.orderId = iprot.readI64();
19708 
        else:
19709 
          iprot.skip(ftype)
19710 
      elif fid == 2:
19711 
        if ftype == TType.I32:
19712 
          self.delayReason = iprot.readI32();
19713 
        else:
19714 
          iprot.skip(ftype)
3986 chandransh 19715 
      elif fid == 3:
19716 
        if ftype == TType.I64:
19717 
          self.furtherDelay = iprot.readI64();
19718 
        else:
19719 
          iprot.skip(ftype)
4647 rajveer 19720 
      elif fid == 4:
19721 
        if ftype == TType.STRING:
19722 
          self.delayReasonText = iprot.readString();
19723 
        else:
19724 
          iprot.skip(ftype)
3553 chandransh 19725 
      else:
19726 
        iprot.skip(ftype)
19727 
      iprot.readFieldEnd()
19728 
    iprot.readStructEnd()
19729 
 
19730 
  def write(self, oprot):
19731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19733 
      return
19734 
    oprot.writeStructBegin('addDelayReason_args')
19735 
    if self.orderId is not None:
19736 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
19737 
      oprot.writeI64(self.orderId)
19738 
      oprot.writeFieldEnd()
19739 
    if self.delayReason is not None:
19740 
      oprot.writeFieldBegin('delayReason', TType.I32, 2)
19741 
      oprot.writeI32(self.delayReason)
19742 
      oprot.writeFieldEnd()
3986 chandransh 19743 
    if self.furtherDelay is not None:
19744 
      oprot.writeFieldBegin('furtherDelay', TType.I64, 3)
19745 
      oprot.writeI64(self.furtherDelay)
19746 
      oprot.writeFieldEnd()
4647 rajveer 19747 
    if self.delayReasonText is not None:
19748 
      oprot.writeFieldBegin('delayReasonText', TType.STRING, 4)
19749 
      oprot.writeString(self.delayReasonText)
19750 
      oprot.writeFieldEnd()
3553 chandransh 19751 
    oprot.writeFieldStop()
19752 
    oprot.writeStructEnd()
19753 
 
19754 
  def validate(self):
19755 
    return
19756 
 
19757 
 
19758 
  def __repr__(self):
19759 
    L = ['%s=%r' % (key, value)
19760 
      for key, value in self.__dict__.iteritems()]
19761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19762 
 
19763 
  def __eq__(self, other):
19764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19765 
 
19766 
  def __ne__(self, other):
19767 
    return not (self == other)
19768 
 
19769 
class addDelayReason_result:
19770 
  """
19771 
  Attributes:
19772 
   - success
19773 
   - ex
19774 
  """
19775 
 
19776 
  thrift_spec = (
19777 
    (0, TType.BOOL, 'success', None, None, ), # 0
19778 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19779 
  )
19780 
 
19781 
  def __init__(self, success=None, ex=None,):
19782 
    self.success = success
19783 
    self.ex = ex
19784 
 
19785 
  def read(self, iprot):
19786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19788 
      return
19789 
    iprot.readStructBegin()
19790 
    while True:
19791 
      (fname, ftype, fid) = iprot.readFieldBegin()
19792 
      if ftype == TType.STOP:
19793 
        break
19794 
      if fid == 0:
19795 
        if ftype == TType.BOOL:
19796 
          self.success = iprot.readBool();
19797 
        else:
19798 
          iprot.skip(ftype)
19799 
      elif fid == 1:
19800 
        if ftype == TType.STRUCT:
19801 
          self.ex = TransactionServiceException()
19802 
          self.ex.read(iprot)
19803 
        else:
19804 
          iprot.skip(ftype)
19805 
      else:
19806 
        iprot.skip(ftype)
19807 
      iprot.readFieldEnd()
19808 
    iprot.readStructEnd()
19809 
 
19810 
  def write(self, oprot):
19811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19813 
      return
19814 
    oprot.writeStructBegin('addDelayReason_result')
19815 
    if self.success is not None:
19816 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
19817 
      oprot.writeBool(self.success)
19818 
      oprot.writeFieldEnd()
19819 
    if self.ex is not None:
19820 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
19821 
      self.ex.write(oprot)
19822 
      oprot.writeFieldEnd()
19823 
    oprot.writeFieldStop()
19824 
    oprot.writeStructEnd()
19825 
 
19826 
  def validate(self):
19827 
    return
19828 
 
19829 
 
19830 
  def __repr__(self):
19831 
    L = ['%s=%r' % (key, value)
19832 
      for key, value in self.__dict__.iteritems()]
19833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19834 
 
19835 
  def __eq__(self, other):
19836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19837 
 
19838 
  def __ne__(self, other):
19839 
    return not (self == other)
3956 chandransh 19840 
 
19841 
class reconcileCodCollection_args:
19842 
  """
19843 
  Attributes:
19844 
   - collectedAmountMap
19845 
   - xferBy
19846 
   - xferTxnId
19847 
   - xferDate
19848 
  """
19849 
 
19850 
  thrift_spec = (
19851 
    None, # 0
19852 
    (1, TType.MAP, 'collectedAmountMap', (TType.STRING,None,TType.DOUBLE,None), None, ), # 1
19853 
    (2, TType.STRING, 'xferBy', None, None, ), # 2
19854 
    (3, TType.STRING, 'xferTxnId', None, None, ), # 3
19855 
    (4, TType.I64, 'xferDate', None, None, ), # 4
19856 
  )
19857 
 
19858 
  def __init__(self, collectedAmountMap=None, xferBy=None, xferTxnId=None, xferDate=None,):
19859 
    self.collectedAmountMap = collectedAmountMap
19860 
    self.xferBy = xferBy
19861 
    self.xferTxnId = xferTxnId
19862 
    self.xferDate = xferDate
19863 
 
19864 
  def read(self, iprot):
19865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19867 
      return
19868 
    iprot.readStructBegin()
19869 
    while True:
19870 
      (fname, ftype, fid) = iprot.readFieldBegin()
19871 
      if ftype == TType.STOP:
19872 
        break
19873 
      if fid == 1:
19874 
        if ftype == TType.MAP:
19875 
          self.collectedAmountMap = {}
6188 rajveer 19876 
          (_ktype454, _vtype455, _size453 ) = iprot.readMapBegin()
19877 
          for _i457 in xrange(_size453):
19878 
            _key458 = iprot.readString();
19879 
            _val459 = iprot.readDouble();
19880 
            self.collectedAmountMap[_key458] = _val459
3956 chandransh 19881 
          iprot.readMapEnd()
19882 
        else:
19883 
          iprot.skip(ftype)
19884 
      elif fid == 2:
19885 
        if ftype == TType.STRING:
19886 
          self.xferBy = iprot.readString();
19887 
        else:
19888 
          iprot.skip(ftype)
19889 
      elif fid == 3:
19890 
        if ftype == TType.STRING:
19891 
          self.xferTxnId = iprot.readString();
19892 
        else:
19893 
          iprot.skip(ftype)
19894 
      elif fid == 4:
19895 
        if ftype == TType.I64:
19896 
          self.xferDate = iprot.readI64();
19897 
        else:
19898 
          iprot.skip(ftype)
19899 
      else:
19900 
        iprot.skip(ftype)
19901 
      iprot.readFieldEnd()
19902 
    iprot.readStructEnd()
19903 
 
19904 
  def write(self, oprot):
19905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19907 
      return
19908 
    oprot.writeStructBegin('reconcileCodCollection_args')
19909 
    if self.collectedAmountMap is not None:
19910 
      oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
19911 
      oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
6188 rajveer 19912 
      for kiter460,viter461 in self.collectedAmountMap.items():
19913 
        oprot.writeString(kiter460)
19914 
        oprot.writeDouble(viter461)
3956 chandransh 19915 
      oprot.writeMapEnd()
19916 
      oprot.writeFieldEnd()
19917 
    if self.xferBy is not None:
19918 
      oprot.writeFieldBegin('xferBy', TType.STRING, 2)
19919 
      oprot.writeString(self.xferBy)
19920 
      oprot.writeFieldEnd()
19921 
    if self.xferTxnId is not None:
19922 
      oprot.writeFieldBegin('xferTxnId', TType.STRING, 3)
19923 
      oprot.writeString(self.xferTxnId)
19924 
      oprot.writeFieldEnd()
19925 
    if self.xferDate is not None:
19926 
      oprot.writeFieldBegin('xferDate', TType.I64, 4)
19927 
      oprot.writeI64(self.xferDate)
19928 
      oprot.writeFieldEnd()
19929 
    oprot.writeFieldStop()
19930 
    oprot.writeStructEnd()
19931 
 
19932 
  def validate(self):
19933 
    return
19934 
 
19935 
 
19936 
  def __repr__(self):
19937 
    L = ['%s=%r' % (key, value)
19938 
      for key, value in self.__dict__.iteritems()]
19939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
19940 
 
19941 
  def __eq__(self, other):
19942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
19943 
 
19944 
  def __ne__(self, other):
19945 
    return not (self == other)
19946 
 
19947 
class reconcileCodCollection_result:
19948 
  """
19949 
  Attributes:
19950 
   - success
19951 
   - ex
19952 
  """
19953 
 
19954 
  thrift_spec = (
19955 
    (0, TType.MAP, 'success', (TType.STRING,None,TType.STRING,None), None, ), # 0
19956 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
19957 
  )
19958 
 
19959 
  def __init__(self, success=None, ex=None,):
19960 
    self.success = success
19961 
    self.ex = ex
19962 
 
19963 
  def read(self, iprot):
19964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
19965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
19966 
      return
19967 
    iprot.readStructBegin()
19968 
    while True:
19969 
      (fname, ftype, fid) = iprot.readFieldBegin()
19970 
      if ftype == TType.STOP:
19971 
        break
19972 
      if fid == 0:
19973 
        if ftype == TType.MAP:
19974 
          self.success = {}
6188 rajveer 19975 
          (_ktype463, _vtype464, _size462 ) = iprot.readMapBegin()
19976 
          for _i466 in xrange(_size462):
19977 
            _key467 = iprot.readString();
19978 
            _val468 = iprot.readString();
19979 
            self.success[_key467] = _val468
3956 chandransh 19980 
          iprot.readMapEnd()
19981 
        else:
19982 
          iprot.skip(ftype)
19983 
      elif fid == 1:
19984 
        if ftype == TType.STRUCT:
19985 
          self.ex = TransactionServiceException()
19986 
          self.ex.read(iprot)
19987 
        else:
19988 
          iprot.skip(ftype)
19989 
      else:
19990 
        iprot.skip(ftype)
19991 
      iprot.readFieldEnd()
19992 
    iprot.readStructEnd()
19993 
 
19994 
  def write(self, oprot):
19995 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
19996 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
19997 
      return
19998 
    oprot.writeStructBegin('reconcileCodCollection_result')
19999 
    if self.success is not None:
20000 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20001 
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
6188 rajveer 20002 
      for kiter469,viter470 in self.success.items():
20003 
        oprot.writeString(kiter469)
20004 
        oprot.writeString(viter470)
3956 chandransh 20005 
      oprot.writeMapEnd()
20006 
      oprot.writeFieldEnd()
20007 
    if self.ex is not None:
20008 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20009 
      self.ex.write(oprot)
20010 
      oprot.writeFieldEnd()
20011 
    oprot.writeFieldStop()
20012 
    oprot.writeStructEnd()
20013 
 
20014 
  def validate(self):
20015 
    return
20016 
 
20017 
 
20018 
  def __repr__(self):
20019 
    L = ['%s=%r' % (key, value)
20020 
      for key, value in self.__dict__.iteritems()]
20021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20022 
 
20023 
  def __eq__(self, other):
20024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20025 
 
20026 
  def __ne__(self, other):
20027 
    return not (self == other)
4008 mandeep.dh 20028 
 
20029 
class getTransactionsRequiringExtraProcessing_args:
20030 
  """
20031 
  Attributes:
20032 
   - category
20033 
  """
20034 
 
20035 
  thrift_spec = (
20036 
    None, # 0
20037 
    (1, TType.I32, 'category', None, None, ), # 1
20038 
  )
20039 
 
20040 
  def __init__(self, category=None,):
20041 
    self.category = category
20042 
 
20043 
  def read(self, iprot):
20044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20046 
      return
20047 
    iprot.readStructBegin()
20048 
    while True:
20049 
      (fname, ftype, fid) = iprot.readFieldBegin()
20050 
      if ftype == TType.STOP:
20051 
        break
20052 
      if fid == 1:
20053 
        if ftype == TType.I32:
20054 
          self.category = iprot.readI32();
20055 
        else:
20056 
          iprot.skip(ftype)
20057 
      else:
20058 
        iprot.skip(ftype)
20059 
      iprot.readFieldEnd()
20060 
    iprot.readStructEnd()
20061 
 
20062 
  def write(self, oprot):
20063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20065 
      return
20066 
    oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_args')
20067 
    if self.category is not None:
20068 
      oprot.writeFieldBegin('category', TType.I32, 1)
20069 
      oprot.writeI32(self.category)
20070 
      oprot.writeFieldEnd()
20071 
    oprot.writeFieldStop()
20072 
    oprot.writeStructEnd()
20073 
 
20074 
  def validate(self):
20075 
    return
20076 
 
20077 
 
20078 
  def __repr__(self):
20079 
    L = ['%s=%r' % (key, value)
20080 
      for key, value in self.__dict__.iteritems()]
20081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20082 
 
20083 
  def __eq__(self, other):
20084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20085 
 
20086 
  def __ne__(self, other):
20087 
    return not (self == other)
20088 
 
20089 
class getTransactionsRequiringExtraProcessing_result:
20090 
  """
20091 
  Attributes:
20092 
   - success
20093 
  """
20094 
 
20095 
  thrift_spec = (
20096 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
20097 
  )
20098 
 
20099 
  def __init__(self, success=None,):
20100 
    self.success = success
20101 
 
20102 
  def read(self, iprot):
20103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20105 
      return
20106 
    iprot.readStructBegin()
20107 
    while True:
20108 
      (fname, ftype, fid) = iprot.readFieldBegin()
20109 
      if ftype == TType.STOP:
20110 
        break
20111 
      if fid == 0:
20112 
        if ftype == TType.LIST:
20113 
          self.success = []
6188 rajveer 20114 
          (_etype474, _size471) = iprot.readListBegin()
20115 
          for _i475 in xrange(_size471):
20116 
            _elem476 = iprot.readI64();
20117 
            self.success.append(_elem476)
4008 mandeep.dh 20118 
          iprot.readListEnd()
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_result')
20131 
    if self.success is not None:
20132 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20133 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 20134 
      for iter477 in self.success:
20135 
        oprot.writeI64(iter477)
4008 mandeep.dh 20136 
      oprot.writeListEnd()
20137 
      oprot.writeFieldEnd()
20138 
    oprot.writeFieldStop()
20139 
    oprot.writeStructEnd()
20140 
 
20141 
  def validate(self):
20142 
    return
20143 
 
20144 
 
20145 
  def __repr__(self):
20146 
    L = ['%s=%r' % (key, value)
20147 
      for key, value in self.__dict__.iteritems()]
20148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20149 
 
20150 
  def __eq__(self, other):
20151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20152 
 
20153 
  def __ne__(self, other):
20154 
    return not (self == other)
20155 
 
20156 
class markTransactionAsProcessed_args:
20157 
  """
20158 
  Attributes:
20159 
   - transactionId
20160 
   - category
20161 
  """
20162 
 
20163 
  thrift_spec = (
20164 
    None, # 0
20165 
    (1, TType.I64, 'transactionId', None, None, ), # 1
20166 
    (2, TType.I32, 'category', None, None, ), # 2
20167 
  )
20168 
 
20169 
  def __init__(self, transactionId=None, category=None,):
20170 
    self.transactionId = transactionId
20171 
    self.category = category
20172 
 
20173 
  def read(self, iprot):
20174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20176 
      return
20177 
    iprot.readStructBegin()
20178 
    while True:
20179 
      (fname, ftype, fid) = iprot.readFieldBegin()
20180 
      if ftype == TType.STOP:
20181 
        break
20182 
      if fid == 1:
20183 
        if ftype == TType.I64:
20184 
          self.transactionId = iprot.readI64();
20185 
        else:
20186 
          iprot.skip(ftype)
20187 
      elif fid == 2:
20188 
        if ftype == TType.I32:
20189 
          self.category = iprot.readI32();
20190 
        else:
20191 
          iprot.skip(ftype)
20192 
      else:
20193 
        iprot.skip(ftype)
20194 
      iprot.readFieldEnd()
20195 
    iprot.readStructEnd()
20196 
 
20197 
  def write(self, oprot):
20198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20200 
      return
20201 
    oprot.writeStructBegin('markTransactionAsProcessed_args')
20202 
    if self.transactionId is not None:
20203 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20204 
      oprot.writeI64(self.transactionId)
20205 
      oprot.writeFieldEnd()
20206 
    if self.category is not None:
20207 
      oprot.writeFieldBegin('category', TType.I32, 2)
20208 
      oprot.writeI32(self.category)
20209 
      oprot.writeFieldEnd()
20210 
    oprot.writeFieldStop()
20211 
    oprot.writeStructEnd()
20212 
 
20213 
  def validate(self):
20214 
    return
20215 
 
20216 
 
20217 
  def __repr__(self):
20218 
    L = ['%s=%r' % (key, value)
20219 
      for key, value in self.__dict__.iteritems()]
20220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20221 
 
20222 
  def __eq__(self, other):
20223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20224 
 
20225 
  def __ne__(self, other):
20226 
    return not (self == other)
20227 
 
20228 
class markTransactionAsProcessed_result:
20229 
 
20230 
  thrift_spec = (
20231 
  )
20232 
 
20233 
  def read(self, iprot):
20234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20236 
      return
20237 
    iprot.readStructBegin()
20238 
    while True:
20239 
      (fname, ftype, fid) = iprot.readFieldBegin()
20240 
      if ftype == TType.STOP:
20241 
        break
20242 
      else:
20243 
        iprot.skip(ftype)
20244 
      iprot.readFieldEnd()
20245 
    iprot.readStructEnd()
20246 
 
20247 
  def write(self, oprot):
20248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20250 
      return
20251 
    oprot.writeStructBegin('markTransactionAsProcessed_result')
20252 
    oprot.writeFieldStop()
20253 
    oprot.writeStructEnd()
20254 
 
20255 
  def validate(self):
20256 
    return
20257 
 
20258 
 
20259 
  def __repr__(self):
20260 
    L = ['%s=%r' % (key, value)
20261 
      for key, value in self.__dict__.iteritems()]
20262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20263 
 
20264 
  def __eq__(self, other):
20265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20266 
 
20267 
  def __ne__(self, other):
20268 
    return not (self == other)
4018 chandransh 20269 
 
20270 
class getItemWiseRiskyOrdersCount_args:
20271 
 
20272 
  thrift_spec = (
20273 
  )
20274 
 
20275 
  def read(self, iprot):
20276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20278 
      return
20279 
    iprot.readStructBegin()
20280 
    while True:
20281 
      (fname, ftype, fid) = iprot.readFieldBegin()
20282 
      if ftype == TType.STOP:
20283 
        break
20284 
      else:
20285 
        iprot.skip(ftype)
20286 
      iprot.readFieldEnd()
20287 
    iprot.readStructEnd()
20288 
 
20289 
  def write(self, oprot):
20290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20292 
      return
20293 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_args')
20294 
    oprot.writeFieldStop()
20295 
    oprot.writeStructEnd()
20296 
 
20297 
  def validate(self):
20298 
    return
20299 
 
20300 
 
20301 
  def __repr__(self):
20302 
    L = ['%s=%r' % (key, value)
20303 
      for key, value in self.__dict__.iteritems()]
20304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20305 
 
20306 
  def __eq__(self, other):
20307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20308 
 
20309 
  def __ne__(self, other):
20310 
    return not (self == other)
20311 
 
20312 
class getItemWiseRiskyOrdersCount_result:
20313 
  """
20314 
  Attributes:
20315 
   - success
20316 
  """
20317 
 
20318 
  thrift_spec = (
20319 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
20320 
  )
20321 
 
20322 
  def __init__(self, success=None,):
20323 
    self.success = success
20324 
 
20325 
  def read(self, iprot):
20326 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20327 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20328 
      return
20329 
    iprot.readStructBegin()
20330 
    while True:
20331 
      (fname, ftype, fid) = iprot.readFieldBegin()
20332 
      if ftype == TType.STOP:
20333 
        break
20334 
      if fid == 0:
20335 
        if ftype == TType.MAP:
20336 
          self.success = {}
6188 rajveer 20337 
          (_ktype479, _vtype480, _size478 ) = iprot.readMapBegin()
20338 
          for _i482 in xrange(_size478):
20339 
            _key483 = iprot.readI64();
20340 
            _val484 = iprot.readI64();
20341 
            self.success[_key483] = _val484
4018 chandransh 20342 
          iprot.readMapEnd()
20343 
        else:
20344 
          iprot.skip(ftype)
20345 
      else:
20346 
        iprot.skip(ftype)
20347 
      iprot.readFieldEnd()
20348 
    iprot.readStructEnd()
20349 
 
20350 
  def write(self, oprot):
20351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20353 
      return
20354 
    oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
20355 
    if self.success is not None:
20356 
      oprot.writeFieldBegin('success', TType.MAP, 0)
20357 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 20358 
      for kiter485,viter486 in self.success.items():
20359 
        oprot.writeI64(kiter485)
20360 
        oprot.writeI64(viter486)
4018 chandransh 20361 
      oprot.writeMapEnd()
20362 
      oprot.writeFieldEnd()
20363 
    oprot.writeFieldStop()
20364 
    oprot.writeStructEnd()
20365 
 
20366 
  def validate(self):
20367 
    return
20368 
 
20369 
 
20370 
  def __repr__(self):
20371 
    L = ['%s=%r' % (key, value)
20372 
      for key, value in self.__dict__.iteritems()]
20373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20374 
 
20375 
  def __eq__(self, other):
20376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20377 
 
20378 
  def __ne__(self, other):
20379 
    return not (self == other)
4247 rajveer 20380 
 
4295 varun.gupt 20381 
class getOrdersForItemIds_args:
20382 
  """
20383 
  Attributes:
20384 
   - itemIds
20385 
  """
20386 
 
20387 
  thrift_spec = (
20388 
    None, # 0
20389 
    (1, TType.LIST, 'itemIds', (TType.I64,None), None, ), # 1
20390 
  )
20391 
 
20392 
  def __init__(self, itemIds=None,):
20393 
    self.itemIds = itemIds
20394 
 
20395 
  def read(self, iprot):
20396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20398 
      return
20399 
    iprot.readStructBegin()
20400 
    while True:
20401 
      (fname, ftype, fid) = iprot.readFieldBegin()
20402 
      if ftype == TType.STOP:
20403 
        break
20404 
      if fid == 1:
20405 
        if ftype == TType.LIST:
20406 
          self.itemIds = []
6188 rajveer 20407 
          (_etype490, _size487) = iprot.readListBegin()
20408 
          for _i491 in xrange(_size487):
20409 
            _elem492 = iprot.readI64();
20410 
            self.itemIds.append(_elem492)
4295 varun.gupt 20411 
          iprot.readListEnd()
20412 
        else:
20413 
          iprot.skip(ftype)
20414 
      else:
20415 
        iprot.skip(ftype)
20416 
      iprot.readFieldEnd()
20417 
    iprot.readStructEnd()
20418 
 
20419 
  def write(self, oprot):
20420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20422 
      return
20423 
    oprot.writeStructBegin('getOrdersForItemIds_args')
20424 
    if self.itemIds is not None:
20425 
      oprot.writeFieldBegin('itemIds', TType.LIST, 1)
20426 
      oprot.writeListBegin(TType.I64, len(self.itemIds))
6188 rajveer 20427 
      for iter493 in self.itemIds:
20428 
        oprot.writeI64(iter493)
4295 varun.gupt 20429 
      oprot.writeListEnd()
20430 
      oprot.writeFieldEnd()
20431 
    oprot.writeFieldStop()
20432 
    oprot.writeStructEnd()
20433 
 
20434 
  def validate(self):
20435 
    return
20436 
 
20437 
 
20438 
  def __repr__(self):
20439 
    L = ['%s=%r' % (key, value)
20440 
      for key, value in self.__dict__.iteritems()]
20441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20442 
 
20443 
  def __eq__(self, other):
20444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20445 
 
20446 
  def __ne__(self, other):
20447 
    return not (self == other)
20448 
 
20449 
class getOrdersForItemIds_result:
20450 
  """
20451 
  Attributes:
20452 
   - success
20453 
  """
20454 
 
20455 
  thrift_spec = (
20456 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
20457 
  )
20458 
 
20459 
  def __init__(self, success=None,):
20460 
    self.success = success
20461 
 
20462 
  def read(self, iprot):
20463 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20464 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20465 
      return
20466 
    iprot.readStructBegin()
20467 
    while True:
20468 
      (fname, ftype, fid) = iprot.readFieldBegin()
20469 
      if ftype == TType.STOP:
20470 
        break
20471 
      if fid == 0:
20472 
        if ftype == TType.LIST:
20473 
          self.success = []
6188 rajveer 20474 
          (_etype497, _size494) = iprot.readListBegin()
20475 
          for _i498 in xrange(_size494):
20476 
            _elem499 = Order()
20477 
            _elem499.read(iprot)
20478 
            self.success.append(_elem499)
4295 varun.gupt 20479 
          iprot.readListEnd()
20480 
        else:
20481 
          iprot.skip(ftype)
20482 
      else:
20483 
        iprot.skip(ftype)
20484 
      iprot.readFieldEnd()
20485 
    iprot.readStructEnd()
20486 
 
20487 
  def write(self, oprot):
20488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20490 
      return
20491 
    oprot.writeStructBegin('getOrdersForItemIds_result')
20492 
    if self.success is not None:
20493 
      oprot.writeFieldBegin('success', TType.LIST, 0)
20494 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 20495 
      for iter500 in self.success:
20496 
        iter500.write(oprot)
4295 varun.gupt 20497 
      oprot.writeListEnd()
20498 
      oprot.writeFieldEnd()
20499 
    oprot.writeFieldStop()
20500 
    oprot.writeStructEnd()
20501 
 
20502 
  def validate(self):
20503 
    return
20504 
 
20505 
 
20506 
  def __repr__(self):
20507 
    L = ['%s=%r' % (key, value)
20508 
      for key, value in self.__dict__.iteritems()]
20509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20510 
 
20511 
  def __eq__(self, other):
20512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20513 
 
20514 
  def __ne__(self, other):
20515 
    return not (self == other)
20516 
 
4247 rajveer 20517 
class markOrderCancellationRequestReceived_args:
20518 
  """
20519 
  Attributes:
20520 
   - orderId
20521 
  """
20522 
 
20523 
  thrift_spec = (
20524 
    None, # 0
20525 
    (1, TType.I64, 'orderId', None, None, ), # 1
20526 
  )
20527 
 
20528 
  def __init__(self, orderId=None,):
20529 
    self.orderId = orderId
20530 
 
20531 
  def read(self, iprot):
20532 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20533 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20534 
      return
20535 
    iprot.readStructBegin()
20536 
    while True:
20537 
      (fname, ftype, fid) = iprot.readFieldBegin()
20538 
      if ftype == TType.STOP:
20539 
        break
20540 
      if fid == 1:
20541 
        if ftype == TType.I64:
20542 
          self.orderId = iprot.readI64();
20543 
        else:
20544 
          iprot.skip(ftype)
20545 
      else:
20546 
        iprot.skip(ftype)
20547 
      iprot.readFieldEnd()
20548 
    iprot.readStructEnd()
20549 
 
20550 
  def write(self, oprot):
20551 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20552 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20553 
      return
20554 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_args')
20555 
    if self.orderId is not None:
20556 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20557 
      oprot.writeI64(self.orderId)
20558 
      oprot.writeFieldEnd()
20559 
    oprot.writeFieldStop()
20560 
    oprot.writeStructEnd()
20561 
 
20562 
  def validate(self):
20563 
    return
20564 
 
20565 
 
20566 
  def __repr__(self):
20567 
    L = ['%s=%r' % (key, value)
20568 
      for key, value in self.__dict__.iteritems()]
20569 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20570 
 
20571 
  def __eq__(self, other):
20572 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20573 
 
20574 
  def __ne__(self, other):
20575 
    return not (self == other)
20576 
 
20577 
class markOrderCancellationRequestReceived_result:
20578 
  """
20579 
  Attributes:
20580 
   - ex
20581 
  """
20582 
 
20583 
  thrift_spec = (
20584 
    None, # 0
20585 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20586 
  )
20587 
 
20588 
  def __init__(self, ex=None,):
20589 
    self.ex = ex
20590 
 
20591 
  def read(self, iprot):
20592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20594 
      return
20595 
    iprot.readStructBegin()
20596 
    while True:
20597 
      (fname, ftype, fid) = iprot.readFieldBegin()
20598 
      if ftype == TType.STOP:
20599 
        break
20600 
      if fid == 1:
20601 
        if ftype == TType.STRUCT:
20602 
          self.ex = TransactionServiceException()
20603 
          self.ex.read(iprot)
20604 
        else:
20605 
          iprot.skip(ftype)
20606 
      else:
20607 
        iprot.skip(ftype)
20608 
      iprot.readFieldEnd()
20609 
    iprot.readStructEnd()
20610 
 
20611 
  def write(self, oprot):
20612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20614 
      return
20615 
    oprot.writeStructBegin('markOrderCancellationRequestReceived_result')
20616 
    if self.ex is not None:
20617 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20618 
      self.ex.write(oprot)
20619 
      oprot.writeFieldEnd()
20620 
    oprot.writeFieldStop()
20621 
    oprot.writeStructEnd()
20622 
 
20623 
  def validate(self):
20624 
    return
20625 
 
20626 
 
20627 
  def __repr__(self):
20628 
    L = ['%s=%r' % (key, value)
20629 
      for key, value in self.__dict__.iteritems()]
20630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20631 
 
20632 
  def __eq__(self, other):
20633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20634 
 
20635 
  def __ne__(self, other):
20636 
    return not (self == other)
20637 
 
20638 
class markOrderCancellationRequestConfirmed_args:
20639 
  """
20640 
  Attributes:
20641 
   - orderId
20642 
  """
20643 
 
20644 
  thrift_spec = (
20645 
    None, # 0
20646 
    (1, TType.I64, 'orderId', None, None, ), # 1
20647 
  )
20648 
 
20649 
  def __init__(self, orderId=None,):
20650 
    self.orderId = orderId
20651 
 
20652 
  def read(self, iprot):
20653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20655 
      return
20656 
    iprot.readStructBegin()
20657 
    while True:
20658 
      (fname, ftype, fid) = iprot.readFieldBegin()
20659 
      if ftype == TType.STOP:
20660 
        break
20661 
      if fid == 1:
20662 
        if ftype == TType.I64:
20663 
          self.orderId = iprot.readI64();
20664 
        else:
20665 
          iprot.skip(ftype)
20666 
      else:
20667 
        iprot.skip(ftype)
20668 
      iprot.readFieldEnd()
20669 
    iprot.readStructEnd()
20670 
 
20671 
  def write(self, oprot):
20672 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20673 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20674 
      return
20675 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_args')
20676 
    if self.orderId is not None:
20677 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20678 
      oprot.writeI64(self.orderId)
20679 
      oprot.writeFieldEnd()
20680 
    oprot.writeFieldStop()
20681 
    oprot.writeStructEnd()
20682 
 
20683 
  def validate(self):
20684 
    return
20685 
 
20686 
 
20687 
  def __repr__(self):
20688 
    L = ['%s=%r' % (key, value)
20689 
      for key, value in self.__dict__.iteritems()]
20690 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20691 
 
20692 
  def __eq__(self, other):
20693 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20694 
 
20695 
  def __ne__(self, other):
20696 
    return not (self == other)
20697 
 
20698 
class markOrderCancellationRequestConfirmed_result:
20699 
  """
20700 
  Attributes:
20701 
   - ex
20702 
  """
20703 
 
20704 
  thrift_spec = (
20705 
    None, # 0
20706 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20707 
  )
20708 
 
20709 
  def __init__(self, ex=None,):
20710 
    self.ex = ex
20711 
 
20712 
  def read(self, iprot):
20713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20715 
      return
20716 
    iprot.readStructBegin()
20717 
    while True:
20718 
      (fname, ftype, fid) = iprot.readFieldBegin()
20719 
      if ftype == TType.STOP:
20720 
        break
20721 
      if fid == 1:
20722 
        if ftype == TType.STRUCT:
20723 
          self.ex = TransactionServiceException()
20724 
          self.ex.read(iprot)
20725 
        else:
20726 
          iprot.skip(ftype)
20727 
      else:
20728 
        iprot.skip(ftype)
20729 
      iprot.readFieldEnd()
20730 
    iprot.readStructEnd()
20731 
 
20732 
  def write(self, oprot):
20733 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20734 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20735 
      return
20736 
    oprot.writeStructBegin('markOrderCancellationRequestConfirmed_result')
20737 
    if self.ex is not None:
20738 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20739 
      self.ex.write(oprot)
20740 
      oprot.writeFieldEnd()
20741 
    oprot.writeFieldStop()
20742 
    oprot.writeStructEnd()
20743 
 
20744 
  def validate(self):
20745 
    return
20746 
 
20747 
 
20748 
  def __repr__(self):
20749 
    L = ['%s=%r' % (key, value)
20750 
      for key, value in self.__dict__.iteritems()]
20751 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20752 
 
20753 
  def __eq__(self, other):
20754 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20755 
 
20756 
  def __ne__(self, other):
20757 
    return not (self == other)
20758 
 
20759 
class markOrderCancellationRequestDenied_args:
20760 
  """
20761 
  Attributes:
20762 
   - orderId
20763 
  """
20764 
 
20765 
  thrift_spec = (
20766 
    None, # 0
20767 
    (1, TType.I64, 'orderId', None, None, ), # 1
20768 
  )
20769 
 
20770 
  def __init__(self, orderId=None,):
20771 
    self.orderId = orderId
20772 
 
20773 
  def read(self, iprot):
20774 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20775 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20776 
      return
20777 
    iprot.readStructBegin()
20778 
    while True:
20779 
      (fname, ftype, fid) = iprot.readFieldBegin()
20780 
      if ftype == TType.STOP:
20781 
        break
20782 
      if fid == 1:
20783 
        if ftype == TType.I64:
20784 
          self.orderId = iprot.readI64();
20785 
        else:
20786 
          iprot.skip(ftype)
20787 
      else:
20788 
        iprot.skip(ftype)
20789 
      iprot.readFieldEnd()
20790 
    iprot.readStructEnd()
20791 
 
20792 
  def write(self, oprot):
20793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20795 
      return
20796 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_args')
20797 
    if self.orderId is not None:
20798 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
20799 
      oprot.writeI64(self.orderId)
20800 
      oprot.writeFieldEnd()
20801 
    oprot.writeFieldStop()
20802 
    oprot.writeStructEnd()
20803 
 
20804 
  def validate(self):
20805 
    return
20806 
 
20807 
 
20808 
  def __repr__(self):
20809 
    L = ['%s=%r' % (key, value)
20810 
      for key, value in self.__dict__.iteritems()]
20811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20812 
 
20813 
  def __eq__(self, other):
20814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20815 
 
20816 
  def __ne__(self, other):
20817 
    return not (self == other)
20818 
 
20819 
class markOrderCancellationRequestDenied_result:
20820 
  """
20821 
  Attributes:
20822 
   - ex
20823 
  """
20824 
 
20825 
  thrift_spec = (
20826 
    None, # 0
20827 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20828 
  )
20829 
 
20830 
  def __init__(self, ex=None,):
20831 
    self.ex = ex
20832 
 
20833 
  def read(self, iprot):
20834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20836 
      return
20837 
    iprot.readStructBegin()
20838 
    while True:
20839 
      (fname, ftype, fid) = iprot.readFieldBegin()
20840 
      if ftype == TType.STOP:
20841 
        break
20842 
      if fid == 1:
20843 
        if ftype == TType.STRUCT:
20844 
          self.ex = TransactionServiceException()
20845 
          self.ex.read(iprot)
20846 
        else:
20847 
          iprot.skip(ftype)
20848 
      else:
20849 
        iprot.skip(ftype)
20850 
      iprot.readFieldEnd()
20851 
    iprot.readStructEnd()
20852 
 
20853 
  def write(self, oprot):
20854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20856 
      return
20857 
    oprot.writeStructBegin('markOrderCancellationRequestDenied_result')
20858 
    if self.ex is not None:
20859 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20860 
      self.ex.write(oprot)
20861 
      oprot.writeFieldEnd()
20862 
    oprot.writeFieldStop()
20863 
    oprot.writeStructEnd()
20864 
 
20865 
  def validate(self):
20866 
    return
20867 
 
20868 
 
20869 
  def __repr__(self):
20870 
    L = ['%s=%r' % (key, value)
20871 
      for key, value in self.__dict__.iteritems()]
20872 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20873 
 
20874 
  def __eq__(self, other):
20875 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20876 
 
20877 
  def __ne__(self, other):
20878 
    return not (self == other)
20879 
 
4258 rajveer 20880 
class markTransactionAsPaymentFlagRemoved_args:
4247 rajveer 20881 
  """
20882 
  Attributes:
4258 rajveer 20883 
   - transactionId
4247 rajveer 20884 
  """
20885 
 
20886 
  thrift_spec = (
20887 
    None, # 0
4258 rajveer 20888 
    (1, TType.I64, 'transactionId', None, None, ), # 1
4247 rajveer 20889 
  )
20890 
 
4258 rajveer 20891 
  def __init__(self, transactionId=None,):
20892 
    self.transactionId = transactionId
4247 rajveer 20893 
 
20894 
  def read(self, iprot):
20895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20897 
      return
20898 
    iprot.readStructBegin()
20899 
    while True:
20900 
      (fname, ftype, fid) = iprot.readFieldBegin()
20901 
      if ftype == TType.STOP:
20902 
        break
20903 
      if fid == 1:
20904 
        if ftype == TType.I64:
4258 rajveer 20905 
          self.transactionId = iprot.readI64();
4247 rajveer 20906 
        else:
20907 
          iprot.skip(ftype)
20908 
      else:
20909 
        iprot.skip(ftype)
20910 
      iprot.readFieldEnd()
20911 
    iprot.readStructEnd()
20912 
 
20913 
  def write(self, oprot):
20914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20916 
      return
4258 rajveer 20917 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_args')
20918 
    if self.transactionId is not None:
20919 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
20920 
      oprot.writeI64(self.transactionId)
4247 rajveer 20921 
      oprot.writeFieldEnd()
20922 
    oprot.writeFieldStop()
20923 
    oprot.writeStructEnd()
20924 
 
20925 
  def validate(self):
20926 
    return
20927 
 
20928 
 
20929 
  def __repr__(self):
20930 
    L = ['%s=%r' % (key, value)
20931 
      for key, value in self.__dict__.iteritems()]
20932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20933 
 
20934 
  def __eq__(self, other):
20935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20936 
 
20937 
  def __ne__(self, other):
20938 
    return not (self == other)
20939 
 
4258 rajveer 20940 
class markTransactionAsPaymentFlagRemoved_result:
4247 rajveer 20941 
  """
20942 
  Attributes:
20943 
   - ex
20944 
  """
20945 
 
20946 
  thrift_spec = (
20947 
    None, # 0
20948 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
20949 
  )
20950 
 
20951 
  def __init__(self, ex=None,):
20952 
    self.ex = ex
20953 
 
20954 
  def read(self, iprot):
20955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
20956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
20957 
      return
20958 
    iprot.readStructBegin()
20959 
    while True:
20960 
      (fname, ftype, fid) = iprot.readFieldBegin()
20961 
      if ftype == TType.STOP:
20962 
        break
20963 
      if fid == 1:
20964 
        if ftype == TType.STRUCT:
20965 
          self.ex = TransactionServiceException()
20966 
          self.ex.read(iprot)
20967 
        else:
20968 
          iprot.skip(ftype)
20969 
      else:
20970 
        iprot.skip(ftype)
20971 
      iprot.readFieldEnd()
20972 
    iprot.readStructEnd()
20973 
 
20974 
  def write(self, oprot):
20975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
20976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
20977 
      return
4258 rajveer 20978 
    oprot.writeStructBegin('markTransactionAsPaymentFlagRemoved_result')
4247 rajveer 20979 
    if self.ex is not None:
20980 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
20981 
      self.ex.write(oprot)
20982 
      oprot.writeFieldEnd()
20983 
    oprot.writeFieldStop()
20984 
    oprot.writeStructEnd()
20985 
 
20986 
  def validate(self):
20987 
    return
20988 
 
20989 
 
20990 
  def __repr__(self):
20991 
    L = ['%s=%r' % (key, value)
20992 
      for key, value in self.__dict__.iteritems()]
20993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
20994 
 
20995 
  def __eq__(self, other):
20996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
20997 
 
20998 
  def __ne__(self, other):
20999 
    return not (self == other)
4259 anupam.sin 21000 
 
21001 
class refundTransaction_args:
21002 
  """
21003 
  Attributes:
21004 
   - transactionId
21005 
   - refundedBy
21006 
   - reason
21007 
  """
21008 
 
21009 
  thrift_spec = (
21010 
    None, # 0
21011 
    (1, TType.I64, 'transactionId', None, None, ), # 1
21012 
    (2, TType.STRING, 'refundedBy', None, None, ), # 2
21013 
    (3, TType.STRING, 'reason', None, None, ), # 3
21014 
  )
21015 
 
21016 
  def __init__(self, transactionId=None, refundedBy=None, reason=None,):
21017 
    self.transactionId = transactionId
21018 
    self.refundedBy = refundedBy
21019 
    self.reason = reason
21020 
 
21021 
  def read(self, iprot):
21022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21024 
      return
21025 
    iprot.readStructBegin()
21026 
    while True:
21027 
      (fname, ftype, fid) = iprot.readFieldBegin()
21028 
      if ftype == TType.STOP:
21029 
        break
21030 
      if fid == 1:
21031 
        if ftype == TType.I64:
21032 
          self.transactionId = iprot.readI64();
21033 
        else:
21034 
          iprot.skip(ftype)
21035 
      elif fid == 2:
21036 
        if ftype == TType.STRING:
21037 
          self.refundedBy = iprot.readString();
21038 
        else:
21039 
          iprot.skip(ftype)
21040 
      elif fid == 3:
21041 
        if ftype == TType.STRING:
21042 
          self.reason = iprot.readString();
21043 
        else:
21044 
          iprot.skip(ftype)
21045 
      else:
21046 
        iprot.skip(ftype)
21047 
      iprot.readFieldEnd()
21048 
    iprot.readStructEnd()
21049 
 
21050 
  def write(self, oprot):
21051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21053 
      return
21054 
    oprot.writeStructBegin('refundTransaction_args')
21055 
    if self.transactionId is not None:
21056 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
21057 
      oprot.writeI64(self.transactionId)
21058 
      oprot.writeFieldEnd()
21059 
    if self.refundedBy is not None:
21060 
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
21061 
      oprot.writeString(self.refundedBy)
21062 
      oprot.writeFieldEnd()
21063 
    if self.reason is not None:
21064 
      oprot.writeFieldBegin('reason', TType.STRING, 3)
21065 
      oprot.writeString(self.reason)
21066 
      oprot.writeFieldEnd()
21067 
    oprot.writeFieldStop()
21068 
    oprot.writeStructEnd()
21069 
 
21070 
  def validate(self):
21071 
    return
21072 
 
21073 
 
21074 
  def __repr__(self):
21075 
    L = ['%s=%r' % (key, value)
21076 
      for key, value in self.__dict__.iteritems()]
21077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21078 
 
21079 
  def __eq__(self, other):
21080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21081 
 
21082 
  def __ne__(self, other):
21083 
    return not (self == other)
21084 
 
21085 
class refundTransaction_result:
21086 
  """
21087 
  Attributes:
21088 
   - ex
21089 
  """
21090 
 
21091 
  thrift_spec = (
21092 
    None, # 0
21093 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21094 
  )
21095 
 
21096 
  def __init__(self, ex=None,):
21097 
    self.ex = ex
21098 
 
21099 
  def read(self, iprot):
21100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21102 
      return
21103 
    iprot.readStructBegin()
21104 
    while True:
21105 
      (fname, ftype, fid) = iprot.readFieldBegin()
21106 
      if ftype == TType.STOP:
21107 
        break
21108 
      if fid == 1:
21109 
        if ftype == TType.STRUCT:
21110 
          self.ex = TransactionServiceException()
21111 
          self.ex.read(iprot)
21112 
        else:
21113 
          iprot.skip(ftype)
21114 
      else:
21115 
        iprot.skip(ftype)
21116 
      iprot.readFieldEnd()
21117 
    iprot.readStructEnd()
21118 
 
21119 
  def write(self, oprot):
21120 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21121 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21122 
      return
21123 
    oprot.writeStructBegin('refundTransaction_result')
21124 
    if self.ex is not None:
21125 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21126 
      self.ex.write(oprot)
21127 
      oprot.writeFieldEnd()
21128 
    oprot.writeFieldStop()
21129 
    oprot.writeStructEnd()
21130 
 
21131 
  def validate(self):
21132 
    return
21133 
 
21134 
 
21135 
  def __repr__(self):
21136 
    L = ['%s=%r' % (key, value)
21137 
      for key, value in self.__dict__.iteritems()]
21138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21139 
 
21140 
  def __eq__(self, other):
21141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21142 
 
21143 
  def __ne__(self, other):
21144 
    return not (self == other)
4285 rajveer 21145 
 
4324 mandeep.dh 21146 
class updateShipmentAddress_args:
21147 
  """
21148 
  Attributes:
21149 
   - orderId
21150 
   - addressId
21151 
  """
21152 
 
21153 
  thrift_spec = (
21154 
    None, # 0
21155 
    (1, TType.I64, 'orderId', None, None, ), # 1
21156 
    (2, TType.I64, 'addressId', None, None, ), # 2
21157 
  )
21158 
 
21159 
  def __init__(self, orderId=None, addressId=None,):
21160 
    self.orderId = orderId
21161 
    self.addressId = addressId
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.I64:
21174 
          self.orderId = iprot.readI64();
21175 
        else:
21176 
          iprot.skip(ftype)
21177 
      elif fid == 2:
21178 
        if ftype == TType.I64:
21179 
          self.addressId = iprot.readI64();
21180 
        else:
21181 
          iprot.skip(ftype)
21182 
      else:
21183 
        iprot.skip(ftype)
21184 
      iprot.readFieldEnd()
21185 
    iprot.readStructEnd()
21186 
 
21187 
  def write(self, oprot):
21188 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21189 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21190 
      return
21191 
    oprot.writeStructBegin('updateShipmentAddress_args')
21192 
    if self.orderId is not None:
21193 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
21194 
      oprot.writeI64(self.orderId)
21195 
      oprot.writeFieldEnd()
21196 
    if self.addressId is not None:
21197 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
21198 
      oprot.writeI64(self.addressId)
21199 
      oprot.writeFieldEnd()
21200 
    oprot.writeFieldStop()
21201 
    oprot.writeStructEnd()
21202 
 
21203 
  def validate(self):
21204 
    return
21205 
 
21206 
 
21207 
  def __repr__(self):
21208 
    L = ['%s=%r' % (key, value)
21209 
      for key, value in self.__dict__.iteritems()]
21210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21211 
 
21212 
  def __eq__(self, other):
21213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21214 
 
21215 
  def __ne__(self, other):
21216 
    return not (self == other)
21217 
 
21218 
class updateShipmentAddress_result:
21219 
  """
21220 
  Attributes:
21221 
   - ex
21222 
  """
21223 
 
21224 
  thrift_spec = (
21225 
    None, # 0
21226 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21227 
  )
21228 
 
21229 
  def __init__(self, ex=None,):
21230 
    self.ex = ex
21231 
 
21232 
  def read(self, iprot):
21233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21235 
      return
21236 
    iprot.readStructBegin()
21237 
    while True:
21238 
      (fname, ftype, fid) = iprot.readFieldBegin()
21239 
      if ftype == TType.STOP:
21240 
        break
21241 
      if fid == 1:
21242 
        if ftype == TType.STRUCT:
21243 
          self.ex = TransactionServiceException()
21244 
          self.ex.read(iprot)
21245 
        else:
21246 
          iprot.skip(ftype)
21247 
      else:
21248 
        iprot.skip(ftype)
21249 
      iprot.readFieldEnd()
21250 
    iprot.readStructEnd()
21251 
 
21252 
  def write(self, oprot):
21253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21255 
      return
21256 
    oprot.writeStructBegin('updateShipmentAddress_result')
21257 
    if self.ex is not None:
21258 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21259 
      self.ex.write(oprot)
21260 
      oprot.writeFieldEnd()
21261 
    oprot.writeFieldStop()
21262 
    oprot.writeStructEnd()
21263 
 
21264 
  def validate(self):
21265 
    return
21266 
 
21267 
 
21268 
  def __repr__(self):
21269 
    L = ['%s=%r' % (key, value)
21270 
      for key, value in self.__dict__.iteritems()]
21271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21272 
 
21273 
  def __eq__(self, other):
21274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21275 
 
21276 
  def __ne__(self, other):
21277 
    return not (self == other)
21278 
 
4285 rajveer 21279 
class acceptOrdersForItemId_args:
21280 
  """
21281 
  Attributes:
21282 
   - itemId
21283 
   - inventory
21284 
  """
21285 
 
21286 
  thrift_spec = (
21287 
    None, # 0
21288 
    (1, TType.I64, 'itemId', None, None, ), # 1
21289 
    (2, TType.I64, 'inventory', None, None, ), # 2
21290 
  )
21291 
 
21292 
  def __init__(self, itemId=None, inventory=None,):
21293 
    self.itemId = itemId
21294 
    self.inventory = inventory
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.I64:
21307 
          self.itemId = iprot.readI64();
21308 
        else:
21309 
          iprot.skip(ftype)
21310 
      elif fid == 2:
21311 
        if ftype == TType.I64:
21312 
          self.inventory = iprot.readI64();
21313 
        else:
21314 
          iprot.skip(ftype)
21315 
      else:
21316 
        iprot.skip(ftype)
21317 
      iprot.readFieldEnd()
21318 
    iprot.readStructEnd()
21319 
 
21320 
  def write(self, oprot):
21321 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21322 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21323 
      return
21324 
    oprot.writeStructBegin('acceptOrdersForItemId_args')
21325 
    if self.itemId is not None:
21326 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
21327 
      oprot.writeI64(self.itemId)
21328 
      oprot.writeFieldEnd()
21329 
    if self.inventory is not None:
21330 
      oprot.writeFieldBegin('inventory', TType.I64, 2)
21331 
      oprot.writeI64(self.inventory)
21332 
      oprot.writeFieldEnd()
21333 
    oprot.writeFieldStop()
21334 
    oprot.writeStructEnd()
21335 
 
21336 
  def validate(self):
21337 
    return
21338 
 
21339 
 
21340 
  def __repr__(self):
21341 
    L = ['%s=%r' % (key, value)
21342 
      for key, value in self.__dict__.iteritems()]
21343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21344 
 
21345 
  def __eq__(self, other):
21346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21347 
 
21348 
  def __ne__(self, other):
21349 
    return not (self == other)
21350 
 
21351 
class acceptOrdersForItemId_result:
21352 
  """
21353 
  Attributes:
21354 
   - success
21355 
   - ex
21356 
  """
21357 
 
21358 
  thrift_spec = (
21359 
    (0, TType.BOOL, 'success', None, None, ), # 0
21360 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21361 
  )
21362 
 
21363 
  def __init__(self, success=None, ex=None,):
21364 
    self.success = success
21365 
    self.ex = ex
21366 
 
21367 
  def read(self, iprot):
21368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21370 
      return
21371 
    iprot.readStructBegin()
21372 
    while True:
21373 
      (fname, ftype, fid) = iprot.readFieldBegin()
21374 
      if ftype == TType.STOP:
21375 
        break
21376 
      if fid == 0:
21377 
        if ftype == TType.BOOL:
21378 
          self.success = iprot.readBool();
21379 
        else:
21380 
          iprot.skip(ftype)
21381 
      elif fid == 1:
21382 
        if ftype == TType.STRUCT:
21383 
          self.ex = TransactionServiceException()
21384 
          self.ex.read(iprot)
21385 
        else:
21386 
          iprot.skip(ftype)
21387 
      else:
21388 
        iprot.skip(ftype)
21389 
      iprot.readFieldEnd()
21390 
    iprot.readStructEnd()
21391 
 
21392 
  def write(self, oprot):
21393 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21394 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21395 
      return
21396 
    oprot.writeStructBegin('acceptOrdersForItemId_result')
21397 
    if self.success is not None:
21398 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
21399 
      oprot.writeBool(self.success)
21400 
      oprot.writeFieldEnd()
21401 
    if self.ex is not None:
21402 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21403 
      self.ex.write(oprot)
21404 
      oprot.writeFieldEnd()
21405 
    oprot.writeFieldStop()
21406 
    oprot.writeStructEnd()
21407 
 
21408 
  def validate(self):
21409 
    return
21410 
 
21411 
 
21412 
  def __repr__(self):
21413 
    L = ['%s=%r' % (key, value)
21414 
      for key, value in self.__dict__.iteritems()]
21415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21416 
 
21417 
  def __eq__(self, other):
21418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21419 
 
21420 
  def __ne__(self, other):
21421 
    return not (self == other)
4303 rajveer 21422 
 
21423 
class markOrdersAsPORaised_args:
21424 
  """
21425 
  Attributes:
21426 
   - vendorId
21427 
   - itemId
21428 
   - quantity
21429 
   - estimate
4369 rajveer 21430 
   - isReminder
4303 rajveer 21431 
  """
21432 
 
21433 
  thrift_spec = (
21434 
    None, # 0
21435 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21436 
    (2, TType.I64, 'itemId', None, None, ), # 2
21437 
    (3, TType.I64, 'quantity', None, None, ), # 3
21438 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21439 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21440 
  )
21441 
 
4369 rajveer 21442 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21443 
    self.vendorId = vendorId
21444 
    self.itemId = itemId
21445 
    self.quantity = quantity
21446 
    self.estimate = estimate
4369 rajveer 21447 
    self.isReminder = isReminder
4303 rajveer 21448 
 
21449 
  def read(self, iprot):
21450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21452 
      return
21453 
    iprot.readStructBegin()
21454 
    while True:
21455 
      (fname, ftype, fid) = iprot.readFieldBegin()
21456 
      if ftype == TType.STOP:
21457 
        break
21458 
      if fid == 1:
21459 
        if ftype == TType.I64:
21460 
          self.vendorId = iprot.readI64();
21461 
        else:
21462 
          iprot.skip(ftype)
21463 
      elif fid == 2:
21464 
        if ftype == TType.I64:
21465 
          self.itemId = iprot.readI64();
21466 
        else:
21467 
          iprot.skip(ftype)
21468 
      elif fid == 3:
21469 
        if ftype == TType.I64:
21470 
          self.quantity = iprot.readI64();
21471 
        else:
21472 
          iprot.skip(ftype)
21473 
      elif fid == 4:
21474 
        if ftype == TType.I64:
21475 
          self.estimate = iprot.readI64();
21476 
        else:
21477 
          iprot.skip(ftype)
4369 rajveer 21478 
      elif fid == 5:
21479 
        if ftype == TType.BOOL:
21480 
          self.isReminder = iprot.readBool();
21481 
        else:
21482 
          iprot.skip(ftype)
4303 rajveer 21483 
      else:
21484 
        iprot.skip(ftype)
21485 
      iprot.readFieldEnd()
21486 
    iprot.readStructEnd()
21487 
 
21488 
  def write(self, oprot):
21489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21491 
      return
21492 
    oprot.writeStructBegin('markOrdersAsPORaised_args')
21493 
    if self.vendorId is not None:
21494 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21495 
      oprot.writeI64(self.vendorId)
21496 
      oprot.writeFieldEnd()
21497 
    if self.itemId is not None:
21498 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21499 
      oprot.writeI64(self.itemId)
21500 
      oprot.writeFieldEnd()
21501 
    if self.quantity is not None:
21502 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21503 
      oprot.writeI64(self.quantity)
21504 
      oprot.writeFieldEnd()
21505 
    if self.estimate is not None:
21506 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21507 
      oprot.writeI64(self.estimate)
21508 
      oprot.writeFieldEnd()
4369 rajveer 21509 
    if self.isReminder is not None:
21510 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21511 
      oprot.writeBool(self.isReminder)
21512 
      oprot.writeFieldEnd()
4303 rajveer 21513 
    oprot.writeFieldStop()
21514 
    oprot.writeStructEnd()
21515 
 
21516 
  def validate(self):
21517 
    return
21518 
 
21519 
 
21520 
  def __repr__(self):
21521 
    L = ['%s=%r' % (key, value)
21522 
      for key, value in self.__dict__.iteritems()]
21523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21524 
 
21525 
  def __eq__(self, other):
21526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21527 
 
21528 
  def __ne__(self, other):
21529 
    return not (self == other)
21530 
 
21531 
class markOrdersAsPORaised_result:
21532 
  """
21533 
  Attributes:
21534 
   - ex
21535 
  """
21536 
 
21537 
  thrift_spec = (
21538 
    None, # 0
21539 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21540 
  )
21541 
 
21542 
  def __init__(self, ex=None,):
21543 
    self.ex = ex
21544 
 
21545 
  def read(self, iprot):
21546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21548 
      return
21549 
    iprot.readStructBegin()
21550 
    while True:
21551 
      (fname, ftype, fid) = iprot.readFieldBegin()
21552 
      if ftype == TType.STOP:
21553 
        break
21554 
      if fid == 1:
21555 
        if ftype == TType.STRUCT:
21556 
          self.ex = TransactionServiceException()
21557 
          self.ex.read(iprot)
21558 
        else:
21559 
          iprot.skip(ftype)
21560 
      else:
21561 
        iprot.skip(ftype)
21562 
      iprot.readFieldEnd()
21563 
    iprot.readStructEnd()
21564 
 
21565 
  def write(self, oprot):
21566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21568 
      return
21569 
    oprot.writeStructBegin('markOrdersAsPORaised_result')
21570 
    if self.ex is not None:
21571 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21572 
      self.ex.write(oprot)
21573 
      oprot.writeFieldEnd()
21574 
    oprot.writeFieldStop()
21575 
    oprot.writeStructEnd()
21576 
 
21577 
  def validate(self):
21578 
    return
21579 
 
21580 
 
21581 
  def __repr__(self):
21582 
    L = ['%s=%r' % (key, value)
21583 
      for key, value in self.__dict__.iteritems()]
21584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21585 
 
21586 
  def __eq__(self, other):
21587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21588 
 
21589 
  def __ne__(self, other):
21590 
    return not (self == other)
21591 
 
21592 
class markOrdersAsReversalInitiated_args:
21593 
  """
21594 
  Attributes:
21595 
   - vendorId
21596 
   - itemId
21597 
   - quantity
21598 
   - estimate
4369 rajveer 21599 
   - isReminder
4303 rajveer 21600 
  """
21601 
 
21602 
  thrift_spec = (
21603 
    None, # 0
21604 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21605 
    (2, TType.I64, 'itemId', None, None, ), # 2
21606 
    (3, TType.I64, 'quantity', None, None, ), # 3
21607 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21608 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21609 
  )
21610 
 
4369 rajveer 21611 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21612 
    self.vendorId = vendorId
21613 
    self.itemId = itemId
21614 
    self.quantity = quantity
21615 
    self.estimate = estimate
4369 rajveer 21616 
    self.isReminder = isReminder
4303 rajveer 21617 
 
21618 
  def read(self, iprot):
21619 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21620 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21621 
      return
21622 
    iprot.readStructBegin()
21623 
    while True:
21624 
      (fname, ftype, fid) = iprot.readFieldBegin()
21625 
      if ftype == TType.STOP:
21626 
        break
21627 
      if fid == 1:
21628 
        if ftype == TType.I64:
21629 
          self.vendorId = iprot.readI64();
21630 
        else:
21631 
          iprot.skip(ftype)
21632 
      elif fid == 2:
21633 
        if ftype == TType.I64:
21634 
          self.itemId = iprot.readI64();
21635 
        else:
21636 
          iprot.skip(ftype)
21637 
      elif fid == 3:
21638 
        if ftype == TType.I64:
21639 
          self.quantity = iprot.readI64();
21640 
        else:
21641 
          iprot.skip(ftype)
21642 
      elif fid == 4:
21643 
        if ftype == TType.I64:
21644 
          self.estimate = iprot.readI64();
21645 
        else:
21646 
          iprot.skip(ftype)
4369 rajveer 21647 
      elif fid == 5:
21648 
        if ftype == TType.BOOL:
21649 
          self.isReminder = iprot.readBool();
21650 
        else:
21651 
          iprot.skip(ftype)
4303 rajveer 21652 
      else:
21653 
        iprot.skip(ftype)
21654 
      iprot.readFieldEnd()
21655 
    iprot.readStructEnd()
21656 
 
21657 
  def write(self, oprot):
21658 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21659 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21660 
      return
21661 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_args')
21662 
    if self.vendorId is not None:
21663 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21664 
      oprot.writeI64(self.vendorId)
21665 
      oprot.writeFieldEnd()
21666 
    if self.itemId is not None:
21667 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21668 
      oprot.writeI64(self.itemId)
21669 
      oprot.writeFieldEnd()
21670 
    if self.quantity is not None:
21671 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21672 
      oprot.writeI64(self.quantity)
21673 
      oprot.writeFieldEnd()
21674 
    if self.estimate is not None:
21675 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21676 
      oprot.writeI64(self.estimate)
21677 
      oprot.writeFieldEnd()
4369 rajveer 21678 
    if self.isReminder is not None:
21679 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21680 
      oprot.writeBool(self.isReminder)
21681 
      oprot.writeFieldEnd()
4303 rajveer 21682 
    oprot.writeFieldStop()
21683 
    oprot.writeStructEnd()
21684 
 
21685 
  def validate(self):
21686 
    return
21687 
 
21688 
 
21689 
  def __repr__(self):
21690 
    L = ['%s=%r' % (key, value)
21691 
      for key, value in self.__dict__.iteritems()]
21692 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21693 
 
21694 
  def __eq__(self, other):
21695 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21696 
 
21697 
  def __ne__(self, other):
21698 
    return not (self == other)
21699 
 
21700 
class markOrdersAsReversalInitiated_result:
21701 
  """
21702 
  Attributes:
21703 
   - ex
21704 
  """
21705 
 
21706 
  thrift_spec = (
21707 
    None, # 0
21708 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21709 
  )
21710 
 
21711 
  def __init__(self, ex=None,):
21712 
    self.ex = ex
21713 
 
21714 
  def read(self, iprot):
21715 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21716 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21717 
      return
21718 
    iprot.readStructBegin()
21719 
    while True:
21720 
      (fname, ftype, fid) = iprot.readFieldBegin()
21721 
      if ftype == TType.STOP:
21722 
        break
21723 
      if fid == 1:
21724 
        if ftype == TType.STRUCT:
21725 
          self.ex = TransactionServiceException()
21726 
          self.ex.read(iprot)
21727 
        else:
21728 
          iprot.skip(ftype)
21729 
      else:
21730 
        iprot.skip(ftype)
21731 
      iprot.readFieldEnd()
21732 
    iprot.readStructEnd()
21733 
 
21734 
  def write(self, oprot):
21735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21737 
      return
21738 
    oprot.writeStructBegin('markOrdersAsReversalInitiated_result')
21739 
    if self.ex is not None:
21740 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21741 
      self.ex.write(oprot)
21742 
      oprot.writeFieldEnd()
21743 
    oprot.writeFieldStop()
21744 
    oprot.writeStructEnd()
21745 
 
21746 
  def validate(self):
21747 
    return
21748 
 
21749 
 
21750 
  def __repr__(self):
21751 
    L = ['%s=%r' % (key, value)
21752 
      for key, value in self.__dict__.iteritems()]
21753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21754 
 
21755 
  def __eq__(self, other):
21756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21757 
 
21758 
  def __ne__(self, other):
21759 
    return not (self == other)
21760 
 
21761 
class markOrdersAsNotAvailabke_args:
21762 
  """
21763 
  Attributes:
21764 
   - vendorId
21765 
   - itemId
21766 
   - quantity
21767 
   - estimate
4369 rajveer 21768 
   - isReminder
4303 rajveer 21769 
  """
21770 
 
21771 
  thrift_spec = (
21772 
    None, # 0
21773 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21774 
    (2, TType.I64, 'itemId', None, None, ), # 2
21775 
    (3, TType.I64, 'quantity', None, None, ), # 3
21776 
    (4, TType.I64, 'estimate', None, None, ), # 4
4369 rajveer 21777 
    (5, TType.BOOL, 'isReminder', None, None, ), # 5
4303 rajveer 21778 
  )
21779 
 
4369 rajveer 21780 
  def __init__(self, vendorId=None, itemId=None, quantity=None, estimate=None, isReminder=None,):
4303 rajveer 21781 
    self.vendorId = vendorId
21782 
    self.itemId = itemId
21783 
    self.quantity = quantity
21784 
    self.estimate = estimate
4369 rajveer 21785 
    self.isReminder = isReminder
4303 rajveer 21786 
 
21787 
  def read(self, iprot):
21788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21790 
      return
21791 
    iprot.readStructBegin()
21792 
    while True:
21793 
      (fname, ftype, fid) = iprot.readFieldBegin()
21794 
      if ftype == TType.STOP:
21795 
        break
21796 
      if fid == 1:
21797 
        if ftype == TType.I64:
21798 
          self.vendorId = iprot.readI64();
21799 
        else:
21800 
          iprot.skip(ftype)
21801 
      elif fid == 2:
21802 
        if ftype == TType.I64:
21803 
          self.itemId = iprot.readI64();
21804 
        else:
21805 
          iprot.skip(ftype)
21806 
      elif fid == 3:
21807 
        if ftype == TType.I64:
21808 
          self.quantity = iprot.readI64();
21809 
        else:
21810 
          iprot.skip(ftype)
21811 
      elif fid == 4:
21812 
        if ftype == TType.I64:
21813 
          self.estimate = iprot.readI64();
21814 
        else:
21815 
          iprot.skip(ftype)
4369 rajveer 21816 
      elif fid == 5:
21817 
        if ftype == TType.BOOL:
21818 
          self.isReminder = iprot.readBool();
21819 
        else:
21820 
          iprot.skip(ftype)
4303 rajveer 21821 
      else:
21822 
        iprot.skip(ftype)
21823 
      iprot.readFieldEnd()
21824 
    iprot.readStructEnd()
21825 
 
21826 
  def write(self, oprot):
21827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21829 
      return
21830 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_args')
21831 
    if self.vendorId is not None:
21832 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21833 
      oprot.writeI64(self.vendorId)
21834 
      oprot.writeFieldEnd()
21835 
    if self.itemId is not None:
21836 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
21837 
      oprot.writeI64(self.itemId)
21838 
      oprot.writeFieldEnd()
21839 
    if self.quantity is not None:
21840 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
21841 
      oprot.writeI64(self.quantity)
21842 
      oprot.writeFieldEnd()
21843 
    if self.estimate is not None:
21844 
      oprot.writeFieldBegin('estimate', TType.I64, 4)
21845 
      oprot.writeI64(self.estimate)
21846 
      oprot.writeFieldEnd()
4369 rajveer 21847 
    if self.isReminder is not None:
21848 
      oprot.writeFieldBegin('isReminder', TType.BOOL, 5)
21849 
      oprot.writeBool(self.isReminder)
21850 
      oprot.writeFieldEnd()
4303 rajveer 21851 
    oprot.writeFieldStop()
21852 
    oprot.writeStructEnd()
21853 
 
21854 
  def validate(self):
21855 
    return
21856 
 
21857 
 
21858 
  def __repr__(self):
21859 
    L = ['%s=%r' % (key, value)
21860 
      for key, value in self.__dict__.iteritems()]
21861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21862 
 
21863 
  def __eq__(self, other):
21864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21865 
 
21866 
  def __ne__(self, other):
21867 
    return not (self == other)
21868 
 
21869 
class markOrdersAsNotAvailabke_result:
21870 
  """
21871 
  Attributes:
21872 
   - ex
21873 
  """
21874 
 
21875 
  thrift_spec = (
21876 
    None, # 0
21877 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
21878 
  )
21879 
 
21880 
  def __init__(self, ex=None,):
21881 
    self.ex = ex
21882 
 
21883 
  def read(self, iprot):
21884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21886 
      return
21887 
    iprot.readStructBegin()
21888 
    while True:
21889 
      (fname, ftype, fid) = iprot.readFieldBegin()
21890 
      if ftype == TType.STOP:
21891 
        break
21892 
      if fid == 1:
21893 
        if ftype == TType.STRUCT:
21894 
          self.ex = TransactionServiceException()
21895 
          self.ex.read(iprot)
21896 
        else:
21897 
          iprot.skip(ftype)
21898 
      else:
21899 
        iprot.skip(ftype)
21900 
      iprot.readFieldEnd()
21901 
    iprot.readStructEnd()
21902 
 
21903 
  def write(self, oprot):
21904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21906 
      return
21907 
    oprot.writeStructBegin('markOrdersAsNotAvailabke_result')
21908 
    if self.ex is not None:
21909 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
21910 
      self.ex.write(oprot)
21911 
      oprot.writeFieldEnd()
21912 
    oprot.writeFieldStop()
21913 
    oprot.writeStructEnd()
21914 
 
21915 
  def validate(self):
21916 
    return
21917 
 
21918 
 
21919 
  def __repr__(self):
21920 
    L = ['%s=%r' % (key, value)
21921 
      for key, value in self.__dict__.iteritems()]
21922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21923 
 
21924 
  def __eq__(self, other):
21925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21926 
 
21927 
  def __ne__(self, other):
21928 
    return not (self == other)
4369 rajveer 21929 
 
21930 
class markOrdersAsTimeout_args:
21931 
  """
21932 
  Attributes:
21933 
   - vendorId
21934 
  """
21935 
 
21936 
  thrift_spec = (
21937 
    None, # 0
21938 
    (1, TType.I64, 'vendorId', None, None, ), # 1
21939 
  )
21940 
 
21941 
  def __init__(self, vendorId=None,):
21942 
    self.vendorId = vendorId
21943 
 
21944 
  def read(self, iprot):
21945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
21946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
21947 
      return
21948 
    iprot.readStructBegin()
21949 
    while True:
21950 
      (fname, ftype, fid) = iprot.readFieldBegin()
21951 
      if ftype == TType.STOP:
21952 
        break
21953 
      if fid == 1:
21954 
        if ftype == TType.I64:
21955 
          self.vendorId = iprot.readI64();
21956 
        else:
21957 
          iprot.skip(ftype)
21958 
      else:
21959 
        iprot.skip(ftype)
21960 
      iprot.readFieldEnd()
21961 
    iprot.readStructEnd()
21962 
 
21963 
  def write(self, oprot):
21964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
21965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
21966 
      return
21967 
    oprot.writeStructBegin('markOrdersAsTimeout_args')
21968 
    if self.vendorId is not None:
21969 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
21970 
      oprot.writeI64(self.vendorId)
21971 
      oprot.writeFieldEnd()
21972 
    oprot.writeFieldStop()
21973 
    oprot.writeStructEnd()
21974 
 
21975 
  def validate(self):
21976 
    return
21977 
 
21978 
 
21979 
  def __repr__(self):
21980 
    L = ['%s=%r' % (key, value)
21981 
      for key, value in self.__dict__.iteritems()]
21982 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
21983 
 
21984 
  def __eq__(self, other):
21985 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
21986 
 
21987 
  def __ne__(self, other):
21988 
    return not (self == other)
21989 
 
21990 
class markOrdersAsTimeout_result:
21991 
  """
21992 
  Attributes:
21993 
   - success
21994 
   - ex
21995 
  """
21996 
 
21997 
  thrift_spec = (
21998 
    (0, TType.MAP, 'success', (TType.I32,None,TType.STRUCT,(TimeoutSummary, TimeoutSummary.thrift_spec)), None, ), # 0
21999 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22000 
  )
22001 
 
22002 
  def __init__(self, success=None, ex=None,):
22003 
    self.success = success
22004 
    self.ex = ex
22005 
 
22006 
  def read(self, iprot):
22007 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22008 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22009 
      return
22010 
    iprot.readStructBegin()
22011 
    while True:
22012 
      (fname, ftype, fid) = iprot.readFieldBegin()
22013 
      if ftype == TType.STOP:
22014 
        break
22015 
      if fid == 0:
22016 
        if ftype == TType.MAP:
22017 
          self.success = {}
6188 rajveer 22018 
          (_ktype502, _vtype503, _size501 ) = iprot.readMapBegin()
22019 
          for _i505 in xrange(_size501):
22020 
            _key506 = iprot.readI32();
22021 
            _val507 = TimeoutSummary()
22022 
            _val507.read(iprot)
22023 
            self.success[_key506] = _val507
4369 rajveer 22024 
          iprot.readMapEnd()
22025 
        else:
22026 
          iprot.skip(ftype)
22027 
      elif fid == 1:
22028 
        if ftype == TType.STRUCT:
22029 
          self.ex = TransactionServiceException()
22030 
          self.ex.read(iprot)
22031 
        else:
22032 
          iprot.skip(ftype)
22033 
      else:
22034 
        iprot.skip(ftype)
22035 
      iprot.readFieldEnd()
22036 
    iprot.readStructEnd()
22037 
 
22038 
  def write(self, oprot):
22039 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22040 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22041 
      return
22042 
    oprot.writeStructBegin('markOrdersAsTimeout_result')
22043 
    if self.success is not None:
22044 
      oprot.writeFieldBegin('success', TType.MAP, 0)
22045 
      oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
6188 rajveer 22046 
      for kiter508,viter509 in self.success.items():
22047 
        oprot.writeI32(kiter508)
22048 
        viter509.write(oprot)
4369 rajveer 22049 
      oprot.writeMapEnd()
22050 
      oprot.writeFieldEnd()
22051 
    if self.ex is not None:
22052 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22053 
      self.ex.write(oprot)
22054 
      oprot.writeFieldEnd()
22055 
    oprot.writeFieldStop()
22056 
    oprot.writeStructEnd()
22057 
 
22058 
  def validate(self):
22059 
    return
22060 
 
22061 
 
22062 
  def __repr__(self):
22063 
    L = ['%s=%r' % (key, value)
22064 
      for key, value in self.__dict__.iteritems()]
22065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22066 
 
22067 
  def __eq__(self, other):
22068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22069 
 
22070 
  def __ne__(self, other):
22071 
    return not (self == other)
4386 anupam.sin 22072 
 
4662 rajveer 22073 
class markOrderAsLostInTransit_args:
22074 
  """
22075 
  Attributes:
22076 
   - orderId
22077 
  """
22078 
 
22079 
  thrift_spec = (
22080 
    None, # 0
22081 
    (1, TType.I64, 'orderId', None, None, ), # 1
22082 
  )
22083 
 
22084 
  def __init__(self, orderId=None,):
22085 
    self.orderId = orderId
22086 
 
22087 
  def read(self, iprot):
22088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22090 
      return
22091 
    iprot.readStructBegin()
22092 
    while True:
22093 
      (fname, ftype, fid) = iprot.readFieldBegin()
22094 
      if ftype == TType.STOP:
22095 
        break
22096 
      if fid == 1:
22097 
        if ftype == TType.I64:
22098 
          self.orderId = iprot.readI64();
22099 
        else:
22100 
          iprot.skip(ftype)
22101 
      else:
22102 
        iprot.skip(ftype)
22103 
      iprot.readFieldEnd()
22104 
    iprot.readStructEnd()
22105 
 
22106 
  def write(self, oprot):
22107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22109 
      return
22110 
    oprot.writeStructBegin('markOrderAsLostInTransit_args')
22111 
    if self.orderId is not None:
22112 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
22113 
      oprot.writeI64(self.orderId)
22114 
      oprot.writeFieldEnd()
22115 
    oprot.writeFieldStop()
22116 
    oprot.writeStructEnd()
22117 
 
22118 
  def validate(self):
22119 
    return
22120 
 
22121 
 
22122 
  def __repr__(self):
22123 
    L = ['%s=%r' % (key, value)
22124 
      for key, value in self.__dict__.iteritems()]
22125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22126 
 
22127 
  def __eq__(self, other):
22128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22129 
 
22130 
  def __ne__(self, other):
22131 
    return not (self == other)
22132 
 
22133 
class markOrderAsLostInTransit_result:
22134 
  """
22135 
  Attributes:
22136 
   - success
22137 
   - ex
22138 
  """
22139 
 
22140 
  thrift_spec = (
22141 
    (0, TType.BOOL, 'success', None, None, ), # 0
22142 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22143 
  )
22144 
 
22145 
  def __init__(self, success=None, ex=None,):
22146 
    self.success = success
22147 
    self.ex = ex
22148 
 
22149 
  def read(self, iprot):
22150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22152 
      return
22153 
    iprot.readStructBegin()
22154 
    while True:
22155 
      (fname, ftype, fid) = iprot.readFieldBegin()
22156 
      if ftype == TType.STOP:
22157 
        break
22158 
      if fid == 0:
22159 
        if ftype == TType.BOOL:
22160 
          self.success = iprot.readBool();
22161 
        else:
22162 
          iprot.skip(ftype)
22163 
      elif fid == 1:
22164 
        if ftype == TType.STRUCT:
22165 
          self.ex = TransactionServiceException()
22166 
          self.ex.read(iprot)
22167 
        else:
22168 
          iprot.skip(ftype)
22169 
      else:
22170 
        iprot.skip(ftype)
22171 
      iprot.readFieldEnd()
22172 
    iprot.readStructEnd()
22173 
 
22174 
  def write(self, oprot):
22175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22177 
      return
22178 
    oprot.writeStructBegin('markOrderAsLostInTransit_result')
22179 
    if self.success is not None:
22180 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
22181 
      oprot.writeBool(self.success)
22182 
      oprot.writeFieldEnd()
22183 
    if self.ex is not None:
22184 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22185 
      self.ex.write(oprot)
22186 
      oprot.writeFieldEnd()
22187 
    oprot.writeFieldStop()
22188 
    oprot.writeStructEnd()
22189 
 
22190 
  def validate(self):
22191 
    return
22192 
 
22193 
 
22194 
  def __repr__(self):
22195 
    L = ['%s=%r' % (key, value)
22196 
      for key, value in self.__dict__.iteritems()]
22197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22198 
 
22199 
  def __eq__(self, other):
22200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22201 
 
22202 
  def __ne__(self, other):
22203 
    return not (self == other)
22204 
 
4386 anupam.sin 22205 
class getOrderForAwb_args:
22206 
  """
22207 
  Attributes:
22208 
   - awb
22209 
  """
22210 
 
22211 
  thrift_spec = (
22212 
    None, # 0
22213 
    (1, TType.STRING, 'awb', None, None, ), # 1
22214 
  )
22215 
 
22216 
  def __init__(self, awb=None,):
22217 
    self.awb = awb
22218 
 
22219 
  def read(self, iprot):
22220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22222 
      return
22223 
    iprot.readStructBegin()
22224 
    while True:
22225 
      (fname, ftype, fid) = iprot.readFieldBegin()
22226 
      if ftype == TType.STOP:
22227 
        break
22228 
      if fid == 1:
22229 
        if ftype == TType.STRING:
22230 
          self.awb = iprot.readString();
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('getOrderForAwb_args')
22243 
    if self.awb is not None:
22244 
      oprot.writeFieldBegin('awb', TType.STRING, 1)
22245 
      oprot.writeString(self.awb)
22246 
      oprot.writeFieldEnd()
22247 
    oprot.writeFieldStop()
22248 
    oprot.writeStructEnd()
22249 
 
22250 
  def validate(self):
22251 
    return
22252 
 
22253 
 
22254 
  def __repr__(self):
22255 
    L = ['%s=%r' % (key, value)
22256 
      for key, value in self.__dict__.iteritems()]
22257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22258 
 
22259 
  def __eq__(self, other):
22260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22261 
 
22262 
  def __ne__(self, other):
22263 
    return not (self == other)
22264 
 
22265 
class getOrderForAwb_result:
22266 
  """
22267 
  Attributes:
22268 
   - success
22269 
   - ex
22270 
  """
22271 
 
22272 
  thrift_spec = (
22273 
    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
22274 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22275 
  )
22276 
 
22277 
  def __init__(self, success=None, ex=None,):
22278 
    self.success = success
22279 
    self.ex = ex
22280 
 
22281 
  def read(self, iprot):
22282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22284 
      return
22285 
    iprot.readStructBegin()
22286 
    while True:
22287 
      (fname, ftype, fid) = iprot.readFieldBegin()
22288 
      if ftype == TType.STOP:
22289 
        break
22290 
      if fid == 0:
22291 
        if ftype == TType.STRUCT:
22292 
          self.success = Order()
22293 
          self.success.read(iprot)
22294 
        else:
22295 
          iprot.skip(ftype)
22296 
      elif fid == 1:
22297 
        if ftype == TType.STRUCT:
22298 
          self.ex = TransactionServiceException()
22299 
          self.ex.read(iprot)
22300 
        else:
22301 
          iprot.skip(ftype)
22302 
      else:
22303 
        iprot.skip(ftype)
22304 
      iprot.readFieldEnd()
22305 
    iprot.readStructEnd()
22306 
 
22307 
  def write(self, oprot):
22308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22310 
      return
22311 
    oprot.writeStructBegin('getOrderForAwb_result')
22312 
    if self.success is not None:
22313 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
22314 
      self.success.write(oprot)
22315 
      oprot.writeFieldEnd()
22316 
    if self.ex is not None:
22317 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22318 
      self.ex.write(oprot)
22319 
      oprot.writeFieldEnd()
22320 
    oprot.writeFieldStop()
22321 
    oprot.writeStructEnd()
22322 
 
22323 
  def validate(self):
22324 
    return
22325 
 
22326 
 
22327 
  def __repr__(self):
22328 
    L = ['%s=%r' % (key, value)
22329 
      for key, value in self.__dict__.iteritems()]
22330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22331 
 
22332 
  def __eq__(self, other):
22333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22334 
 
22335 
  def __ne__(self, other):
22336 
    return not (self == other)
4506 phani.kuma 22337 
 
22338 
class getOrdersForProviderForStatus_args:
22339 
  """
22340 
  Attributes:
22341 
   - logistics_provider_id
4910 phani.kuma 22342 
   - order_status_list
4506 phani.kuma 22343 
  """
22344 
 
22345 
  thrift_spec = (
22346 
    None, # 0
22347 
    (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
4910 phani.kuma 22348 
    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
4506 phani.kuma 22349 
  )
22350 
 
4910 phani.kuma 22351 
  def __init__(self, logistics_provider_id=None, order_status_list=None,):
4506 phani.kuma 22352 
    self.logistics_provider_id = logistics_provider_id
4910 phani.kuma 22353 
    self.order_status_list = order_status_list
4506 phani.kuma 22354 
 
22355 
  def read(self, iprot):
22356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22358 
      return
22359 
    iprot.readStructBegin()
22360 
    while True:
22361 
      (fname, ftype, fid) = iprot.readFieldBegin()
22362 
      if ftype == TType.STOP:
22363 
        break
22364 
      if fid == 1:
22365 
        if ftype == TType.I64:
22366 
          self.logistics_provider_id = iprot.readI64();
22367 
        else:
22368 
          iprot.skip(ftype)
22369 
      elif fid == 2:
4910 phani.kuma 22370 
        if ftype == TType.LIST:
22371 
          self.order_status_list = []
6188 rajveer 22372 
          (_etype513, _size510) = iprot.readListBegin()
22373 
          for _i514 in xrange(_size510):
22374 
            _elem515 = iprot.readI32();
22375 
            self.order_status_list.append(_elem515)
4910 phani.kuma 22376 
          iprot.readListEnd()
4506 phani.kuma 22377 
        else:
22378 
          iprot.skip(ftype)
22379 
      else:
22380 
        iprot.skip(ftype)
22381 
      iprot.readFieldEnd()
22382 
    iprot.readStructEnd()
22383 
 
22384 
  def write(self, oprot):
22385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22387 
      return
22388 
    oprot.writeStructBegin('getOrdersForProviderForStatus_args')
22389 
    if self.logistics_provider_id is not None:
22390 
      oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
22391 
      oprot.writeI64(self.logistics_provider_id)
22392 
      oprot.writeFieldEnd()
4910 phani.kuma 22393 
    if self.order_status_list is not None:
22394 
      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
22395 
      oprot.writeListBegin(TType.I32, len(self.order_status_list))
6188 rajveer 22396 
      for iter516 in self.order_status_list:
22397 
        oprot.writeI32(iter516)
4910 phani.kuma 22398 
      oprot.writeListEnd()
4506 phani.kuma 22399 
      oprot.writeFieldEnd()
22400 
    oprot.writeFieldStop()
22401 
    oprot.writeStructEnd()
22402 
 
22403 
  def validate(self):
22404 
    return
22405 
 
22406 
 
22407 
  def __repr__(self):
22408 
    L = ['%s=%r' % (key, value)
22409 
      for key, value in self.__dict__.iteritems()]
22410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22411 
 
22412 
  def __eq__(self, other):
22413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22414 
 
22415 
  def __ne__(self, other):
22416 
    return not (self == other)
22417 
 
22418 
class getOrdersForProviderForStatus_result:
22419 
  """
22420 
  Attributes:
22421 
   - success
22422 
   - ex
22423 
  """
22424 
 
22425 
  thrift_spec = (
22426 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22427 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22428 
  )
22429 
 
22430 
  def __init__(self, success=None, ex=None,):
22431 
    self.success = success
22432 
    self.ex = ex
22433 
 
22434 
  def read(self, iprot):
22435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22437 
      return
22438 
    iprot.readStructBegin()
22439 
    while True:
22440 
      (fname, ftype, fid) = iprot.readFieldBegin()
22441 
      if ftype == TType.STOP:
22442 
        break
22443 
      if fid == 0:
22444 
        if ftype == TType.LIST:
22445 
          self.success = []
6188 rajveer 22446 
          (_etype520, _size517) = iprot.readListBegin()
22447 
          for _i521 in xrange(_size517):
22448 
            _elem522 = Order()
22449 
            _elem522.read(iprot)
22450 
            self.success.append(_elem522)
4506 phani.kuma 22451 
          iprot.readListEnd()
22452 
        else:
22453 
          iprot.skip(ftype)
22454 
      elif fid == 1:
22455 
        if ftype == TType.STRUCT:
22456 
          self.ex = TransactionServiceException()
22457 
          self.ex.read(iprot)
22458 
        else:
22459 
          iprot.skip(ftype)
22460 
      else:
22461 
        iprot.skip(ftype)
22462 
      iprot.readFieldEnd()
22463 
    iprot.readStructEnd()
22464 
 
22465 
  def write(self, oprot):
22466 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22467 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22468 
      return
22469 
    oprot.writeStructBegin('getOrdersForProviderForStatus_result')
22470 
    if self.success is not None:
22471 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22472 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22473 
      for iter523 in self.success:
22474 
        iter523.write(oprot)
4506 phani.kuma 22475 
      oprot.writeListEnd()
22476 
      oprot.writeFieldEnd()
22477 
    if self.ex is not None:
22478 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22479 
      self.ex.write(oprot)
22480 
      oprot.writeFieldEnd()
22481 
    oprot.writeFieldStop()
22482 
    oprot.writeStructEnd()
22483 
 
22484 
  def validate(self):
22485 
    return
22486 
 
22487 
 
22488 
  def __repr__(self):
22489 
    L = ['%s=%r' % (key, value)
22490 
      for key, value in self.__dict__.iteritems()]
22491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22492 
 
22493 
  def __eq__(self, other):
22494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22495 
 
22496 
  def __ne__(self, other):
22497 
    return not (self == other)
4600 varun.gupt 22498 
 
22499 
class getBilledOrdersForVendor_args:
22500 
  """
22501 
  Attributes:
22502 
   - vendorId
22503 
   - billingDateFrom
22504 
   - billingDateTo
22505 
  """
22506 
 
22507 
  thrift_spec = (
22508 
    None, # 0
22509 
    (1, TType.I64, 'vendorId', None, None, ), # 1
22510 
    (2, TType.I64, 'billingDateFrom', None, None, ), # 2
22511 
    (3, TType.I64, 'billingDateTo', None, None, ), # 3
22512 
  )
22513 
 
22514 
  def __init__(self, vendorId=None, billingDateFrom=None, billingDateTo=None,):
22515 
    self.vendorId = vendorId
22516 
    self.billingDateFrom = billingDateFrom
22517 
    self.billingDateTo = billingDateTo
22518 
 
22519 
  def read(self, iprot):
22520 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22521 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22522 
      return
22523 
    iprot.readStructBegin()
22524 
    while True:
22525 
      (fname, ftype, fid) = iprot.readFieldBegin()
22526 
      if ftype == TType.STOP:
22527 
        break
22528 
      if fid == 1:
22529 
        if ftype == TType.I64:
22530 
          self.vendorId = iprot.readI64();
22531 
        else:
22532 
          iprot.skip(ftype)
22533 
      elif fid == 2:
22534 
        if ftype == TType.I64:
22535 
          self.billingDateFrom = iprot.readI64();
22536 
        else:
22537 
          iprot.skip(ftype)
22538 
      elif fid == 3:
22539 
        if ftype == TType.I64:
22540 
          self.billingDateTo = iprot.readI64();
22541 
        else:
22542 
          iprot.skip(ftype)
22543 
      else:
22544 
        iprot.skip(ftype)
22545 
      iprot.readFieldEnd()
22546 
    iprot.readStructEnd()
22547 
 
22548 
  def write(self, oprot):
22549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22551 
      return
22552 
    oprot.writeStructBegin('getBilledOrdersForVendor_args')
22553 
    if self.vendorId is not None:
22554 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
22555 
      oprot.writeI64(self.vendorId)
22556 
      oprot.writeFieldEnd()
22557 
    if self.billingDateFrom is not None:
22558 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 2)
22559 
      oprot.writeI64(self.billingDateFrom)
22560 
      oprot.writeFieldEnd()
22561 
    if self.billingDateTo is not None:
22562 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 3)
22563 
      oprot.writeI64(self.billingDateTo)
22564 
      oprot.writeFieldEnd()
22565 
    oprot.writeFieldStop()
22566 
    oprot.writeStructEnd()
22567 
 
22568 
  def validate(self):
22569 
    return
22570 
 
22571 
 
22572 
  def __repr__(self):
22573 
    L = ['%s=%r' % (key, value)
22574 
      for key, value in self.__dict__.iteritems()]
22575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22576 
 
22577 
  def __eq__(self, other):
22578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22579 
 
22580 
  def __ne__(self, other):
22581 
    return not (self == other)
22582 
 
22583 
class getBilledOrdersForVendor_result:
22584 
  """
22585 
  Attributes:
22586 
   - success
22587 
   - ex
22588 
  """
22589 
 
22590 
  thrift_spec = (
22591 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22592 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22593 
  )
22594 
 
22595 
  def __init__(self, success=None, ex=None,):
22596 
    self.success = success
22597 
    self.ex = ex
22598 
 
22599 
  def read(self, iprot):
22600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22602 
      return
22603 
    iprot.readStructBegin()
22604 
    while True:
22605 
      (fname, ftype, fid) = iprot.readFieldBegin()
22606 
      if ftype == TType.STOP:
22607 
        break
22608 
      if fid == 0:
22609 
        if ftype == TType.LIST:
22610 
          self.success = []
6188 rajveer 22611 
          (_etype527, _size524) = iprot.readListBegin()
22612 
          for _i528 in xrange(_size524):
22613 
            _elem529 = Order()
22614 
            _elem529.read(iprot)
22615 
            self.success.append(_elem529)
4600 varun.gupt 22616 
          iprot.readListEnd()
22617 
        else:
22618 
          iprot.skip(ftype)
22619 
      elif fid == 1:
22620 
        if ftype == TType.STRUCT:
22621 
          self.ex = TransactionServiceException()
22622 
          self.ex.read(iprot)
22623 
        else:
22624 
          iprot.skip(ftype)
22625 
      else:
22626 
        iprot.skip(ftype)
22627 
      iprot.readFieldEnd()
22628 
    iprot.readStructEnd()
22629 
 
22630 
  def write(self, oprot):
22631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22633 
      return
22634 
    oprot.writeStructBegin('getBilledOrdersForVendor_result')
22635 
    if self.success is not None:
22636 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22637 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22638 
      for iter530 in self.success:
22639 
        iter530.write(oprot)
4600 varun.gupt 22640 
      oprot.writeListEnd()
22641 
      oprot.writeFieldEnd()
22642 
    if self.ex is not None:
22643 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22644 
      self.ex.write(oprot)
22645 
      oprot.writeFieldEnd()
22646 
    oprot.writeFieldStop()
22647 
    oprot.writeStructEnd()
22648 
 
22649 
  def validate(self):
22650 
    return
22651 
 
22652 
 
22653 
  def __repr__(self):
22654 
    L = ['%s=%r' % (key, value)
22655 
      for key, value in self.__dict__.iteritems()]
22656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22657 
 
22658 
  def __eq__(self, other):
22659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22660 
 
22661 
  def __ne__(self, other):
22662 
    return not (self == other)
22663 
 
4607 rajveer 22664 
class getSlippedSippingDateOrders_args:
22665 
 
22666 
  thrift_spec = (
22667 
  )
22668 
 
22669 
  def read(self, iprot):
22670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22672 
      return
22673 
    iprot.readStructBegin()
22674 
    while True:
22675 
      (fname, ftype, fid) = iprot.readFieldBegin()
22676 
      if ftype == TType.STOP:
22677 
        break
22678 
      else:
22679 
        iprot.skip(ftype)
22680 
      iprot.readFieldEnd()
22681 
    iprot.readStructEnd()
22682 
 
22683 
  def write(self, oprot):
22684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22686 
      return
22687 
    oprot.writeStructBegin('getSlippedSippingDateOrders_args')
22688 
    oprot.writeFieldStop()
22689 
    oprot.writeStructEnd()
22690 
 
22691 
  def validate(self):
22692 
    return
22693 
 
22694 
 
22695 
  def __repr__(self):
22696 
    L = ['%s=%r' % (key, value)
22697 
      for key, value in self.__dict__.iteritems()]
22698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22699 
 
22700 
  def __eq__(self, other):
22701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22702 
 
22703 
  def __ne__(self, other):
22704 
    return not (self == other)
22705 
 
22706 
class getSlippedSippingDateOrders_result:
22707 
  """
22708 
  Attributes:
22709 
   - success
22710 
   - ex
22711 
  """
22712 
 
22713 
  thrift_spec = (
22714 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22715 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22716 
  )
22717 
 
22718 
  def __init__(self, success=None, ex=None,):
22719 
    self.success = success
22720 
    self.ex = ex
22721 
 
22722 
  def read(self, iprot):
22723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22725 
      return
22726 
    iprot.readStructBegin()
22727 
    while True:
22728 
      (fname, ftype, fid) = iprot.readFieldBegin()
22729 
      if ftype == TType.STOP:
22730 
        break
22731 
      if fid == 0:
22732 
        if ftype == TType.LIST:
22733 
          self.success = []
6188 rajveer 22734 
          (_etype534, _size531) = iprot.readListBegin()
22735 
          for _i535 in xrange(_size531):
22736 
            _elem536 = Order()
22737 
            _elem536.read(iprot)
22738 
            self.success.append(_elem536)
4607 rajveer 22739 
          iprot.readListEnd()
22740 
        else:
22741 
          iprot.skip(ftype)
22742 
      elif fid == 1:
22743 
        if ftype == TType.STRUCT:
22744 
          self.ex = TransactionServiceException()
22745 
          self.ex.read(iprot)
22746 
        else:
22747 
          iprot.skip(ftype)
22748 
      else:
22749 
        iprot.skip(ftype)
22750 
      iprot.readFieldEnd()
22751 
    iprot.readStructEnd()
22752 
 
22753 
  def write(self, oprot):
22754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22756 
      return
22757 
    oprot.writeStructBegin('getSlippedSippingDateOrders_result')
22758 
    if self.success is not None:
22759 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22760 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22761 
      for iter537 in self.success:
22762 
        iter537.write(oprot)
4607 rajveer 22763 
      oprot.writeListEnd()
22764 
      oprot.writeFieldEnd()
22765 
    if self.ex is not None:
22766 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22767 
      self.ex.write(oprot)
22768 
      oprot.writeFieldEnd()
22769 
    oprot.writeFieldStop()
22770 
    oprot.writeStructEnd()
22771 
 
22772 
  def validate(self):
22773 
    return
22774 
 
22775 
 
22776 
  def __repr__(self):
22777 
    L = ['%s=%r' % (key, value)
22778 
      for key, value in self.__dict__.iteritems()]
22779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22780 
 
22781 
  def __eq__(self, other):
22782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22783 
 
22784 
  def __ne__(self, other):
22785 
    return not (self == other)
22786 
 
4709 rajveer 22787 
class getCancelledOrders_args:
22788 
  """
22789 
  Attributes:
22790 
   - cancelDateFrom
22791 
   - cancelDateTo
22792 
  """
22793 
 
22794 
  thrift_spec = (
22795 
    None, # 0
22796 
    (1, TType.I64, 'cancelDateFrom', None, None, ), # 1
22797 
    (2, TType.I64, 'cancelDateTo', None, None, ), # 2
22798 
  )
22799 
 
22800 
  def __init__(self, cancelDateFrom=None, cancelDateTo=None,):
22801 
    self.cancelDateFrom = cancelDateFrom
22802 
    self.cancelDateTo = cancelDateTo
22803 
 
22804 
  def read(self, iprot):
22805 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22806 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22807 
      return
22808 
    iprot.readStructBegin()
22809 
    while True:
22810 
      (fname, ftype, fid) = iprot.readFieldBegin()
22811 
      if ftype == TType.STOP:
22812 
        break
22813 
      if fid == 1:
22814 
        if ftype == TType.I64:
22815 
          self.cancelDateFrom = iprot.readI64();
22816 
        else:
22817 
          iprot.skip(ftype)
22818 
      elif fid == 2:
22819 
        if ftype == TType.I64:
22820 
          self.cancelDateTo = iprot.readI64();
22821 
        else:
22822 
          iprot.skip(ftype)
22823 
      else:
22824 
        iprot.skip(ftype)
22825 
      iprot.readFieldEnd()
22826 
    iprot.readStructEnd()
22827 
 
22828 
  def write(self, oprot):
22829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22831 
      return
22832 
    oprot.writeStructBegin('getCancelledOrders_args')
22833 
    if self.cancelDateFrom is not None:
22834 
      oprot.writeFieldBegin('cancelDateFrom', TType.I64, 1)
22835 
      oprot.writeI64(self.cancelDateFrom)
22836 
      oprot.writeFieldEnd()
22837 
    if self.cancelDateTo is not None:
22838 
      oprot.writeFieldBegin('cancelDateTo', TType.I64, 2)
22839 
      oprot.writeI64(self.cancelDateTo)
22840 
      oprot.writeFieldEnd()
22841 
    oprot.writeFieldStop()
22842 
    oprot.writeStructEnd()
22843 
 
22844 
  def validate(self):
22845 
    return
22846 
 
22847 
 
22848 
  def __repr__(self):
22849 
    L = ['%s=%r' % (key, value)
22850 
      for key, value in self.__dict__.iteritems()]
22851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22852 
 
22853 
  def __eq__(self, other):
22854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22855 
 
22856 
  def __ne__(self, other):
22857 
    return not (self == other)
22858 
 
22859 
class getCancelledOrders_result:
22860 
  """
22861 
  Attributes:
22862 
   - success
22863 
   - ex
22864 
  """
22865 
 
22866 
  thrift_spec = (
22867 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
22868 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
22869 
  )
22870 
 
22871 
  def __init__(self, success=None, ex=None,):
22872 
    self.success = success
22873 
    self.ex = ex
22874 
 
22875 
  def read(self, iprot):
22876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22878 
      return
22879 
    iprot.readStructBegin()
22880 
    while True:
22881 
      (fname, ftype, fid) = iprot.readFieldBegin()
22882 
      if ftype == TType.STOP:
22883 
        break
22884 
      if fid == 0:
22885 
        if ftype == TType.LIST:
22886 
          self.success = []
6188 rajveer 22887 
          (_etype541, _size538) = iprot.readListBegin()
22888 
          for _i542 in xrange(_size538):
22889 
            _elem543 = Order()
22890 
            _elem543.read(iprot)
22891 
            self.success.append(_elem543)
4709 rajveer 22892 
          iprot.readListEnd()
22893 
        else:
22894 
          iprot.skip(ftype)
22895 
      elif fid == 1:
22896 
        if ftype == TType.STRUCT:
22897 
          self.ex = TransactionServiceException()
22898 
          self.ex.read(iprot)
22899 
        else:
22900 
          iprot.skip(ftype)
22901 
      else:
22902 
        iprot.skip(ftype)
22903 
      iprot.readFieldEnd()
22904 
    iprot.readStructEnd()
22905 
 
22906 
  def write(self, oprot):
22907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22909 
      return
22910 
    oprot.writeStructBegin('getCancelledOrders_result')
22911 
    if self.success is not None:
22912 
      oprot.writeFieldBegin('success', TType.LIST, 0)
22913 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 22914 
      for iter544 in self.success:
22915 
        iter544.write(oprot)
4709 rajveer 22916 
      oprot.writeListEnd()
22917 
      oprot.writeFieldEnd()
22918 
    if self.ex is not None:
22919 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
22920 
      self.ex.write(oprot)
22921 
      oprot.writeFieldEnd()
22922 
    oprot.writeFieldStop()
22923 
    oprot.writeStructEnd()
22924 
 
22925 
  def validate(self):
22926 
    return
22927 
 
22928 
 
22929 
  def __repr__(self):
22930 
    L = ['%s=%r' % (key, value)
22931 
      for key, value in self.__dict__.iteritems()]
22932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
22933 
 
22934 
  def __eq__(self, other):
22935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
22936 
 
22937 
  def __ne__(self, other):
22938 
    return not (self == other)
22939 
 
4600 varun.gupt 22940 
class saveBluedartSettlements_args:
22941 
  """
22942 
  Attributes:
22943 
   - mapAWBAndAmount
22944 
  """
22945 
 
22946 
  thrift_spec = (
22947 
    None, # 0
22948 
    (1, TType.MAP, 'mapAWBAndAmount', (TType.I64,None,TType.DOUBLE,None), None, ), # 1
22949 
  )
22950 
 
22951 
  def __init__(self, mapAWBAndAmount=None,):
22952 
    self.mapAWBAndAmount = mapAWBAndAmount
22953 
 
22954 
  def read(self, iprot):
22955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
22956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
22957 
      return
22958 
    iprot.readStructBegin()
22959 
    while True:
22960 
      (fname, ftype, fid) = iprot.readFieldBegin()
22961 
      if ftype == TType.STOP:
22962 
        break
22963 
      if fid == 1:
22964 
        if ftype == TType.MAP:
22965 
          self.mapAWBAndAmount = {}
6188 rajveer 22966 
          (_ktype546, _vtype547, _size545 ) = iprot.readMapBegin()
22967 
          for _i549 in xrange(_size545):
22968 
            _key550 = iprot.readI64();
22969 
            _val551 = iprot.readDouble();
22970 
            self.mapAWBAndAmount[_key550] = _val551
4600 varun.gupt 22971 
          iprot.readMapEnd()
22972 
        else:
22973 
          iprot.skip(ftype)
22974 
      else:
22975 
        iprot.skip(ftype)
22976 
      iprot.readFieldEnd()
22977 
    iprot.readStructEnd()
22978 
 
22979 
  def write(self, oprot):
22980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
22981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
22982 
      return
22983 
    oprot.writeStructBegin('saveBluedartSettlements_args')
22984 
    if self.mapAWBAndAmount is not None:
22985 
      oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
22986 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
6188 rajveer 22987 
      for kiter552,viter553 in self.mapAWBAndAmount.items():
22988 
        oprot.writeI64(kiter552)
22989 
        oprot.writeDouble(viter553)
4600 varun.gupt 22990 
      oprot.writeMapEnd()
22991 
      oprot.writeFieldEnd()
22992 
    oprot.writeFieldStop()
22993 
    oprot.writeStructEnd()
22994 
 
22995 
  def validate(self):
22996 
    return
22997 
 
22998 
 
22999 
  def __repr__(self):
23000 
    L = ['%s=%r' % (key, value)
23001 
      for key, value in self.__dict__.iteritems()]
23002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23003 
 
23004 
  def __eq__(self, other):
23005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23006 
 
23007 
  def __ne__(self, other):
23008 
    return not (self == other)
23009 
 
23010 
class saveBluedartSettlements_result:
23011 
  """
23012 
  Attributes:
23013 
   - ex
23014 
  """
23015 
 
23016 
  thrift_spec = (
23017 
    None, # 0
23018 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23019 
  )
23020 
 
23021 
  def __init__(self, ex=None,):
23022 
    self.ex = ex
23023 
 
23024 
  def read(self, iprot):
23025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23027 
      return
23028 
    iprot.readStructBegin()
23029 
    while True:
23030 
      (fname, ftype, fid) = iprot.readFieldBegin()
23031 
      if ftype == TType.STOP:
23032 
        break
23033 
      if fid == 1:
23034 
        if ftype == TType.STRUCT:
23035 
          self.ex = TransactionServiceException()
23036 
          self.ex.read(iprot)
23037 
        else:
23038 
          iprot.skip(ftype)
23039 
      else:
23040 
        iprot.skip(ftype)
23041 
      iprot.readFieldEnd()
23042 
    iprot.readStructEnd()
23043 
 
23044 
  def write(self, oprot):
23045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23047 
      return
23048 
    oprot.writeStructBegin('saveBluedartSettlements_result')
23049 
    if self.ex is not None:
23050 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23051 
      self.ex.write(oprot)
23052 
      oprot.writeFieldEnd()
23053 
    oprot.writeFieldStop()
23054 
    oprot.writeStructEnd()
23055 
 
23056 
  def validate(self):
23057 
    return
23058 
 
23059 
 
23060 
  def __repr__(self):
23061 
    L = ['%s=%r' % (key, value)
23062 
      for key, value in self.__dict__.iteritems()]
23063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23064 
 
23065 
  def __eq__(self, other):
23066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23067 
 
23068 
  def __ne__(self, other):
23069 
    return not (self == other)
23070 
 
23071 
class savePaymentSettlements_args:
23072 
  """
23073 
  Attributes:
23074 
   - settlementDate
23075 
   - paymentGatewayId
4905 varun.gupt 23076 
   - referenceId
4600 varun.gupt 23077 
   - serviceTax
23078 
   - otherCharges
23079 
   - netCollection
23080 
  """
23081 
 
23082 
  thrift_spec = (
23083 
    None, # 0
23084 
    (1, TType.I64, 'settlementDate', None, None, ), # 1
23085 
    (2, TType.I64, 'paymentGatewayId', None, None, ), # 2
4905 varun.gupt 23086 
    (3, TType.I64, 'referenceId', None, None, ), # 3
4600 varun.gupt 23087 
    (4, TType.DOUBLE, 'serviceTax', None, None, ), # 4
23088 
    (5, TType.DOUBLE, 'otherCharges', None, None, ), # 5
23089 
    (6, TType.DOUBLE, 'netCollection', None, None, ), # 6
23090 
  )
23091 
 
4905 varun.gupt 23092 
  def __init__(self, settlementDate=None, paymentGatewayId=None, referenceId=None, serviceTax=None, otherCharges=None, netCollection=None,):
4600 varun.gupt 23093 
    self.settlementDate = settlementDate
23094 
    self.paymentGatewayId = paymentGatewayId
4905 varun.gupt 23095 
    self.referenceId = referenceId
4600 varun.gupt 23096 
    self.serviceTax = serviceTax
23097 
    self.otherCharges = otherCharges
23098 
    self.netCollection = netCollection
23099 
 
23100 
  def read(self, iprot):
23101 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23102 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23103 
      return
23104 
    iprot.readStructBegin()
23105 
    while True:
23106 
      (fname, ftype, fid) = iprot.readFieldBegin()
23107 
      if ftype == TType.STOP:
23108 
        break
23109 
      if fid == 1:
23110 
        if ftype == TType.I64:
23111 
          self.settlementDate = iprot.readI64();
23112 
        else:
23113 
          iprot.skip(ftype)
23114 
      elif fid == 2:
23115 
        if ftype == TType.I64:
23116 
          self.paymentGatewayId = iprot.readI64();
23117 
        else:
23118 
          iprot.skip(ftype)
23119 
      elif fid == 3:
23120 
        if ftype == TType.I64:
4905 varun.gupt 23121 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23122 
        else:
23123 
          iprot.skip(ftype)
23124 
      elif fid == 4:
23125 
        if ftype == TType.DOUBLE:
23126 
          self.serviceTax = iprot.readDouble();
23127 
        else:
23128 
          iprot.skip(ftype)
23129 
      elif fid == 5:
23130 
        if ftype == TType.DOUBLE:
23131 
          self.otherCharges = iprot.readDouble();
23132 
        else:
23133 
          iprot.skip(ftype)
23134 
      elif fid == 6:
23135 
        if ftype == TType.DOUBLE:
23136 
          self.netCollection = iprot.readDouble();
23137 
        else:
23138 
          iprot.skip(ftype)
23139 
      else:
23140 
        iprot.skip(ftype)
23141 
      iprot.readFieldEnd()
23142 
    iprot.readStructEnd()
23143 
 
23144 
  def write(self, oprot):
23145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23147 
      return
23148 
    oprot.writeStructBegin('savePaymentSettlements_args')
23149 
    if self.settlementDate is not None:
23150 
      oprot.writeFieldBegin('settlementDate', TType.I64, 1)
23151 
      oprot.writeI64(self.settlementDate)
23152 
      oprot.writeFieldEnd()
23153 
    if self.paymentGatewayId is not None:
23154 
      oprot.writeFieldBegin('paymentGatewayId', TType.I64, 2)
23155 
      oprot.writeI64(self.paymentGatewayId)
23156 
      oprot.writeFieldEnd()
4905 varun.gupt 23157 
    if self.referenceId is not None:
23158 
      oprot.writeFieldBegin('referenceId', TType.I64, 3)
23159 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23160 
      oprot.writeFieldEnd()
23161 
    if self.serviceTax is not None:
23162 
      oprot.writeFieldBegin('serviceTax', TType.DOUBLE, 4)
23163 
      oprot.writeDouble(self.serviceTax)
23164 
      oprot.writeFieldEnd()
23165 
    if self.otherCharges is not None:
23166 
      oprot.writeFieldBegin('otherCharges', TType.DOUBLE, 5)
23167 
      oprot.writeDouble(self.otherCharges)
23168 
      oprot.writeFieldEnd()
23169 
    if self.netCollection is not None:
23170 
      oprot.writeFieldBegin('netCollection', TType.DOUBLE, 6)
23171 
      oprot.writeDouble(self.netCollection)
23172 
      oprot.writeFieldEnd()
23173 
    oprot.writeFieldStop()
23174 
    oprot.writeStructEnd()
23175 
 
23176 
  def validate(self):
23177 
    return
23178 
 
23179 
 
23180 
  def __repr__(self):
23181 
    L = ['%s=%r' % (key, value)
23182 
      for key, value in self.__dict__.iteritems()]
23183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23184 
 
23185 
  def __eq__(self, other):
23186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23187 
 
23188 
  def __ne__(self, other):
23189 
    return not (self == other)
23190 
 
23191 
class savePaymentSettlements_result:
23192 
  """
23193 
  Attributes:
23194 
   - ex
23195 
  """
23196 
 
23197 
  thrift_spec = (
23198 
    None, # 0
23199 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23200 
  )
23201 
 
23202 
  def __init__(self, ex=None,):
23203 
    self.ex = ex
23204 
 
23205 
  def read(self, iprot):
23206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23208 
      return
23209 
    iprot.readStructBegin()
23210 
    while True:
23211 
      (fname, ftype, fid) = iprot.readFieldBegin()
23212 
      if ftype == TType.STOP:
23213 
        break
23214 
      if fid == 1:
23215 
        if ftype == TType.STRUCT:
23216 
          self.ex = TransactionServiceException()
23217 
          self.ex.read(iprot)
23218 
        else:
23219 
          iprot.skip(ftype)
23220 
      else:
23221 
        iprot.skip(ftype)
23222 
      iprot.readFieldEnd()
23223 
    iprot.readStructEnd()
23224 
 
23225 
  def write(self, oprot):
23226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23228 
      return
23229 
    oprot.writeStructBegin('savePaymentSettlements_result')
23230 
    if self.ex is not None:
23231 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23232 
      self.ex.write(oprot)
23233 
      oprot.writeFieldEnd()
23234 
    oprot.writeFieldStop()
23235 
    oprot.writeStructEnd()
23236 
 
23237 
  def validate(self):
23238 
    return
23239 
 
23240 
 
23241 
  def __repr__(self):
23242 
    L = ['%s=%r' % (key, value)
23243 
      for key, value in self.__dict__.iteritems()]
23244 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23245 
 
23246 
  def __eq__(self, other):
23247 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23248 
 
23249 
  def __ne__(self, other):
23250 
    return not (self == other)
23251 
 
23252 
class saveEBSSettlementSummary_args:
23253 
  """
23254 
  Attributes:
23255 
   - settlementId
23256 
   - settlementDate
23257 
   - transactionDateFrom
23258 
   - transactionDateTo
23259 
   - amount
23260 
  """
23261 
 
23262 
  thrift_spec = (
23263 
    None, # 0
23264 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23265 
    (2, TType.I64, 'settlementDate', None, None, ), # 2
23266 
    (3, TType.I64, 'transactionDateFrom', None, None, ), # 3
23267 
    (4, TType.I64, 'transactionDateTo', None, None, ), # 4
23268 
    (5, TType.DOUBLE, 'amount', None, None, ), # 5
23269 
  )
23270 
 
23271 
  def __init__(self, settlementId=None, settlementDate=None, transactionDateFrom=None, transactionDateTo=None, amount=None,):
23272 
    self.settlementId = settlementId
23273 
    self.settlementDate = settlementDate
23274 
    self.transactionDateFrom = transactionDateFrom
23275 
    self.transactionDateTo = transactionDateTo
23276 
    self.amount = amount
23277 
 
23278 
  def read(self, iprot):
23279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23281 
      return
23282 
    iprot.readStructBegin()
23283 
    while True:
23284 
      (fname, ftype, fid) = iprot.readFieldBegin()
23285 
      if ftype == TType.STOP:
23286 
        break
23287 
      if fid == 1:
23288 
        if ftype == TType.I64:
23289 
          self.settlementId = iprot.readI64();
23290 
        else:
23291 
          iprot.skip(ftype)
23292 
      elif fid == 2:
23293 
        if ftype == TType.I64:
23294 
          self.settlementDate = iprot.readI64();
23295 
        else:
23296 
          iprot.skip(ftype)
23297 
      elif fid == 3:
23298 
        if ftype == TType.I64:
23299 
          self.transactionDateFrom = iprot.readI64();
23300 
        else:
23301 
          iprot.skip(ftype)
23302 
      elif fid == 4:
23303 
        if ftype == TType.I64:
23304 
          self.transactionDateTo = iprot.readI64();
23305 
        else:
23306 
          iprot.skip(ftype)
23307 
      elif fid == 5:
23308 
        if ftype == TType.DOUBLE:
23309 
          self.amount = iprot.readDouble();
23310 
        else:
23311 
          iprot.skip(ftype)
23312 
      else:
23313 
        iprot.skip(ftype)
23314 
      iprot.readFieldEnd()
23315 
    iprot.readStructEnd()
23316 
 
23317 
  def write(self, oprot):
23318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23320 
      return
23321 
    oprot.writeStructBegin('saveEBSSettlementSummary_args')
23322 
    if self.settlementId is not None:
23323 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23324 
      oprot.writeI64(self.settlementId)
23325 
      oprot.writeFieldEnd()
23326 
    if self.settlementDate is not None:
23327 
      oprot.writeFieldBegin('settlementDate', TType.I64, 2)
23328 
      oprot.writeI64(self.settlementDate)
23329 
      oprot.writeFieldEnd()
23330 
    if self.transactionDateFrom is not None:
23331 
      oprot.writeFieldBegin('transactionDateFrom', TType.I64, 3)
23332 
      oprot.writeI64(self.transactionDateFrom)
23333 
      oprot.writeFieldEnd()
23334 
    if self.transactionDateTo is not None:
23335 
      oprot.writeFieldBegin('transactionDateTo', TType.I64, 4)
23336 
      oprot.writeI64(self.transactionDateTo)
23337 
      oprot.writeFieldEnd()
23338 
    if self.amount is not None:
23339 
      oprot.writeFieldBegin('amount', TType.DOUBLE, 5)
23340 
      oprot.writeDouble(self.amount)
23341 
      oprot.writeFieldEnd()
23342 
    oprot.writeFieldStop()
23343 
    oprot.writeStructEnd()
23344 
 
23345 
  def validate(self):
23346 
    return
23347 
 
23348 
 
23349 
  def __repr__(self):
23350 
    L = ['%s=%r' % (key, value)
23351 
      for key, value in self.__dict__.iteritems()]
23352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23353 
 
23354 
  def __eq__(self, other):
23355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23356 
 
23357 
  def __ne__(self, other):
23358 
    return not (self == other)
23359 
 
23360 
class saveEBSSettlementSummary_result:
23361 
  """
23362 
  Attributes:
23363 
   - ex
23364 
  """
23365 
 
23366 
  thrift_spec = (
23367 
    None, # 0
23368 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23369 
  )
23370 
 
23371 
  def __init__(self, ex=None,):
23372 
    self.ex = ex
23373 
 
23374 
  def read(self, iprot):
23375 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23376 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23377 
      return
23378 
    iprot.readStructBegin()
23379 
    while True:
23380 
      (fname, ftype, fid) = iprot.readFieldBegin()
23381 
      if ftype == TType.STOP:
23382 
        break
23383 
      if fid == 1:
23384 
        if ftype == TType.STRUCT:
23385 
          self.ex = TransactionServiceException()
23386 
          self.ex.read(iprot)
23387 
        else:
23388 
          iprot.skip(ftype)
23389 
      else:
23390 
        iprot.skip(ftype)
23391 
      iprot.readFieldEnd()
23392 
    iprot.readStructEnd()
23393 
 
23394 
  def write(self, oprot):
23395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23397 
      return
23398 
    oprot.writeStructBegin('saveEBSSettlementSummary_result')
23399 
    if self.ex is not None:
23400 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23401 
      self.ex.write(oprot)
23402 
      oprot.writeFieldEnd()
23403 
    oprot.writeFieldStop()
23404 
    oprot.writeStructEnd()
23405 
 
23406 
  def validate(self):
23407 
    return
23408 
 
23409 
 
23410 
  def __repr__(self):
23411 
    L = ['%s=%r' % (key, value)
23412 
      for key, value in self.__dict__.iteritems()]
23413 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23414 
 
23415 
  def __eq__(self, other):
23416 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23417 
 
23418 
  def __ne__(self, other):
23419 
    return not (self == other)
23420 
 
5386 phani.kuma 23421 
class getSettlementForPrepaid_args:
4600 varun.gupt 23422 
  """
23423 
  Attributes:
5189 varun.gupt 23424 
   - referenceId
23425 
   - isRefund
4600 varun.gupt 23426 
  """
23427 
 
23428 
  thrift_spec = (
23429 
    None, # 0
5189 varun.gupt 23430 
    (1, TType.I64, 'referenceId', None, None, ), # 1
5386 phani.kuma 23431 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
4600 varun.gupt 23432 
  )
23433 
 
5386 phani.kuma 23434 
  def __init__(self, referenceId=None, isRefund=None,):
5189 varun.gupt 23435 
    self.referenceId = referenceId
23436 
    self.isRefund = isRefund
4600 varun.gupt 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.I64:
5189 varun.gupt 23449 
          self.referenceId = iprot.readI64();
4600 varun.gupt 23450 
        else:
23451 
          iprot.skip(ftype)
5189 varun.gupt 23452 
      elif fid == 2:
23453 
        if ftype == TType.BOOL:
23454 
          self.isRefund = iprot.readBool();
23455 
        else:
23456 
          iprot.skip(ftype)
4600 varun.gupt 23457 
      else:
23458 
        iprot.skip(ftype)
23459 
      iprot.readFieldEnd()
23460 
    iprot.readStructEnd()
23461 
 
23462 
  def write(self, oprot):
23463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23465 
      return
5386 phani.kuma 23466 
    oprot.writeStructBegin('getSettlementForPrepaid_args')
5189 varun.gupt 23467 
    if self.referenceId is not None:
23468 
      oprot.writeFieldBegin('referenceId', TType.I64, 1)
23469 
      oprot.writeI64(self.referenceId)
4600 varun.gupt 23470 
      oprot.writeFieldEnd()
5386 phani.kuma 23471 
    if self.isRefund is not None:
23472 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
23473 
      oprot.writeBool(self.isRefund)
5382 varun.gupt 23474 
      oprot.writeFieldEnd()
5386 phani.kuma 23475 
    oprot.writeFieldStop()
23476 
    oprot.writeStructEnd()
23477 
 
23478 
  def validate(self):
23479 
    return
23480 
 
23481 
 
23482 
  def __repr__(self):
23483 
    L = ['%s=%r' % (key, value)
23484 
      for key, value in self.__dict__.iteritems()]
23485 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23486 
 
23487 
  def __eq__(self, other):
23488 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23489 
 
23490 
  def __ne__(self, other):
23491 
    return not (self == other)
23492 
 
23493 
class getSettlementForPrepaid_result:
23494 
  """
23495 
  Attributes:
23496 
   - success
23497 
   - ex
23498 
  """
23499 
 
23500 
  thrift_spec = (
23501 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23502 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23503 
  )
23504 
 
23505 
  def __init__(self, success=None, ex=None,):
23506 
    self.success = success
23507 
    self.ex = ex
23508 
 
23509 
  def read(self, iprot):
23510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23512 
      return
23513 
    iprot.readStructBegin()
23514 
    while True:
23515 
      (fname, ftype, fid) = iprot.readFieldBegin()
23516 
      if ftype == TType.STOP:
23517 
        break
23518 
      if fid == 0:
23519 
        if ftype == TType.STRUCT:
23520 
          self.success = PaymentSettlement()
23521 
          self.success.read(iprot)
23522 
        else:
23523 
          iprot.skip(ftype)
23524 
      elif fid == 1:
23525 
        if ftype == TType.STRUCT:
23526 
          self.ex = TransactionServiceException()
23527 
          self.ex.read(iprot)
23528 
        else:
23529 
          iprot.skip(ftype)
23530 
      else:
23531 
        iprot.skip(ftype)
23532 
      iprot.readFieldEnd()
23533 
    iprot.readStructEnd()
23534 
 
23535 
  def write(self, oprot):
23536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23538 
      return
23539 
    oprot.writeStructBegin('getSettlementForPrepaid_result')
23540 
    if self.success is not None:
23541 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23542 
      self.success.write(oprot)
23543 
      oprot.writeFieldEnd()
23544 
    if self.ex is not None:
23545 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23546 
      self.ex.write(oprot)
23547 
      oprot.writeFieldEnd()
23548 
    oprot.writeFieldStop()
23549 
    oprot.writeStructEnd()
23550 
 
23551 
  def validate(self):
23552 
    return
23553 
 
23554 
 
23555 
  def __repr__(self):
23556 
    L = ['%s=%r' % (key, value)
23557 
      for key, value in self.__dict__.iteritems()]
23558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23559 
 
23560 
  def __eq__(self, other):
23561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23562 
 
23563 
  def __ne__(self, other):
23564 
    return not (self == other)
23565 
 
23566 
class getSettlementForCod_args:
23567 
  """
23568 
  Attributes:
23569 
   - orderId
23570 
   - isRefund
23571 
  """
23572 
 
23573 
  thrift_spec = (
23574 
    None, # 0
23575 
    (1, TType.I64, 'orderId', None, None, ), # 1
23576 
    (2, TType.BOOL, 'isRefund', None, None, ), # 2
23577 
  )
23578 
 
23579 
  def __init__(self, orderId=None, isRefund=None,):
23580 
    self.orderId = orderId
23581 
    self.isRefund = isRefund
23582 
 
23583 
  def read(self, iprot):
23584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23586 
      return
23587 
    iprot.readStructBegin()
23588 
    while True:
23589 
      (fname, ftype, fid) = iprot.readFieldBegin()
23590 
      if ftype == TType.STOP:
23591 
        break
23592 
      if fid == 1:
23593 
        if ftype == TType.I64:
23594 
          self.orderId = iprot.readI64();
23595 
        else:
23596 
          iprot.skip(ftype)
23597 
      elif fid == 2:
23598 
        if ftype == TType.BOOL:
23599 
          self.isRefund = iprot.readBool();
23600 
        else:
23601 
          iprot.skip(ftype)
23602 
      else:
23603 
        iprot.skip(ftype)
23604 
      iprot.readFieldEnd()
23605 
    iprot.readStructEnd()
23606 
 
23607 
  def write(self, oprot):
23608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23610 
      return
23611 
    oprot.writeStructBegin('getSettlementForCod_args')
23612 
    if self.orderId is not None:
23613 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
23614 
      oprot.writeI64(self.orderId)
23615 
      oprot.writeFieldEnd()
5189 varun.gupt 23616 
    if self.isRefund is not None:
5386 phani.kuma 23617 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 2)
5189 varun.gupt 23618 
      oprot.writeBool(self.isRefund)
23619 
      oprot.writeFieldEnd()
4600 varun.gupt 23620 
    oprot.writeFieldStop()
23621 
    oprot.writeStructEnd()
23622 
 
23623 
  def validate(self):
23624 
    return
23625 
 
23626 
 
23627 
  def __repr__(self):
23628 
    L = ['%s=%r' % (key, value)
23629 
      for key, value in self.__dict__.iteritems()]
23630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23631 
 
23632 
  def __eq__(self, other):
23633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23634 
 
23635 
  def __ne__(self, other):
23636 
    return not (self == other)
23637 
 
5386 phani.kuma 23638 
class getSettlementForCod_result:
4600 varun.gupt 23639 
  """
23640 
  Attributes:
23641 
   - success
23642 
   - ex
23643 
  """
23644 
 
23645 
  thrift_spec = (
23646 
    (0, TType.STRUCT, 'success', (PaymentSettlement, PaymentSettlement.thrift_spec), None, ), # 0
23647 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23648 
  )
23649 
 
23650 
  def __init__(self, success=None, ex=None,):
23651 
    self.success = success
23652 
    self.ex = ex
23653 
 
23654 
  def read(self, iprot):
23655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23657 
      return
23658 
    iprot.readStructBegin()
23659 
    while True:
23660 
      (fname, ftype, fid) = iprot.readFieldBegin()
23661 
      if ftype == TType.STOP:
23662 
        break
23663 
      if fid == 0:
23664 
        if ftype == TType.STRUCT:
23665 
          self.success = PaymentSettlement()
23666 
          self.success.read(iprot)
23667 
        else:
23668 
          iprot.skip(ftype)
23669 
      elif fid == 1:
23670 
        if ftype == TType.STRUCT:
23671 
          self.ex = TransactionServiceException()
23672 
          self.ex.read(iprot)
23673 
        else:
23674 
          iprot.skip(ftype)
23675 
      else:
23676 
        iprot.skip(ftype)
23677 
      iprot.readFieldEnd()
23678 
    iprot.readStructEnd()
23679 
 
23680 
  def write(self, oprot):
23681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23683 
      return
5386 phani.kuma 23684 
    oprot.writeStructBegin('getSettlementForCod_result')
4600 varun.gupt 23685 
    if self.success is not None:
23686 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
23687 
      self.success.write(oprot)
23688 
      oprot.writeFieldEnd()
23689 
    if self.ex is not None:
23690 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23691 
      self.ex.write(oprot)
23692 
      oprot.writeFieldEnd()
23693 
    oprot.writeFieldStop()
23694 
    oprot.writeStructEnd()
23695 
 
23696 
  def validate(self):
23697 
    return
23698 
 
23699 
 
23700 
  def __repr__(self):
23701 
    L = ['%s=%r' % (key, value)
23702 
      for key, value in self.__dict__.iteritems()]
23703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23704 
 
23705 
  def __eq__(self, other):
23706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23707 
 
23708 
  def __ne__(self, other):
23709 
    return not (self == other)
23710 
 
23711 
class getEBSSettlementSummaries_args:
23712 
 
23713 
  thrift_spec = (
23714 
  )
23715 
 
23716 
  def read(self, iprot):
23717 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23718 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23719 
      return
23720 
    iprot.readStructBegin()
23721 
    while True:
23722 
      (fname, ftype, fid) = iprot.readFieldBegin()
23723 
      if ftype == TType.STOP:
23724 
        break
23725 
      else:
23726 
        iprot.skip(ftype)
23727 
      iprot.readFieldEnd()
23728 
    iprot.readStructEnd()
23729 
 
23730 
  def write(self, oprot):
23731 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23732 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23733 
      return
23734 
    oprot.writeStructBegin('getEBSSettlementSummaries_args')
23735 
    oprot.writeFieldStop()
23736 
    oprot.writeStructEnd()
23737 
 
23738 
  def validate(self):
23739 
    return
23740 
 
23741 
 
23742 
  def __repr__(self):
23743 
    L = ['%s=%r' % (key, value)
23744 
      for key, value in self.__dict__.iteritems()]
23745 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23746 
 
23747 
  def __eq__(self, other):
23748 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23749 
 
23750 
  def __ne__(self, other):
23751 
    return not (self == other)
23752 
 
23753 
class getEBSSettlementSummaries_result:
23754 
  """
23755 
  Attributes:
23756 
   - success
23757 
   - ex
23758 
  """
23759 
 
23760 
  thrift_spec = (
23761 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
23762 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23763 
  )
23764 
 
23765 
  def __init__(self, success=None, ex=None,):
23766 
    self.success = success
23767 
    self.ex = ex
23768 
 
23769 
  def read(self, iprot):
23770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23772 
      return
23773 
    iprot.readStructBegin()
23774 
    while True:
23775 
      (fname, ftype, fid) = iprot.readFieldBegin()
23776 
      if ftype == TType.STOP:
23777 
        break
23778 
      if fid == 0:
23779 
        if ftype == TType.MAP:
23780 
          self.success = {}
6188 rajveer 23781 
          (_ktype555, _vtype556, _size554 ) = iprot.readMapBegin()
23782 
          for _i558 in xrange(_size554):
23783 
            _key559 = iprot.readI64();
23784 
            _val560 = iprot.readString();
23785 
            self.success[_key559] = _val560
4600 varun.gupt 23786 
          iprot.readMapEnd()
23787 
        else:
23788 
          iprot.skip(ftype)
23789 
      elif fid == 1:
23790 
        if ftype == TType.STRUCT:
23791 
          self.ex = TransactionServiceException()
23792 
          self.ex.read(iprot)
23793 
        else:
23794 
          iprot.skip(ftype)
23795 
      else:
23796 
        iprot.skip(ftype)
23797 
      iprot.readFieldEnd()
23798 
    iprot.readStructEnd()
23799 
 
23800 
  def write(self, oprot):
23801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23803 
      return
23804 
    oprot.writeStructBegin('getEBSSettlementSummaries_result')
23805 
    if self.success is not None:
23806 
      oprot.writeFieldBegin('success', TType.MAP, 0)
23807 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 23808 
      for kiter561,viter562 in self.success.items():
23809 
        oprot.writeI64(kiter561)
23810 
        oprot.writeString(viter562)
4600 varun.gupt 23811 
      oprot.writeMapEnd()
23812 
      oprot.writeFieldEnd()
23813 
    if self.ex is not None:
23814 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23815 
      self.ex.write(oprot)
23816 
      oprot.writeFieldEnd()
23817 
    oprot.writeFieldStop()
23818 
    oprot.writeStructEnd()
23819 
 
23820 
  def validate(self):
23821 
    return
23822 
 
23823 
 
23824 
  def __repr__(self):
23825 
    L = ['%s=%r' % (key, value)
23826 
      for key, value in self.__dict__.iteritems()]
23827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23828 
 
23829 
  def __eq__(self, other):
23830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23831 
 
23832 
  def __ne__(self, other):
23833 
    return not (self == other)
23834 
 
23835 
class markEBSSettlementUploaded_args:
23836 
  """
23837 
  Attributes:
23838 
   - settlementId
23839 
  """
23840 
 
23841 
  thrift_spec = (
23842 
    None, # 0
23843 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23844 
  )
23845 
 
23846 
  def __init__(self, settlementId=None,):
23847 
    self.settlementId = settlementId
23848 
 
23849 
  def read(self, iprot):
23850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23852 
      return
23853 
    iprot.readStructBegin()
23854 
    while True:
23855 
      (fname, ftype, fid) = iprot.readFieldBegin()
23856 
      if ftype == TType.STOP:
23857 
        break
23858 
      if fid == 1:
23859 
        if ftype == TType.I64:
23860 
          self.settlementId = iprot.readI64();
23861 
        else:
23862 
          iprot.skip(ftype)
23863 
      else:
23864 
        iprot.skip(ftype)
23865 
      iprot.readFieldEnd()
23866 
    iprot.readStructEnd()
23867 
 
23868 
  def write(self, oprot):
23869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23871 
      return
23872 
    oprot.writeStructBegin('markEBSSettlementUploaded_args')
23873 
    if self.settlementId is not None:
23874 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23875 
      oprot.writeI64(self.settlementId)
23876 
      oprot.writeFieldEnd()
23877 
    oprot.writeFieldStop()
23878 
    oprot.writeStructEnd()
23879 
 
23880 
  def validate(self):
23881 
    return
23882 
 
23883 
 
23884 
  def __repr__(self):
23885 
    L = ['%s=%r' % (key, value)
23886 
      for key, value in self.__dict__.iteritems()]
23887 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23888 
 
23889 
  def __eq__(self, other):
23890 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23891 
 
23892 
  def __ne__(self, other):
23893 
    return not (self == other)
23894 
 
23895 
class markEBSSettlementUploaded_result:
23896 
  """
23897 
  Attributes:
23898 
   - ex
23899 
  """
23900 
 
23901 
  thrift_spec = (
23902 
    None, # 0
23903 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
23904 
  )
23905 
 
23906 
  def __init__(self, ex=None,):
23907 
    self.ex = ex
23908 
 
23909 
  def read(self, iprot):
23910 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23911 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23912 
      return
23913 
    iprot.readStructBegin()
23914 
    while True:
23915 
      (fname, ftype, fid) = iprot.readFieldBegin()
23916 
      if ftype == TType.STOP:
23917 
        break
23918 
      if fid == 1:
23919 
        if ftype == TType.STRUCT:
23920 
          self.ex = TransactionServiceException()
23921 
          self.ex.read(iprot)
23922 
        else:
23923 
          iprot.skip(ftype)
23924 
      else:
23925 
        iprot.skip(ftype)
23926 
      iprot.readFieldEnd()
23927 
    iprot.readStructEnd()
23928 
 
23929 
  def write(self, oprot):
23930 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23931 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23932 
      return
23933 
    oprot.writeStructBegin('markEBSSettlementUploaded_result')
23934 
    if self.ex is not None:
23935 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
23936 
      self.ex.write(oprot)
23937 
      oprot.writeFieldEnd()
23938 
    oprot.writeFieldStop()
23939 
    oprot.writeStructEnd()
23940 
 
23941 
  def validate(self):
23942 
    return
23943 
 
23944 
 
23945 
  def __repr__(self):
23946 
    L = ['%s=%r' % (key, value)
23947 
      for key, value in self.__dict__.iteritems()]
23948 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
23949 
 
23950 
  def __eq__(self, other):
23951 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
23952 
 
23953 
  def __ne__(self, other):
23954 
    return not (self == other)
23955 
 
23956 
class getEBSSettlementDate_args:
23957 
  """
23958 
  Attributes:
23959 
   - settlementId
23960 
  """
23961 
 
23962 
  thrift_spec = (
23963 
    None, # 0
23964 
    (1, TType.I64, 'settlementId', None, None, ), # 1
23965 
  )
23966 
 
23967 
  def __init__(self, settlementId=None,):
23968 
    self.settlementId = settlementId
23969 
 
23970 
  def read(self, iprot):
23971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
23972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
23973 
      return
23974 
    iprot.readStructBegin()
23975 
    while True:
23976 
      (fname, ftype, fid) = iprot.readFieldBegin()
23977 
      if ftype == TType.STOP:
23978 
        break
23979 
      if fid == 1:
23980 
        if ftype == TType.I64:
23981 
          self.settlementId = iprot.readI64();
23982 
        else:
23983 
          iprot.skip(ftype)
23984 
      else:
23985 
        iprot.skip(ftype)
23986 
      iprot.readFieldEnd()
23987 
    iprot.readStructEnd()
23988 
 
23989 
  def write(self, oprot):
23990 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
23991 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
23992 
      return
23993 
    oprot.writeStructBegin('getEBSSettlementDate_args')
23994 
    if self.settlementId is not None:
23995 
      oprot.writeFieldBegin('settlementId', TType.I64, 1)
23996 
      oprot.writeI64(self.settlementId)
23997 
      oprot.writeFieldEnd()
23998 
    oprot.writeFieldStop()
23999 
    oprot.writeStructEnd()
24000 
 
24001 
  def validate(self):
24002 
    return
24003 
 
24004 
 
24005 
  def __repr__(self):
24006 
    L = ['%s=%r' % (key, value)
24007 
      for key, value in self.__dict__.iteritems()]
24008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24009 
 
24010 
  def __eq__(self, other):
24011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24012 
 
24013 
  def __ne__(self, other):
24014 
    return not (self == other)
24015 
 
24016 
class getEBSSettlementDate_result:
24017 
  """
24018 
  Attributes:
24019 
   - success
24020 
   - ex
24021 
  """
24022 
 
24023 
  thrift_spec = (
24024 
    (0, TType.I64, 'success', None, None, ), # 0
24025 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24026 
  )
24027 
 
24028 
  def __init__(self, success=None, ex=None,):
24029 
    self.success = success
24030 
    self.ex = ex
24031 
 
24032 
  def read(self, iprot):
24033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24035 
      return
24036 
    iprot.readStructBegin()
24037 
    while True:
24038 
      (fname, ftype, fid) = iprot.readFieldBegin()
24039 
      if ftype == TType.STOP:
24040 
        break
24041 
      if fid == 0:
24042 
        if ftype == TType.I64:
24043 
          self.success = iprot.readI64();
24044 
        else:
24045 
          iprot.skip(ftype)
24046 
      elif fid == 1:
24047 
        if ftype == TType.STRUCT:
24048 
          self.ex = TransactionServiceException()
24049 
          self.ex.read(iprot)
24050 
        else:
24051 
          iprot.skip(ftype)
24052 
      else:
24053 
        iprot.skip(ftype)
24054 
      iprot.readFieldEnd()
24055 
    iprot.readStructEnd()
24056 
 
24057 
  def write(self, oprot):
24058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24060 
      return
24061 
    oprot.writeStructBegin('getEBSSettlementDate_result')
24062 
    if self.success is not None:
24063 
      oprot.writeFieldBegin('success', TType.I64, 0)
24064 
      oprot.writeI64(self.success)
24065 
      oprot.writeFieldEnd()
24066 
    if self.ex is not None:
24067 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24068 
      self.ex.write(oprot)
24069 
      oprot.writeFieldEnd()
24070 
    oprot.writeFieldStop()
24071 
    oprot.writeStructEnd()
24072 
 
24073 
  def validate(self):
24074 
    return
24075 
 
24076 
 
24077 
  def __repr__(self):
24078 
    L = ['%s=%r' % (key, value)
24079 
      for key, value in self.__dict__.iteritems()]
24080 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24081 
 
24082 
  def __eq__(self, other):
24083 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24084 
 
24085 
  def __ne__(self, other):
24086 
    return not (self == other)
4715 varun.gupt 24087 
 
24088 
class getSettlementsByDate_args:
24089 
  """
24090 
  Attributes:
24091 
   - settlementDateFrom
24092 
   - settlementDateTo
24093 
   - isRefund
24094 
  """
24095 
 
24096 
  thrift_spec = (
24097 
    None, # 0
24098 
    (1, TType.I64, 'settlementDateFrom', None, None, ), # 1
24099 
    (2, TType.I64, 'settlementDateTo', None, None, ), # 2
24100 
    (3, TType.BOOL, 'isRefund', None, None, ), # 3
24101 
  )
24102 
 
24103 
  def __init__(self, settlementDateFrom=None, settlementDateTo=None, isRefund=None,):
24104 
    self.settlementDateFrom = settlementDateFrom
24105 
    self.settlementDateTo = settlementDateTo
24106 
    self.isRefund = isRefund
24107 
 
24108 
  def read(self, iprot):
24109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24111 
      return
24112 
    iprot.readStructBegin()
24113 
    while True:
24114 
      (fname, ftype, fid) = iprot.readFieldBegin()
24115 
      if ftype == TType.STOP:
24116 
        break
24117 
      if fid == 1:
24118 
        if ftype == TType.I64:
24119 
          self.settlementDateFrom = iprot.readI64();
24120 
        else:
24121 
          iprot.skip(ftype)
24122 
      elif fid == 2:
24123 
        if ftype == TType.I64:
24124 
          self.settlementDateTo = iprot.readI64();
24125 
        else:
24126 
          iprot.skip(ftype)
24127 
      elif fid == 3:
24128 
        if ftype == TType.BOOL:
24129 
          self.isRefund = iprot.readBool();
24130 
        else:
24131 
          iprot.skip(ftype)
24132 
      else:
24133 
        iprot.skip(ftype)
24134 
      iprot.readFieldEnd()
24135 
    iprot.readStructEnd()
24136 
 
24137 
  def write(self, oprot):
24138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24140 
      return
24141 
    oprot.writeStructBegin('getSettlementsByDate_args')
24142 
    if self.settlementDateFrom is not None:
24143 
      oprot.writeFieldBegin('settlementDateFrom', TType.I64, 1)
24144 
      oprot.writeI64(self.settlementDateFrom)
24145 
      oprot.writeFieldEnd()
24146 
    if self.settlementDateTo is not None:
24147 
      oprot.writeFieldBegin('settlementDateTo', TType.I64, 2)
24148 
      oprot.writeI64(self.settlementDateTo)
24149 
      oprot.writeFieldEnd()
24150 
    if self.isRefund is not None:
24151 
      oprot.writeFieldBegin('isRefund', TType.BOOL, 3)
24152 
      oprot.writeBool(self.isRefund)
24153 
      oprot.writeFieldEnd()
24154 
    oprot.writeFieldStop()
24155 
    oprot.writeStructEnd()
24156 
 
24157 
  def validate(self):
24158 
    return
24159 
 
24160 
 
24161 
  def __repr__(self):
24162 
    L = ['%s=%r' % (key, value)
24163 
      for key, value in self.__dict__.iteritems()]
24164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24165 
 
24166 
  def __eq__(self, other):
24167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24168 
 
24169 
  def __ne__(self, other):
24170 
    return not (self == other)
24171 
 
24172 
class getSettlementsByDate_result:
24173 
  """
24174 
  Attributes:
24175 
   - success
24176 
   - ex
24177 
  """
24178 
 
24179 
  thrift_spec = (
24180 
    (0, TType.LIST, 'success', (TType.STRUCT,(PaymentSettlement, PaymentSettlement.thrift_spec)), None, ), # 0
24181 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24182 
  )
24183 
 
24184 
  def __init__(self, success=None, ex=None,):
24185 
    self.success = success
24186 
    self.ex = ex
24187 
 
24188 
  def read(self, iprot):
24189 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24190 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24191 
      return
24192 
    iprot.readStructBegin()
24193 
    while True:
24194 
      (fname, ftype, fid) = iprot.readFieldBegin()
24195 
      if ftype == TType.STOP:
24196 
        break
24197 
      if fid == 0:
24198 
        if ftype == TType.LIST:
24199 
          self.success = []
6188 rajveer 24200 
          (_etype566, _size563) = iprot.readListBegin()
24201 
          for _i567 in xrange(_size563):
24202 
            _elem568 = PaymentSettlement()
24203 
            _elem568.read(iprot)
24204 
            self.success.append(_elem568)
4715 varun.gupt 24205 
          iprot.readListEnd()
24206 
        else:
24207 
          iprot.skip(ftype)
24208 
      elif fid == 1:
24209 
        if ftype == TType.STRUCT:
24210 
          self.ex = TransactionServiceException()
24211 
          self.ex.read(iprot)
24212 
        else:
24213 
          iprot.skip(ftype)
24214 
      else:
24215 
        iprot.skip(ftype)
24216 
      iprot.readFieldEnd()
24217 
    iprot.readStructEnd()
24218 
 
24219 
  def write(self, oprot):
24220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24222 
      return
24223 
    oprot.writeStructBegin('getSettlementsByDate_result')
24224 
    if self.success is not None:
24225 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24226 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24227 
      for iter569 in self.success:
24228 
        iter569.write(oprot)
4715 varun.gupt 24229 
      oprot.writeListEnd()
24230 
      oprot.writeFieldEnd()
24231 
    if self.ex is not None:
24232 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24233 
      self.ex.write(oprot)
24234 
      oprot.writeFieldEnd()
24235 
    oprot.writeFieldStop()
24236 
    oprot.writeStructEnd()
24237 
 
24238 
  def validate(self):
24239 
    return
24240 
 
24241 
 
24242 
  def __repr__(self):
24243 
    L = ['%s=%r' % (key, value)
24244 
      for key, value in self.__dict__.iteritems()]
24245 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24246 
 
24247 
  def __eq__(self, other):
24248 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24249 
 
24250 
  def __ne__(self, other):
24251 
    return not (self == other)
24252 
 
24253 
class getReshippedOrderIds_args:
24254 
  """
24255 
  Attributes:
24256 
   - orderIds
24257 
  """
24258 
 
24259 
  thrift_spec = (
24260 
    None, # 0
24261 
    (1, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 1
24262 
  )
24263 
 
24264 
  def __init__(self, orderIds=None,):
24265 
    self.orderIds = orderIds
24266 
 
24267 
  def read(self, iprot):
24268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24270 
      return
24271 
    iprot.readStructBegin()
24272 
    while True:
24273 
      (fname, ftype, fid) = iprot.readFieldBegin()
24274 
      if ftype == TType.STOP:
24275 
        break
24276 
      if fid == 1:
24277 
        if ftype == TType.LIST:
24278 
          self.orderIds = []
6188 rajveer 24279 
          (_etype573, _size570) = iprot.readListBegin()
24280 
          for _i574 in xrange(_size570):
24281 
            _elem575 = iprot.readI64();
24282 
            self.orderIds.append(_elem575)
4715 varun.gupt 24283 
          iprot.readListEnd()
24284 
        else:
24285 
          iprot.skip(ftype)
24286 
      else:
24287 
        iprot.skip(ftype)
24288 
      iprot.readFieldEnd()
24289 
    iprot.readStructEnd()
24290 
 
24291 
  def write(self, oprot):
24292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24294 
      return
24295 
    oprot.writeStructBegin('getReshippedOrderIds_args')
24296 
    if self.orderIds is not None:
24297 
      oprot.writeFieldBegin('orderIds', TType.LIST, 1)
24298 
      oprot.writeListBegin(TType.I64, len(self.orderIds))
6188 rajveer 24299 
      for iter576 in self.orderIds:
24300 
        oprot.writeI64(iter576)
4715 varun.gupt 24301 
      oprot.writeListEnd()
24302 
      oprot.writeFieldEnd()
24303 
    oprot.writeFieldStop()
24304 
    oprot.writeStructEnd()
24305 
 
24306 
  def validate(self):
24307 
    return
24308 
 
24309 
 
24310 
  def __repr__(self):
24311 
    L = ['%s=%r' % (key, value)
24312 
      for key, value in self.__dict__.iteritems()]
24313 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24314 
 
24315 
  def __eq__(self, other):
24316 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24317 
 
24318 
  def __ne__(self, other):
24319 
    return not (self == other)
24320 
 
24321 
class getReshippedOrderIds_result:
24322 
  """
24323 
  Attributes:
24324 
   - success
24325 
   - ex
24326 
  """
24327 
 
24328 
  thrift_spec = (
24329 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24330 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24331 
  )
24332 
 
24333 
  def __init__(self, success=None, ex=None,):
24334 
    self.success = success
24335 
    self.ex = ex
24336 
 
24337 
  def read(self, iprot):
24338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24340 
      return
24341 
    iprot.readStructBegin()
24342 
    while True:
24343 
      (fname, ftype, fid) = iprot.readFieldBegin()
24344 
      if ftype == TType.STOP:
24345 
        break
24346 
      if fid == 0:
24347 
        if ftype == TType.LIST:
24348 
          self.success = []
6188 rajveer 24349 
          (_etype580, _size577) = iprot.readListBegin()
24350 
          for _i581 in xrange(_size577):
24351 
            _elem582 = iprot.readI64();
24352 
            self.success.append(_elem582)
4715 varun.gupt 24353 
          iprot.readListEnd()
24354 
        else:
24355 
          iprot.skip(ftype)
24356 
      elif fid == 1:
24357 
        if ftype == TType.STRUCT:
24358 
          self.ex = TransactionServiceException()
24359 
          self.ex.read(iprot)
24360 
        else:
24361 
          iprot.skip(ftype)
24362 
      else:
24363 
        iprot.skip(ftype)
24364 
      iprot.readFieldEnd()
24365 
    iprot.readStructEnd()
24366 
 
24367 
  def write(self, oprot):
24368 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24369 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24370 
      return
24371 
    oprot.writeStructBegin('getReshippedOrderIds_result')
24372 
    if self.success is not None:
24373 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24374 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24375 
      for iter583 in self.success:
24376 
        oprot.writeI64(iter583)
4715 varun.gupt 24377 
      oprot.writeListEnd()
24378 
      oprot.writeFieldEnd()
24379 
    if self.ex is not None:
24380 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24381 
      self.ex.write(oprot)
24382 
      oprot.writeFieldEnd()
24383 
    oprot.writeFieldStop()
24384 
    oprot.writeStructEnd()
24385 
 
24386 
  def validate(self):
24387 
    return
24388 
 
24389 
 
24390 
  def __repr__(self):
24391 
    L = ['%s=%r' % (key, value)
24392 
      for key, value in self.__dict__.iteritems()]
24393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24394 
 
24395 
  def __eq__(self, other):
24396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24397 
 
24398 
  def __ne__(self, other):
24399 
    return not (self == other)
4757 mandeep.dh 24400 
 
5481 phani.kuma 24401 
class getBilledOrders_args:
4875 varun.gupt 24402 
  """
24403 
  Attributes:
24404 
   - vendorId
5481 phani.kuma 24405 
   - onlyVendorNotPaid
24406 
   - billingDateFrom
24407 
   - billingDateTo
4875 varun.gupt 24408 
  """
24409 
 
24410 
  thrift_spec = (
24411 
    None, # 0
24412 
    (1, TType.I64, 'vendorId', None, None, ), # 1
5481 phani.kuma 24413 
    (2, TType.BOOL, 'onlyVendorNotPaid', None, None, ), # 2
24414 
    (3, TType.I64, 'billingDateFrom', None, None, ), # 3
24415 
    (4, TType.I64, 'billingDateTo', None, None, ), # 4
4875 varun.gupt 24416 
  )
24417 
 
5481 phani.kuma 24418 
  def __init__(self, vendorId=None, onlyVendorNotPaid=None, billingDateFrom=None, billingDateTo=None,):
4875 varun.gupt 24419 
    self.vendorId = vendorId
5481 phani.kuma 24420 
    self.onlyVendorNotPaid = onlyVendorNotPaid
24421 
    self.billingDateFrom = billingDateFrom
24422 
    self.billingDateTo = billingDateTo
4875 varun.gupt 24423 
 
24424 
  def read(self, iprot):
24425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24427 
      return
24428 
    iprot.readStructBegin()
24429 
    while True:
24430 
      (fname, ftype, fid) = iprot.readFieldBegin()
24431 
      if ftype == TType.STOP:
24432 
        break
24433 
      if fid == 1:
24434 
        if ftype == TType.I64:
24435 
          self.vendorId = iprot.readI64();
24436 
        else:
24437 
          iprot.skip(ftype)
5481 phani.kuma 24438 
      elif fid == 2:
24439 
        if ftype == TType.BOOL:
24440 
          self.onlyVendorNotPaid = iprot.readBool();
24441 
        else:
24442 
          iprot.skip(ftype)
24443 
      elif fid == 3:
24444 
        if ftype == TType.I64:
24445 
          self.billingDateFrom = iprot.readI64();
24446 
        else:
24447 
          iprot.skip(ftype)
24448 
      elif fid == 4:
24449 
        if ftype == TType.I64:
24450 
          self.billingDateTo = iprot.readI64();
24451 
        else:
24452 
          iprot.skip(ftype)
4875 varun.gupt 24453 
      else:
24454 
        iprot.skip(ftype)
24455 
      iprot.readFieldEnd()
24456 
    iprot.readStructEnd()
24457 
 
24458 
  def write(self, oprot):
24459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24461 
      return
5481 phani.kuma 24462 
    oprot.writeStructBegin('getBilledOrders_args')
4875 varun.gupt 24463 
    if self.vendorId is not None:
24464 
      oprot.writeFieldBegin('vendorId', TType.I64, 1)
24465 
      oprot.writeI64(self.vendorId)
24466 
      oprot.writeFieldEnd()
5481 phani.kuma 24467 
    if self.onlyVendorNotPaid is not None:
24468 
      oprot.writeFieldBegin('onlyVendorNotPaid', TType.BOOL, 2)
24469 
      oprot.writeBool(self.onlyVendorNotPaid)
24470 
      oprot.writeFieldEnd()
24471 
    if self.billingDateFrom is not None:
24472 
      oprot.writeFieldBegin('billingDateFrom', TType.I64, 3)
24473 
      oprot.writeI64(self.billingDateFrom)
24474 
      oprot.writeFieldEnd()
24475 
    if self.billingDateTo is not None:
24476 
      oprot.writeFieldBegin('billingDateTo', TType.I64, 4)
24477 
      oprot.writeI64(self.billingDateTo)
24478 
      oprot.writeFieldEnd()
4875 varun.gupt 24479 
    oprot.writeFieldStop()
24480 
    oprot.writeStructEnd()
24481 
 
24482 
  def validate(self):
24483 
    return
24484 
 
24485 
 
24486 
  def __repr__(self):
24487 
    L = ['%s=%r' % (key, value)
24488 
      for key, value in self.__dict__.iteritems()]
24489 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24490 
 
24491 
  def __eq__(self, other):
24492 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24493 
 
24494 
  def __ne__(self, other):
24495 
    return not (self == other)
24496 
 
5481 phani.kuma 24497 
class getBilledOrders_result:
4875 varun.gupt 24498 
  """
24499 
  Attributes:
24500 
   - success
24501 
   - ex
24502 
  """
24503 
 
24504 
  thrift_spec = (
24505 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
24506 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24507 
  )
24508 
 
24509 
  def __init__(self, success=None, ex=None,):
24510 
    self.success = success
24511 
    self.ex = ex
24512 
 
24513 
  def read(self, iprot):
24514 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24515 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24516 
      return
24517 
    iprot.readStructBegin()
24518 
    while True:
24519 
      (fname, ftype, fid) = iprot.readFieldBegin()
24520 
      if ftype == TType.STOP:
24521 
        break
24522 
      if fid == 0:
24523 
        if ftype == TType.LIST:
24524 
          self.success = []
6188 rajveer 24525 
          (_etype587, _size584) = iprot.readListBegin()
24526 
          for _i588 in xrange(_size584):
24527 
            _elem589 = Order()
24528 
            _elem589.read(iprot)
24529 
            self.success.append(_elem589)
4875 varun.gupt 24530 
          iprot.readListEnd()
24531 
        else:
24532 
          iprot.skip(ftype)
24533 
      elif fid == 1:
24534 
        if ftype == TType.STRUCT:
24535 
          self.ex = TransactionServiceException()
24536 
          self.ex.read(iprot)
24537 
        else:
24538 
          iprot.skip(ftype)
24539 
      else:
24540 
        iprot.skip(ftype)
24541 
      iprot.readFieldEnd()
24542 
    iprot.readStructEnd()
24543 
 
24544 
  def write(self, oprot):
24545 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24546 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24547 
      return
5481 phani.kuma 24548 
    oprot.writeStructBegin('getBilledOrders_result')
4875 varun.gupt 24549 
    if self.success is not None:
24550 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24551 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 24552 
      for iter590 in self.success:
24553 
        iter590.write(oprot)
4875 varun.gupt 24554 
      oprot.writeListEnd()
24555 
      oprot.writeFieldEnd()
24556 
    if self.ex is not None:
24557 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24558 
      self.ex.write(oprot)
24559 
      oprot.writeFieldEnd()
24560 
    oprot.writeFieldStop()
24561 
    oprot.writeStructEnd()
24562 
 
24563 
  def validate(self):
24564 
    return
24565 
 
24566 
 
24567 
  def __repr__(self):
24568 
    L = ['%s=%r' % (key, value)
24569 
      for key, value in self.__dict__.iteritems()]
24570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24571 
 
24572 
  def __eq__(self, other):
24573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24574 
 
24575 
  def __ne__(self, other):
24576 
    return not (self == other)
5031 varun.gupt 24577 
 
24578 
class getStatusDistributionOfOrders_args:
24579 
  """
24580 
  Attributes:
24581 
   - startDate
24582 
   - endDate
24583 
  """
24584 
 
24585 
  thrift_spec = (
24586 
    None, # 0
24587 
    (1, TType.I64, 'startDate', None, None, ), # 1
24588 
    (2, TType.I64, 'endDate', None, None, ), # 2
24589 
  )
24590 
 
24591 
  def __init__(self, startDate=None, endDate=None,):
24592 
    self.startDate = startDate
24593 
    self.endDate = endDate
24594 
 
24595 
  def read(self, iprot):
24596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24598 
      return
24599 
    iprot.readStructBegin()
24600 
    while True:
24601 
      (fname, ftype, fid) = iprot.readFieldBegin()
24602 
      if ftype == TType.STOP:
24603 
        break
24604 
      if fid == 1:
24605 
        if ftype == TType.I64:
24606 
          self.startDate = iprot.readI64();
24607 
        else:
24608 
          iprot.skip(ftype)
24609 
      elif fid == 2:
24610 
        if ftype == TType.I64:
24611 
          self.endDate = iprot.readI64();
24612 
        else:
24613 
          iprot.skip(ftype)
24614 
      else:
24615 
        iprot.skip(ftype)
24616 
      iprot.readFieldEnd()
24617 
    iprot.readStructEnd()
24618 
 
24619 
  def write(self, oprot):
24620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24622 
      return
24623 
    oprot.writeStructBegin('getStatusDistributionOfOrders_args')
24624 
    if self.startDate is not None:
24625 
      oprot.writeFieldBegin('startDate', TType.I64, 1)
24626 
      oprot.writeI64(self.startDate)
24627 
      oprot.writeFieldEnd()
24628 
    if self.endDate is not None:
24629 
      oprot.writeFieldBegin('endDate', TType.I64, 2)
24630 
      oprot.writeI64(self.endDate)
24631 
      oprot.writeFieldEnd()
24632 
    oprot.writeFieldStop()
24633 
    oprot.writeStructEnd()
24634 
 
24635 
  def validate(self):
24636 
    return
24637 
 
24638 
 
24639 
  def __repr__(self):
24640 
    L = ['%s=%r' % (key, value)
24641 
      for key, value in self.__dict__.iteritems()]
24642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24643 
 
24644 
  def __eq__(self, other):
24645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24646 
 
24647 
  def __ne__(self, other):
24648 
    return not (self == other)
24649 
 
24650 
class getStatusDistributionOfOrders_result:
24651 
  """
24652 
  Attributes:
24653 
   - success
24654 
   - ex
24655 
  """
24656 
 
24657 
  thrift_spec = (
24658 
    (0, TType.MAP, 'success', (TType.I64,None,TType.I64,None), None, ), # 0
24659 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24660 
  )
24661 
 
24662 
  def __init__(self, success=None, ex=None,):
24663 
    self.success = success
24664 
    self.ex = ex
24665 
 
24666 
  def read(self, iprot):
24667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24669 
      return
24670 
    iprot.readStructBegin()
24671 
    while True:
24672 
      (fname, ftype, fid) = iprot.readFieldBegin()
24673 
      if ftype == TType.STOP:
24674 
        break
24675 
      if fid == 0:
24676 
        if ftype == TType.MAP:
24677 
          self.success = {}
6188 rajveer 24678 
          (_ktype592, _vtype593, _size591 ) = iprot.readMapBegin()
24679 
          for _i595 in xrange(_size591):
24680 
            _key596 = iprot.readI64();
24681 
            _val597 = iprot.readI64();
24682 
            self.success[_key596] = _val597
5031 varun.gupt 24683 
          iprot.readMapEnd()
24684 
        else:
24685 
          iprot.skip(ftype)
24686 
      elif fid == 1:
24687 
        if ftype == TType.STRUCT:
24688 
          self.ex = TransactionServiceException()
24689 
          self.ex.read(iprot)
24690 
        else:
24691 
          iprot.skip(ftype)
24692 
      else:
24693 
        iprot.skip(ftype)
24694 
      iprot.readFieldEnd()
24695 
    iprot.readStructEnd()
24696 
 
24697 
  def write(self, oprot):
24698 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24699 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24700 
      return
24701 
    oprot.writeStructBegin('getStatusDistributionOfOrders_result')
24702 
    if self.success is not None:
24703 
      oprot.writeFieldBegin('success', TType.MAP, 0)
24704 
      oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
6188 rajveer 24705 
      for kiter598,viter599 in self.success.items():
24706 
        oprot.writeI64(kiter598)
24707 
        oprot.writeI64(viter599)
5031 varun.gupt 24708 
      oprot.writeMapEnd()
24709 
      oprot.writeFieldEnd()
24710 
    if self.ex is not None:
24711 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24712 
      self.ex.write(oprot)
24713 
      oprot.writeFieldEnd()
24714 
    oprot.writeFieldStop()
24715 
    oprot.writeStructEnd()
24716 
 
24717 
  def validate(self):
24718 
    return
24719 
 
24720 
 
24721 
  def __repr__(self):
24722 
    L = ['%s=%r' % (key, value)
24723 
      for key, value in self.__dict__.iteritems()]
24724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24725 
 
24726 
  def __eq__(self, other):
24727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24728 
 
24729 
  def __ne__(self, other):
24730 
    return not (self == other)
5067 varun.gupt 24731 
 
24732 
class getOrderIdsForStatus_args:
24733 
  """
24734 
  Attributes:
24735 
   - status
24736 
   - startDatetime
24737 
   - endDatetime
24738 
  """
24739 
 
24740 
  thrift_spec = (
24741 
    None, # 0
24742 
    (1, TType.I64, 'status', None, None, ), # 1
24743 
    (2, TType.I64, 'startDatetime', None, None, ), # 2
24744 
    (3, TType.I64, 'endDatetime', None, None, ), # 3
24745 
  )
24746 
 
24747 
  def __init__(self, status=None, startDatetime=None, endDatetime=None,):
24748 
    self.status = status
24749 
    self.startDatetime = startDatetime
24750 
    self.endDatetime = endDatetime
24751 
 
24752 
  def read(self, iprot):
24753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24755 
      return
24756 
    iprot.readStructBegin()
24757 
    while True:
24758 
      (fname, ftype, fid) = iprot.readFieldBegin()
24759 
      if ftype == TType.STOP:
24760 
        break
24761 
      if fid == 1:
24762 
        if ftype == TType.I64:
24763 
          self.status = iprot.readI64();
24764 
        else:
24765 
          iprot.skip(ftype)
24766 
      elif fid == 2:
24767 
        if ftype == TType.I64:
24768 
          self.startDatetime = iprot.readI64();
24769 
        else:
24770 
          iprot.skip(ftype)
24771 
      elif fid == 3:
24772 
        if ftype == TType.I64:
24773 
          self.endDatetime = iprot.readI64();
24774 
        else:
24775 
          iprot.skip(ftype)
24776 
      else:
24777 
        iprot.skip(ftype)
24778 
      iprot.readFieldEnd()
24779 
    iprot.readStructEnd()
24780 
 
24781 
  def write(self, oprot):
24782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24784 
      return
24785 
    oprot.writeStructBegin('getOrderIdsForStatus_args')
24786 
    if self.status is not None:
24787 
      oprot.writeFieldBegin('status', TType.I64, 1)
24788 
      oprot.writeI64(self.status)
24789 
      oprot.writeFieldEnd()
24790 
    if self.startDatetime is not None:
24791 
      oprot.writeFieldBegin('startDatetime', TType.I64, 2)
24792 
      oprot.writeI64(self.startDatetime)
24793 
      oprot.writeFieldEnd()
24794 
    if self.endDatetime is not None:
24795 
      oprot.writeFieldBegin('endDatetime', TType.I64, 3)
24796 
      oprot.writeI64(self.endDatetime)
24797 
      oprot.writeFieldEnd()
24798 
    oprot.writeFieldStop()
24799 
    oprot.writeStructEnd()
24800 
 
24801 
  def validate(self):
24802 
    return
24803 
 
24804 
 
24805 
  def __repr__(self):
24806 
    L = ['%s=%r' % (key, value)
24807 
      for key, value in self.__dict__.iteritems()]
24808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24809 
 
24810 
  def __eq__(self, other):
24811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24812 
 
24813 
  def __ne__(self, other):
24814 
    return not (self == other)
24815 
 
24816 
class getOrderIdsForStatus_result:
24817 
  """
24818 
  Attributes:
24819 
   - success
24820 
   - ex
24821 
  """
24822 
 
24823 
  thrift_spec = (
24824 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
24825 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24826 
  )
24827 
 
24828 
  def __init__(self, success=None, ex=None,):
24829 
    self.success = success
24830 
    self.ex = ex
24831 
 
24832 
  def read(self, iprot):
24833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24835 
      return
24836 
    iprot.readStructBegin()
24837 
    while True:
24838 
      (fname, ftype, fid) = iprot.readFieldBegin()
24839 
      if ftype == TType.STOP:
24840 
        break
24841 
      if fid == 0:
24842 
        if ftype == TType.LIST:
24843 
          self.success = []
6188 rajveer 24844 
          (_etype603, _size600) = iprot.readListBegin()
24845 
          for _i604 in xrange(_size600):
24846 
            _elem605 = iprot.readI64();
24847 
            self.success.append(_elem605)
5067 varun.gupt 24848 
          iprot.readListEnd()
24849 
        else:
24850 
          iprot.skip(ftype)
24851 
      elif fid == 1:
24852 
        if ftype == TType.STRUCT:
24853 
          self.ex = TransactionServiceException()
24854 
          self.ex.read(iprot)
24855 
        else:
24856 
          iprot.skip(ftype)
24857 
      else:
24858 
        iprot.skip(ftype)
24859 
      iprot.readFieldEnd()
24860 
    iprot.readStructEnd()
24861 
 
24862 
  def write(self, oprot):
24863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24865 
      return
24866 
    oprot.writeStructBegin('getOrderIdsForStatus_result')
24867 
    if self.success is not None:
24868 
      oprot.writeFieldBegin('success', TType.LIST, 0)
24869 
      oprot.writeListBegin(TType.I64, len(self.success))
6188 rajveer 24870 
      for iter606 in self.success:
24871 
        oprot.writeI64(iter606)
5067 varun.gupt 24872 
      oprot.writeListEnd()
24873 
      oprot.writeFieldEnd()
24874 
    if self.ex is not None:
24875 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
24876 
      self.ex.write(oprot)
24877 
      oprot.writeFieldEnd()
24878 
    oprot.writeFieldStop()
24879 
    oprot.writeStructEnd()
24880 
 
24881 
  def validate(self):
24882 
    return
24883 
 
24884 
 
24885 
  def __repr__(self):
24886 
    L = ['%s=%r' % (key, value)
24887 
      for key, value in self.__dict__.iteritems()]
24888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24889 
 
24890 
  def __eq__(self, other):
24891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24892 
 
24893 
  def __ne__(self, other):
24894 
    return not (self == other)
5099 varun.gupt 24895 
 
5348 anupam.sin 24896 
class updateCODAgent_args:
24897 
  """
24898 
  Attributes:
24899 
   - agent
24900 
   - orderId
24901 
  """
24902 
 
24903 
  thrift_spec = (
24904 
    None, # 0
24905 
    (1, TType.STRING, 'agent', None, None, ), # 1
24906 
    (2, TType.I64, 'orderId', None, None, ), # 2
24907 
  )
24908 
 
24909 
  def __init__(self, agent=None, orderId=None,):
24910 
    self.agent = agent
24911 
    self.orderId = orderId
24912 
 
24913 
  def read(self, iprot):
24914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24916 
      return
24917 
    iprot.readStructBegin()
24918 
    while True:
24919 
      (fname, ftype, fid) = iprot.readFieldBegin()
24920 
      if ftype == TType.STOP:
24921 
        break
24922 
      if fid == 1:
24923 
        if ftype == TType.STRING:
24924 
          self.agent = iprot.readString();
24925 
        else:
24926 
          iprot.skip(ftype)
24927 
      elif fid == 2:
24928 
        if ftype == TType.I64:
24929 
          self.orderId = iprot.readI64();
24930 
        else:
24931 
          iprot.skip(ftype)
24932 
      else:
24933 
        iprot.skip(ftype)
24934 
      iprot.readFieldEnd()
24935 
    iprot.readStructEnd()
24936 
 
24937 
  def write(self, oprot):
24938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
24939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
24940 
      return
24941 
    oprot.writeStructBegin('updateCODAgent_args')
24942 
    if self.agent is not None:
24943 
      oprot.writeFieldBegin('agent', TType.STRING, 1)
24944 
      oprot.writeString(self.agent)
24945 
      oprot.writeFieldEnd()
24946 
    if self.orderId is not None:
24947 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
24948 
      oprot.writeI64(self.orderId)
24949 
      oprot.writeFieldEnd()
24950 
    oprot.writeFieldStop()
24951 
    oprot.writeStructEnd()
24952 
 
24953 
  def validate(self):
24954 
    return
24955 
 
24956 
 
24957 
  def __repr__(self):
24958 
    L = ['%s=%r' % (key, value)
24959 
      for key, value in self.__dict__.iteritems()]
24960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
24961 
 
24962 
  def __eq__(self, other):
24963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
24964 
 
24965 
  def __ne__(self, other):
24966 
    return not (self == other)
24967 
 
24968 
class updateCODAgent_result:
24969 
  """
24970 
  Attributes:
24971 
   - ex
24972 
  """
24973 
 
24974 
  thrift_spec = (
24975 
    None, # 0
24976 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
24977 
  )
24978 
 
24979 
  def __init__(self, ex=None,):
24980 
    self.ex = ex
24981 
 
24982 
  def read(self, iprot):
24983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
24984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
24985 
      return
24986 
    iprot.readStructBegin()
24987 
    while True:
24988 
      (fname, ftype, fid) = iprot.readFieldBegin()
24989 
      if ftype == TType.STOP:
24990 
        break
24991 
      if fid == 1:
24992 
        if ftype == TType.STRUCT:
24993 
          self.ex = TransactionServiceException()
24994 
          self.ex.read(iprot)
24995 
        else:
24996 
          iprot.skip(ftype)
24997 
      else:
24998 
        iprot.skip(ftype)
24999 
      iprot.readFieldEnd()
25000 
    iprot.readStructEnd()
25001 
 
25002 
  def write(self, oprot):
25003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25005 
      return
25006 
    oprot.writeStructBegin('updateCODAgent_result')
25007 
    if self.ex is not None:
25008 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25009 
      self.ex.write(oprot)
25010 
      oprot.writeFieldEnd()
25011 
    oprot.writeFieldStop()
25012 
    oprot.writeStructEnd()
25013 
 
25014 
  def validate(self):
25015 
    return
25016 
 
25017 
 
25018 
  def __repr__(self):
25019 
    L = ['%s=%r' % (key, value)
25020 
      for key, value in self.__dict__.iteritems()]
25021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25022 
 
25023 
  def __eq__(self, other):
25024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25025 
 
25026 
  def __ne__(self, other):
25027 
    return not (self == other)
25028 
 
5099 varun.gupt 25029 
class updateOrderAsPaidToVendor_args:
25030 
  """
25031 
  Attributes:
25032 
   - orderId
25033 
  """
25034 
 
25035 
  thrift_spec = (
25036 
    None, # 0
25037 
    (1, TType.I64, 'orderId', None, None, ), # 1
25038 
  )
25039 
 
25040 
  def __init__(self, orderId=None,):
25041 
    self.orderId = orderId
25042 
 
25043 
  def read(self, iprot):
25044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25046 
      return
25047 
    iprot.readStructBegin()
25048 
    while True:
25049 
      (fname, ftype, fid) = iprot.readFieldBegin()
25050 
      if ftype == TType.STOP:
25051 
        break
25052 
      if fid == 1:
25053 
        if ftype == TType.I64:
25054 
          self.orderId = iprot.readI64();
25055 
        else:
25056 
          iprot.skip(ftype)
25057 
      else:
25058 
        iprot.skip(ftype)
25059 
      iprot.readFieldEnd()
25060 
    iprot.readStructEnd()
25061 
 
25062 
  def write(self, oprot):
25063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25065 
      return
25066 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_args')
25067 
    if self.orderId is not None:
25068 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25069 
      oprot.writeI64(self.orderId)
25070 
      oprot.writeFieldEnd()
25071 
    oprot.writeFieldStop()
25072 
    oprot.writeStructEnd()
25073 
 
25074 
  def validate(self):
25075 
    return
25076 
 
25077 
 
25078 
  def __repr__(self):
25079 
    L = ['%s=%r' % (key, value)
25080 
      for key, value in self.__dict__.iteritems()]
25081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25082 
 
25083 
  def __eq__(self, other):
25084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25085 
 
25086 
  def __ne__(self, other):
25087 
    return not (self == other)
25088 
 
25089 
class updateOrderAsPaidToVendor_result:
25090 
  """
25091 
  Attributes:
25092 
   - ex
25093 
  """
25094 
 
25095 
  thrift_spec = (
25096 
    None, # 0
25097 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25098 
  )
25099 
 
25100 
  def __init__(self, ex=None,):
25101 
    self.ex = ex
25102 
 
25103 
  def read(self, iprot):
25104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25106 
      return
25107 
    iprot.readStructBegin()
25108 
    while True:
25109 
      (fname, ftype, fid) = iprot.readFieldBegin()
25110 
      if ftype == TType.STOP:
25111 
        break
25112 
      if fid == 1:
25113 
        if ftype == TType.STRUCT:
25114 
          self.ex = TransactionServiceException()
25115 
          self.ex.read(iprot)
25116 
        else:
25117 
          iprot.skip(ftype)
25118 
      else:
25119 
        iprot.skip(ftype)
25120 
      iprot.readFieldEnd()
25121 
    iprot.readStructEnd()
25122 
 
25123 
  def write(self, oprot):
25124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25126 
      return
25127 
    oprot.writeStructBegin('updateOrderAsPaidToVendor_result')
25128 
    if self.ex is not None:
25129 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25130 
      self.ex.write(oprot)
25131 
      oprot.writeFieldEnd()
25132 
    oprot.writeFieldStop()
25133 
    oprot.writeStructEnd()
25134 
 
25135 
  def validate(self):
25136 
    return
25137 
 
25138 
 
25139 
  def __repr__(self):
25140 
    L = ['%s=%r' % (key, value)
25141 
      for key, value in self.__dict__.iteritems()]
25142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25143 
 
25144 
  def __eq__(self, other):
25145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25146 
 
25147 
  def __ne__(self, other):
25148 
    return not (self == other)
5208 varun.gupt 25149 
 
5386 phani.kuma 25150 
class updateOrderOnlyAsPaidToVendor_args:
25151 
  """
25152 
  Attributes:
25153 
   - orderId
25154 
  """
25155 
 
25156 
  thrift_spec = (
25157 
    None, # 0
25158 
    (1, TType.I64, 'orderId', None, None, ), # 1
25159 
  )
25160 
 
25161 
  def __init__(self, orderId=None,):
25162 
    self.orderId = orderId
25163 
 
25164 
  def read(self, iprot):
25165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25167 
      return
25168 
    iprot.readStructBegin()
25169 
    while True:
25170 
      (fname, ftype, fid) = iprot.readFieldBegin()
25171 
      if ftype == TType.STOP:
25172 
        break
25173 
      if fid == 1:
25174 
        if ftype == TType.I64:
25175 
          self.orderId = iprot.readI64();
25176 
        else:
25177 
          iprot.skip(ftype)
25178 
      else:
25179 
        iprot.skip(ftype)
25180 
      iprot.readFieldEnd()
25181 
    iprot.readStructEnd()
25182 
 
25183 
  def write(self, oprot):
25184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25186 
      return
25187 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_args')
25188 
    if self.orderId is not None:
25189 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25190 
      oprot.writeI64(self.orderId)
25191 
      oprot.writeFieldEnd()
25192 
    oprot.writeFieldStop()
25193 
    oprot.writeStructEnd()
25194 
 
25195 
  def validate(self):
25196 
    return
25197 
 
25198 
 
25199 
  def __repr__(self):
25200 
    L = ['%s=%r' % (key, value)
25201 
      for key, value in self.__dict__.iteritems()]
25202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25203 
 
25204 
  def __eq__(self, other):
25205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25206 
 
25207 
  def __ne__(self, other):
25208 
    return not (self == other)
25209 
 
25210 
class updateOrderOnlyAsPaidToVendor_result:
25211 
  """
25212 
  Attributes:
25213 
   - ex
25214 
  """
25215 
 
25216 
  thrift_spec = (
25217 
    None, # 0
25218 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25219 
  )
25220 
 
25221 
  def __init__(self, ex=None,):
25222 
    self.ex = ex
25223 
 
25224 
  def read(self, iprot):
25225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25227 
      return
25228 
    iprot.readStructBegin()
25229 
    while True:
25230 
      (fname, ftype, fid) = iprot.readFieldBegin()
25231 
      if ftype == TType.STOP:
25232 
        break
25233 
      if fid == 1:
25234 
        if ftype == TType.STRUCT:
25235 
          self.ex = TransactionServiceException()
25236 
          self.ex.read(iprot)
25237 
        else:
25238 
          iprot.skip(ftype)
25239 
      else:
25240 
        iprot.skip(ftype)
25241 
      iprot.readFieldEnd()
25242 
    iprot.readStructEnd()
25243 
 
25244 
  def write(self, oprot):
25245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25247 
      return
25248 
    oprot.writeStructBegin('updateOrderOnlyAsPaidToVendor_result')
25249 
    if self.ex is not None:
25250 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25251 
      self.ex.write(oprot)
25252 
      oprot.writeFieldEnd()
25253 
    oprot.writeFieldStop()
25254 
    oprot.writeStructEnd()
25255 
 
25256 
  def validate(self):
25257 
    return
25258 
 
25259 
 
25260 
  def __repr__(self):
25261 
    L = ['%s=%r' % (key, value)
25262 
      for key, value in self.__dict__.iteritems()]
25263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25264 
 
25265 
  def __eq__(self, other):
25266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25267 
 
25268 
  def __ne__(self, other):
25269 
    return not (self == other)
25270 
 
5208 varun.gupt 25271 
class getRefundedOrdersMarkedPaid_args:
25272 
 
25273 
  thrift_spec = (
25274 
  )
25275 
 
25276 
  def read(self, iprot):
25277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25279 
      return
25280 
    iprot.readStructBegin()
25281 
    while True:
25282 
      (fname, ftype, fid) = iprot.readFieldBegin()
25283 
      if ftype == TType.STOP:
25284 
        break
25285 
      else:
25286 
        iprot.skip(ftype)
25287 
      iprot.readFieldEnd()
25288 
    iprot.readStructEnd()
25289 
 
25290 
  def write(self, oprot):
25291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25293 
      return
25294 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_args')
25295 
    oprot.writeFieldStop()
25296 
    oprot.writeStructEnd()
25297 
 
25298 
  def validate(self):
25299 
    return
25300 
 
25301 
 
25302 
  def __repr__(self):
25303 
    L = ['%s=%r' % (key, value)
25304 
      for key, value in self.__dict__.iteritems()]
25305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25306 
 
25307 
  def __eq__(self, other):
25308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25309 
 
25310 
  def __ne__(self, other):
25311 
    return not (self == other)
25312 
 
25313 
class getRefundedOrdersMarkedPaid_result:
25314 
  """
25315 
  Attributes:
25316 
   - success
25317 
   - ex
25318 
  """
25319 
 
25320 
  thrift_spec = (
25321 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25322 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
25323 
  )
25324 
 
25325 
  def __init__(self, success=None, ex=None,):
25326 
    self.success = success
25327 
    self.ex = ex
25328 
 
25329 
  def read(self, iprot):
25330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25332 
      return
25333 
    iprot.readStructBegin()
25334 
    while True:
25335 
      (fname, ftype, fid) = iprot.readFieldBegin()
25336 
      if ftype == TType.STOP:
25337 
        break
25338 
      if fid == 0:
25339 
        if ftype == TType.LIST:
25340 
          self.success = []
6188 rajveer 25341 
          (_etype610, _size607) = iprot.readListBegin()
25342 
          for _i611 in xrange(_size607):
25343 
            _elem612 = Order()
25344 
            _elem612.read(iprot)
25345 
            self.success.append(_elem612)
5208 varun.gupt 25346 
          iprot.readListEnd()
25347 
        else:
25348 
          iprot.skip(ftype)
25349 
      elif fid == 1:
25350 
        if ftype == TType.STRUCT:
25351 
          self.ex = TransactionServiceException()
25352 
          self.ex.read(iprot)
25353 
        else:
25354 
          iprot.skip(ftype)
25355 
      else:
25356 
        iprot.skip(ftype)
25357 
      iprot.readFieldEnd()
25358 
    iprot.readStructEnd()
25359 
 
25360 
  def write(self, oprot):
25361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25363 
      return
25364 
    oprot.writeStructBegin('getRefundedOrdersMarkedPaid_result')
25365 
    if self.success is not None:
25366 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25367 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25368 
      for iter613 in self.success:
25369 
        iter613.write(oprot)
5208 varun.gupt 25370 
      oprot.writeListEnd()
25371 
      oprot.writeFieldEnd()
25372 
    if self.ex is not None:
25373 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
25374 
      self.ex.write(oprot)
25375 
      oprot.writeFieldEnd()
25376 
    oprot.writeFieldStop()
25377 
    oprot.writeStructEnd()
25378 
 
25379 
  def validate(self):
25380 
    return
25381 
 
25382 
 
25383 
  def __repr__(self):
25384 
    L = ['%s=%r' % (key, value)
25385 
      for key, value in self.__dict__.iteritems()]
25386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25387 
 
25388 
  def __eq__(self, other):
25389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25390 
 
25391 
  def __ne__(self, other):
25392 
    return not (self == other)
5447 anupam.sin 25393 
 
25394 
class getAllVerificationAgents_args:
25395 
  """
25396 
  Attributes:
25397 
   - minOrderId
25398 
   - maxOrderId
25399 
  """
25400 
 
25401 
  thrift_spec = (
25402 
    None, # 0
25403 
    (1, TType.I64, 'minOrderId', None, None, ), # 1
25404 
    (2, TType.I64, 'maxOrderId', None, None, ), # 2
25405 
  )
25406 
 
25407 
  def __init__(self, minOrderId=None, maxOrderId=None,):
25408 
    self.minOrderId = minOrderId
25409 
    self.maxOrderId = maxOrderId
25410 
 
25411 
  def read(self, iprot):
25412 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25413 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25414 
      return
25415 
    iprot.readStructBegin()
25416 
    while True:
25417 
      (fname, ftype, fid) = iprot.readFieldBegin()
25418 
      if ftype == TType.STOP:
25419 
        break
25420 
      if fid == 1:
25421 
        if ftype == TType.I64:
25422 
          self.minOrderId = iprot.readI64();
25423 
        else:
25424 
          iprot.skip(ftype)
25425 
      elif fid == 2:
25426 
        if ftype == TType.I64:
25427 
          self.maxOrderId = iprot.readI64();
25428 
        else:
25429 
          iprot.skip(ftype)
25430 
      else:
25431 
        iprot.skip(ftype)
25432 
      iprot.readFieldEnd()
25433 
    iprot.readStructEnd()
25434 
 
25435 
  def write(self, oprot):
25436 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25437 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25438 
      return
25439 
    oprot.writeStructBegin('getAllVerificationAgents_args')
25440 
    if self.minOrderId is not None:
25441 
      oprot.writeFieldBegin('minOrderId', TType.I64, 1)
25442 
      oprot.writeI64(self.minOrderId)
25443 
      oprot.writeFieldEnd()
25444 
    if self.maxOrderId is not None:
25445 
      oprot.writeFieldBegin('maxOrderId', TType.I64, 2)
25446 
      oprot.writeI64(self.maxOrderId)
25447 
      oprot.writeFieldEnd()
25448 
    oprot.writeFieldStop()
25449 
    oprot.writeStructEnd()
25450 
 
25451 
  def validate(self):
25452 
    return
25453 
 
25454 
 
25455 
  def __repr__(self):
25456 
    L = ['%s=%r' % (key, value)
25457 
      for key, value in self.__dict__.iteritems()]
25458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25459 
 
25460 
  def __eq__(self, other):
25461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25462 
 
25463 
  def __ne__(self, other):
25464 
    return not (self == other)
25465 
 
25466 
class getAllVerificationAgents_result:
25467 
  """
25468 
  Attributes:
25469 
   - success
25470 
  """
25471 
 
25472 
  thrift_spec = (
25473 
    (0, TType.LIST, 'success', (TType.STRUCT,(CODVerificationAgent, CODVerificationAgent.thrift_spec)), None, ), # 0
25474 
  )
25475 
 
25476 
  def __init__(self, success=None,):
25477 
    self.success = success
25478 
 
25479 
  def read(self, iprot):
25480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25482 
      return
25483 
    iprot.readStructBegin()
25484 
    while True:
25485 
      (fname, ftype, fid) = iprot.readFieldBegin()
25486 
      if ftype == TType.STOP:
25487 
        break
25488 
      if fid == 0:
25489 
        if ftype == TType.LIST:
25490 
          self.success = []
6188 rajveer 25491 
          (_etype617, _size614) = iprot.readListBegin()
25492 
          for _i618 in xrange(_size614):
25493 
            _elem619 = CODVerificationAgent()
25494 
            _elem619.read(iprot)
25495 
            self.success.append(_elem619)
5447 anupam.sin 25496 
          iprot.readListEnd()
25497 
        else:
25498 
          iprot.skip(ftype)
25499 
      else:
25500 
        iprot.skip(ftype)
25501 
      iprot.readFieldEnd()
25502 
    iprot.readStructEnd()
25503 
 
25504 
  def write(self, oprot):
25505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25507 
      return
25508 
    oprot.writeStructBegin('getAllVerificationAgents_result')
25509 
    if self.success is not None:
25510 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25511 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25512 
      for iter620 in self.success:
25513 
        iter620.write(oprot)
5447 anupam.sin 25514 
      oprot.writeListEnd()
25515 
      oprot.writeFieldEnd()
25516 
    oprot.writeFieldStop()
25517 
    oprot.writeStructEnd()
25518 
 
25519 
  def validate(self):
25520 
    return
25521 
 
25522 
 
25523 
  def __repr__(self):
25524 
    L = ['%s=%r' % (key, value)
25525 
      for key, value in self.__dict__.iteritems()]
25526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25527 
 
25528 
  def __eq__(self, other):
25529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25530 
 
25531 
  def __ne__(self, other):
25532 
    return not (self == other)
5527 anupam.sin 25533 
 
25534 
class getAllAttributesForOrderId_args:
25535 
  """
25536 
  Attributes:
25537 
   - orderId
25538 
  """
25539 
 
25540 
  thrift_spec = (
25541 
    None, # 0
25542 
    (1, TType.I64, 'orderId', None, None, ), # 1
25543 
  )
25544 
 
25545 
  def __init__(self, orderId=None,):
25546 
    self.orderId = orderId
25547 
 
25548 
  def read(self, iprot):
25549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25551 
      return
25552 
    iprot.readStructBegin()
25553 
    while True:
25554 
      (fname, ftype, fid) = iprot.readFieldBegin()
25555 
      if ftype == TType.STOP:
25556 
        break
25557 
      if fid == 1:
25558 
        if ftype == TType.I64:
25559 
          self.orderId = iprot.readI64();
25560 
        else:
25561 
          iprot.skip(ftype)
25562 
      else:
25563 
        iprot.skip(ftype)
25564 
      iprot.readFieldEnd()
25565 
    iprot.readStructEnd()
25566 
 
25567 
  def write(self, oprot):
25568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25570 
      return
25571 
    oprot.writeStructBegin('getAllAttributesForOrderId_args')
25572 
    if self.orderId is not None:
25573 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25574 
      oprot.writeI64(self.orderId)
25575 
      oprot.writeFieldEnd()
25576 
    oprot.writeFieldStop()
25577 
    oprot.writeStructEnd()
25578 
 
25579 
  def validate(self):
25580 
    return
25581 
 
25582 
 
25583 
  def __repr__(self):
25584 
    L = ['%s=%r' % (key, value)
25585 
      for key, value in self.__dict__.iteritems()]
25586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25587 
 
25588 
  def __eq__(self, other):
25589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25590 
 
25591 
  def __ne__(self, other):
25592 
    return not (self == other)
25593 
 
25594 
class getAllAttributesForOrderId_result:
25595 
  """
25596 
  Attributes:
25597 
   - success
25598 
  """
25599 
 
25600 
  thrift_spec = (
25601 
    (0, TType.LIST, 'success', (TType.STRUCT,(Attribute, Attribute.thrift_spec)), None, ), # 0
25602 
  )
25603 
 
25604 
  def __init__(self, success=None,):
25605 
    self.success = success
25606 
 
25607 
  def read(self, iprot):
25608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25610 
      return
25611 
    iprot.readStructBegin()
25612 
    while True:
25613 
      (fname, ftype, fid) = iprot.readFieldBegin()
25614 
      if ftype == TType.STOP:
25615 
        break
25616 
      if fid == 0:
25617 
        if ftype == TType.LIST:
25618 
          self.success = []
6188 rajveer 25619 
          (_etype624, _size621) = iprot.readListBegin()
25620 
          for _i625 in xrange(_size621):
25621 
            _elem626 = Attribute()
25622 
            _elem626.read(iprot)
25623 
            self.success.append(_elem626)
5527 anupam.sin 25624 
          iprot.readListEnd()
25625 
        else:
25626 
          iprot.skip(ftype)
25627 
      else:
25628 
        iprot.skip(ftype)
25629 
      iprot.readFieldEnd()
25630 
    iprot.readStructEnd()
25631 
 
25632 
  def write(self, oprot):
25633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25635 
      return
25636 
    oprot.writeStructBegin('getAllAttributesForOrderId_result')
25637 
    if self.success is not None:
25638 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25639 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25640 
      for iter627 in self.success:
25641 
        iter627.write(oprot)
5527 anupam.sin 25642 
      oprot.writeListEnd()
25643 
      oprot.writeFieldEnd()
25644 
    oprot.writeFieldStop()
25645 
    oprot.writeStructEnd()
25646 
 
25647 
  def validate(self):
25648 
    return
25649 
 
25650 
 
25651 
  def __repr__(self):
25652 
    L = ['%s=%r' % (key, value)
25653 
      for key, value in self.__dict__.iteritems()]
25654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25655 
 
25656 
  def __eq__(self, other):
25657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25658 
 
25659 
  def __ne__(self, other):
25660 
    return not (self == other)
25661 
 
5676 rajveer 25662 
class setOrderAttributes_args:
25663 
  """
25664 
  Attributes:
25665 
   - orderId
25666 
   - attributes
25667 
  """
25668 
 
25669 
  thrift_spec = None
25670 
  def __init__(self, orderId=None, attributes=None,):
25671 
    self.orderId = orderId
25672 
    self.attributes = attributes
25673 
 
25674 
  def read(self, iprot):
25675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25677 
      return
25678 
    iprot.readStructBegin()
25679 
    while True:
25680 
      (fname, ftype, fid) = iprot.readFieldBegin()
25681 
      if ftype == TType.STOP:
25682 
        break
25683 
      if fid == 1:
25684 
        if ftype == TType.I64:
25685 
          self.orderId = iprot.readI64();
25686 
        else:
25687 
          iprot.skip(ftype)
25688 
      elif fid == -1:
25689 
        if ftype == TType.LIST:
25690 
          self.attributes = []
6188 rajveer 25691 
          (_etype631, _size628) = iprot.readListBegin()
25692 
          for _i632 in xrange(_size628):
25693 
            _elem633 = Attribute()
25694 
            _elem633.read(iprot)
25695 
            self.attributes.append(_elem633)
5676 rajveer 25696 
          iprot.readListEnd()
25697 
        else:
25698 
          iprot.skip(ftype)
25699 
      else:
25700 
        iprot.skip(ftype)
25701 
      iprot.readFieldEnd()
25702 
    iprot.readStructEnd()
25703 
 
25704 
  def write(self, oprot):
25705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25707 
      return
25708 
    oprot.writeStructBegin('setOrderAttributes_args')
25709 
    if self.attributes is not None:
25710 
      oprot.writeFieldBegin('attributes', TType.LIST, -1)
25711 
      oprot.writeListBegin(TType.STRUCT, len(self.attributes))
6188 rajveer 25712 
      for iter634 in self.attributes:
25713 
        iter634.write(oprot)
5676 rajveer 25714 
      oprot.writeListEnd()
25715 
      oprot.writeFieldEnd()
25716 
    if self.orderId is not None:
25717 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
25718 
      oprot.writeI64(self.orderId)
25719 
      oprot.writeFieldEnd()
25720 
    oprot.writeFieldStop()
25721 
    oprot.writeStructEnd()
25722 
 
25723 
  def validate(self):
25724 
    return
25725 
 
25726 
 
25727 
  def __repr__(self):
25728 
    L = ['%s=%r' % (key, value)
25729 
      for key, value in self.__dict__.iteritems()]
25730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25731 
 
25732 
  def __eq__(self, other):
25733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25734 
 
25735 
  def __ne__(self, other):
25736 
    return not (self == other)
25737 
 
25738 
class setOrderAttributes_result:
25739 
 
25740 
  thrift_spec = (
25741 
  )
25742 
 
25743 
  def read(self, iprot):
25744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25746 
      return
25747 
    iprot.readStructBegin()
25748 
    while True:
25749 
      (fname, ftype, fid) = iprot.readFieldBegin()
25750 
      if ftype == TType.STOP:
25751 
        break
25752 
      else:
25753 
        iprot.skip(ftype)
25754 
      iprot.readFieldEnd()
25755 
    iprot.readStructEnd()
25756 
 
25757 
  def write(self, oprot):
25758 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25759 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25760 
      return
25761 
    oprot.writeStructBegin('setOrderAttributes_result')
25762 
    oprot.writeFieldStop()
25763 
    oprot.writeStructEnd()
25764 
 
25765 
  def validate(self):
25766 
    return
25767 
 
25768 
 
25769 
  def __repr__(self):
25770 
    L = ['%s=%r' % (key, value)
25771 
      for key, value in self.__dict__.iteritems()]
25772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25773 
 
25774 
  def __eq__(self, other):
25775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25776 
 
25777 
  def __ne__(self, other):
25778 
    return not (self == other)
25779 
 
5527 anupam.sin 25780 
class setOrderAttributeForTransaction_args:
25781 
  """
25782 
  Attributes:
25783 
   - transactionId
25784 
   - attribute
25785 
  """
25786 
 
25787 
  thrift_spec = None
25788 
  def __init__(self, transactionId=None, attribute=None,):
25789 
    self.transactionId = transactionId
25790 
    self.attribute = attribute
25791 
 
25792 
  def read(self, iprot):
25793 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25794 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25795 
      return
25796 
    iprot.readStructBegin()
25797 
    while True:
25798 
      (fname, ftype, fid) = iprot.readFieldBegin()
25799 
      if ftype == TType.STOP:
25800 
        break
25801 
      if fid == 1:
25802 
        if ftype == TType.I64:
25803 
          self.transactionId = iprot.readI64();
25804 
        else:
25805 
          iprot.skip(ftype)
25806 
      elif fid == -1:
25807 
        if ftype == TType.STRUCT:
25808 
          self.attribute = Attribute()
25809 
          self.attribute.read(iprot)
25810 
        else:
25811 
          iprot.skip(ftype)
25812 
      else:
25813 
        iprot.skip(ftype)
25814 
      iprot.readFieldEnd()
25815 
    iprot.readStructEnd()
25816 
 
25817 
  def write(self, oprot):
25818 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25819 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25820 
      return
25821 
    oprot.writeStructBegin('setOrderAttributeForTransaction_args')
25822 
    if self.attribute is not None:
25823 
      oprot.writeFieldBegin('attribute', TType.STRUCT, -1)
25824 
      self.attribute.write(oprot)
25825 
      oprot.writeFieldEnd()
25826 
    if self.transactionId is not None:
25827 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
25828 
      oprot.writeI64(self.transactionId)
25829 
      oprot.writeFieldEnd()
25830 
    oprot.writeFieldStop()
25831 
    oprot.writeStructEnd()
25832 
 
25833 
  def validate(self):
25834 
    return
25835 
 
25836 
 
25837 
  def __repr__(self):
25838 
    L = ['%s=%r' % (key, value)
25839 
      for key, value in self.__dict__.iteritems()]
25840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25841 
 
25842 
  def __eq__(self, other):
25843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25844 
 
25845 
  def __ne__(self, other):
25846 
    return not (self == other)
25847 
 
25848 
class setOrderAttributeForTransaction_result:
25849 
 
25850 
  thrift_spec = (
25851 
  )
25852 
 
25853 
  def read(self, iprot):
25854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25856 
      return
25857 
    iprot.readStructBegin()
25858 
    while True:
25859 
      (fname, ftype, fid) = iprot.readFieldBegin()
25860 
      if ftype == TType.STOP:
25861 
        break
25862 
      else:
25863 
        iprot.skip(ftype)
25864 
      iprot.readFieldEnd()
25865 
    iprot.readStructEnd()
25866 
 
25867 
  def write(self, oprot):
25868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25870 
      return
25871 
    oprot.writeStructBegin('setOrderAttributeForTransaction_result')
25872 
    oprot.writeFieldStop()
25873 
    oprot.writeStructEnd()
25874 
 
25875 
  def validate(self):
25876 
    return
25877 
 
25878 
 
25879 
  def __repr__(self):
25880 
    L = ['%s=%r' % (key, value)
25881 
      for key, value in self.__dict__.iteritems()]
25882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25883 
 
25884 
  def __eq__(self, other):
25885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25886 
 
25887 
  def __ne__(self, other):
25888 
    return not (self == other)
5553 rajveer 25889 
 
25890 
class getReceivePendingOrders_args:
25891 
  """
25892 
  Attributes:
25893 
   - storeId
25894 
  """
25895 
 
25896 
  thrift_spec = (
25897 
    None, # 0
25898 
    (1, TType.I64, 'storeId', None, None, ), # 1
25899 
  )
25900 
 
25901 
  def __init__(self, storeId=None,):
25902 
    self.storeId = storeId
25903 
 
25904 
  def read(self, iprot):
25905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25907 
      return
25908 
    iprot.readStructBegin()
25909 
    while True:
25910 
      (fname, ftype, fid) = iprot.readFieldBegin()
25911 
      if ftype == TType.STOP:
25912 
        break
25913 
      if fid == 1:
25914 
        if ftype == TType.I64:
25915 
          self.storeId = iprot.readI64();
25916 
        else:
25917 
          iprot.skip(ftype)
25918 
      else:
25919 
        iprot.skip(ftype)
25920 
      iprot.readFieldEnd()
25921 
    iprot.readStructEnd()
25922 
 
25923 
  def write(self, oprot):
25924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25926 
      return
25927 
    oprot.writeStructBegin('getReceivePendingOrders_args')
25928 
    if self.storeId is not None:
25929 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
25930 
      oprot.writeI64(self.storeId)
25931 
      oprot.writeFieldEnd()
25932 
    oprot.writeFieldStop()
25933 
    oprot.writeStructEnd()
25934 
 
25935 
  def validate(self):
25936 
    return
25937 
 
25938 
 
25939 
  def __repr__(self):
25940 
    L = ['%s=%r' % (key, value)
25941 
      for key, value in self.__dict__.iteritems()]
25942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
25943 
 
25944 
  def __eq__(self, other):
25945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
25946 
 
25947 
  def __ne__(self, other):
25948 
    return not (self == other)
25949 
 
25950 
class getReceivePendingOrders_result:
25951 
  """
25952 
  Attributes:
25953 
   - success
25954 
  """
25955 
 
25956 
  thrift_spec = (
25957 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
25958 
  )
25959 
 
25960 
  def __init__(self, success=None,):
25961 
    self.success = success
25962 
 
25963 
  def read(self, iprot):
25964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
25965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
25966 
      return
25967 
    iprot.readStructBegin()
25968 
    while True:
25969 
      (fname, ftype, fid) = iprot.readFieldBegin()
25970 
      if ftype == TType.STOP:
25971 
        break
25972 
      if fid == 0:
25973 
        if ftype == TType.LIST:
25974 
          self.success = []
6188 rajveer 25975 
          (_etype638, _size635) = iprot.readListBegin()
25976 
          for _i639 in xrange(_size635):
25977 
            _elem640 = Order()
25978 
            _elem640.read(iprot)
25979 
            self.success.append(_elem640)
5553 rajveer 25980 
          iprot.readListEnd()
25981 
        else:
25982 
          iprot.skip(ftype)
25983 
      else:
25984 
        iprot.skip(ftype)
25985 
      iprot.readFieldEnd()
25986 
    iprot.readStructEnd()
25987 
 
25988 
  def write(self, oprot):
25989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
25990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
25991 
      return
25992 
    oprot.writeStructBegin('getReceivePendingOrders_result')
25993 
    if self.success is not None:
25994 
      oprot.writeFieldBegin('success', TType.LIST, 0)
25995 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 25996 
      for iter641 in self.success:
25997 
        iter641.write(oprot)
5553 rajveer 25998 
      oprot.writeListEnd()
25999 
      oprot.writeFieldEnd()
26000 
    oprot.writeFieldStop()
26001 
    oprot.writeStructEnd()
26002 
 
26003 
  def validate(self):
26004 
    return
26005 
 
26006 
 
26007 
  def __repr__(self):
26008 
    L = ['%s=%r' % (key, value)
26009 
      for key, value in self.__dict__.iteritems()]
26010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26011 
 
26012 
  def __eq__(self, other):
26013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26014 
 
26015 
  def __ne__(self, other):
26016 
    return not (self == other)
26017 
 
26018 
class getReceivedAtStoreOrders_args:
26019 
  """
26020 
  Attributes:
26021 
   - storeId
26022 
  """
26023 
 
26024 
  thrift_spec = (
26025 
    None, # 0
26026 
    (1, TType.I64, 'storeId', None, None, ), # 1
26027 
  )
26028 
 
26029 
  def __init__(self, storeId=None,):
26030 
    self.storeId = storeId
26031 
 
26032 
  def read(self, iprot):
26033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26035 
      return
26036 
    iprot.readStructBegin()
26037 
    while True:
26038 
      (fname, ftype, fid) = iprot.readFieldBegin()
26039 
      if ftype == TType.STOP:
26040 
        break
26041 
      if fid == 1:
26042 
        if ftype == TType.I64:
26043 
          self.storeId = iprot.readI64();
26044 
        else:
26045 
          iprot.skip(ftype)
26046 
      else:
26047 
        iprot.skip(ftype)
26048 
      iprot.readFieldEnd()
26049 
    iprot.readStructEnd()
26050 
 
26051 
  def write(self, oprot):
26052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26054 
      return
26055 
    oprot.writeStructBegin('getReceivedAtStoreOrders_args')
26056 
    if self.storeId is not None:
26057 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26058 
      oprot.writeI64(self.storeId)
26059 
      oprot.writeFieldEnd()
26060 
    oprot.writeFieldStop()
26061 
    oprot.writeStructEnd()
26062 
 
26063 
  def validate(self):
26064 
    return
26065 
 
26066 
 
26067 
  def __repr__(self):
26068 
    L = ['%s=%r' % (key, value)
26069 
      for key, value in self.__dict__.iteritems()]
26070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26071 
 
26072 
  def __eq__(self, other):
26073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26074 
 
26075 
  def __ne__(self, other):
26076 
    return not (self == other)
26077 
 
26078 
class getReceivedAtStoreOrders_result:
26079 
  """
26080 
  Attributes:
26081 
   - success
26082 
  """
26083 
 
26084 
  thrift_spec = (
26085 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26086 
  )
26087 
 
26088 
  def __init__(self, success=None,):
26089 
    self.success = success
26090 
 
26091 
  def read(self, iprot):
26092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26094 
      return
26095 
    iprot.readStructBegin()
26096 
    while True:
26097 
      (fname, ftype, fid) = iprot.readFieldBegin()
26098 
      if ftype == TType.STOP:
26099 
        break
26100 
      if fid == 0:
26101 
        if ftype == TType.LIST:
26102 
          self.success = []
6188 rajveer 26103 
          (_etype645, _size642) = iprot.readListBegin()
26104 
          for _i646 in xrange(_size642):
26105 
            _elem647 = Order()
26106 
            _elem647.read(iprot)
26107 
            self.success.append(_elem647)
5553 rajveer 26108 
          iprot.readListEnd()
26109 
        else:
26110 
          iprot.skip(ftype)
26111 
      else:
26112 
        iprot.skip(ftype)
26113 
      iprot.readFieldEnd()
26114 
    iprot.readStructEnd()
26115 
 
26116 
  def write(self, oprot):
26117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26119 
      return
26120 
    oprot.writeStructBegin('getReceivedAtStoreOrders_result')
26121 
    if self.success is not None:
26122 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26123 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26124 
      for iter648 in self.success:
26125 
        iter648.write(oprot)
5553 rajveer 26126 
      oprot.writeListEnd()
26127 
      oprot.writeFieldEnd()
26128 
    oprot.writeFieldStop()
26129 
    oprot.writeStructEnd()
26130 
 
26131 
  def validate(self):
26132 
    return
26133 
 
26134 
 
26135 
  def __repr__(self):
26136 
    L = ['%s=%r' % (key, value)
26137 
      for key, value in self.__dict__.iteritems()]
26138 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26139 
 
26140 
  def __eq__(self, other):
26141 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26142 
 
26143 
  def __ne__(self, other):
26144 
    return not (self == other)
5593 mandeep.dh 26145 
 
5713 rajveer 26146 
class getOrdersCollectionAtStore_args:
26147 
  """
26148 
  Attributes:
26149 
   - storeId
26150 
   - fromDate
26151 
   - toDate
26152 
   - onlyCod
26153 
  """
26154 
 
26155 
  thrift_spec = (
26156 
    None, # 0
26157 
    (1, TType.I64, 'storeId', None, None, ), # 1
26158 
    (2, TType.I64, 'fromDate', None, None, ), # 2
26159 
    (3, TType.I64, 'toDate', None, None, ), # 3
26160 
    (4, TType.BOOL, 'onlyCod', None, None, ), # 4
26161 
  )
26162 
 
26163 
  def __init__(self, storeId=None, fromDate=None, toDate=None, onlyCod=None,):
26164 
    self.storeId = storeId
26165 
    self.fromDate = fromDate
26166 
    self.toDate = toDate
26167 
    self.onlyCod = onlyCod
26168 
 
26169 
  def read(self, iprot):
26170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26172 
      return
26173 
    iprot.readStructBegin()
26174 
    while True:
26175 
      (fname, ftype, fid) = iprot.readFieldBegin()
26176 
      if ftype == TType.STOP:
26177 
        break
26178 
      if fid == 1:
26179 
        if ftype == TType.I64:
26180 
          self.storeId = iprot.readI64();
26181 
        else:
26182 
          iprot.skip(ftype)
26183 
      elif fid == 2:
26184 
        if ftype == TType.I64:
26185 
          self.fromDate = iprot.readI64();
26186 
        else:
26187 
          iprot.skip(ftype)
26188 
      elif fid == 3:
26189 
        if ftype == TType.I64:
26190 
          self.toDate = iprot.readI64();
26191 
        else:
26192 
          iprot.skip(ftype)
26193 
      elif fid == 4:
26194 
        if ftype == TType.BOOL:
26195 
          self.onlyCod = iprot.readBool();
26196 
        else:
26197 
          iprot.skip(ftype)
26198 
      else:
26199 
        iprot.skip(ftype)
26200 
      iprot.readFieldEnd()
26201 
    iprot.readStructEnd()
26202 
 
26203 
  def write(self, oprot):
26204 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26205 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26206 
      return
26207 
    oprot.writeStructBegin('getOrdersCollectionAtStore_args')
26208 
    if self.storeId is not None:
26209 
      oprot.writeFieldBegin('storeId', TType.I64, 1)
26210 
      oprot.writeI64(self.storeId)
26211 
      oprot.writeFieldEnd()
26212 
    if self.fromDate is not None:
26213 
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
26214 
      oprot.writeI64(self.fromDate)
26215 
      oprot.writeFieldEnd()
26216 
    if self.toDate is not None:
26217 
      oprot.writeFieldBegin('toDate', TType.I64, 3)
26218 
      oprot.writeI64(self.toDate)
26219 
      oprot.writeFieldEnd()
26220 
    if self.onlyCod is not None:
26221 
      oprot.writeFieldBegin('onlyCod', TType.BOOL, 4)
26222 
      oprot.writeBool(self.onlyCod)
26223 
      oprot.writeFieldEnd()
26224 
    oprot.writeFieldStop()
26225 
    oprot.writeStructEnd()
26226 
 
26227 
  def validate(self):
26228 
    return
26229 
 
26230 
 
26231 
  def __repr__(self):
26232 
    L = ['%s=%r' % (key, value)
26233 
      for key, value in self.__dict__.iteritems()]
26234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26235 
 
26236 
  def __eq__(self, other):
26237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26238 
 
26239 
  def __ne__(self, other):
26240 
    return not (self == other)
26241 
 
26242 
class getOrdersCollectionAtStore_result:
26243 
  """
26244 
  Attributes:
26245 
   - success
26246 
  """
26247 
 
26248 
  thrift_spec = (
26249 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
26250 
  )
26251 
 
26252 
  def __init__(self, success=None,):
26253 
    self.success = success
26254 
 
26255 
  def read(self, iprot):
26256 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26257 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26258 
      return
26259 
    iprot.readStructBegin()
26260 
    while True:
26261 
      (fname, ftype, fid) = iprot.readFieldBegin()
26262 
      if ftype == TType.STOP:
26263 
        break
26264 
      if fid == 0:
26265 
        if ftype == TType.LIST:
26266 
          self.success = []
6188 rajveer 26267 
          (_etype652, _size649) = iprot.readListBegin()
26268 
          for _i653 in xrange(_size649):
26269 
            _elem654 = Order()
26270 
            _elem654.read(iprot)
26271 
            self.success.append(_elem654)
5713 rajveer 26272 
          iprot.readListEnd()
26273 
        else:
26274 
          iprot.skip(ftype)
26275 
      else:
26276 
        iprot.skip(ftype)
26277 
      iprot.readFieldEnd()
26278 
    iprot.readStructEnd()
26279 
 
26280 
  def write(self, oprot):
26281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26283 
      return
26284 
    oprot.writeStructBegin('getOrdersCollectionAtStore_result')
26285 
    if self.success is not None:
26286 
      oprot.writeFieldBegin('success', TType.LIST, 0)
26287 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 26288 
      for iter655 in self.success:
26289 
        iter655.write(oprot)
5713 rajveer 26290 
      oprot.writeListEnd()
26291 
      oprot.writeFieldEnd()
26292 
    oprot.writeFieldStop()
26293 
    oprot.writeStructEnd()
26294 
 
26295 
  def validate(self):
26296 
    return
26297 
 
26298 
 
26299 
  def __repr__(self):
26300 
    L = ['%s=%r' % (key, value)
26301 
      for key, value in self.__dict__.iteritems()]
26302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26303 
 
26304 
  def __eq__(self, other):
26305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26306 
 
26307 
  def __ne__(self, other):
26308 
    return not (self == other)
26309 
 
5833 rajveer 26310 
class getOrderAttributeValue_args:
26311 
  """
26312 
  Attributes:
26313 
   - orderId
26314 
   - attributeName
26315 
  """
26316 
 
26317 
  thrift_spec = None
26318 
  def __init__(self, orderId=None, attributeName=None,):
26319 
    self.orderId = orderId
26320 
    self.attributeName = attributeName
26321 
 
26322 
  def read(self, iprot):
26323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26325 
      return
26326 
    iprot.readStructBegin()
26327 
    while True:
26328 
      (fname, ftype, fid) = iprot.readFieldBegin()
26329 
      if ftype == TType.STOP:
26330 
        break
26331 
      if fid == 1:
26332 
        if ftype == TType.I64:
26333 
          self.orderId = iprot.readI64();
26334 
        else:
26335 
          iprot.skip(ftype)
26336 
      elif fid == -1:
26337 
        if ftype == TType.STRING:
26338 
          self.attributeName = iprot.readString();
26339 
        else:
26340 
          iprot.skip(ftype)
26341 
      else:
26342 
        iprot.skip(ftype)
26343 
      iprot.readFieldEnd()
26344 
    iprot.readStructEnd()
26345 
 
26346 
  def write(self, oprot):
26347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26349 
      return
26350 
    oprot.writeStructBegin('getOrderAttributeValue_args')
26351 
    if self.attributeName is not None:
26352 
      oprot.writeFieldBegin('attributeName', TType.STRING, -1)
26353 
      oprot.writeString(self.attributeName)
26354 
      oprot.writeFieldEnd()
26355 
    if self.orderId is not None:
26356 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26357 
      oprot.writeI64(self.orderId)
26358 
      oprot.writeFieldEnd()
26359 
    oprot.writeFieldStop()
26360 
    oprot.writeStructEnd()
26361 
 
26362 
  def validate(self):
26363 
    return
26364 
 
26365 
 
26366 
  def __repr__(self):
26367 
    L = ['%s=%r' % (key, value)
26368 
      for key, value in self.__dict__.iteritems()]
26369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26370 
 
26371 
  def __eq__(self, other):
26372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26373 
 
26374 
  def __ne__(self, other):
26375 
    return not (self == other)
26376 
 
26377 
class getOrderAttributeValue_result:
26378 
  """
26379 
  Attributes:
26380 
   - success
26381 
  """
26382 
 
26383 
  thrift_spec = (
26384 
    (0, TType.STRING, 'success', None, None, ), # 0
26385 
  )
26386 
 
26387 
  def __init__(self, success=None,):
26388 
    self.success = success
26389 
 
26390 
  def read(self, iprot):
26391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26393 
      return
26394 
    iprot.readStructBegin()
26395 
    while True:
26396 
      (fname, ftype, fid) = iprot.readFieldBegin()
26397 
      if ftype == TType.STOP:
26398 
        break
26399 
      if fid == 0:
26400 
        if ftype == TType.STRING:
26401 
          self.success = iprot.readString();
26402 
        else:
26403 
          iprot.skip(ftype)
26404 
      else:
26405 
        iprot.skip(ftype)
26406 
      iprot.readFieldEnd()
26407 
    iprot.readStructEnd()
26408 
 
26409 
  def write(self, oprot):
26410 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26411 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26412 
      return
26413 
    oprot.writeStructBegin('getOrderAttributeValue_result')
26414 
    if self.success is not None:
26415 
      oprot.writeFieldBegin('success', TType.STRING, 0)
26416 
      oprot.writeString(self.success)
26417 
      oprot.writeFieldEnd()
26418 
    oprot.writeFieldStop()
26419 
    oprot.writeStructEnd()
26420 
 
26421 
  def validate(self):
26422 
    return
26423 
 
26424 
 
26425 
  def __repr__(self):
26426 
    L = ['%s=%r' % (key, value)
26427 
      for key, value in self.__dict__.iteritems()]
26428 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26429 
 
26430 
  def __eq__(self, other):
26431 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26432 
 
26433 
  def __ne__(self, other):
26434 
    return not (self == other)
26435 
 
6019 rajveer 26436 
class changeJacketNumber_args:
26437 
  """
26438 
  Attributes:
26439 
   - orderId
26440 
   - jacketNumber
26441 
  """
26442 
 
26443 
  thrift_spec = (
26444 
    None, # 0
26445 
    (1, TType.I64, 'orderId', None, None, ), # 1
26446 
    (2, TType.I64, 'jacketNumber', None, None, ), # 2
26447 
  )
26448 
 
26449 
  def __init__(self, orderId=None, jacketNumber=None,):
26450 
    self.orderId = orderId
26451 
    self.jacketNumber = jacketNumber
26452 
 
26453 
  def read(self, iprot):
26454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26456 
      return
26457 
    iprot.readStructBegin()
26458 
    while True:
26459 
      (fname, ftype, fid) = iprot.readFieldBegin()
26460 
      if ftype == TType.STOP:
26461 
        break
26462 
      if fid == 1:
26463 
        if ftype == TType.I64:
26464 
          self.orderId = iprot.readI64();
26465 
        else:
26466 
          iprot.skip(ftype)
26467 
      elif fid == 2:
26468 
        if ftype == TType.I64:
26469 
          self.jacketNumber = iprot.readI64();
26470 
        else:
26471 
          iprot.skip(ftype)
26472 
      else:
26473 
        iprot.skip(ftype)
26474 
      iprot.readFieldEnd()
26475 
    iprot.readStructEnd()
26476 
 
26477 
  def write(self, oprot):
26478 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26479 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26480 
      return
26481 
    oprot.writeStructBegin('changeJacketNumber_args')
26482 
    if self.orderId is not None:
26483 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26484 
      oprot.writeI64(self.orderId)
26485 
      oprot.writeFieldEnd()
26486 
    if self.jacketNumber is not None:
26487 
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
26488 
      oprot.writeI64(self.jacketNumber)
26489 
      oprot.writeFieldEnd()
26490 
    oprot.writeFieldStop()
26491 
    oprot.writeStructEnd()
26492 
 
26493 
  def validate(self):
26494 
    return
26495 
 
26496 
 
26497 
  def __repr__(self):
26498 
    L = ['%s=%r' % (key, value)
26499 
      for key, value in self.__dict__.iteritems()]
26500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26501 
 
26502 
  def __eq__(self, other):
26503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26504 
 
26505 
  def __ne__(self, other):
26506 
    return not (self == other)
26507 
 
26508 
class changeJacketNumber_result:
26509 
  """
26510 
  Attributes:
26511 
   - success
26512 
  """
26513 
 
26514 
  thrift_spec = (
26515 
    (0, TType.BOOL, 'success', None, None, ), # 0
26516 
  )
26517 
 
26518 
  def __init__(self, success=None,):
26519 
    self.success = success
26520 
 
26521 
  def read(self, iprot):
26522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26524 
      return
26525 
    iprot.readStructBegin()
26526 
    while True:
26527 
      (fname, ftype, fid) = iprot.readFieldBegin()
26528 
      if ftype == TType.STOP:
26529 
        break
26530 
      if fid == 0:
26531 
        if ftype == TType.BOOL:
26532 
          self.success = iprot.readBool();
26533 
        else:
26534 
          iprot.skip(ftype)
26535 
      else:
26536 
        iprot.skip(ftype)
26537 
      iprot.readFieldEnd()
26538 
    iprot.readStructEnd()
26539 
 
26540 
  def write(self, oprot):
26541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26543 
      return
26544 
    oprot.writeStructBegin('changeJacketNumber_result')
26545 
    if self.success is not None:
26546 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26547 
      oprot.writeBool(self.success)
26548 
      oprot.writeFieldEnd()
26549 
    oprot.writeFieldStop()
26550 
    oprot.writeStructEnd()
26551 
 
26552 
  def validate(self):
26553 
    return
26554 
 
26555 
 
26556 
  def __repr__(self):
26557 
    L = ['%s=%r' % (key, value)
26558 
      for key, value in self.__dict__.iteritems()]
26559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26560 
 
26561 
  def __eq__(self, other):
26562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26563 
 
26564 
  def __ne__(self, other):
26565 
    return not (self == other)
26566 
 
26567 
class markOrderAsRtoInTransit_args:
26568 
  """
26569 
  Attributes:
26570 
   - orderId
26571 
  """
26572 
 
26573 
  thrift_spec = (
26574 
    None, # 0
26575 
    (1, TType.I64, 'orderId', None, None, ), # 1
26576 
  )
26577 
 
26578 
  def __init__(self, orderId=None,):
26579 
    self.orderId = orderId
26580 
 
26581 
  def read(self, iprot):
26582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26584 
      return
26585 
    iprot.readStructBegin()
26586 
    while True:
26587 
      (fname, ftype, fid) = iprot.readFieldBegin()
26588 
      if ftype == TType.STOP:
26589 
        break
26590 
      if fid == 1:
26591 
        if ftype == TType.I64:
26592 
          self.orderId = iprot.readI64();
26593 
        else:
26594 
          iprot.skip(ftype)
26595 
      else:
26596 
        iprot.skip(ftype)
26597 
      iprot.readFieldEnd()
26598 
    iprot.readStructEnd()
26599 
 
26600 
  def write(self, oprot):
26601 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26602 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26603 
      return
26604 
    oprot.writeStructBegin('markOrderAsRtoInTransit_args')
26605 
    if self.orderId is not None:
26606 
      oprot.writeFieldBegin('orderId', TType.I64, 1)
26607 
      oprot.writeI64(self.orderId)
26608 
      oprot.writeFieldEnd()
26609 
    oprot.writeFieldStop()
26610 
    oprot.writeStructEnd()
26611 
 
26612 
  def validate(self):
26613 
    return
26614 
 
26615 
 
26616 
  def __repr__(self):
26617 
    L = ['%s=%r' % (key, value)
26618 
      for key, value in self.__dict__.iteritems()]
26619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26620 
 
26621 
  def __eq__(self, other):
26622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26623 
 
26624 
  def __ne__(self, other):
26625 
    return not (self == other)
26626 
 
26627 
class markOrderAsRtoInTransit_result:
26628 
  """
26629 
  Attributes:
26630 
   - success
26631 
  """
26632 
 
26633 
  thrift_spec = (
26634 
    (0, TType.BOOL, 'success', None, None, ), # 0
26635 
  )
26636 
 
26637 
  def __init__(self, success=None,):
26638 
    self.success = success
26639 
 
26640 
  def read(self, iprot):
26641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26643 
      return
26644 
    iprot.readStructBegin()
26645 
    while True:
26646 
      (fname, ftype, fid) = iprot.readFieldBegin()
26647 
      if ftype == TType.STOP:
26648 
        break
26649 
      if fid == 0:
26650 
        if ftype == TType.BOOL:
26651 
          self.success = iprot.readBool();
26652 
        else:
26653 
          iprot.skip(ftype)
26654 
      else:
26655 
        iprot.skip(ftype)
26656 
      iprot.readFieldEnd()
26657 
    iprot.readStructEnd()
26658 
 
26659 
  def write(self, oprot):
26660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26662 
      return
26663 
    oprot.writeStructBegin('markOrderAsRtoInTransit_result')
26664 
    if self.success is not None:
26665 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
26666 
      oprot.writeBool(self.success)
26667 
      oprot.writeFieldEnd()
26668 
    oprot.writeFieldStop()
26669 
    oprot.writeStructEnd()
26670 
 
26671 
  def validate(self):
26672 
    return
26673 
 
26674 
 
26675 
  def __repr__(self):
26676 
    L = ['%s=%r' % (key, value)
26677 
      for key, value in self.__dict__.iteritems()]
26678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26679 
 
26680 
  def __eq__(self, other):
26681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26682 
 
26683 
  def __ne__(self, other):
26684 
    return not (self == other)
26685 
 
5593 mandeep.dh 26686 
class acceptOrderForItem_args:
26687 
  """
26688 
  Attributes:
26689 
   - itemId
26690 
   - quantity
26691 
   - fulfilmentWarehouseId
26692 
   - billingWarehouseId
26693 
  """
26694 
 
26695 
  thrift_spec = (
26696 
    None, # 0
26697 
    (1, TType.I64, 'itemId', None, None, ), # 1
26698 
    (2, TType.I64, 'quantity', None, None, ), # 2
26699 
    (3, TType.I64, 'fulfilmentWarehouseId', None, None, ), # 3
26700 
    (4, TType.I64, 'billingWarehouseId', None, None, ), # 4
26701 
  )
26702 
 
26703 
  def __init__(self, itemId=None, quantity=None, fulfilmentWarehouseId=None, billingWarehouseId=None,):
26704 
    self.itemId = itemId
26705 
    self.quantity = quantity
26706 
    self.fulfilmentWarehouseId = fulfilmentWarehouseId
26707 
    self.billingWarehouseId = billingWarehouseId
26708 
 
26709 
  def read(self, iprot):
26710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26712 
      return
26713 
    iprot.readStructBegin()
26714 
    while True:
26715 
      (fname, ftype, fid) = iprot.readFieldBegin()
26716 
      if ftype == TType.STOP:
26717 
        break
26718 
      if fid == 1:
26719 
        if ftype == TType.I64:
26720 
          self.itemId = iprot.readI64();
26721 
        else:
26722 
          iprot.skip(ftype)
26723 
      elif fid == 2:
26724 
        if ftype == TType.I64:
26725 
          self.quantity = iprot.readI64();
26726 
        else:
26727 
          iprot.skip(ftype)
26728 
      elif fid == 3:
26729 
        if ftype == TType.I64:
26730 
          self.fulfilmentWarehouseId = iprot.readI64();
26731 
        else:
26732 
          iprot.skip(ftype)
26733 
      elif fid == 4:
26734 
        if ftype == TType.I64:
26735 
          self.billingWarehouseId = iprot.readI64();
26736 
        else:
26737 
          iprot.skip(ftype)
26738 
      else:
26739 
        iprot.skip(ftype)
26740 
      iprot.readFieldEnd()
26741 
    iprot.readStructEnd()
26742 
 
26743 
  def write(self, oprot):
26744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26746 
      return
26747 
    oprot.writeStructBegin('acceptOrderForItem_args')
26748 
    if self.itemId is not None:
26749 
      oprot.writeFieldBegin('itemId', TType.I64, 1)
26750 
      oprot.writeI64(self.itemId)
26751 
      oprot.writeFieldEnd()
26752 
    if self.quantity is not None:
26753 
      oprot.writeFieldBegin('quantity', TType.I64, 2)
26754 
      oprot.writeI64(self.quantity)
26755 
      oprot.writeFieldEnd()
26756 
    if self.fulfilmentWarehouseId is not None:
26757 
      oprot.writeFieldBegin('fulfilmentWarehouseId', TType.I64, 3)
26758 
      oprot.writeI64(self.fulfilmentWarehouseId)
26759 
      oprot.writeFieldEnd()
26760 
    if self.billingWarehouseId is not None:
26761 
      oprot.writeFieldBegin('billingWarehouseId', TType.I64, 4)
26762 
      oprot.writeI64(self.billingWarehouseId)
26763 
      oprot.writeFieldEnd()
26764 
    oprot.writeFieldStop()
26765 
    oprot.writeStructEnd()
26766 
 
26767 
  def validate(self):
26768 
    return
26769 
 
26770 
 
26771 
  def __repr__(self):
26772 
    L = ['%s=%r' % (key, value)
26773 
      for key, value in self.__dict__.iteritems()]
26774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26775 
 
26776 
  def __eq__(self, other):
26777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26778 
 
26779 
  def __ne__(self, other):
26780 
    return not (self == other)
26781 
 
26782 
class acceptOrderForItem_result:
26783 
 
26784 
  thrift_spec = (
26785 
  )
26786 
 
26787 
  def read(self, iprot):
26788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26790 
      return
26791 
    iprot.readStructBegin()
26792 
    while True:
26793 
      (fname, ftype, fid) = iprot.readFieldBegin()
26794 
      if ftype == TType.STOP:
26795 
        break
26796 
      else:
26797 
        iprot.skip(ftype)
26798 
      iprot.readFieldEnd()
26799 
    iprot.readStructEnd()
26800 
 
26801 
  def write(self, oprot):
26802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26804 
      return
26805 
    oprot.writeStructBegin('acceptOrderForItem_result')
26806 
    oprot.writeFieldStop()
26807 
    oprot.writeStructEnd()
26808 
 
26809 
  def validate(self):
26810 
    return
26811 
 
26812 
 
26813 
  def __repr__(self):
26814 
    L = ['%s=%r' % (key, value)
26815 
      for key, value in self.__dict__.iteritems()]
26816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26817 
 
26818 
  def __eq__(self, other):
26819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26820 
 
26821 
  def __ne__(self, other):
26822 
    return not (self == other)
6000 mandeep.dh 26823 
 
26824 
class createRechargeOrder_args:
26825 
  """
26826 
  Attributes:
26827 
   - rechargeOrder
26828 
  """
26829 
 
26830 
  thrift_spec = (
26831 
    None, # 0
26832 
    (1, TType.STRUCT, 'rechargeOrder', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 1
26833 
  )
26834 
 
26835 
  def __init__(self, rechargeOrder=None,):
26836 
    self.rechargeOrder = rechargeOrder
26837 
 
26838 
  def read(self, iprot):
26839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26841 
      return
26842 
    iprot.readStructBegin()
26843 
    while True:
26844 
      (fname, ftype, fid) = iprot.readFieldBegin()
26845 
      if ftype == TType.STOP:
26846 
        break
26847 
      if fid == 1:
26848 
        if ftype == TType.STRUCT:
26849 
          self.rechargeOrder = RechargeOrder()
26850 
          self.rechargeOrder.read(iprot)
26851 
        else:
26852 
          iprot.skip(ftype)
26853 
      else:
26854 
        iprot.skip(ftype)
26855 
      iprot.readFieldEnd()
26856 
    iprot.readStructEnd()
26857 
 
26858 
  def write(self, oprot):
26859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26861 
      return
26862 
    oprot.writeStructBegin('createRechargeOrder_args')
26863 
    if self.rechargeOrder is not None:
26864 
      oprot.writeFieldBegin('rechargeOrder', TType.STRUCT, 1)
26865 
      self.rechargeOrder.write(oprot)
26866 
      oprot.writeFieldEnd()
26867 
    oprot.writeFieldStop()
26868 
    oprot.writeStructEnd()
26869 
 
26870 
  def validate(self):
26871 
    return
26872 
 
26873 
 
26874 
  def __repr__(self):
26875 
    L = ['%s=%r' % (key, value)
26876 
      for key, value in self.__dict__.iteritems()]
26877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26878 
 
26879 
  def __eq__(self, other):
26880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26881 
 
26882 
  def __ne__(self, other):
26883 
    return not (self == other)
26884 
 
26885 
class createRechargeOrder_result:
26886 
  """
26887 
  Attributes:
26888 
   - success
26889 
   - ex
26890 
  """
26891 
 
26892 
  thrift_spec = (
26893 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
26894 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
26895 
  )
26896 
 
26897 
  def __init__(self, success=None, ex=None,):
26898 
    self.success = success
26899 
    self.ex = ex
26900 
 
26901 
  def read(self, iprot):
26902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26904 
      return
26905 
    iprot.readStructBegin()
26906 
    while True:
26907 
      (fname, ftype, fid) = iprot.readFieldBegin()
26908 
      if ftype == TType.STOP:
26909 
        break
26910 
      if fid == 0:
26911 
        if ftype == TType.STRUCT:
26912 
          self.success = RechargeOrder()
26913 
          self.success.read(iprot)
26914 
        else:
26915 
          iprot.skip(ftype)
26916 
      elif fid == 1:
26917 
        if ftype == TType.STRUCT:
26918 
          self.ex = TransactionServiceException()
26919 
          self.ex.read(iprot)
26920 
        else:
26921 
          iprot.skip(ftype)
26922 
      else:
26923 
        iprot.skip(ftype)
26924 
      iprot.readFieldEnd()
26925 
    iprot.readStructEnd()
26926 
 
26927 
  def write(self, oprot):
26928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
26929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
26930 
      return
26931 
    oprot.writeStructBegin('createRechargeOrder_result')
26932 
    if self.success is not None:
26933 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
26934 
      self.success.write(oprot)
26935 
      oprot.writeFieldEnd()
26936 
    if self.ex is not None:
26937 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
26938 
      self.ex.write(oprot)
26939 
      oprot.writeFieldEnd()
26940 
    oprot.writeFieldStop()
26941 
    oprot.writeStructEnd()
26942 
 
26943 
  def validate(self):
26944 
    return
26945 
 
26946 
 
26947 
  def __repr__(self):
26948 
    L = ['%s=%r' % (key, value)
26949 
      for key, value in self.__dict__.iteritems()]
26950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
26951 
 
26952 
  def __eq__(self, other):
26953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
26954 
 
26955 
  def __ne__(self, other):
26956 
    return not (self == other)
26957 
 
6031 rajveer 26958 
class getRechargeOrder_args:
26959 
  """
26960 
  Attributes:
26961 
   - rechargeRrderId
26962 
  """
26963 
 
26964 
  thrift_spec = (
26965 
    None, # 0
26966 
    (1, TType.I64, 'rechargeRrderId', None, None, ), # 1
26967 
  )
26968 
 
26969 
  def __init__(self, rechargeRrderId=None,):
26970 
    self.rechargeRrderId = rechargeRrderId
26971 
 
26972 
  def read(self, iprot):
26973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
26974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
26975 
      return
26976 
    iprot.readStructBegin()
26977 
    while True:
26978 
      (fname, ftype, fid) = iprot.readFieldBegin()
26979 
      if ftype == TType.STOP:
26980 
        break
26981 
      if fid == 1:
26982 
        if ftype == TType.I64:
26983 
          self.rechargeRrderId = iprot.readI64();
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('getRechargeOrder_args')
26996 
    if self.rechargeRrderId is not None:
26997 
      oprot.writeFieldBegin('rechargeRrderId', TType.I64, 1)
26998 
      oprot.writeI64(self.rechargeRrderId)
26999 
      oprot.writeFieldEnd()
27000 
    oprot.writeFieldStop()
27001 
    oprot.writeStructEnd()
27002 
 
27003 
  def validate(self):
27004 
    return
27005 
 
27006 
 
27007 
  def __repr__(self):
27008 
    L = ['%s=%r' % (key, value)
27009 
      for key, value in self.__dict__.iteritems()]
27010 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27011 
 
27012 
  def __eq__(self, other):
27013 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27014 
 
27015 
  def __ne__(self, other):
27016 
    return not (self == other)
27017 
 
27018 
class getRechargeOrder_result:
27019 
  """
27020 
  Attributes:
27021 
   - success
27022 
   - ex
27023 
  """
27024 
 
27025 
  thrift_spec = (
27026 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27027 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27028 
  )
27029 
 
27030 
  def __init__(self, success=None, ex=None,):
27031 
    self.success = success
27032 
    self.ex = ex
27033 
 
27034 
  def read(self, iprot):
27035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27037 
      return
27038 
    iprot.readStructBegin()
27039 
    while True:
27040 
      (fname, ftype, fid) = iprot.readFieldBegin()
27041 
      if ftype == TType.STOP:
27042 
        break
27043 
      if fid == 0:
27044 
        if ftype == TType.STRUCT:
27045 
          self.success = RechargeOrder()
27046 
          self.success.read(iprot)
27047 
        else:
27048 
          iprot.skip(ftype)
27049 
      elif fid == 1:
27050 
        if ftype == TType.STRUCT:
27051 
          self.ex = TransactionServiceException()
27052 
          self.ex.read(iprot)
27053 
        else:
27054 
          iprot.skip(ftype)
27055 
      else:
27056 
        iprot.skip(ftype)
27057 
      iprot.readFieldEnd()
27058 
    iprot.readStructEnd()
27059 
 
27060 
  def write(self, oprot):
27061 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27062 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27063 
      return
27064 
    oprot.writeStructBegin('getRechargeOrder_result')
27065 
    if self.success is not None:
27066 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27067 
      self.success.write(oprot)
27068 
      oprot.writeFieldEnd()
27069 
    if self.ex is not None:
27070 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27071 
      self.ex.write(oprot)
27072 
      oprot.writeFieldEnd()
27073 
    oprot.writeFieldStop()
27074 
    oprot.writeStructEnd()
27075 
 
27076 
  def validate(self):
27077 
    return
27078 
 
27079 
 
27080 
  def __repr__(self):
27081 
    L = ['%s=%r' % (key, value)
27082 
      for key, value in self.__dict__.iteritems()]
27083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27084 
 
27085 
  def __eq__(self, other):
27086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27087 
 
27088 
  def __ne__(self, other):
27089 
    return not (self == other)
27090 
 
27091 
class getRechargeOrders_args:
27092 
  """
27093 
  Attributes:
27094 
   - userId
27095 
  """
27096 
 
27097 
  thrift_spec = (
27098 
    None, # 0
27099 
    (1, TType.I64, 'userId', None, None, ), # 1
27100 
  )
27101 
 
27102 
  def __init__(self, userId=None,):
27103 
    self.userId = userId
27104 
 
27105 
  def read(self, iprot):
27106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27108 
      return
27109 
    iprot.readStructBegin()
27110 
    while True:
27111 
      (fname, ftype, fid) = iprot.readFieldBegin()
27112 
      if ftype == TType.STOP:
27113 
        break
27114 
      if fid == 1:
27115 
        if ftype == TType.I64:
27116 
          self.userId = iprot.readI64();
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('getRechargeOrders_args')
27129 
    if self.userId is not None:
27130 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27131 
      oprot.writeI64(self.userId)
27132 
      oprot.writeFieldEnd()
27133 
    oprot.writeFieldStop()
27134 
    oprot.writeStructEnd()
27135 
 
27136 
  def validate(self):
27137 
    return
27138 
 
27139 
 
27140 
  def __repr__(self):
27141 
    L = ['%s=%r' % (key, value)
27142 
      for key, value in self.__dict__.iteritems()]
27143 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27144 
 
27145 
  def __eq__(self, other):
27146 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27147 
 
27148 
  def __ne__(self, other):
27149 
    return not (self == other)
27150 
 
27151 
class getRechargeOrders_result:
27152 
  """
27153 
  Attributes:
27154 
   - success
27155 
  """
27156 
 
27157 
  thrift_spec = (
27158 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
27159 
  )
27160 
 
27161 
  def __init__(self, success=None,):
27162 
    self.success = success
27163 
 
27164 
  def read(self, iprot):
27165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27167 
      return
27168 
    iprot.readStructBegin()
27169 
    while True:
27170 
      (fname, ftype, fid) = iprot.readFieldBegin()
27171 
      if ftype == TType.STOP:
27172 
        break
27173 
      if fid == 0:
27174 
        if ftype == TType.LIST:
27175 
          self.success = []
6188 rajveer 27176 
          (_etype659, _size656) = iprot.readListBegin()
27177 
          for _i660 in xrange(_size656):
27178 
            _elem661 = RechargeOrder()
27179 
            _elem661.read(iprot)
27180 
            self.success.append(_elem661)
6031 rajveer 27181 
          iprot.readListEnd()
27182 
        else:
27183 
          iprot.skip(ftype)
27184 
      else:
27185 
        iprot.skip(ftype)
27186 
      iprot.readFieldEnd()
27187 
    iprot.readStructEnd()
27188 
 
27189 
  def write(self, oprot):
27190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27192 
      return
27193 
    oprot.writeStructBegin('getRechargeOrders_result')
27194 
    if self.success is not None:
27195 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27196 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27197 
      for iter662 in self.success:
27198 
        iter662.write(oprot)
6031 rajveer 27199 
      oprot.writeListEnd()
27200 
      oprot.writeFieldEnd()
27201 
    oprot.writeFieldStop()
27202 
    oprot.writeStructEnd()
27203 
 
27204 
  def validate(self):
27205 
    return
27206 
 
27207 
 
27208 
  def __repr__(self):
27209 
    L = ['%s=%r' % (key, value)
27210 
      for key, value in self.__dict__.iteritems()]
27211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27212 
 
27213 
  def __eq__(self, other):
27214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27215 
 
27216 
  def __ne__(self, other):
27217 
    return not (self == other)
27218 
 
6000 mandeep.dh 27219 
class updateRechargeOrderStatus_args:
27220 
  """
27221 
  Attributes:
27222 
   - rechargeOrderId
27223 
   - rechargeOrderStatus
27224 
  """
27225 
 
27226 
  thrift_spec = (
27227 
    None, # 0
27228 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
27229 
    (2, TType.I32, 'rechargeOrderStatus', None, None, ), # 2
27230 
  )
27231 
 
27232 
  def __init__(self, rechargeOrderId=None, rechargeOrderStatus=None,):
27233 
    self.rechargeOrderId = rechargeOrderId
27234 
    self.rechargeOrderStatus = rechargeOrderStatus
27235 
 
27236 
  def read(self, iprot):
27237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27239 
      return
27240 
    iprot.readStructBegin()
27241 
    while True:
27242 
      (fname, ftype, fid) = iprot.readFieldBegin()
27243 
      if ftype == TType.STOP:
27244 
        break
27245 
      if fid == 1:
27246 
        if ftype == TType.I64:
27247 
          self.rechargeOrderId = iprot.readI64();
27248 
        else:
27249 
          iprot.skip(ftype)
27250 
      elif fid == 2:
27251 
        if ftype == TType.I32:
27252 
          self.rechargeOrderStatus = iprot.readI32();
27253 
        else:
27254 
          iprot.skip(ftype)
27255 
      else:
27256 
        iprot.skip(ftype)
27257 
      iprot.readFieldEnd()
27258 
    iprot.readStructEnd()
27259 
 
27260 
  def write(self, oprot):
27261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27263 
      return
27264 
    oprot.writeStructBegin('updateRechargeOrderStatus_args')
27265 
    if self.rechargeOrderId is not None:
27266 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27267 
      oprot.writeI64(self.rechargeOrderId)
27268 
      oprot.writeFieldEnd()
27269 
    if self.rechargeOrderStatus is not None:
27270 
      oprot.writeFieldBegin('rechargeOrderStatus', TType.I32, 2)
27271 
      oprot.writeI32(self.rechargeOrderStatus)
27272 
      oprot.writeFieldEnd()
27273 
    oprot.writeFieldStop()
27274 
    oprot.writeStructEnd()
27275 
 
27276 
  def validate(self):
27277 
    return
27278 
 
27279 
 
27280 
  def __repr__(self):
27281 
    L = ['%s=%r' % (key, value)
27282 
      for key, value in self.__dict__.iteritems()]
27283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27284 
 
27285 
  def __eq__(self, other):
27286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27287 
 
27288 
  def __ne__(self, other):
27289 
    return not (self == other)
27290 
 
27291 
class updateRechargeOrderStatus_result:
27292 
  """
27293 
  Attributes:
6031 rajveer 27294 
   - success
6000 mandeep.dh 27295 
   - ex
27296 
  """
27297 
 
27298 
  thrift_spec = (
6031 rajveer 27299 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27300 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27301 
  )
27302 
 
6031 rajveer 27303 
  def __init__(self, success=None, ex=None,):
27304 
    self.success = success
6000 mandeep.dh 27305 
    self.ex = ex
27306 
 
27307 
  def read(self, iprot):
27308 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27309 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27310 
      return
27311 
    iprot.readStructBegin()
27312 
    while True:
27313 
      (fname, ftype, fid) = iprot.readFieldBegin()
27314 
      if ftype == TType.STOP:
27315 
        break
6031 rajveer 27316 
      if fid == 0:
27317 
        if ftype == TType.BOOL:
27318 
          self.success = iprot.readBool();
27319 
        else:
27320 
          iprot.skip(ftype)
27321 
      elif fid == 1:
6000 mandeep.dh 27322 
        if ftype == TType.STRUCT:
27323 
          self.ex = TransactionServiceException()
27324 
          self.ex.read(iprot)
27325 
        else:
27326 
          iprot.skip(ftype)
27327 
      else:
27328 
        iprot.skip(ftype)
27329 
      iprot.readFieldEnd()
27330 
    iprot.readStructEnd()
27331 
 
27332 
  def write(self, oprot):
27333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27335 
      return
27336 
    oprot.writeStructBegin('updateRechargeOrderStatus_result')
6031 rajveer 27337 
    if self.success is not None:
27338 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27339 
      oprot.writeBool(self.success)
27340 
      oprot.writeFieldEnd()
6000 mandeep.dh 27341 
    if self.ex is not None:
27342 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27343 
      self.ex.write(oprot)
27344 
      oprot.writeFieldEnd()
27345 
    oprot.writeFieldStop()
27346 
    oprot.writeStructEnd()
27347 
 
27348 
  def validate(self):
27349 
    return
27350 
 
27351 
 
27352 
  def __repr__(self):
27353 
    L = ['%s=%r' % (key, value)
27354 
      for key, value in self.__dict__.iteritems()]
27355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27356 
 
27357 
  def __eq__(self, other):
27358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27359 
 
27360 
  def __ne__(self, other):
27361 
    return not (self == other)
27362 
 
27363 
class activateRechargeTxn_args:
27364 
  """
27365 
  Attributes:
6031 rajveer 27366 
   - rechargeOrderId
6000 mandeep.dh 27367 
  """
27368 
 
27369 
  thrift_spec = (
27370 
    None, # 0
6031 rajveer 27371 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
6000 mandeep.dh 27372 
  )
27373 
 
6031 rajveer 27374 
  def __init__(self, rechargeOrderId=None,):
27375 
    self.rechargeOrderId = rechargeOrderId
6000 mandeep.dh 27376 
 
27377 
  def read(self, iprot):
27378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27380 
      return
27381 
    iprot.readStructBegin()
27382 
    while True:
27383 
      (fname, ftype, fid) = iprot.readFieldBegin()
27384 
      if ftype == TType.STOP:
27385 
        break
27386 
      if fid == 1:
6031 rajveer 27387 
        if ftype == TType.I64:
27388 
          self.rechargeOrderId = iprot.readI64();
6000 mandeep.dh 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('activateRechargeTxn_args')
6031 rajveer 27401 
    if self.rechargeOrderId is not None:
27402 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
27403 
      oprot.writeI64(self.rechargeOrderId)
6000 mandeep.dh 27404 
      oprot.writeFieldEnd()
27405 
    oprot.writeFieldStop()
27406 
    oprot.writeStructEnd()
27407 
 
27408 
  def validate(self):
27409 
    return
27410 
 
27411 
 
27412 
  def __repr__(self):
27413 
    L = ['%s=%r' % (key, value)
27414 
      for key, value in self.__dict__.iteritems()]
27415 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27416 
 
27417 
  def __eq__(self, other):
27418 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27419 
 
27420 
  def __ne__(self, other):
27421 
    return not (self == other)
27422 
 
27423 
class activateRechargeTxn_result:
27424 
  """
27425 
  Attributes:
27426 
   - success
27427 
   - ex
27428 
  """
27429 
 
27430 
  thrift_spec = (
6031 rajveer 27431 
    (0, TType.BOOL, 'success', None, None, ), # 0
6000 mandeep.dh 27432 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27433 
  )
27434 
 
27435 
  def __init__(self, success=None, ex=None,):
27436 
    self.success = success
27437 
    self.ex = ex
27438 
 
27439 
  def read(self, iprot):
27440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27442 
      return
27443 
    iprot.readStructBegin()
27444 
    while True:
27445 
      (fname, ftype, fid) = iprot.readFieldBegin()
27446 
      if ftype == TType.STOP:
27447 
        break
27448 
      if fid == 0:
6031 rajveer 27449 
        if ftype == TType.BOOL:
27450 
          self.success = iprot.readBool();
6000 mandeep.dh 27451 
        else:
27452 
          iprot.skip(ftype)
27453 
      elif fid == 1:
27454 
        if ftype == TType.STRUCT:
27455 
          self.ex = TransactionServiceException()
27456 
          self.ex.read(iprot)
27457 
        else:
27458 
          iprot.skip(ftype)
27459 
      else:
27460 
        iprot.skip(ftype)
27461 
      iprot.readFieldEnd()
27462 
    iprot.readStructEnd()
27463 
 
27464 
  def write(self, oprot):
27465 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27466 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27467 
      return
27468 
    oprot.writeStructBegin('activateRechargeTxn_result')
27469 
    if self.success is not None:
6031 rajveer 27470 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
27471 
      oprot.writeBool(self.success)
6000 mandeep.dh 27472 
      oprot.writeFieldEnd()
27473 
    if self.ex is not None:
27474 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27475 
      self.ex.write(oprot)
27476 
      oprot.writeFieldEnd()
27477 
    oprot.writeFieldStop()
27478 
    oprot.writeStructEnd()
27479 
 
27480 
  def validate(self):
27481 
    return
27482 
 
27483 
 
27484 
  def __repr__(self):
27485 
    L = ['%s=%r' % (key, value)
27486 
      for key, value in self.__dict__.iteritems()]
27487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27488 
 
27489 
  def __eq__(self, other):
27490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27491 
 
27492 
  def __ne__(self, other):
27493 
    return not (self == other)
27494 
 
6031 rajveer 27495 
class getUserWallet_args:
6000 mandeep.dh 27496 
  """
27497 
  Attributes:
6031 rajveer 27498 
   - userId
6000 mandeep.dh 27499 
  """
27500 
 
27501 
  thrift_spec = (
27502 
    None, # 0
6031 rajveer 27503 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27504 
  )
27505 
 
6031 rajveer 27506 
  def __init__(self, userId=None,):
27507 
    self.userId = userId
6000 mandeep.dh 27508 
 
27509 
  def read(self, iprot):
27510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27512 
      return
27513 
    iprot.readStructBegin()
27514 
    while True:
27515 
      (fname, ftype, fid) = iprot.readFieldBegin()
27516 
      if ftype == TType.STOP:
27517 
        break
27518 
      if fid == 1:
27519 
        if ftype == TType.I64:
6031 rajveer 27520 
          self.userId = iprot.readI64();
6000 mandeep.dh 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
6031 rajveer 27532 
    oprot.writeStructBegin('getUserWallet_args')
27533 
    if self.userId is not None:
27534 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27535 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27536 
      oprot.writeFieldEnd()
27537 
    oprot.writeFieldStop()
27538 
    oprot.writeStructEnd()
27539 
 
27540 
  def validate(self):
27541 
    return
27542 
 
27543 
 
27544 
  def __repr__(self):
27545 
    L = ['%s=%r' % (key, value)
27546 
      for key, value in self.__dict__.iteritems()]
27547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27548 
 
27549 
  def __eq__(self, other):
27550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27551 
 
27552 
  def __ne__(self, other):
27553 
    return not (self == other)
27554 
 
6031 rajveer 27555 
class getUserWallet_result:
6000 mandeep.dh 27556 
  """
27557 
  Attributes:
27558 
   - success
27559 
  """
27560 
 
27561 
  thrift_spec = (
6031 rajveer 27562 
    (0, TType.STRUCT, 'success', (UserWallet, UserWallet.thrift_spec), None, ), # 0
6000 mandeep.dh 27563 
  )
27564 
 
27565 
  def __init__(self, success=None,):
27566 
    self.success = success
27567 
 
27568 
  def read(self, iprot):
27569 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27570 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27571 
      return
27572 
    iprot.readStructBegin()
27573 
    while True:
27574 
      (fname, ftype, fid) = iprot.readFieldBegin()
27575 
      if ftype == TType.STOP:
27576 
        break
27577 
      if fid == 0:
6031 rajveer 27578 
        if ftype == TType.STRUCT:
27579 
          self.success = UserWallet()
27580 
          self.success.read(iprot)
6000 mandeep.dh 27581 
        else:
27582 
          iprot.skip(ftype)
27583 
      else:
27584 
        iprot.skip(ftype)
27585 
      iprot.readFieldEnd()
27586 
    iprot.readStructEnd()
27587 
 
27588 
  def write(self, oprot):
27589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27591 
      return
6031 rajveer 27592 
    oprot.writeStructBegin('getUserWallet_result')
6000 mandeep.dh 27593 
    if self.success is not None:
6031 rajveer 27594 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27595 
      self.success.write(oprot)
6000 mandeep.dh 27596 
      oprot.writeFieldEnd()
27597 
    oprot.writeFieldStop()
27598 
    oprot.writeStructEnd()
27599 
 
27600 
  def validate(self):
27601 
    return
27602 
 
27603 
 
27604 
  def __repr__(self):
27605 
    L = ['%s=%r' % (key, value)
27606 
      for key, value in self.__dict__.iteritems()]
27607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27608 
 
27609 
  def __eq__(self, other):
27610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27611 
 
27612 
  def __ne__(self, other):
27613 
    return not (self == other)
27614 
 
6031 rajveer 27615 
class getUserWalletHistory_args:
6000 mandeep.dh 27616 
  """
27617 
  Attributes:
6031 rajveer 27618 
   - userId
6000 mandeep.dh 27619 
  """
27620 
 
27621 
  thrift_spec = (
27622 
    None, # 0
6031 rajveer 27623 
    (1, TType.I64, 'userId', None, None, ), # 1
6000 mandeep.dh 27624 
  )
27625 
 
6031 rajveer 27626 
  def __init__(self, userId=None,):
27627 
    self.userId = userId
6000 mandeep.dh 27628 
 
27629 
  def read(self, iprot):
27630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27632 
      return
27633 
    iprot.readStructBegin()
27634 
    while True:
27635 
      (fname, ftype, fid) = iprot.readFieldBegin()
27636 
      if ftype == TType.STOP:
27637 
        break
27638 
      if fid == 1:
27639 
        if ftype == TType.I64:
6031 rajveer 27640 
          self.userId = iprot.readI64();
6000 mandeep.dh 27641 
        else:
27642 
          iprot.skip(ftype)
27643 
      else:
27644 
        iprot.skip(ftype)
27645 
      iprot.readFieldEnd()
27646 
    iprot.readStructEnd()
27647 
 
27648 
  def write(self, oprot):
27649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27651 
      return
6031 rajveer 27652 
    oprot.writeStructBegin('getUserWalletHistory_args')
27653 
    if self.userId is not None:
27654 
      oprot.writeFieldBegin('userId', TType.I64, 1)
27655 
      oprot.writeI64(self.userId)
6000 mandeep.dh 27656 
      oprot.writeFieldEnd()
27657 
    oprot.writeFieldStop()
27658 
    oprot.writeStructEnd()
27659 
 
27660 
  def validate(self):
27661 
    return
27662 
 
27663 
 
27664 
  def __repr__(self):
27665 
    L = ['%s=%r' % (key, value)
27666 
      for key, value in self.__dict__.iteritems()]
27667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27668 
 
27669 
  def __eq__(self, other):
27670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27671 
 
27672 
  def __ne__(self, other):
27673 
    return not (self == other)
27674 
 
6031 rajveer 27675 
class getUserWalletHistory_result:
6000 mandeep.dh 27676 
  """
27677 
  Attributes:
27678 
   - success
27679 
  """
27680 
 
27681 
  thrift_spec = (
6031 rajveer 27682 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserWalletHistory, UserWalletHistory.thrift_spec)), None, ), # 0
6000 mandeep.dh 27683 
  )
27684 
 
27685 
  def __init__(self, success=None,):
27686 
    self.success = success
27687 
 
27688 
  def read(self, iprot):
27689 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27690 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27691 
      return
27692 
    iprot.readStructBegin()
27693 
    while True:
27694 
      (fname, ftype, fid) = iprot.readFieldBegin()
27695 
      if ftype == TType.STOP:
27696 
        break
27697 
      if fid == 0:
27698 
        if ftype == TType.LIST:
27699 
          self.success = []
6188 rajveer 27700 
          (_etype666, _size663) = iprot.readListBegin()
27701 
          for _i667 in xrange(_size663):
27702 
            _elem668 = UserWalletHistory()
27703 
            _elem668.read(iprot)
27704 
            self.success.append(_elem668)
6000 mandeep.dh 27705 
          iprot.readListEnd()
27706 
        else:
27707 
          iprot.skip(ftype)
27708 
      else:
27709 
        iprot.skip(ftype)
27710 
      iprot.readFieldEnd()
27711 
    iprot.readStructEnd()
27712 
 
27713 
  def write(self, oprot):
27714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27716 
      return
6031 rajveer 27717 
    oprot.writeStructBegin('getUserWalletHistory_result')
6000 mandeep.dh 27718 
    if self.success is not None:
27719 
      oprot.writeFieldBegin('success', TType.LIST, 0)
27720 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 27721 
      for iter669 in self.success:
27722 
        iter669.write(oprot)
6000 mandeep.dh 27723 
      oprot.writeListEnd()
27724 
      oprot.writeFieldEnd()
27725 
    oprot.writeFieldStop()
27726 
    oprot.writeStructEnd()
27727 
 
27728 
  def validate(self):
27729 
    return
27730 
 
27731 
 
27732 
  def __repr__(self):
27733 
    L = ['%s=%r' % (key, value)
27734 
      for key, value in self.__dict__.iteritems()]
27735 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27736 
 
27737 
  def __eq__(self, other):
27738 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27739 
 
27740 
  def __ne__(self, other):
27741 
    return not (self == other)
6048 rajveer 27742 
 
6050 anupam.sin 27743 
class getRechargeOrdersForTransaction_args:
27744 
  """
27745 
  Attributes:
27746 
   - txnId
27747 
  """
27748 
 
27749 
  thrift_spec = (
27750 
    None, # 0
27751 
    (1, TType.I64, 'txnId', None, None, ), # 1
27752 
  )
27753 
 
27754 
  def __init__(self, txnId=None,):
27755 
    self.txnId = txnId
27756 
 
27757 
  def read(self, iprot):
27758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27760 
      return
27761 
    iprot.readStructBegin()
27762 
    while True:
27763 
      (fname, ftype, fid) = iprot.readFieldBegin()
27764 
      if ftype == TType.STOP:
27765 
        break
27766 
      if fid == 1:
27767 
        if ftype == TType.I64:
27768 
          self.txnId = iprot.readI64();
27769 
        else:
27770 
          iprot.skip(ftype)
27771 
      else:
27772 
        iprot.skip(ftype)
27773 
      iprot.readFieldEnd()
27774 
    iprot.readStructEnd()
27775 
 
27776 
  def write(self, oprot):
27777 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27778 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27779 
      return
27780 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_args')
27781 
    if self.txnId is not None:
27782 
      oprot.writeFieldBegin('txnId', TType.I64, 1)
27783 
      oprot.writeI64(self.txnId)
27784 
      oprot.writeFieldEnd()
27785 
    oprot.writeFieldStop()
27786 
    oprot.writeStructEnd()
27787 
 
27788 
  def validate(self):
27789 
    return
27790 
 
27791 
 
27792 
  def __repr__(self):
27793 
    L = ['%s=%r' % (key, value)
27794 
      for key, value in self.__dict__.iteritems()]
27795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27796 
 
27797 
  def __eq__(self, other):
27798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27799 
 
27800 
  def __ne__(self, other):
27801 
    return not (self == other)
27802 
 
27803 
class getRechargeOrdersForTransaction_result:
27804 
  """
27805 
  Attributes:
27806 
   - success
27807 
   - ex
27808 
  """
27809 
 
27810 
  thrift_spec = (
27811 
    (0, TType.STRUCT, 'success', (RechargeOrder, RechargeOrder.thrift_spec), None, ), # 0
27812 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
27813 
  )
27814 
 
27815 
  def __init__(self, success=None, ex=None,):
27816 
    self.success = success
27817 
    self.ex = ex
27818 
 
27819 
  def read(self, iprot):
27820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27822 
      return
27823 
    iprot.readStructBegin()
27824 
    while True:
27825 
      (fname, ftype, fid) = iprot.readFieldBegin()
27826 
      if ftype == TType.STOP:
27827 
        break
27828 
      if fid == 0:
27829 
        if ftype == TType.STRUCT:
27830 
          self.success = RechargeOrder()
27831 
          self.success.read(iprot)
27832 
        else:
27833 
          iprot.skip(ftype)
27834 
      elif fid == 1:
27835 
        if ftype == TType.STRUCT:
27836 
          self.ex = TransactionServiceException()
27837 
          self.ex.read(iprot)
27838 
        else:
27839 
          iprot.skip(ftype)
27840 
      else:
27841 
        iprot.skip(ftype)
27842 
      iprot.readFieldEnd()
27843 
    iprot.readStructEnd()
27844 
 
27845 
  def write(self, oprot):
27846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27848 
      return
27849 
    oprot.writeStructBegin('getRechargeOrdersForTransaction_result')
27850 
    if self.success is not None:
27851 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
27852 
      self.success.write(oprot)
27853 
      oprot.writeFieldEnd()
27854 
    if self.ex is not None:
27855 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
27856 
      self.ex.write(oprot)
27857 
      oprot.writeFieldEnd()
27858 
    oprot.writeFieldStop()
27859 
    oprot.writeStructEnd()
27860 
 
27861 
  def validate(self):
27862 
    return
27863 
 
27864 
 
27865 
  def __repr__(self):
27866 
    L = ['%s=%r' % (key, value)
27867 
      for key, value in self.__dict__.iteritems()]
27868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27869 
 
27870 
  def __eq__(self, other):
27871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27872 
 
27873 
  def __ne__(self, other):
27874 
    return not (self == other)
27875 
 
6048 rajveer 27876 
class getServiceProviders_args:
27877 
  """
27878 
  Attributes:
27879 
   - rechargeType
6206 rajveer 27880 
   - onlyActive
6048 rajveer 27881 
  """
27882 
 
27883 
  thrift_spec = (
27884 
    None, # 0
27885 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
6206 rajveer 27886 
    (2, TType.BOOL, 'onlyActive', None, None, ), # 2
6048 rajveer 27887 
  )
27888 
 
6206 rajveer 27889 
  def __init__(self, rechargeType=None, onlyActive=None,):
6048 rajveer 27890 
    self.rechargeType = rechargeType
6206 rajveer 27891 
    self.onlyActive = onlyActive
6048 rajveer 27892 
 
27893 
  def read(self, iprot):
27894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27896 
      return
27897 
    iprot.readStructBegin()
27898 
    while True:
27899 
      (fname, ftype, fid) = iprot.readFieldBegin()
27900 
      if ftype == TType.STOP:
27901 
        break
27902 
      if fid == 1:
27903 
        if ftype == TType.I32:
27904 
          self.rechargeType = iprot.readI32();
27905 
        else:
27906 
          iprot.skip(ftype)
6206 rajveer 27907 
      elif fid == 2:
27908 
        if ftype == TType.BOOL:
27909 
          self.onlyActive = iprot.readBool();
27910 
        else:
27911 
          iprot.skip(ftype)
6048 rajveer 27912 
      else:
27913 
        iprot.skip(ftype)
27914 
      iprot.readFieldEnd()
27915 
    iprot.readStructEnd()
27916 
 
27917 
  def write(self, oprot):
27918 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27919 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27920 
      return
27921 
    oprot.writeStructBegin('getServiceProviders_args')
27922 
    if self.rechargeType is not None:
27923 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
27924 
      oprot.writeI32(self.rechargeType)
27925 
      oprot.writeFieldEnd()
6206 rajveer 27926 
    if self.onlyActive is not None:
27927 
      oprot.writeFieldBegin('onlyActive', TType.BOOL, 2)
27928 
      oprot.writeBool(self.onlyActive)
27929 
      oprot.writeFieldEnd()
6048 rajveer 27930 
    oprot.writeFieldStop()
27931 
    oprot.writeStructEnd()
27932 
 
27933 
  def validate(self):
27934 
    return
27935 
 
27936 
 
27937 
  def __repr__(self):
27938 
    L = ['%s=%r' % (key, value)
27939 
      for key, value in self.__dict__.iteritems()]
27940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
27941 
 
27942 
  def __eq__(self, other):
27943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
27944 
 
27945 
  def __ne__(self, other):
27946 
    return not (self == other)
27947 
 
27948 
class getServiceProviders_result:
27949 
  """
27950 
  Attributes:
27951 
   - success
27952 
  """
27953 
 
27954 
  thrift_spec = (
27955 
    (0, TType.MAP, 'success', (TType.I64,None,TType.STRING,None), None, ), # 0
27956 
  )
27957 
 
27958 
  def __init__(self, success=None,):
27959 
    self.success = success
27960 
 
27961 
  def read(self, iprot):
27962 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
27963 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
27964 
      return
27965 
    iprot.readStructBegin()
27966 
    while True:
27967 
      (fname, ftype, fid) = iprot.readFieldBegin()
27968 
      if ftype == TType.STOP:
27969 
        break
27970 
      if fid == 0:
27971 
        if ftype == TType.MAP:
27972 
          self.success = {}
6188 rajveer 27973 
          (_ktype671, _vtype672, _size670 ) = iprot.readMapBegin()
27974 
          for _i674 in xrange(_size670):
27975 
            _key675 = iprot.readI64();
27976 
            _val676 = iprot.readString();
27977 
            self.success[_key675] = _val676
6048 rajveer 27978 
          iprot.readMapEnd()
27979 
        else:
27980 
          iprot.skip(ftype)
27981 
      else:
27982 
        iprot.skip(ftype)
27983 
      iprot.readFieldEnd()
27984 
    iprot.readStructEnd()
27985 
 
27986 
  def write(self, oprot):
27987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
27988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
27989 
      return
27990 
    oprot.writeStructBegin('getServiceProviders_result')
27991 
    if self.success is not None:
27992 
      oprot.writeFieldBegin('success', TType.MAP, 0)
27993 
      oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
6188 rajveer 27994 
      for kiter677,viter678 in self.success.items():
27995 
        oprot.writeI64(kiter677)
27996 
        oprot.writeString(viter678)
6048 rajveer 27997 
      oprot.writeMapEnd()
27998 
      oprot.writeFieldEnd()
27999 
    oprot.writeFieldStop()
28000 
    oprot.writeStructEnd()
28001 
 
28002 
  def validate(self):
28003 
    return
28004 
 
28005 
 
28006 
  def __repr__(self):
28007 
    L = ['%s=%r' % (key, value)
28008 
      for key, value in self.__dict__.iteritems()]
28009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28010 
 
28011 
  def __eq__(self, other):
28012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28013 
 
28014 
  def __ne__(self, other):
28015 
    return not (self == other)
28016 
 
28017 
class getServiceProviderForDevice_args:
28018 
  """
28019 
  Attributes:
6049 rajveer 28020 
   - rechargeType
6048 rajveer 28021 
   - deviceNumber
28022 
  """
28023 
 
28024 
  thrift_spec = (
28025 
    None, # 0
6049 rajveer 28026 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28027 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6048 rajveer 28028 
  )
28029 
 
6049 rajveer 28030 
  def __init__(self, rechargeType=None, deviceNumber=None,):
28031 
    self.rechargeType = rechargeType
6048 rajveer 28032 
    self.deviceNumber = deviceNumber
28033 
 
28034 
  def read(self, iprot):
28035 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28036 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28037 
      return
28038 
    iprot.readStructBegin()
28039 
    while True:
28040 
      (fname, ftype, fid) = iprot.readFieldBegin()
28041 
      if ftype == TType.STOP:
28042 
        break
28043 
      if fid == 1:
6049 rajveer 28044 
        if ftype == TType.I32:
28045 
          self.rechargeType = iprot.readI32();
28046 
        else:
28047 
          iprot.skip(ftype)
28048 
      elif fid == 2:
6048 rajveer 28049 
        if ftype == TType.STRING:
28050 
          self.deviceNumber = iprot.readString();
28051 
        else:
28052 
          iprot.skip(ftype)
28053 
      else:
28054 
        iprot.skip(ftype)
28055 
      iprot.readFieldEnd()
28056 
    iprot.readStructEnd()
28057 
 
28058 
  def write(self, oprot):
28059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28061 
      return
28062 
    oprot.writeStructBegin('getServiceProviderForDevice_args')
6049 rajveer 28063 
    if self.rechargeType is not None:
28064 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28065 
      oprot.writeI32(self.rechargeType)
28066 
      oprot.writeFieldEnd()
6048 rajveer 28067 
    if self.deviceNumber is not None:
6049 rajveer 28068 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
6048 rajveer 28069 
      oprot.writeString(self.deviceNumber)
28070 
      oprot.writeFieldEnd()
28071 
    oprot.writeFieldStop()
28072 
    oprot.writeStructEnd()
28073 
 
28074 
  def validate(self):
28075 
    return
28076 
 
28077 
 
28078 
  def __repr__(self):
28079 
    L = ['%s=%r' % (key, value)
28080 
      for key, value in self.__dict__.iteritems()]
28081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28082 
 
28083 
  def __eq__(self, other):
28084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28085 
 
28086 
  def __ne__(self, other):
28087 
    return not (self == other)
28088 
 
28089 
class getServiceProviderForDevice_result:
28090 
  """
28091 
  Attributes:
28092 
   - success
28093 
  """
28094 
 
28095 
  thrift_spec = (
6289 anupam.sin 28096 
    (0, TType.STRUCT, 'success', (DeviceNumberInfo, DeviceNumberInfo.thrift_spec), None, ), # 0
6048 rajveer 28097 
  )
28098 
 
28099 
  def __init__(self, success=None,):
28100 
    self.success = success
28101 
 
28102 
  def read(self, iprot):
28103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28105 
      return
28106 
    iprot.readStructBegin()
28107 
    while True:
28108 
      (fname, ftype, fid) = iprot.readFieldBegin()
28109 
      if ftype == TType.STOP:
28110 
        break
28111 
      if fid == 0:
6289 anupam.sin 28112 
        if ftype == TType.STRUCT:
28113 
          self.success = DeviceNumberInfo()
28114 
          self.success.read(iprot)
6048 rajveer 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_result')
28127 
    if self.success is not None:
6289 anupam.sin 28128 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28129 
      self.success.write(oprot)
6048 rajveer 28130 
      oprot.writeFieldEnd()
28131 
    oprot.writeFieldStop()
28132 
    oprot.writeStructEnd()
28133 
 
28134 
  def validate(self):
28135 
    return
28136 
 
28137 
 
28138 
  def __repr__(self):
28139 
    L = ['%s=%r' % (key, value)
28140 
      for key, value in self.__dict__.iteritems()]
28141 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28142 
 
28143 
  def __eq__(self, other):
28144 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28145 
 
28146 
  def __ne__(self, other):
28147 
    return not (self == other)
6094 rajveer 28148 
 
6269 rajveer 28149 
class validateRecharge_args:
28150 
  """
28151 
  Attributes:
28152 
   - rechargeType
28153 
   - deviceNumber
6307 anupam.sin 28154 
   - userSelectedProviderId
6591 anupam.sin 28155 
   - clientAddress
6269 rajveer 28156 
  """
28157 
 
28158 
  thrift_spec = (
28159 
    None, # 0
28160 
    (1, TType.I32, 'rechargeType', None, None, ), # 1
28161 
    (2, TType.STRING, 'deviceNumber', None, None, ), # 2
6336 anupam.sin 28162 
    (3, TType.I64, 'userSelectedProviderId', None, None, ), # 3
6591 anupam.sin 28163 
    (4, TType.STRING, 'clientAddress', None, None, ), # 4
6269 rajveer 28164 
  )
28165 
 
6591 anupam.sin 28166 
  def __init__(self, rechargeType=None, deviceNumber=None, userSelectedProviderId=None, clientAddress=None,):
6269 rajveer 28167 
    self.rechargeType = rechargeType
28168 
    self.deviceNumber = deviceNumber
6307 anupam.sin 28169 
    self.userSelectedProviderId = userSelectedProviderId
6591 anupam.sin 28170 
    self.clientAddress = clientAddress
6269 rajveer 28171 
 
28172 
  def read(self, iprot):
28173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28175 
      return
28176 
    iprot.readStructBegin()
28177 
    while True:
28178 
      (fname, ftype, fid) = iprot.readFieldBegin()
28179 
      if ftype == TType.STOP:
28180 
        break
28181 
      if fid == 1:
28182 
        if ftype == TType.I32:
28183 
          self.rechargeType = iprot.readI32();
28184 
        else:
28185 
          iprot.skip(ftype)
28186 
      elif fid == 2:
28187 
        if ftype == TType.STRING:
28188 
          self.deviceNumber = iprot.readString();
28189 
        else:
28190 
          iprot.skip(ftype)
6307 anupam.sin 28191 
      elif fid == 3:
28192 
        if ftype == TType.I64:
28193 
          self.userSelectedProviderId = iprot.readI64();
28194 
        else:
28195 
          iprot.skip(ftype)
6591 anupam.sin 28196 
      elif fid == 4:
28197 
        if ftype == TType.STRING:
28198 
          self.clientAddress = iprot.readString();
28199 
        else:
28200 
          iprot.skip(ftype)
6269 rajveer 28201 
      else:
28202 
        iprot.skip(ftype)
28203 
      iprot.readFieldEnd()
28204 
    iprot.readStructEnd()
28205 
 
28206 
  def write(self, oprot):
28207 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28208 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28209 
      return
28210 
    oprot.writeStructBegin('validateRecharge_args')
28211 
    if self.rechargeType is not None:
28212 
      oprot.writeFieldBegin('rechargeType', TType.I32, 1)
28213 
      oprot.writeI32(self.rechargeType)
28214 
      oprot.writeFieldEnd()
28215 
    if self.deviceNumber is not None:
28216 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 2)
28217 
      oprot.writeString(self.deviceNumber)
28218 
      oprot.writeFieldEnd()
6307 anupam.sin 28219 
    if self.userSelectedProviderId is not None:
6336 anupam.sin 28220 
      oprot.writeFieldBegin('userSelectedProviderId', TType.I64, 3)
6307 anupam.sin 28221 
      oprot.writeI64(self.userSelectedProviderId)
28222 
      oprot.writeFieldEnd()
6591 anupam.sin 28223 
    if self.clientAddress is not None:
28224 
      oprot.writeFieldBegin('clientAddress', TType.STRING, 4)
28225 
      oprot.writeString(self.clientAddress)
28226 
      oprot.writeFieldEnd()
6269 rajveer 28227 
    oprot.writeFieldStop()
28228 
    oprot.writeStructEnd()
28229 
 
28230 
  def validate(self):
28231 
    return
28232 
 
28233 
 
28234 
  def __repr__(self):
28235 
    L = ['%s=%r' % (key, value)
28236 
      for key, value in self.__dict__.iteritems()]
28237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28238 
 
28239 
  def __eq__(self, other):
28240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28241 
 
28242 
  def __ne__(self, other):
28243 
    return not (self == other)
28244 
 
28245 
class validateRecharge_result:
28246 
  """
28247 
  Attributes:
28248 
   - success
28249 
  """
28250 
 
28251 
  thrift_spec = (
28252 
    (0, TType.STRING, 'success', None, None, ), # 0
28253 
  )
28254 
 
28255 
  def __init__(self, success=None,):
28256 
    self.success = success
28257 
 
28258 
  def read(self, iprot):
28259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28261 
      return
28262 
    iprot.readStructBegin()
28263 
    while True:
28264 
      (fname, ftype, fid) = iprot.readFieldBegin()
28265 
      if ftype == TType.STOP:
28266 
        break
28267 
      if fid == 0:
28268 
        if ftype == TType.STRING:
28269 
          self.success = iprot.readString();
28270 
        else:
28271 
          iprot.skip(ftype)
28272 
      else:
28273 
        iprot.skip(ftype)
28274 
      iprot.readFieldEnd()
28275 
    iprot.readStructEnd()
28276 
 
28277 
  def write(self, oprot):
28278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28280 
      return
28281 
    oprot.writeStructBegin('validateRecharge_result')
28282 
    if self.success is not None:
28283 
      oprot.writeFieldBegin('success', TType.STRING, 0)
28284 
      oprot.writeString(self.success)
28285 
      oprot.writeFieldEnd()
28286 
    oprot.writeFieldStop()
28287 
    oprot.writeStructEnd()
28288 
 
28289 
  def validate(self):
28290 
    return
28291 
 
28292 
 
28293 
  def __repr__(self):
28294 
    L = ['%s=%r' % (key, value)
28295 
      for key, value in self.__dict__.iteritems()]
28296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28297 
 
28298 
  def __eq__(self, other):
28299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28300 
 
28301 
  def __ne__(self, other):
28302 
    return not (self == other)
28303 
 
6094 rajveer 28304 
class getRechargeOrdersForDevice_args:
28305 
  """
28306 
  Attributes:
28307 
   - deviceNumber
28308 
  """
28309 
 
28310 
  thrift_spec = (
28311 
    None, # 0
28312 
    (1, TType.STRING, 'deviceNumber', None, None, ), # 1
28313 
  )
28314 
 
28315 
  def __init__(self, deviceNumber=None,):
28316 
    self.deviceNumber = deviceNumber
28317 
 
28318 
  def read(self, iprot):
28319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28321 
      return
28322 
    iprot.readStructBegin()
28323 
    while True:
28324 
      (fname, ftype, fid) = iprot.readFieldBegin()
28325 
      if ftype == TType.STOP:
28326 
        break
28327 
      if fid == 1:
28328 
        if ftype == TType.STRING:
28329 
          self.deviceNumber = iprot.readString();
28330 
        else:
28331 
          iprot.skip(ftype)
28332 
      else:
28333 
        iprot.skip(ftype)
28334 
      iprot.readFieldEnd()
28335 
    iprot.readStructEnd()
28336 
 
28337 
  def write(self, oprot):
28338 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28339 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28340 
      return
28341 
    oprot.writeStructBegin('getRechargeOrdersForDevice_args')
28342 
    if self.deviceNumber is not None:
28343 
      oprot.writeFieldBegin('deviceNumber', TType.STRING, 1)
28344 
      oprot.writeString(self.deviceNumber)
28345 
      oprot.writeFieldEnd()
28346 
    oprot.writeFieldStop()
28347 
    oprot.writeStructEnd()
28348 
 
28349 
  def validate(self):
28350 
    return
28351 
 
28352 
 
28353 
  def __repr__(self):
28354 
    L = ['%s=%r' % (key, value)
28355 
      for key, value in self.__dict__.iteritems()]
28356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28357 
 
28358 
  def __eq__(self, other):
28359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28360 
 
28361 
  def __ne__(self, other):
28362 
    return not (self == other)
28363 
 
28364 
class getRechargeOrdersForDevice_result:
28365 
  """
28366 
  Attributes:
28367 
   - success
28368 
  """
28369 
 
28370 
  thrift_spec = (
28371 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28372 
  )
28373 
 
28374 
  def __init__(self, success=None,):
28375 
    self.success = success
28376 
 
28377 
  def read(self, iprot):
28378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28380 
      return
28381 
    iprot.readStructBegin()
28382 
    while True:
28383 
      (fname, ftype, fid) = iprot.readFieldBegin()
28384 
      if ftype == TType.STOP:
28385 
        break
28386 
      if fid == 0:
28387 
        if ftype == TType.LIST:
28388 
          self.success = []
6188 rajveer 28389 
          (_etype682, _size679) = iprot.readListBegin()
28390 
          for _i683 in xrange(_size679):
28391 
            _elem684 = RechargeOrder()
28392 
            _elem684.read(iprot)
28393 
            self.success.append(_elem684)
6094 rajveer 28394 
          iprot.readListEnd()
28395 
        else:
28396 
          iprot.skip(ftype)
28397 
      else:
28398 
        iprot.skip(ftype)
28399 
      iprot.readFieldEnd()
28400 
    iprot.readStructEnd()
28401 
 
28402 
  def write(self, oprot):
28403 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28404 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28405 
      return
28406 
    oprot.writeStructBegin('getRechargeOrdersForDevice_result')
28407 
    if self.success is not None:
28408 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28409 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28410 
      for iter685 in self.success:
28411 
        iter685.write(oprot)
6094 rajveer 28412 
      oprot.writeListEnd()
28413 
      oprot.writeFieldEnd()
28414 
    oprot.writeFieldStop()
28415 
    oprot.writeStructEnd()
28416 
 
28417 
  def validate(self):
28418 
    return
28419 
 
28420 
 
28421 
  def __repr__(self):
28422 
    L = ['%s=%r' % (key, value)
28423 
      for key, value in self.__dict__.iteritems()]
28424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28425 
 
28426 
  def __eq__(self, other):
28427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28428 
 
28429 
  def __ne__(self, other):
28430 
    return not (self == other)
28431 
 
28432 
class addAmountToWallet_args:
28433 
  """
28434 
  Attributes:
28435 
   - userId
28436 
   - orderId
28437 
   - amount
28438 
  """
28439 
 
28440 
  thrift_spec = (
28441 
    None, # 0
28442 
    (1, TType.I64, 'userId', None, None, ), # 1
28443 
    (2, TType.I64, 'orderId', None, None, ), # 2
28444 
    (3, TType.I64, 'amount', None, None, ), # 3
28445 
  )
28446 
 
28447 
  def __init__(self, userId=None, orderId=None, amount=None,):
28448 
    self.userId = userId
28449 
    self.orderId = orderId
28450 
    self.amount = amount
28451 
 
28452 
  def read(self, iprot):
28453 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28454 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28455 
      return
28456 
    iprot.readStructBegin()
28457 
    while True:
28458 
      (fname, ftype, fid) = iprot.readFieldBegin()
28459 
      if ftype == TType.STOP:
28460 
        break
28461 
      if fid == 1:
28462 
        if ftype == TType.I64:
28463 
          self.userId = iprot.readI64();
28464 
        else:
28465 
          iprot.skip(ftype)
28466 
      elif fid == 2:
28467 
        if ftype == TType.I64:
28468 
          self.orderId = iprot.readI64();
28469 
        else:
28470 
          iprot.skip(ftype)
28471 
      elif fid == 3:
28472 
        if ftype == TType.I64:
28473 
          self.amount = iprot.readI64();
28474 
        else:
28475 
          iprot.skip(ftype)
28476 
      else:
28477 
        iprot.skip(ftype)
28478 
      iprot.readFieldEnd()
28479 
    iprot.readStructEnd()
28480 
 
28481 
  def write(self, oprot):
28482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28484 
      return
28485 
    oprot.writeStructBegin('addAmountToWallet_args')
28486 
    if self.userId is not None:
28487 
      oprot.writeFieldBegin('userId', TType.I64, 1)
28488 
      oprot.writeI64(self.userId)
28489 
      oprot.writeFieldEnd()
28490 
    if self.orderId is not None:
28491 
      oprot.writeFieldBegin('orderId', TType.I64, 2)
28492 
      oprot.writeI64(self.orderId)
28493 
      oprot.writeFieldEnd()
28494 
    if self.amount is not None:
28495 
      oprot.writeFieldBegin('amount', TType.I64, 3)
28496 
      oprot.writeI64(self.amount)
28497 
      oprot.writeFieldEnd()
28498 
    oprot.writeFieldStop()
28499 
    oprot.writeStructEnd()
28500 
 
28501 
  def validate(self):
28502 
    return
28503 
 
28504 
 
28505 
  def __repr__(self):
28506 
    L = ['%s=%r' % (key, value)
28507 
      for key, value in self.__dict__.iteritems()]
28508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28509 
 
28510 
  def __eq__(self, other):
28511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28512 
 
28513 
  def __ne__(self, other):
28514 
    return not (self == other)
28515 
 
28516 
class addAmountToWallet_result:
28517 
 
28518 
  thrift_spec = (
28519 
  )
28520 
 
28521 
  def read(self, iprot):
28522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28524 
      return
28525 
    iprot.readStructBegin()
28526 
    while True:
28527 
      (fname, ftype, fid) = iprot.readFieldBegin()
28528 
      if ftype == TType.STOP:
28529 
        break
28530 
      else:
28531 
        iprot.skip(ftype)
28532 
      iprot.readFieldEnd()
28533 
    iprot.readStructEnd()
28534 
 
28535 
  def write(self, oprot):
28536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28538 
      return
28539 
    oprot.writeStructBegin('addAmountToWallet_result')
28540 
    oprot.writeFieldStop()
28541 
    oprot.writeStructEnd()
28542 
 
28543 
  def validate(self):
28544 
    return
28545 
 
28546 
 
28547 
  def __repr__(self):
28548 
    L = ['%s=%r' % (key, value)
28549 
      for key, value in self.__dict__.iteritems()]
28550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28551 
 
28552 
  def __eq__(self, other):
28553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28554 
 
28555 
  def __ne__(self, other):
28556 
    return not (self == other)
6154 rajveer 28557 
 
6188 rajveer 28558 
class getRechargeStatistics_args:
28559 
 
28560 
  thrift_spec = (
28561 
  )
28562 
 
28563 
  def read(self, iprot):
28564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28566 
      return
28567 
    iprot.readStructBegin()
28568 
    while True:
28569 
      (fname, ftype, fid) = iprot.readFieldBegin()
28570 
      if ftype == TType.STOP:
28571 
        break
28572 
      else:
28573 
        iprot.skip(ftype)
28574 
      iprot.readFieldEnd()
28575 
    iprot.readStructEnd()
28576 
 
28577 
  def write(self, oprot):
28578 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28579 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28580 
      return
28581 
    oprot.writeStructBegin('getRechargeStatistics_args')
28582 
    oprot.writeFieldStop()
28583 
    oprot.writeStructEnd()
28584 
 
28585 
  def validate(self):
28586 
    return
28587 
 
28588 
 
28589 
  def __repr__(self):
28590 
    L = ['%s=%r' % (key, value)
28591 
      for key, value in self.__dict__.iteritems()]
28592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28593 
 
28594 
  def __eq__(self, other):
28595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28596 
 
28597 
  def __ne__(self, other):
28598 
    return not (self == other)
28599 
 
28600 
class getRechargeStatistics_result:
28601 
  """
28602 
  Attributes:
28603 
   - success
28604 
  """
28605 
 
28606 
  thrift_spec = (
28607 
    (0, TType.STRUCT, 'success', (RechargeStatistics, RechargeStatistics.thrift_spec), None, ), # 0
28608 
  )
28609 
 
28610 
  def __init__(self, success=None,):
28611 
    self.success = success
28612 
 
28613 
  def read(self, iprot):
28614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28616 
      return
28617 
    iprot.readStructBegin()
28618 
    while True:
28619 
      (fname, ftype, fid) = iprot.readFieldBegin()
28620 
      if ftype == TType.STOP:
28621 
        break
28622 
      if fid == 0:
28623 
        if ftype == TType.STRUCT:
28624 
          self.success = RechargeStatistics()
28625 
          self.success.read(iprot)
28626 
        else:
28627 
          iprot.skip(ftype)
28628 
      else:
28629 
        iprot.skip(ftype)
28630 
      iprot.readFieldEnd()
28631 
    iprot.readStructEnd()
28632 
 
28633 
  def write(self, oprot):
28634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28636 
      return
28637 
    oprot.writeStructBegin('getRechargeStatistics_result')
28638 
    if self.success is not None:
28639 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
28640 
      self.success.write(oprot)
28641 
      oprot.writeFieldEnd()
28642 
    oprot.writeFieldStop()
28643 
    oprot.writeStructEnd()
28644 
 
28645 
  def validate(self):
28646 
    return
28647 
 
28648 
 
28649 
  def __repr__(self):
28650 
    L = ['%s=%r' % (key, value)
28651 
      for key, value in self.__dict__.iteritems()]
28652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28653 
 
28654 
  def __eq__(self, other):
28655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28656 
 
28657 
  def __ne__(self, other):
28658 
    return not (self == other)
28659 
 
6154 rajveer 28660 
class getRechargeOrdersForStatus_args:
28661 
  """
28662 
  Attributes:
28663 
   - status
28664 
  """
28665 
 
28666 
  thrift_spec = (
28667 
    None, # 0
28668 
    (1, TType.I64, 'status', None, None, ), # 1
28669 
  )
28670 
 
28671 
  def __init__(self, status=None,):
28672 
    self.status = status
28673 
 
28674 
  def read(self, iprot):
28675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28677 
      return
28678 
    iprot.readStructBegin()
28679 
    while True:
28680 
      (fname, ftype, fid) = iprot.readFieldBegin()
28681 
      if ftype == TType.STOP:
28682 
        break
28683 
      if fid == 1:
28684 
        if ftype == TType.I64:
28685 
          self.status = iprot.readI64();
28686 
        else:
28687 
          iprot.skip(ftype)
28688 
      else:
28689 
        iprot.skip(ftype)
28690 
      iprot.readFieldEnd()
28691 
    iprot.readStructEnd()
28692 
 
28693 
  def write(self, oprot):
28694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28696 
      return
28697 
    oprot.writeStructBegin('getRechargeOrdersForStatus_args')
28698 
    if self.status is not None:
28699 
      oprot.writeFieldBegin('status', TType.I64, 1)
28700 
      oprot.writeI64(self.status)
28701 
      oprot.writeFieldEnd()
28702 
    oprot.writeFieldStop()
28703 
    oprot.writeStructEnd()
28704 
 
28705 
  def validate(self):
28706 
    return
28707 
 
28708 
 
28709 
  def __repr__(self):
28710 
    L = ['%s=%r' % (key, value)
28711 
      for key, value in self.__dict__.iteritems()]
28712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28713 
 
28714 
  def __eq__(self, other):
28715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28716 
 
28717 
  def __ne__(self, other):
28718 
    return not (self == other)
28719 
 
28720 
class getRechargeOrdersForStatus_result:
28721 
  """
28722 
  Attributes:
28723 
   - success
28724 
  """
28725 
 
28726 
  thrift_spec = (
28727 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeOrder, RechargeOrder.thrift_spec)), None, ), # 0
28728 
  )
28729 
 
28730 
  def __init__(self, success=None,):
28731 
    self.success = success
28732 
 
28733 
  def read(self, iprot):
28734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28736 
      return
28737 
    iprot.readStructBegin()
28738 
    while True:
28739 
      (fname, ftype, fid) = iprot.readFieldBegin()
28740 
      if ftype == TType.STOP:
28741 
        break
28742 
      if fid == 0:
28743 
        if ftype == TType.LIST:
28744 
          self.success = []
6188 rajveer 28745 
          (_etype689, _size686) = iprot.readListBegin()
28746 
          for _i690 in xrange(_size686):
28747 
            _elem691 = RechargeOrder()
28748 
            _elem691.read(iprot)
28749 
            self.success.append(_elem691)
6154 rajveer 28750 
          iprot.readListEnd()
28751 
        else:
28752 
          iprot.skip(ftype)
28753 
      else:
28754 
        iprot.skip(ftype)
28755 
      iprot.readFieldEnd()
28756 
    iprot.readStructEnd()
28757 
 
28758 
  def write(self, oprot):
28759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28761 
      return
28762 
    oprot.writeStructBegin('getRechargeOrdersForStatus_result')
28763 
    if self.success is not None:
28764 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28765 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28766 
      for iter692 in self.success:
28767 
        iter692.write(oprot)
6154 rajveer 28768 
      oprot.writeListEnd()
28769 
      oprot.writeFieldEnd()
28770 
    oprot.writeFieldStop()
28771 
    oprot.writeStructEnd()
28772 
 
28773 
  def validate(self):
28774 
    return
28775 
 
28776 
 
28777 
  def __repr__(self):
28778 
    L = ['%s=%r' % (key, value)
28779 
      for key, value in self.__dict__.iteritems()]
28780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28781 
 
28782 
  def __eq__(self, other):
28783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28784 
 
28785 
  def __ne__(self, other):
28786 
    return not (self == other)
6159 rajveer 28787 
 
28788 
class getPlansForOperator_args:
28789 
  """
28790 
  Attributes:
28791 
   - operatorId
28792 
  """
28793 
 
28794 
  thrift_spec = (
28795 
    None, # 0
28796 
    (1, TType.I64, 'operatorId', None, None, ), # 1
28797 
  )
28798 
 
28799 
  def __init__(self, operatorId=None,):
28800 
    self.operatorId = operatorId
28801 
 
28802 
  def read(self, iprot):
28803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28805 
      return
28806 
    iprot.readStructBegin()
28807 
    while True:
28808 
      (fname, ftype, fid) = iprot.readFieldBegin()
28809 
      if ftype == TType.STOP:
28810 
        break
28811 
      if fid == 1:
28812 
        if ftype == TType.I64:
28813 
          self.operatorId = iprot.readI64();
28814 
        else:
28815 
          iprot.skip(ftype)
28816 
      else:
28817 
        iprot.skip(ftype)
28818 
      iprot.readFieldEnd()
28819 
    iprot.readStructEnd()
28820 
 
28821 
  def write(self, oprot):
28822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28824 
      return
28825 
    oprot.writeStructBegin('getPlansForOperator_args')
28826 
    if self.operatorId is not None:
28827 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28828 
      oprot.writeI64(self.operatorId)
28829 
      oprot.writeFieldEnd()
28830 
    oprot.writeFieldStop()
28831 
    oprot.writeStructEnd()
28832 
 
28833 
  def validate(self):
28834 
    return
28835 
 
28836 
 
28837 
  def __repr__(self):
28838 
    L = ['%s=%r' % (key, value)
28839 
      for key, value in self.__dict__.iteritems()]
28840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28841 
 
28842 
  def __eq__(self, other):
28843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28844 
 
28845 
  def __ne__(self, other):
28846 
    return not (self == other)
28847 
 
28848 
class getPlansForOperator_result:
28849 
  """
28850 
  Attributes:
28851 
   - success
28852 
  """
28853 
 
28854 
  thrift_spec = (
28855 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargePlan, RechargePlan.thrift_spec)), None, ), # 0
28856 
  )
28857 
 
28858 
  def __init__(self, success=None,):
28859 
    self.success = success
28860 
 
28861 
  def read(self, iprot):
28862 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28863 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28864 
      return
28865 
    iprot.readStructBegin()
28866 
    while True:
28867 
      (fname, ftype, fid) = iprot.readFieldBegin()
28868 
      if ftype == TType.STOP:
28869 
        break
28870 
      if fid == 0:
28871 
        if ftype == TType.LIST:
28872 
          self.success = []
6188 rajveer 28873 
          (_etype696, _size693) = iprot.readListBegin()
28874 
          for _i697 in xrange(_size693):
28875 
            _elem698 = RechargePlan()
28876 
            _elem698.read(iprot)
28877 
            self.success.append(_elem698)
6159 rajveer 28878 
          iprot.readListEnd()
28879 
        else:
28880 
          iprot.skip(ftype)
28881 
      else:
28882 
        iprot.skip(ftype)
28883 
      iprot.readFieldEnd()
28884 
    iprot.readStructEnd()
28885 
 
28886 
  def write(self, oprot):
28887 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28888 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28889 
      return
28890 
    oprot.writeStructBegin('getPlansForOperator_result')
28891 
    if self.success is not None:
28892 
      oprot.writeFieldBegin('success', TType.LIST, 0)
28893 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6188 rajveer 28894 
      for iter699 in self.success:
28895 
        iter699.write(oprot)
6159 rajveer 28896 
      oprot.writeListEnd()
28897 
      oprot.writeFieldEnd()
28898 
    oprot.writeFieldStop()
28899 
    oprot.writeStructEnd()
28900 
 
28901 
  def validate(self):
28902 
    return
28903 
 
28904 
 
28905 
  def __repr__(self):
28906 
    L = ['%s=%r' % (key, value)
28907 
      for key, value in self.__dict__.iteritems()]
28908 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28909 
 
28910 
  def __eq__(self, other):
28911 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28912 
 
28913 
  def __ne__(self, other):
28914 
    return not (self == other)
6289 anupam.sin 28915 
 
28916 
class getRechargeDenominations_args:
28917 
  """
28918 
  Attributes:
28919 
   - operatorId
6307 anupam.sin 28920 
   - circleCode
6289 anupam.sin 28921 
   - denominationType
28922 
  """
28923 
 
28924 
  thrift_spec = (
28925 
    None, # 0
28926 
    (1, TType.I64, 'operatorId', None, None, ), # 1
6307 anupam.sin 28927 
    (2, TType.STRING, 'circleCode', None, None, ), # 2
6289 anupam.sin 28928 
    (3, TType.I32, 'denominationType', None, None, ), # 3
28929 
  )
28930 
 
6307 anupam.sin 28931 
  def __init__(self, operatorId=None, circleCode=None, denominationType=None,):
6289 anupam.sin 28932 
    self.operatorId = operatorId
6307 anupam.sin 28933 
    self.circleCode = circleCode
6289 anupam.sin 28934 
    self.denominationType = denominationType
28935 
 
28936 
  def read(self, iprot):
28937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
28938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
28939 
      return
28940 
    iprot.readStructBegin()
28941 
    while True:
28942 
      (fname, ftype, fid) = iprot.readFieldBegin()
28943 
      if ftype == TType.STOP:
28944 
        break
28945 
      if fid == 1:
28946 
        if ftype == TType.I64:
28947 
          self.operatorId = iprot.readI64();
28948 
        else:
28949 
          iprot.skip(ftype)
28950 
      elif fid == 2:
28951 
        if ftype == TType.STRING:
6307 anupam.sin 28952 
          self.circleCode = iprot.readString();
6289 anupam.sin 28953 
        else:
28954 
          iprot.skip(ftype)
28955 
      elif fid == 3:
28956 
        if ftype == TType.I32:
28957 
          self.denominationType = iprot.readI32();
28958 
        else:
28959 
          iprot.skip(ftype)
28960 
      else:
28961 
        iprot.skip(ftype)
28962 
      iprot.readFieldEnd()
28963 
    iprot.readStructEnd()
28964 
 
28965 
  def write(self, oprot):
28966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
28967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
28968 
      return
28969 
    oprot.writeStructBegin('getRechargeDenominations_args')
28970 
    if self.operatorId is not None:
28971 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
28972 
      oprot.writeI64(self.operatorId)
28973 
      oprot.writeFieldEnd()
6307 anupam.sin 28974 
    if self.circleCode is not None:
28975 
      oprot.writeFieldBegin('circleCode', TType.STRING, 2)
28976 
      oprot.writeString(self.circleCode)
6289 anupam.sin 28977 
      oprot.writeFieldEnd()
28978 
    if self.denominationType is not None:
28979 
      oprot.writeFieldBegin('denominationType', TType.I32, 3)
28980 
      oprot.writeI32(self.denominationType)
28981 
      oprot.writeFieldEnd()
28982 
    oprot.writeFieldStop()
28983 
    oprot.writeStructEnd()
28984 
 
28985 
  def validate(self):
28986 
    return
28987 
 
28988 
 
28989 
  def __repr__(self):
28990 
    L = ['%s=%r' % (key, value)
28991 
      for key, value in self.__dict__.iteritems()]
28992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
28993 
 
28994 
  def __eq__(self, other):
28995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
28996 
 
28997 
  def __ne__(self, other):
28998 
    return not (self == other)
28999 
 
29000 
class getRechargeDenominations_result:
29001 
  """
29002 
  Attributes:
29003 
   - success
29004 
   - ex
29005 
  """
29006 
 
29007 
  thrift_spec = (
29008 
    (0, TType.LIST, 'success', (TType.STRUCT,(RechargeDenomination, RechargeDenomination.thrift_spec)), None, ), # 0
29009 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29010 
  )
29011 
 
29012 
  def __init__(self, success=None, ex=None,):
29013 
    self.success = success
29014 
    self.ex = ex
29015 
 
29016 
  def read(self, iprot):
29017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29019 
      return
29020 
    iprot.readStructBegin()
29021 
    while True:
29022 
      (fname, ftype, fid) = iprot.readFieldBegin()
29023 
      if ftype == TType.STOP:
29024 
        break
29025 
      if fid == 0:
29026 
        if ftype == TType.LIST:
29027 
          self.success = []
29028 
          (_etype703, _size700) = iprot.readListBegin()
29029 
          for _i704 in xrange(_size700):
29030 
            _elem705 = RechargeDenomination()
29031 
            _elem705.read(iprot)
29032 
            self.success.append(_elem705)
29033 
          iprot.readListEnd()
29034 
        else:
29035 
          iprot.skip(ftype)
29036 
      elif fid == 1:
29037 
        if ftype == TType.STRUCT:
29038 
          self.ex = TransactionServiceException()
29039 
          self.ex.read(iprot)
29040 
        else:
29041 
          iprot.skip(ftype)
29042 
      else:
29043 
        iprot.skip(ftype)
29044 
      iprot.readFieldEnd()
29045 
    iprot.readStructEnd()
29046 
 
29047 
  def write(self, oprot):
29048 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29049 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29050 
      return
29051 
    oprot.writeStructBegin('getRechargeDenominations_result')
29052 
    if self.success is not None:
29053 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29054 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29055 
      for iter706 in self.success:
29056 
        iter706.write(oprot)
29057 
      oprot.writeListEnd()
29058 
      oprot.writeFieldEnd()
29059 
    if self.ex is not None:
29060 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29061 
      self.ex.write(oprot)
29062 
      oprot.writeFieldEnd()
29063 
    oprot.writeFieldStop()
29064 
    oprot.writeStructEnd()
29065 
 
29066 
  def validate(self):
29067 
    return
29068 
 
29069 
 
29070 
  def __repr__(self):
29071 
    L = ['%s=%r' % (key, value)
29072 
      for key, value in self.__dict__.iteritems()]
29073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29074 
 
29075 
  def __eq__(self, other):
29076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29077 
 
29078 
  def __ne__(self, other):
29079 
    return not (self == other)
6371 rajveer 29080 
 
29081 
class updateAvailabilityStatus_args:
29082 
  """
29083 
  Attributes:
29084 
   - operatorId
29085 
   - circleId
29086 
   - isAvailable
29087 
  """
29088 
 
29089 
  thrift_spec = (
29090 
    None, # 0
29091 
    (1, TType.I64, 'operatorId', None, None, ), # 1
29092 
    (2, TType.I64, 'circleId', None, None, ), # 2
29093 
    (3, TType.BOOL, 'isAvailable', None, None, ), # 3
29094 
  )
29095 
 
29096 
  def __init__(self, operatorId=None, circleId=None, isAvailable=None,):
29097 
    self.operatorId = operatorId
29098 
    self.circleId = circleId
29099 
    self.isAvailable = isAvailable
29100 
 
29101 
  def read(self, iprot):
29102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29104 
      return
29105 
    iprot.readStructBegin()
29106 
    while True:
29107 
      (fname, ftype, fid) = iprot.readFieldBegin()
29108 
      if ftype == TType.STOP:
29109 
        break
29110 
      if fid == 1:
29111 
        if ftype == TType.I64:
29112 
          self.operatorId = iprot.readI64();
29113 
        else:
29114 
          iprot.skip(ftype)
29115 
      elif fid == 2:
29116 
        if ftype == TType.I64:
29117 
          self.circleId = iprot.readI64();
29118 
        else:
29119 
          iprot.skip(ftype)
29120 
      elif fid == 3:
29121 
        if ftype == TType.BOOL:
29122 
          self.isAvailable = iprot.readBool();
29123 
        else:
29124 
          iprot.skip(ftype)
29125 
      else:
29126 
        iprot.skip(ftype)
29127 
      iprot.readFieldEnd()
29128 
    iprot.readStructEnd()
29129 
 
29130 
  def write(self, oprot):
29131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29133 
      return
29134 
    oprot.writeStructBegin('updateAvailabilityStatus_args')
29135 
    if self.operatorId is not None:
29136 
      oprot.writeFieldBegin('operatorId', TType.I64, 1)
29137 
      oprot.writeI64(self.operatorId)
29138 
      oprot.writeFieldEnd()
29139 
    if self.circleId is not None:
29140 
      oprot.writeFieldBegin('circleId', TType.I64, 2)
29141 
      oprot.writeI64(self.circleId)
29142 
      oprot.writeFieldEnd()
29143 
    if self.isAvailable is not None:
29144 
      oprot.writeFieldBegin('isAvailable', TType.BOOL, 3)
29145 
      oprot.writeBool(self.isAvailable)
29146 
      oprot.writeFieldEnd()
29147 
    oprot.writeFieldStop()
29148 
    oprot.writeStructEnd()
29149 
 
29150 
  def validate(self):
29151 
    return
29152 
 
29153 
 
29154 
  def __repr__(self):
29155 
    L = ['%s=%r' % (key, value)
29156 
      for key, value in self.__dict__.iteritems()]
29157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29158 
 
29159 
  def __eq__(self, other):
29160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29161 
 
29162 
  def __ne__(self, other):
29163 
    return not (self == other)
29164 
 
29165 
class updateAvailabilityStatus_result:
29166 
 
29167 
  thrift_spec = (
29168 
  )
29169 
 
29170 
  def read(self, iprot):
29171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29173 
      return
29174 
    iprot.readStructBegin()
29175 
    while True:
29176 
      (fname, ftype, fid) = iprot.readFieldBegin()
29177 
      if ftype == TType.STOP:
29178 
        break
29179 
      else:
29180 
        iprot.skip(ftype)
29181 
      iprot.readFieldEnd()
29182 
    iprot.readStructEnd()
29183 
 
29184 
  def write(self, oprot):
29185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29187 
      return
29188 
    oprot.writeStructBegin('updateAvailabilityStatus_result')
29189 
    oprot.writeFieldStop()
29190 
    oprot.writeStructEnd()
29191 
 
29192 
  def validate(self):
29193 
    return
29194 
 
29195 
 
29196 
  def __repr__(self):
29197 
    L = ['%s=%r' % (key, value)
29198 
      for key, value in self.__dict__.iteritems()]
29199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29200 
 
29201 
  def __eq__(self, other):
29202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29203 
 
29204 
  def __ne__(self, other):
29205 
    return not (self == other)
6389 rajveer 29206 
 
29207 
class getAvailableEmiSchemes_args:
29208 
 
29209 
  thrift_spec = (
29210 
  )
29211 
 
29212 
  def read(self, iprot):
29213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29215 
      return
29216 
    iprot.readStructBegin()
29217 
    while True:
29218 
      (fname, ftype, fid) = iprot.readFieldBegin()
29219 
      if ftype == TType.STOP:
29220 
        break
29221 
      else:
29222 
        iprot.skip(ftype)
29223 
      iprot.readFieldEnd()
29224 
    iprot.readStructEnd()
29225 
 
29226 
  def write(self, oprot):
29227 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29228 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29229 
      return
29230 
    oprot.writeStructBegin('getAvailableEmiSchemes_args')
29231 
    oprot.writeFieldStop()
29232 
    oprot.writeStructEnd()
29233 
 
29234 
  def validate(self):
29235 
    return
29236 
 
29237 
 
29238 
  def __repr__(self):
29239 
    L = ['%s=%r' % (key, value)
29240 
      for key, value in self.__dict__.iteritems()]
29241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29242 
 
29243 
  def __eq__(self, other):
29244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29245 
 
29246 
  def __ne__(self, other):
29247 
    return not (self == other)
29248 
 
29249 
class getAvailableEmiSchemes_result:
29250 
  """
29251 
  Attributes:
29252 
   - success
29253 
  """
29254 
 
29255 
  thrift_spec = (
29256 
    (0, TType.LIST, 'success', (TType.STRUCT,(EmiScheme, EmiScheme.thrift_spec)), None, ), # 0
29257 
  )
29258 
 
29259 
  def __init__(self, success=None,):
29260 
    self.success = success
29261 
 
29262 
  def read(self, iprot):
29263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29265 
      return
29266 
    iprot.readStructBegin()
29267 
    while True:
29268 
      (fname, ftype, fid) = iprot.readFieldBegin()
29269 
      if ftype == TType.STOP:
29270 
        break
29271 
      if fid == 0:
29272 
        if ftype == TType.LIST:
29273 
          self.success = []
29274 
          (_etype710, _size707) = iprot.readListBegin()
29275 
          for _i711 in xrange(_size707):
29276 
            _elem712 = EmiScheme()
29277 
            _elem712.read(iprot)
29278 
            self.success.append(_elem712)
29279 
          iprot.readListEnd()
29280 
        else:
29281 
          iprot.skip(ftype)
29282 
      else:
29283 
        iprot.skip(ftype)
29284 
      iprot.readFieldEnd()
29285 
    iprot.readStructEnd()
29286 
 
29287 
  def write(self, oprot):
29288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29290 
      return
29291 
    oprot.writeStructBegin('getAvailableEmiSchemes_result')
29292 
    if self.success is not None:
29293 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29294 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29295 
      for iter713 in self.success:
29296 
        iter713.write(oprot)
29297 
      oprot.writeListEnd()
29298 
      oprot.writeFieldEnd()
29299 
    oprot.writeFieldStop()
29300 
    oprot.writeStructEnd()
29301 
 
29302 
  def validate(self):
29303 
    return
29304 
 
29305 
 
29306 
  def __repr__(self):
29307 
    L = ['%s=%r' % (key, value)
29308 
      for key, value in self.__dict__.iteritems()]
29309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29310 
 
29311 
  def __eq__(self, other):
29312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29313 
 
29314 
  def __ne__(self, other):
29315 
    return not (self == other)
29316 
 
29317 
class getMiscCharges_args:
29318 
  """
29319 
  Attributes:
29320 
   - transactionId
29321 
  """
29322 
 
29323 
  thrift_spec = (
29324 
    None, # 0
29325 
    (1, TType.I64, 'transactionId', None, None, ), # 1
29326 
  )
29327 
 
29328 
  def __init__(self, transactionId=None,):
29329 
    self.transactionId = transactionId
29330 
 
29331 
  def read(self, iprot):
29332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29334 
      return
29335 
    iprot.readStructBegin()
29336 
    while True:
29337 
      (fname, ftype, fid) = iprot.readFieldBegin()
29338 
      if ftype == TType.STOP:
29339 
        break
29340 
      if fid == 1:
29341 
        if ftype == TType.I64:
29342 
          self.transactionId = iprot.readI64();
29343 
        else:
29344 
          iprot.skip(ftype)
29345 
      else:
29346 
        iprot.skip(ftype)
29347 
      iprot.readFieldEnd()
29348 
    iprot.readStructEnd()
29349 
 
29350 
  def write(self, oprot):
29351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29353 
      return
29354 
    oprot.writeStructBegin('getMiscCharges_args')
29355 
    if self.transactionId is not None:
29356 
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
29357 
      oprot.writeI64(self.transactionId)
29358 
      oprot.writeFieldEnd()
29359 
    oprot.writeFieldStop()
29360 
    oprot.writeStructEnd()
29361 
 
29362 
  def validate(self):
29363 
    return
29364 
 
29365 
 
29366 
  def __repr__(self):
29367 
    L = ['%s=%r' % (key, value)
29368 
      for key, value in self.__dict__.iteritems()]
29369 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29370 
 
29371 
  def __eq__(self, other):
29372 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29373 
 
29374 
  def __ne__(self, other):
29375 
    return not (self == other)
29376 
 
29377 
class getMiscCharges_result:
29378 
  """
29379 
  Attributes:
29380 
   - success
29381 
  """
29382 
 
29383 
  thrift_spec = (
6412 rajveer 29384 
    (0, TType.MAP, 'success', (TType.I64,None,TType.DOUBLE,None), None, ), # 0
6389 rajveer 29385 
  )
29386 
 
29387 
  def __init__(self, success=None,):
29388 
    self.success = success
29389 
 
29390 
  def read(self, iprot):
29391 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29392 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29393 
      return
29394 
    iprot.readStructBegin()
29395 
    while True:
29396 
      (fname, ftype, fid) = iprot.readFieldBegin()
29397 
      if ftype == TType.STOP:
29398 
        break
29399 
      if fid == 0:
29400 
        if ftype == TType.MAP:
29401 
          self.success = {}
29402 
          (_ktype715, _vtype716, _size714 ) = iprot.readMapBegin()
29403 
          for _i718 in xrange(_size714):
29404 
            _key719 = iprot.readI64();
6412 rajveer 29405 
            _val720 = iprot.readDouble();
6389 rajveer 29406 
            self.success[_key719] = _val720
29407 
          iprot.readMapEnd()
29408 
        else:
29409 
          iprot.skip(ftype)
29410 
      else:
29411 
        iprot.skip(ftype)
29412 
      iprot.readFieldEnd()
29413 
    iprot.readStructEnd()
29414 
 
29415 
  def write(self, oprot):
29416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29418 
      return
29419 
    oprot.writeStructBegin('getMiscCharges_result')
29420 
    if self.success is not None:
29421 
      oprot.writeFieldBegin('success', TType.MAP, 0)
6412 rajveer 29422 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.success))
6389 rajveer 29423 
      for kiter721,viter722 in self.success.items():
29424 
        oprot.writeI64(kiter721)
6412 rajveer 29425 
        oprot.writeDouble(viter722)
6389 rajveer 29426 
      oprot.writeMapEnd()
29427 
      oprot.writeFieldEnd()
29428 
    oprot.writeFieldStop()
29429 
    oprot.writeStructEnd()
29430 
 
29431 
  def validate(self):
29432 
    return
29433 
 
29434 
 
29435 
  def __repr__(self):
29436 
    L = ['%s=%r' % (key, value)
29437 
      for key, value in self.__dict__.iteritems()]
29438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29439 
 
29440 
  def __eq__(self, other):
29441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29442 
 
29443 
  def __ne__(self, other):
29444 
    return not (self == other)
6507 anupam.sin 29445 
 
29446 
class refundRechargeOrder_args:
29447 
  """
29448 
  Attributes:
29449 
   - rechargeOrderId
29450 
  """
29451 
 
29452 
  thrift_spec = (
29453 
    None, # 0
29454 
    (1, TType.I64, 'rechargeOrderId', None, None, ), # 1
29455 
  )
29456 
 
29457 
  def __init__(self, rechargeOrderId=None,):
29458 
    self.rechargeOrderId = rechargeOrderId
29459 
 
29460 
  def read(self, iprot):
29461 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29462 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29463 
      return
29464 
    iprot.readStructBegin()
29465 
    while True:
29466 
      (fname, ftype, fid) = iprot.readFieldBegin()
29467 
      if ftype == TType.STOP:
29468 
        break
29469 
      if fid == 1:
29470 
        if ftype == TType.I64:
29471 
          self.rechargeOrderId = iprot.readI64();
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('refundRechargeOrder_args')
29484 
    if self.rechargeOrderId is not None:
29485 
      oprot.writeFieldBegin('rechargeOrderId', TType.I64, 1)
29486 
      oprot.writeI64(self.rechargeOrderId)
29487 
      oprot.writeFieldEnd()
29488 
    oprot.writeFieldStop()
29489 
    oprot.writeStructEnd()
29490 
 
29491 
  def validate(self):
29492 
    return
29493 
 
29494 
 
29495 
  def __repr__(self):
29496 
    L = ['%s=%r' % (key, value)
29497 
      for key, value in self.__dict__.iteritems()]
29498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29499 
 
29500 
  def __eq__(self, other):
29501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29502 
 
29503 
  def __ne__(self, other):
29504 
    return not (self == other)
29505 
 
29506 
class refundRechargeOrder_result:
29507 
  """
29508 
  Attributes:
29509 
   - success
29510 
   - ex
29511 
  """
29512 
 
29513 
  thrift_spec = (
29514 
    (0, TType.BOOL, 'success', None, None, ), # 0
29515 
    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
29516 
  )
29517 
 
29518 
  def __init__(self, success=None, ex=None,):
29519 
    self.success = success
29520 
    self.ex = ex
29521 
 
29522 
  def read(self, iprot):
29523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29525 
      return
29526 
    iprot.readStructBegin()
29527 
    while True:
29528 
      (fname, ftype, fid) = iprot.readFieldBegin()
29529 
      if ftype == TType.STOP:
29530 
        break
29531 
      if fid == 0:
29532 
        if ftype == TType.BOOL:
29533 
          self.success = iprot.readBool();
29534 
        else:
29535 
          iprot.skip(ftype)
29536 
      elif fid == 1:
29537 
        if ftype == TType.STRUCT:
29538 
          self.ex = TransactionServiceException()
29539 
          self.ex.read(iprot)
29540 
        else:
29541 
          iprot.skip(ftype)
29542 
      else:
29543 
        iprot.skip(ftype)
29544 
      iprot.readFieldEnd()
29545 
    iprot.readStructEnd()
29546 
 
29547 
  def write(self, oprot):
29548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29550 
      return
29551 
    oprot.writeStructBegin('refundRechargeOrder_result')
29552 
    if self.success is not None:
29553 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
29554 
      oprot.writeBool(self.success)
29555 
      oprot.writeFieldEnd()
29556 
    if self.ex is not None:
29557 
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
29558 
      self.ex.write(oprot)
29559 
      oprot.writeFieldEnd()
29560 
    oprot.writeFieldStop()
29561 
    oprot.writeStructEnd()
29562 
 
29563 
  def validate(self):
29564 
    return
29565 
 
29566 
 
29567 
  def __repr__(self):
29568 
    L = ['%s=%r' % (key, value)
29569 
      for key, value in self.__dict__.iteritems()]
29570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29571 
 
29572 
  def __eq__(self, other):
29573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29574 
 
29575 
  def __ne__(self, other):
29576 
    return not (self == other)
6821 amar.kumar 29577 
 
29578 
class getPhysicalOrders_args:
29579 
  """
29580 
  Attributes:
29581 
   - fromDate
29582 
   - toDate
29583 
  """
29584 
 
29585 
  thrift_spec = (
29586 
    None, # 0
29587 
    (1, TType.I64, 'fromDate', None, None, ), # 1
29588 
    (2, TType.I64, 'toDate', None, None, ), # 2
29589 
  )
29590 
 
29591 
  def __init__(self, fromDate=None, toDate=None,):
29592 
    self.fromDate = fromDate
29593 
    self.toDate = toDate
29594 
 
29595 
  def read(self, iprot):
29596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29598 
      return
29599 
    iprot.readStructBegin()
29600 
    while True:
29601 
      (fname, ftype, fid) = iprot.readFieldBegin()
29602 
      if ftype == TType.STOP:
29603 
        break
29604 
      if fid == 1:
29605 
        if ftype == TType.I64:
29606 
          self.fromDate = iprot.readI64();
29607 
        else:
29608 
          iprot.skip(ftype)
29609 
      elif fid == 2:
29610 
        if ftype == TType.I64:
29611 
          self.toDate = iprot.readI64();
29612 
        else:
29613 
          iprot.skip(ftype)
29614 
      else:
29615 
        iprot.skip(ftype)
29616 
      iprot.readFieldEnd()
29617 
    iprot.readStructEnd()
29618 
 
29619 
  def write(self, oprot):
29620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29622 
      return
29623 
    oprot.writeStructBegin('getPhysicalOrders_args')
29624 
    if self.fromDate is not None:
29625 
      oprot.writeFieldBegin('fromDate', TType.I64, 1)
29626 
      oprot.writeI64(self.fromDate)
29627 
      oprot.writeFieldEnd()
29628 
    if self.toDate is not None:
29629 
      oprot.writeFieldBegin('toDate', TType.I64, 2)
29630 
      oprot.writeI64(self.toDate)
29631 
      oprot.writeFieldEnd()
29632 
    oprot.writeFieldStop()
29633 
    oprot.writeStructEnd()
29634 
 
29635 
  def validate(self):
29636 
    return
29637 
 
29638 
 
29639 
  def __repr__(self):
29640 
    L = ['%s=%r' % (key, value)
29641 
      for key, value in self.__dict__.iteritems()]
29642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29643 
 
29644 
  def __eq__(self, other):
29645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29646 
 
29647 
  def __ne__(self, other):
29648 
    return not (self == other)
29649 
 
29650 
class getPhysicalOrders_result:
29651 
  """
29652 
  Attributes:
29653 
   - success
29654 
  """
29655 
 
29656 
  thrift_spec = (
29657 
    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
29658 
  )
29659 
 
29660 
  def __init__(self, success=None,):
29661 
    self.success = success
29662 
 
29663 
  def read(self, iprot):
29664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29666 
      return
29667 
    iprot.readStructBegin()
29668 
    while True:
29669 
      (fname, ftype, fid) = iprot.readFieldBegin()
29670 
      if ftype == TType.STOP:
29671 
        break
29672 
      if fid == 0:
29673 
        if ftype == TType.LIST:
29674 
          self.success = []
29675 
          (_etype726, _size723) = iprot.readListBegin()
29676 
          for _i727 in xrange(_size723):
29677 
            _elem728 = Order()
29678 
            _elem728.read(iprot)
29679 
            self.success.append(_elem728)
29680 
          iprot.readListEnd()
29681 
        else:
29682 
          iprot.skip(ftype)
29683 
      else:
29684 
        iprot.skip(ftype)
29685 
      iprot.readFieldEnd()
29686 
    iprot.readStructEnd()
29687 
 
29688 
  def write(self, oprot):
29689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29691 
      return
29692 
    oprot.writeStructBegin('getPhysicalOrders_result')
29693 
    if self.success is not None:
29694 
      oprot.writeFieldBegin('success', TType.LIST, 0)
29695 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
29696 
      for iter729 in self.success:
29697 
        iter729.write(oprot)
29698 
      oprot.writeListEnd()
29699 
      oprot.writeFieldEnd()
29700 
    oprot.writeFieldStop()
29701 
    oprot.writeStructEnd()
29702 
 
29703 
  def validate(self):
29704 
    return
29705 
 
29706 
 
29707 
  def __repr__(self):
29708 
    L = ['%s=%r' % (key, value)
29709 
      for key, value in self.__dict__.iteritems()]
29710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29711 
 
29712 
  def __eq__(self, other):
29713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29714 
 
29715 
  def __ne__(self, other):
29716 
    return not (self == other)
6906 rajveer 29717 
 
29718 
class getDocument_args:
29719 
  """
29720 
  Attributes:
29721 
   - docType
29722 
   - docSource
29723 
  """
29724 
 
29725 
  thrift_spec = (
29726 
    None, # 0
29727 
    (1, TType.I64, 'docType', None, None, ), # 1
29728 
    (2, TType.I64, 'docSource', None, None, ), # 2
29729 
  )
29730 
 
29731 
  def __init__(self, docType=None, docSource=None,):
29732 
    self.docType = docType
29733 
    self.docSource = docSource
29734 
 
29735 
  def read(self, iprot):
29736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29738 
      return
29739 
    iprot.readStructBegin()
29740 
    while True:
29741 
      (fname, ftype, fid) = iprot.readFieldBegin()
29742 
      if ftype == TType.STOP:
29743 
        break
29744 
      if fid == 1:
29745 
        if ftype == TType.I64:
29746 
          self.docType = iprot.readI64();
29747 
        else:
29748 
          iprot.skip(ftype)
29749 
      elif fid == 2:
29750 
        if ftype == TType.I64:
29751 
          self.docSource = iprot.readI64();
29752 
        else:
29753 
          iprot.skip(ftype)
29754 
      else:
29755 
        iprot.skip(ftype)
29756 
      iprot.readFieldEnd()
29757 
    iprot.readStructEnd()
29758 
 
29759 
  def write(self, oprot):
29760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29762 
      return
29763 
    oprot.writeStructBegin('getDocument_args')
29764 
    if self.docType is not None:
29765 
      oprot.writeFieldBegin('docType', TType.I64, 1)
29766 
      oprot.writeI64(self.docType)
29767 
      oprot.writeFieldEnd()
29768 
    if self.docSource is not None:
29769 
      oprot.writeFieldBegin('docSource', TType.I64, 2)
29770 
      oprot.writeI64(self.docSource)
29771 
      oprot.writeFieldEnd()
29772 
    oprot.writeFieldStop()
29773 
    oprot.writeStructEnd()
29774 
 
29775 
  def validate(self):
29776 
    return
29777 
 
29778 
 
29779 
  def __repr__(self):
29780 
    L = ['%s=%r' % (key, value)
29781 
      for key, value in self.__dict__.iteritems()]
29782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29783 
 
29784 
  def __eq__(self, other):
29785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29786 
 
29787 
  def __ne__(self, other):
29788 
    return not (self == other)
29789 
 
29790 
class getDocument_result:
29791 
  """
29792 
  Attributes:
29793 
   - success
29794 
  """
29795 
 
29796 
  thrift_spec = (
29797 
    (0, TType.STRING, 'success', None, None, ), # 0
29798 
  )
29799 
 
29800 
  def __init__(self, success=None,):
29801 
    self.success = success
29802 
 
29803 
  def read(self, iprot):
29804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
29805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
29806 
      return
29807 
    iprot.readStructBegin()
29808 
    while True:
29809 
      (fname, ftype, fid) = iprot.readFieldBegin()
29810 
      if ftype == TType.STOP:
29811 
        break
29812 
      if fid == 0:
29813 
        if ftype == TType.STRING:
29814 
          self.success = iprot.readString();
29815 
        else:
29816 
          iprot.skip(ftype)
29817 
      else:
29818 
        iprot.skip(ftype)
29819 
      iprot.readFieldEnd()
29820 
    iprot.readStructEnd()
29821 
 
29822 
  def write(self, oprot):
29823 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
29824 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
29825 
      return
29826 
    oprot.writeStructBegin('getDocument_result')
29827 
    if self.success is not None:
29828 
      oprot.writeFieldBegin('success', TType.STRING, 0)
29829 
      oprot.writeString(self.success)
29830 
      oprot.writeFieldEnd()
29831 
    oprot.writeFieldStop()
29832 
    oprot.writeStructEnd()
29833 
 
29834 
  def validate(self):
29835 
    return
29836 
 
29837 
 
29838 
  def __repr__(self):
29839 
    L = ['%s=%r' % (key, value)
29840 
      for key, value in self.__dict__.iteritems()]
29841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
29842 
 
29843 
  def __eq__(self, other):
29844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
29845 
 
29846 
  def __ne__(self, other):
29847 
    return not (self == other)